PIP-0036: RandomHash2 + implementation refactoring for analysis

* Added PIP-0036
* Refactored implementation (not algorithm) for analytical purposes
* Fleshed out diagnostic form for RH2 analysis

PIP/PIP-0036.md

@@ -0,0 +1,660 @@
+<pre>
+  PIP: PIP-0036
+  Title: RandomHash2: Enhanced GPU & ASIC Resistant Hash Algorithm
+  Type: Protocol
+  Impact: Hard-Fork
+  Author: Herman Schoenfeld <i>&lt;[email protected]&gt;</i>
+  Comments-URI: https://discord.gg/sJqcgtD  (channel #pip-0036)
+  Status: Active
+  Created: 2019-07-31
+</pre>
+
+## Summary
+
+A major revision of RandomHash, a GPU and ASIC resistant hashing algorithm, is proposed.
+
+## Motivation
+
+Since the fundamental motivations behind RandomHash2 follow that of [RandomHash][1], only the changes and motivations of moving from RandomHash to RandomHash2 are discussed in this document. The reader is advised to familiarize themselves with [PIP-0009][1] for full context. 
+
+In short, the purpose of RandomHash2 is to address the the need for faster block-header validation currently afflicting PascalCoin due to the predecessor RandomHash PoW algorithm.
+
+## Background 
+
+Whilst RandomHash appears to have empirically achieved it's GPU and ASIC resistivity goals, it's computationally-heavy nature has resulted in an unforeseen consequence of slow blockchain validation.
+
+First of all, RandomHash introduces the concept of nonce-dependency between nonces. This means to evaluate a nonce, the partial evaluation of other random neighboring nonces is required. This allows RandomHash to operate in two modes, validation mode and mining mode. 
+
+In validation mode, RandomHash is simply used to hash a block-header in order to verify it's the correct block in the blockchain -- just the same as how SHA2-256D does in Bitcoin.
+
+In mining mode, RandomHash is used to mine the next block by enumerating many nonces to to find an acceptable Proof-of-Work for the next block. In this mode, RandomHash exploits the partial calculations from previous rounds by resuming them in subsequent hashing rounds. In RandomHash, this mode operates at twice the hashrate as validation mode, and is the basis for the "CPU Bias" and important to achieve GPU resistivity. It is biased towards CPU's since re-using the partially calculated nonces is a serial optimization that cannot be efficiently exploited in a parallelized, batch-computation context (such as GPU mining). In other words, the optimal nonce-set is enumerated on-the-fly and cannot be pre-determined into a range for parallel mining as GPU mining does.
+
+However, on a typical 2019 desktop computer, the validation hashrate of RandomHash is approximately 20 hashes per second. At 288 blocks per day, that's 14 seconds to validate a days worth of blocks and over 1 hour to validate 1 year of blocks. Whilst multi-threading, performance tuning and other optimizations have massively optimize this performance oversight, it remains a fundamental a long-term issue that needs to be resolved.
+
+RandomHash2 offers order of magnitude improvement in both validation hashrate and mining hashrate. In RandomHash2, the same machine validates at ~300 hashes per second yet mines at ~1,000 hashes per second with far less memory-hardness. Whilst not empirically tested, these numbers suggest a 333% CPU bias.
+
+#### RandomHash vs RandomHash2 Measured Performance
+
+| Algorithm                  | Mean Hashrate (H/s)       | Mean Mem Per Hash (b) | Min Mem Per Hash (b) | Max Mem Per Hash (b) | Sample Std Dev. (b) |
+| :------------------------- | :------------------------ | :-------------------- | :------------------- | :------------------- | :------------------ |
+| RandomHash (validation)    | 23                        | 5,018,876             | 5,018,628            | 5,019,116            | 83.86               |
+| RandomHash (mining)        | 44                        | 7,528,288             | 7,527,872            | 7,528,732            | 136                 |
+| RandomHash2 (validation)   | 309                       | 16,719                | 1,380                | 221,536              | 29,420              |
+| **RandomHash2 (mining)**   | 1,051                     | 16,693                | 1,312                | 251,104              | 29,374              |
+
+_**Machine**: AMD FX-8150 8 Core 3.60 Ghz utilizing 1 thread_
+
+**NOTE:**
+- RandomHash2 (validation) is the mode used to validate blocks during load and sync.
+- **RandomHash2 (mining)** is the mode the mining network will use on V5 activation.
+
+## Specification
+
+RandomHash2 is similarly structured to RandomHash, but has some key differences. The below overview outlines the full algorithm. 
+
+### Overview
+
+1. Hashing a nonce requires ```N``` iterations (called levels), which are evaluated recursively;
+2. ```N``` varies per nonce in a non-deterministic manner between ```MIN_N=2``` and ```MAX_N=4```, inclusive;
+3. Each level in (1) also depends on ```J``` neighboring nonces, determined randomly and non-deterministically;
+4. The value ```J``` is restricted to ```MIN_J=2``` and ```MAX_J=4```;
+5. Each round selects a random hash function from a set of 18 well-known hash algorithms;
+6. The input digest hashed at level ```x``` is a compression of the transitive closure of the hash outputs of the it's prior-levels (1) and it's neighbouring nonce's prior-levels (3);
+7. The output of every level is expanded for (low) memory-hardness;
+8. Randomness is generated using ```Mersenne Twister``` algorithm;
+9. Randomness is always seeded using last DWORD of a cryptographic hash algorithm output;
+10. The first input is pre-hashed as using ```SHA2-256```;
+11. The last output is post-hashed using ```SHA2-256```;
+
+### Differences to RandomHash 1
+
+The primary differences to predecessor are:
+
+** Constants
+```pascal
+    MIN_N = 2;
+    MAX_N = 4;
+    MIN_J = 0;
+    MAX_J = 8;
+    M = 256;
+```
+
+**N is now random per nonce**
+```pascal
+  Result := (ARound = MAX_N) OR ((ARound >= MIN_N) AND (GetLastDWordLE(LOutput) MOD MAX_N = 0));       
+```
+
+**Block Header is pre-hashed before used (last DWORD is seed)**
+```pascal
+  if ARound = 1 then begin
+    LRoundInput := FHashAlg[0].ComputeBytes(ABlockHeader).GetBytes;
+    LSeed := GetLastDWordLE( LRoundInput );
+    LGen.Initialize(LSeed);   
+```
+
+**Random number of dependent neighbour nonces**
+```pascal
+    LNumNeighbours := (LGen.NextUInt32 MOD (MAX_J - MIN_J)) + MIN_J;
+    for i := 1 to LNumNeighbours do begin
+```
+ 
+**Neighbouring nonces are only cached when fully evaluated**
+```pascal
+LNeighbourNonceHeader := SetLastDWordLE(ABlockHeader, LGen.NextUInt32); // change nonce
+LNeighbourWasLastRound := CalculateRoundOutputs(LNeighbourNonceHeader, ARound - 1, LNeighborOutputs);
+LRoundOutputs.AddRange(LNeighborOutputs);     
+
+if LNeighbourWasLastRound then begin
+    LCachedHash.Nonce := GetLastDWordLE(LNeighbourNonceHeader);
+    LCachedHash.Header := LNeighbourNonceHeader;
+    LCachedHash.Hash := ComputeVeneerRound(LNeighborOutputs);
+    // if header is different (other than nonce), clear cache
+    if NOT BytesEqual(FCachedHeaderTemplate, LCachedHash.Header, 0, 32 - 4) then begin
+        FCachedHashes.Clear;
+        FCachedHeaderTemplate := SetLastDWordLE(LCachedHash.Header, 0);
+    end;
+    FCachedHashes.Add(LCachedHash);
+end; 
+```
+
+### Full Code 
+ 
+```pascal
+
+  TRandomHash2 = class sealed(TObject)
+    const
+      MIN_N = 2; // Min-number of hashing rounds required to compute a nonce, min total rounds = J^MIN_N
+      MAX_N = 4; // Max-number of hashing rounds required to compute a nonce, max total rounds = J^MAX_N
+      MIN_J = 0; // Min-number of dependent neighbouring nonces required to evaluate a nonce round
+      MAX_J = 8; // Max-number of dependent neighbouring nonces required to evaluate a nonce round
+      M = 256;    // The memory expansion unit (in bytes), max total bytes per nonce = M * ((MAX_J+1)^MAX_N (MAX_N-2) + 2)
+      NUM_HASH_ALGO = 18;
+
+      public type
+
+        TCachedHash = record
+          Nonce : UInt32;
+          Header : TBytes;
+          Hash : TBytes;
+        end;
+
+    private
+      FMurmurHash3_x86_32 : IHash;
+      FHashAlg : array[0..17] of IHash;  // declared here to avoid race-condition during mining
+      FCachedHeaderTemplate : TBytes;
+      FCachedHashes : TList<TCachedHash>;
+
+      function GetCachedHashes : TArray<TCachedHash>; inline;
+      function ContencateByteArrays(const AChunk1, AChunk2: TBytes): TBytes; inline;
+      function MemTransform1(const AChunk: TBytes): TBytes; inline;
+      function MemTransform2(const AChunk: TBytes): TBytes; inline;
+      function MemTransform3(const AChunk: TBytes): TBytes; inline;
+      function MemTransform4(const AChunk: TBytes): TBytes; inline;
+      function MemTransform5(const AChunk: TBytes): TBytes; inline;
+      function MemTransform6(const AChunk: TBytes): TBytes; inline;
+      function MemTransform7(const AChunk: TBytes): TBytes; inline;
+      function MemTransform8(const AChunk: TBytes): TBytes; inline;
+      function Expand(const AInput: TBytes; AExpansionFactor: Int32; ASeed : UInt32) : TBytes;
+      function Compress(const AInputs: TArray<TBytes>; ASeed : UInt32): TBytes; inline;
+      function SetLastDWordLE(const ABytes: TBytes; AValue: UInt32): TBytes; inline;
+      function GetLastDWordLE(const ABytes: TBytes) : UInt32; inline;
+      function ComputeVeneerRound(const ARoundOutputs : TArray<TBytes>) : TBytes; inline;
+      function CalculateRoundOutputs(const ABlockHeader: TBytes; ARound: Int32; out ARoundOutputs : TArray<TBytes>) : Boolean; overload;
+    public
+      constructor Create;
+      destructor Destroy; override;
+      property CachedHashes : TArray<TCachedHash> read GetCachedHashes;
+      function HasCachedHash : Boolean; inline;
+      function PopCachedHash : TCachedHash; inline;
+      function PeekCachedHash : TCachedHash; inline;
+      function TryHash(const ABlockHeader: TBytes; AMaxRound : UInt32; out AHash : TBytes) : Boolean;
+      function Hash(const ABlockHeader: TBytes): TBytes; overload; inline;
+      class function Compute(const ABlockHeader: TBytes): TBytes; overload; static; inline;
+  end;
+
+ { ERandomHash2 }
+
+  ERandomHash2 = class(Exception);
+
+resourcestring
+  SUnSupportedHash = 'Unsupported Hash Selected';
+  SInvalidRound = 'Round must be between 0 and N inclusive';
+  SOverlappingArgs = 'Overlapping read/write regions';
+  SBufferTooSmall = 'Buffer too small to apply memory transform';
+  SBlockHeaderTooSmallForNonce = 'Buffer too small to contain nonce';
+
+implementation
+
+uses UMemory, URandomHash;
+
+{ TRandomHash2 }
+
+constructor TRandomHash2.Create;
+begin
+  FMurmurHash3_x86_32 := THashFactory.THash32.CreateMurmurHash3_x86_32();
+  SetLength(Self.FCachedHeaderTemplate, 0);
+  FCachedHashes := TList<TCachedHash>.Create;
+  FHashAlg[0] := THashFactory.TCrypto.CreateSHA2_256();
+  FHashAlg[1] := THashFactory.TCrypto.CreateSHA2_384();
+  FHashAlg[2] := THashFactory.TCrypto.CreateSHA2_512();
+  FHashAlg[3] := THashFactory.TCrypto.CreateSHA3_256();
+  FHashAlg[4] := THashFactory.TCrypto.CreateSHA3_384();
+  FHashAlg[5] := THashFactory.TCrypto.CreateSHA3_512();
+  FHashAlg[6] := THashFactory.TCrypto.CreateRIPEMD160();
+  FHashAlg[7] := THashFactory.TCrypto.CreateRIPEMD256();
+  FHashAlg[8] := THashFactory.TCrypto.CreateRIPEMD320();
+  FHashAlg[9] := THashFactory.TCrypto.CreateBlake2B_512();
+  FHashAlg[10] := THashFactory.TCrypto.CreateBlake2S_256();
+  FHashAlg[11] := THashFactory.TCrypto.CreateTiger2_5_192();
+  FHashAlg[12] := THashFactory.TCrypto.CreateSnefru_8_256();
+  FHashAlg[13] := THashFactory.TCrypto.CreateGrindahl512();
+  FHashAlg[14] := THashFactory.TCrypto.CreateHaval_5_256();
+  FHashAlg[15] := THashFactory.TCrypto.CreateMD5();
+  FHashAlg[16] := THashFactory.TCrypto.CreateRadioGatun32();
+  FHashAlg[17] := THashFactory.TCrypto.CreateWhirlPool();
+end;
+
+destructor TRandomHash2.Destroy;
+var i : integer;
+begin
+ FCachedHashes.Clear;
+ FreeAndNil(FCachedHashes);
+ FMurmurHash3_x86_32 := nil;
+ for i := Low(FHashAlg) to High(FHashAlg) do
+   FHashAlg[i] := nil;
+ inherited Destroy;
+end;
+
+class function TRandomHash2.Compute(const ABlockHeader: TBytes): TBytes;
+var
+  LHasher : TRandomHash2;
+  LDisposables : TDisposables;
+begin
+ LHasher := LDisposables.AddObject( TRandomHash2.Create ) as TRandomHash2;
+ Result := LHasher.Hash(ABlockHeader);
+end;
+
+function TRandomHash2.TryHash(const ABlockHeader: TBytes; AMaxRound : UInt32; out AHash : TBytes) : Boolean;
+var
+  LOutputs: TArray<TBytes>;
+  LSeed: UInt32;
+begin
+  if NOT CalculateRoundOutputs(ABlockHeader, AMaxRound, LOutputs) then
+    Exit(False);
+  AHash := ComputeVeneerRound(LOutputs);
+  Result := True;
+end;
+
+function TRandomHash2.Hash(const ABlockHeader: TBytes): TBytes;
+begin
+  if NOT TryHash(ABlockHeader, MAX_N, Result) then
+    raise ERandomHash2.Create('Internal Error: 984F52997131417E8D63C43BD686F5B2'); // Should have found final round!
+end;
+
+function TRandomHash2.ComputeVeneerRound(const ARoundOutputs : TArray<TBytes>) : TBytes;
+var
+  LSeed : UInt32;
+begin
+  LSeed := GetLastDWordLE(ARoundOutputs[High(ARoundOutputs)]);
+  // Final "veneer" round of RandomHash is a SHA2-256 of compression of prior round outputs
+  Result := FHashAlg[0].ComputeBytes(Compress(ARoundOutputs, LSeed)).GetBytes;
+end;
+
+function TRandomHash2.CalculateRoundOutputs(const ABlockHeader: TBytes; ARound: Int32; out ARoundOutputs : TArray<TBytes>) : Boolean;
+var
+  LRoundOutputs: TList<TBytes>;
+  LNeighbourWasLastRound : Boolean;
+  LSeed, LNumNeighbours: UInt32;
+  LGen: TMersenne32;
+  LRoundInput, LNeighbourNonceHeader, LOutput : TBytes;
+  LCachedHash : TCachedHash;
+  LParentOutputs, LNeighborOutputs, LToArray, LBuffs2: TArray<TBytes>;
+  LHashFunc: IHash;
+  i: Int32;
+  LDisposables : TDisposables;
+  LBuff : TBytes;
+begin
+  if (ARound < 1) or (ARound > MAX_N) then
+    raise EArgumentOutOfRangeException.CreateRes(@SInvalidRound);
+
+  LRoundOutputs := LDisposables.AddObject( TList<TBytes>.Create() ) as TList<TBytes>;
+  LGen := LDisposables.AddObject( TMersenne32.Create(0) ) as TMersenne32;
+  if ARound = 1 then begin
+    LRoundInput := FHashAlg[0].ComputeBytes(ABlockHeader).GetBytes;
+    LSeed := GetLastDWordLE( LRoundInput );
+    LGen.Initialize(LSeed);
+  end else begin
+    if CalculateRoundOutputs(ABlockHeader, ARound - 1, LParentOutputs) = True then begin
+      // Previous round was the final round, so just return it's value
+      ARoundOutputs := LParentOutputs;
+      Exit(True);
+    end;
+
+    // Add parent round outputs to this round outputs
+    LSeed := GetLastDWordLE( LParentOutputs[High(LParentOutputs)] );
+    LGen.Initialize(LSeed);
+    LRoundOutputs.AddRange( LParentOutputs );
+
+    // Add neighbouring nonce outputs to this round outputs
+    LNumNeighbours := (LGen.NextUInt32 MOD (MAX_J - MIN_J)) + MIN_J;
+    for i := 1 to LNumNeighbours do begin
+      LNeighbourNonceHeader := SetLastDWordLE(ABlockHeader, LGen.NextUInt32); // change nonce
+      LNeighbourWasLastRound := CalculateRoundOutputs(LNeighbourNonceHeader, ARound - 1, LNeighborOutputs);
+      LRoundOutputs.AddRange(LNeighborOutputs);
+
+      // If neighbour was a fully evaluated nonce, cache it for re-use
+      if LNeighbourWasLastRound then begin
+        LCachedHash.Nonce := GetLastDWordLE(LNeighbourNonceHeader);
+        LCachedHash.Header := LNeighbourNonceHeader;
+        LCachedHash.Hash := ComputeVeneerRound(LNeighborOutputs);
+        // if header is different (other than nonce), clear cache
+        if NOT BytesEqual(FCachedHeaderTemplate, LCachedHash.Header, 0, 32 - 4) then begin
+          FCachedHashes.Clear;
+          FCachedHeaderTemplate := SetLastDWordLE(LCachedHash.Header, 0);
+        end;
+        FCachedHashes.Add(LCachedHash);
+      end;
+    end;
+    // Compress the parent/neighbouring outputs to form this rounds input
+    LRoundInput := Compress( LRoundOutputs.ToArray, LGen.NextUInt32 );
+  end;
+
+  // Select a random hash function and hash the input to find the output
+  LHashFunc := FHashAlg[LGen.NextUInt32 mod NUM_HASH_ALGO];
+  LOutput := LHashFunc.ComputeBytes(LRoundInput).GetBytes;
+
+  // Memory-expand the output, add to output list and return output list
+  LOutput := Expand(LOutput, MAX_N - ARound, LGen.NextUInt32);
+  LRoundOutputs.Add(LOutput);
+  ARoundOutputs := LRoundOutputs.ToArray;
+
+  // Determine if final round
+  Result := (ARound = MAX_N) OR ((ARound >= MIN_N) AND (GetLastDWordLE(LOutput) MOD MAX_N = 0));
+end;
+
+function TRandomHash2.SetLastDWordLE(const ABytes: TBytes; AValue: UInt32): TBytes;
+var
+  ABytesLength : Integer;
+begin
+  // Clone the original header
+  Result := Copy(ABytes);
+
+  // If digest not big enough to contain a nonce, just return the clone
+  ABytesLength := Length(ABytes);
+  if ABytesLength < 4 then
+    exit;
+
+  // Overwrite the nonce in little-endian
+  Result[ABytesLength - 4] := Byte(AValue);
+  Result[ABytesLength - 3] := (AValue SHR 8) AND 255;
+  Result[ABytesLength - 2] := (AValue SHR 16) AND 255;
+  Result[ABytesLength - 1] := (AValue SHR 24) AND 255;
+end;
+
+function TRandomHash2.GetLastDWordLE(const ABytes: TBytes) : UInt32;
+var LLen : Integer;
+begin
+  LLen := Length(ABytes);
+  if LLen < 4 then
+   raise EArgumentOutOfRangeException.CreateRes(@SBlockHeaderTooSmallForNonce);
+
+  // Last 4 bytes are nonce (LE)
+  Result := ABytes[LLen - 4] OR
+           (ABytes[LLen - 3] SHL 8) OR
+           (ABytes[LLen - 2] SHL 16) OR
+           (ABytes[LLen - 1] SHL 24);
+end;
+
+function TRandomHash2.Compress(const AInputs : TArray<TBytes>; ASeed : UInt32): TBytes;
+var
+  i: Int32;
+  LSource: TBytes;
+  LGen: TMersenne32;
+  LDisposables : TDisposables;
+begin
+  SetLength(Result, 100);
+  LGen := LDisposables.AddObject( TMersenne32.Create( ASeed ) ) as TMersenne32;
+  for i := 0 to 99 do
+  begin
+    LSource := AInputs[LGen.NextUInt32 mod Length(AInputs)];
+    Result[i] := LSource[LGen.NextUInt32 mod Length(LSource)];
+  end;
+end;
+
+function TRandomHash2.GetCachedHashes : TArray<TCachedHash>;
+begin
+  Result := FCachedHashes.ToArray;
+end;
+
+function TRandomHash2.HasCachedHash : Boolean;
+begin
+  Result := FCachedHashes.Count > 0;
+end;
+
+function TRandomHash2.PopCachedHash : TCachedHash;
+begin
+  Result := FCachedHashes.Last;
+  FCachedHashes.Delete(FCachedHashes.Count - 1);
+end;
+
+function TRandomHash2.PeekCachedHash : TCachedHash;
+begin
+  Result := FCachedHashes.Last;
+end;
+
+function TRandomHash2.ContencateByteArrays(const AChunk1, AChunk2: TBytes): TBytes;
+begin
+  SetLength(Result, Length(AChunk1) + Length(AChunk2));
+  Move(AChunk1[0], Result[0], Length(AChunk1));
+  Move(AChunk2[0], Result[Length(AChunk1)], Length(AChunk2));
+end;
+
+function TRandomHash2.MemTransform1(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength : UInt32;
+  LState : UInt32;
+begin
+  // Seed XorShift32 with last byte
+  LState := GetLastDWordLE(AChunk);
+  if LState = 0 then
+    LState := 1;
+
+  // Select random bytes from input using XorShift32 RNG
+  LChunkLength := Length(AChunk);
+  SetLength(Result, LChunkLength);
+  for i := 0 to High(AChunk) do
+    Result[i] := AChunk[TXorShift32.Next(LState) MOD LChunkLength];
+end;
+
+function TRandomHash2.MemTransform2(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength, LPivot, LOdd: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  LPivot := LChunkLength SHR 1;
+  LOdd := LChunkLength MOD 2;
+  SetLength(Result, LChunkLength);
+  Move(AChunk[LPivot + LOdd], Result[0], LPivot);
+  Move(AChunk[0], Result[LPivot + LOdd], LPivot);
+  // Set middle-byte for odd-length arrays
+  if LOdd = 1 then
+    Result[LPivot] := AChunk[LPivot];
+end;
+
+function TRandomHash2.MemTransform3(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  SetLength(Result, LChunkLength);
+  for i := 0 to High(AChunk) do
+    Result[i] := AChunk[LChunkLength - i - 1];
+end;
+
+function TRandomHash2.MemTransform4(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength, LPivot, LOdd: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  LPivot := LChunkLength SHR 1;
+  LOdd := LChunkLength MOD 2;
+  SetLength(Result, LChunkLength);
+  for i := 0 to Pred(LPivot) do
+  begin
+    Result[(i * 2)] := AChunk[i];
+    Result[(i * 2) + 1] := AChunk[i + LPivot + LOdd];
+  end;
+  // Set final byte for odd-lengths
+  if LOdd = 1 THEN
+    Result[High(Result)] := AChunk[LPivot];
+end;
+
+function TRandomHash2.MemTransform5(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength, LPivot, LOdd: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  LPivot := LChunkLength SHR 1;
+  LOdd := LChunkLength MOD 2;
+  SetLength(Result, LChunkLength);
+  for i := Low(AChunk) to Pred(LPivot) do
+  begin
+    Result[(i * 2)] := AChunk[i + LPivot + LOdd];
+    Result[(i * 2) + 1] := AChunk[i];
+  end;
+  // Set final byte for odd-lengths
+  if LOdd = 1 THEN
+    Result[High(Result)] := AChunk[LPivot];
+end;
+
+function TRandomHash2.MemTransform6(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength, LPivot, LOdd: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  LPivot := LChunkLength SHR 1;
+  LOdd := LChunkLength MOD 2;
+  SetLength(Result, LChunkLength);
+  for i := 0 to Pred(LPivot) do
+  begin
+    Result[i] := AChunk[(i * 2)] xor AChunk[(i * 2) + 1];
+    Result[i + LPivot + LOdd] := AChunk[i] xor AChunk[LChunkLength - i - 1];
+  end;
+  // Set middle-byte for odd-lengths
+  if LOdd = 1 THEN
+    Result[LPivot] := AChunk[High(AChunk)];
+end;
+
+function TRandomHash2.MemTransform7(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  SetLength(Result, LChunkLength);
+  for i := 0 to High(AChunk) do
+    Result[i] := TBits.RotateLeft8(AChunk[i], LChunkLength - i);
+end;
+
+function TRandomHash2.MemTransform8(const AChunk: TBytes): TBytes;
+var
+  i, LChunkLength: Int32;
+begin
+  LChunkLength := Length(AChunk);
+  SetLength(Result, LChunkLength);
+  for i := 0 to High(AChunk) do
+    Result[i] := TBits.RotateRight8(AChunk[i], LChunkLength - i);
+end;
+
+function TRandomHash2.Expand(const AInput: TBytes; AExpansionFactor: Int32; ASeed : UInt32): TBytes;
+var
+  LSize, LBytesToAdd: Int32;
+  LOutput, LNextChunk: TBytes;
+  LRandom: UInt32;
+  LGen: TMersenne32;
+  LDisposables : TDisposables;
+begin
+  LGen := LDisposables.AddObject( TMersenne32.Create (ASeed) ) as TMersenne32;
+  LSize := Length(AInput) + (AExpansionFactor * M);
+  LOutput := Copy(AInput);
+  LBytesToAdd := LSize - Length(AInput);
+
+  while LBytesToAdd > 0 do
+  begin
+    LNextChunk := Copy(LOutput);
+    if Length(LNextChunk) > LBytesToAdd then
+      SetLength(LNextChunk, LBytesToAdd);
+
+    LRandom := LGen.NextUInt32;
+    case LRandom mod 8 of
+      0: LOutput := ContencateByteArrays(LOutput, MemTransform1(LNextChunk));
+      1: LOutput := ContencateByteArrays(LOutput, MemTransform2(LNextChunk));
+      2: LOutput := ContencateByteArrays(LOutput, MemTransform3(LNextChunk));
+      3: LOutput := ContencateByteArrays(LOutput, MemTransform4(LNextChunk));
+      4: LOutput := ContencateByteArrays(LOutput, MemTransform5(LNextChunk));
+      5: LOutput := ContencateByteArrays(LOutput, MemTransform6(LNextChunk));
+      6: LOutput := ContencateByteArrays(LOutput, MemTransform7(LNextChunk));
+      7: LOutput := ContencateByteArrays(LOutput, MemTransform8(LNextChunk));
+    end;
+    LBytesToAdd := LBytesToAdd - Length(LNextChunk);
+  end;
+  Result := LOutput;
+end;
+
+end. 
+
+```
+
+### Analysis
+ 
+#### Cryptographic Strength
+
+Since hashing starts and ends with a ```SHA2-256``` the cryptographic strength of RandomHash2 is **at least** that of ```SHA2-256D``` as used in Bitcoin. Even if one were to assume the data transformations in between the start/end were cryptographically insecure, it wouldn't change this minimum security guarantee.
+
+However, the transformations in between are not weak and involve the use of 18 other cryptographically strong hash algorithms. As a result, RandomHash2 is orders of magnitude more stronger than standard cryptographic hash algorithms since they are combined in random, non-determinstic ways. However this achievement is paid for by significant performance overhead (which is intentional).
+
+However, within the 18 hash algorithms used, some are considered "cryptographically weak" such as MD5. The use of some weak algorithms is inconsequential to overall security since their purpose is not to add to security but to computational complexity to prevent ASIC manufacturing.
+
+In order to get a grasp of the minmum security provided by RandomHash2, consider it's high-level algorithmic structure as essentially a set of nested hashes as follows:
+```
+RandomHash2(Data) = SHA2_256( H1( H2( .... H_N( SHA2_256(DATA)) ...) )
+where
+   H_i = a randomly selected hash function based on the output of H_(i-1)   
+   N = a random number determined by the nonce and neighbouring nonces (indeterminable but bound)
+```
+
+It follows that the weakest possible RandomHash2 for some ```WeakestDigest``` would comprise of 2 levels of evaluation (``MIN_N=2```) with each of those 2 levels having 0 nieghbouring nonce dependencies (```MIN_J```). Also, we assume the hash algorithms are ```MD5``` for all levels, as it is considered weakest of the 18 possible algorithms. In this case, 
+```
+RandomHash2(WeakestDigest) = SHA2_256( MD5 ( MD5 ( SHA2_256( WeakestDigest ) ) ) )
+```
+
+Clearly the above is still far stronger than the typical SHA2-256D used in almost all cryptocurrencies
+```pascal
+SHA2-256D(WeakestDigest) = SHA2-256 ( SHA2-256 ( WeakestDigest ) )
+```
+
+
+In addition to the above, RandomHash2 internally transforms data using expansions and compressions which are themselves cryptographically secure. As a result, it's clear that RandomHash2's cryptographic strength is at least as strong as Bitcoin's ```SHA2-256D``` with likelihood of being orders of magnitude stronger.
+
+### Nonce Scanning Attack
+
+In RandomHash2, the number of levels ```N``` required to mine a nonce is now random and varies per nonce in a non-deterministic manner. The randomization of ```N``` introduces new level of randomness and executive decision-making into the core algorithm in order to enhance GPU and ASIC resistivity. However, it introduces a new attack vector called "Nonce Scanning Attack". In this attack, a miner can implement a simplified miner that only tries to mine "simple nonces" that require few levels to evaluate whilst rejecting "complex nonces" that require more levels to evaluate. By reducing the number of computations required to evaluate a nonce and simplifying the algorithm implementation, a higher hashrate could be achieved and an ASIC implementation made viable.
+
+To thwart this attack, RandomHash2 restricts the range of values ```N``` can take to be between ```MIN_N = 2``` and ```MAX_N = 4```, inclusive.
+
+By forcing a nonce evaluation to have at least 2 levels of computation, the miner necessarily requires the full algorithm implementation which prevents simplified ASIC miners. Also, since each nonce requires at least 2 levels of evaluation, and each of those levels depends on at least 2 more nonces evaluated to at least 1 level each, the number of computations saved by nonce-scanning is balanced by the higher pre-computed cached nonces a miner has by honestly mining without nonce-scanning (due to higher number of dependent neighboring nonces).
+
+In order to determine if this is true, an empirical nonce-scanning attack was conducted. The below table shows empirical results from nonce-scanning ```N=MIN_N``` to ```N=MAX_N```.
+
+| N       | Mean Hashrate (H/s)       | Mean Mem Per Hash (b) | Min Mem Per Hash (b) | Max Mem Per Hash (b) | Sample Std Dev. (b) |
+| :------ | :------------------------ | :-------------------- | :------------------- | :------------------- | :------------------ |
+| 2 (min) | 240                       | 4,175                 | 1,312                | 7,184                | 1,854               |
+| 3       | 651                       | 5,984                 | 1,312                | 49,436               | 6,293               |
+| 4 (max) | 1,051                     | 16,693                | 1,312                | 251,104              | 29,374              |
+
+_**Machine**: AMD FX-8150 8 Core 3.60 Ghz utilizing 1 thread_
+
+As the above table shows, nonce-scanning (via CPU) yields a hashrate penalty, not a benefit. In the opinion of the author, it is unlikely a future implementation optimization would necessarily change this result since it would improve all scanning levels proportionally. However, a line of inquiry is to investigate whether or not the reduced memory-hardness may yield a benefit for GPU-based nonce-scanning.
+ 
+#### CPU Bias
+
+The RandomHash2 algorithm, like it's predecessor, is inherently biased towards CPU mining due to it's highly serial nature, use of non-deterministic recursion and executive-decision making. In addition, RandomHash2 can now evaluate many nonces when evaluating one, allowing CPU miners to enumerate the optimal nonce-set on the fly. Testing shows a 300% - 400% advantage for serial mining over batch mining, which indicates a proportional CPU bias.
+
+#### Memory Complexity
+
+RandomHash is memory-light in order to support low-end hardware.  A CPU will only need 300KB of memory to verify a hash. Unlike RandomHash, mining does not consume additional memory since the cached nonces are fully evaluated.
+
+#### GPU Resistance 
+
+GPU performance is generally driven by parallel execution of identical non-branching code-blocks across private regions of memory. RandomHash2 is a highly serial and recursive algorithm requiring a lot of executive-decision making, and decisions driven by Mersenne Twister random number generator. These characteristics make GPU implementations quite tedious and inefficient. Since the predecessor algorithm was shown to be GPU resistant, and this algorithm only exarcerbates these characteristics (except for memory hardness), it is expected that GPU resistance is maintained, although not confirmed as of the writing of this PIP.
+
+#### ASIC Resistance 
+
+ASIC-resistance is fundamentally achieved on an economic basis. Due to the use of 18 sub-hash algorithms and the use of recursion in the core algorithm, it is expected that the R&D costs of a RandomHash ASIC will mirror that of building 18 independent ASICs rather than 1. This moves the economic viability goal-posts away by an order of magnitude. For as long as the costs of general ASIC development remain in relative parity to the costs of consumer grade CPUs as of today, a RandomHash ASIC will always remain "not worth it" for a "rational economic actor".
+
+Furthermore, RandomHash offers a wide ASIC-breaking attack surface. This is due to it's branch-heavy, serial, recursive nature and heavy dependence on sub-algorithms. By making minor tweaks to the high-level algorithm, or changing a sub-algorithm, an ASIC design can be mostly invalidated and sent back the drawing board with minimal updates to the CPU miner.
+
+This is true since ASIC designs tend to mirror the assembly structure of an algorithm rather than the high-level algorithm itself. Thus by making relatively minor tweaks at the high-level that necessarily result in significant low-level assembly restructuring, an ASIC design is made obsolete. So long as this "tweak-to-break-ASIC" policy is maintained by the PascalCoin Developers and Community, ASIC resistance is guaranteed.
+
+### Hard-Fork Activation
+
+The PIP requires a hard-fork activation involving various aspects discussed below.
+
+## Rationale
+
+Aside from a hash algorithm change, the only other known option to resolve slow validation time is to ship the client with precomputed lookup tables to speed up verification. This has already been done for RandomHash1 periods, but is not a viable option long-term.
+
+## Backwards Compatibility
+
+This PIP is not backwards compatible and requires a hard-fork activation. Previous hashing algorithm must be retained in order to validate blocks mined prior to the hard-fork.
+ 
+## Reference Implementation
+
+A reference implementation of RandomHash can be found [here][2].
+
+## Links
+
+1. [PIP-0009 RandomHash: GPU & ASIC Resistant Hash Algorithm][1]
+2. [RandomHash2 Reference Implementation][2]
+
+[1]: https://github.com/PascalCoin/PascalCoin/blob/master/PIP/PIP-0009.md
+[2]: https://github.com/PascalCoin/PascalCoin/blob/master/src/core/URandomHash2.pas

src/core/URandomHash.pas

@@ -103,7 +103,9 @@ unit URandomHash;
 
 interface
 
-uses {$IFNDEF FPC}System.Generics.Collections{$ELSE}Generics.Collections{$ENDIF}, SysUtils, HlpIHash, HlpBits, HlpHashFactory;
+uses {$IFNDEF FPC}System.Generics.Collections{$ELSE}Generics.Collections{$ENDIF},
+     SysUtils, HlpIHash, HlpBits, HlpHashFactory,
+     UCommon;
 
 type
 
@@ -159,6 +161,7 @@ type
         FComputedIndex : Integer;
         FChecksum : UInt32;
         FMurMur3 : IHash;
+
         function GetCount : Integer;
         function CalculateChecksum : UInt32;
       public
@@ -187,7 +190,9 @@ type
       FCachedHeader : TBytes;
       FCachedNonce : UInt32;
       FCachedOutput : TChecksummedByteCollection;
-
+      FMemStats : TStatistics;
+      FCaptureMemStats : Boolean;
+      FEnableCache : Boolean;
       procedure MemTransform1(var ABuffer: TBytes; AReadStart, AWriteStart, ALength : Integer); inline;
       procedure MemTransform2(var ABuffer: TBytes; AReadStart, AWriteStart, ALength : Integer); inline;
       procedure MemTransform3(var ABuffer: TBytes; AReadStart, AWriteStart, ALength : Integer); inline;
@@ -206,6 +211,9 @@ type
     public
       property NextHeader : TBytes read GetCachedHeader;
       property NextNonce : UInt32 read FCachedNonce;
+      property MemStats : TStatistics read FMemStats;
+      property CaptureMemStats : Boolean read FCaptureMemStats write FCaptureMemStats;
+      property EnableCache : Boolean read FEnableCache write FEnableCache;
       constructor Create;
       destructor Destroy; override;
       function Hash(const ABlockHeader: TBytes): TBytes; overload; inline;
@@ -263,7 +271,7 @@ resourcestring
 
 implementation
 
-uses UCommon, UMemory;
+uses UMemory;
 
 { Global Functions }
 
@@ -604,6 +612,9 @@ begin
   FHashAlg[15] := THashFactory.TCrypto.CreateMD5();
   FHashAlg[16] := THashFactory.TCrypto.CreateRadioGatun32();
   FHashAlg[17] := THashFactory.TCrypto.CreateWhirlPool();
+  FEnableCache := True;
+  FCaptureMemStats := False;
+  FMemStats.Reset;
 end;
 
 destructor TRandomHashFast.Destroy;
@@ -629,11 +640,20 @@ end;
 function TRandomHashFast.Hash(const ABlockHeader: TBytes): TBytes;
 var
   LAllOutputs: TChecksummedByteCollection;
-  LSeed, LTemp: UInt32;
+  LSeed, LTemp, LSize: UInt32;
+  i : Integer;
   LDisposables : TDisposables;
 begin
   LAllOutputs := LDisposables.AddObject( Hash(ABlockHeader, N) ) as TChecksummedByteCollection;
   Result := FHashAlg[0].ComputeBytes(Compress(LAllOutputs)).GetBytes;
+  LSize := 0;
+  for i := 0 to LAllOutputs.Count - 1 do
+    Inc(LSize, Length(LAllOutputs.Get(i)));
+
+  if Assigned(FCachedOutput) then
+    for i := 0 to FCachedOutput.Count - 1 do
+      Inc(LSize, Length(FCachedOutput.Get(i)));
+  FMemStats.AddDatum(LSize);
 end;
 
 function TRandomHashFast.Hash(const ABlockHeader: TBytes; ARound: Int32) : TChecksummedByteCollection;
@@ -678,7 +698,7 @@ begin
     LDisposables.AddObject(LNeighbourOutputs);
 
     // Cache neighbour nonce n-1 calculation if on final round (neighbour will be next nonce)
-    if (ARound = N) then begin
+    if FEnableCache AND (ARound = N) then begin
       FCachedNonce := LNeighbourNonce;
       FCachedHeader := LNeighbourNonceHeader;
       if Assigned(FCachedOutput) then

src/core/URandomHash2.pas

@@ -97,7 +97,7 @@
 
 interface
 
-uses {$IFNDEF FPC}System.Generics.Collections{$ELSE}Generics.Collections{$ENDIF}, SysUtils, HlpIHash, HlpBits, HlpHashFactory;
+uses {$IFNDEF FPC}System.Generics.Collections{$ELSE}Generics.Collections{$ENDIF}, UCommon, SysUtils, HlpIHash, HlpBits, HlpHashFactory;
 
 type
 
@@ -125,6 +125,7 @@ type
       FHashAlg : array[0..17] of IHash;  // declared here to avoid race-condition during mining
       FCachedHeaderTemplate : TBytes;
       FCachedHashes : TList<TCachedHash>;
+      FMemStats : TStatistics;
 
       function GetCachedHashes : TArray<TCachedHash>; inline;
       function ContencateByteArrays(const AChunk1, AChunk2: TBytes): TBytes; inline;
@@ -146,6 +147,7 @@ type
       constructor Create;
       destructor Destroy; override;
       property CachedHashes : TArray<TCachedHash> read GetCachedHashes;
+      property MemStats : TStatistics read FMemStats;
       function HasCachedHash : Boolean; inline;
       function PopCachedHash : TCachedHash; inline;
       function PeekCachedHash : TCachedHash; inline;
@@ -167,7 +169,7 @@ resourcestring
 
 implementation
 
-uses UCommon, UMemory, URandomHash;
+uses UMemory, URandomHash;
 
 { TRandomHash2 }
 
@@ -194,6 +196,7 @@ begin
   FHashAlg[15] := THashFactory.TCrypto.CreateMD5();
   FHashAlg[16] := THashFactory.TCrypto.CreateRadioGatun32();
   FHashAlg[17] := THashFactory.TCrypto.CreateWhirlPool();
+  FMemStats.Reset;
 end;
 
 destructor TRandomHash2.Destroy;
@@ -236,10 +239,22 @@ end;
 function TRandomHash2.ComputeVeneerRound(const ARoundOutputs : TArray<TBytes>) : TBytes;
 var
   LSeed : UInt32;
+  LSize : UInt32;
+  i : integer;
+  LCachedItem : TCachedHash;
 begin
   LSeed := GetLastDWordLE(ARoundOutputs[High(ARoundOutputs)]);
   // Final "veneer" round of RandomHash is a SHA2-256 of compression of prior round outputs
   Result := FHashAlg[0].ComputeBytes(Compress(ARoundOutputs, LSeed)).GetBytes;
+  // Tally memstats
+  LSize := 0;
+  for i := Low(ARoundOutputs) to High(ARoundOutputs) do
+    Inc(LSize, Length(ARoundOutputs[i]));
+  for i := 0 to FCachedHashes.Count - 1 do begin
+    LCachedItem := FCachedHashes.Items[i];
+    Inc(LSize, Length(LCachedItem.Hash) + Length(LCachedItem.Header) + 4);
+  end;
+  FMemStats.AddDatum(LSize);
 end;
 
 function TRandomHash2.CalculateRoundOutputs(const ABlockHeader: TBytes; ARound: Int32; out ARoundOutputs : TArray<TBytes>) : Boolean;
@@ -347,7 +362,6 @@ begin
            (ABytes[LLen - 1] SHL 24);
 end;
 
-
 function TRandomHash2.Compress(const AInputs : TArray<TBytes>; ASeed : UInt32): TBytes;
 var
   i: Int32;

src/gui-classic/UFRMDiagnosticTool.dfm

@@ -27,7 +27,7 @@ object FRMDiagnosticTool: TFRMDiagnosticTool
     OnClick = btnRHClick
   end
   object btnRH2: TButton
-    Left = 144
+    Left = 336
     Top = 8
     Width = 130
     Height = 25
@@ -43,17 +43,17 @@ object FRMDiagnosticTool: TFRMDiagnosticTool
     Anchors = [akLeft, akTop, akRight, akBottom]
     TabOrder = 2
   end
-  object btnRHC: TButton
-    Left = 280
+  object btnRH2C: TButton
+    Left = 472
     Top = 8
     Width = 186
     Height = 25
     Caption = 'Start Random Hash 2 (Cached)'
     TabOrder = 3
-    OnClick = btnRHCClick
+    OnClick = btnRH2CClick
   end
   object btnEntropy: TButton
-    Left = 8
+    Left = 327
     Top = 39
     Width = 130
     Height = 25
@@ -62,12 +62,29 @@ object FRMDiagnosticTool: TFRMDiagnosticTool
     OnClick = btnEntropyClick
   end
   object btnRH2NonceScan: TButton
-    Left = 472
-    Top = 8
+    Left = 8
+    Top = 39
     Width = 186
     Height = 25
     Caption = 'Start Random Hash 2 (Nonce Scan)'
     TabOrder = 5
     OnClick = btnRH2NonceScanClick
   end
+  object txtScanLevel: TEdit
+    Left = 200
+    Top = 39
+    Width = 121
+    Height = 21
+    TabOrder = 6
+    TextHint = 'Enter Scan Level (2-4)'
+  end
+  object btnRHC: TButton
+    Left = 144
+    Top = 8
+    Width = 177
+    Height = 25
+    Caption = 'Start Random Hash (Cached)'
+    TabOrder = 7
+    OnClick = btnRHCClick
+  end
 end

src/gui-classic/UFRMDiagnosticTool.lfm

@@ -1,64 +1,64 @@
 object FRMDiagnosticTool: TFRMDiagnosticTool
   Left = 0
-  Height = 486
+  Height = 648
   Top = 0
-  Width = 855
+  Width = 1140
   Caption = 'FRMDiagnosticTool'
-  ClientHeight = 522
-  ClientWidth = 765
+  ClientHeight = 648
+  ClientWidth = 1140
   Color = clBtnFace
-  DesignTimePPI = 144
+  DesignTimePPI = 192
   Font.Color = clWindowText
-  Font.Height = -17
+  Font.Height = -23
   Font.Name = 'Tahoma'
   OnCreate = FormCreate
   LCLVersion = '2.1.0.0'
   object btnRH: TButton
-    Left = 12
-    Height = 38
-    Top = 12
-    Width = 195
+    Left = 16
+    Height = 51
+    Top = 16
+    Width = 260
     Caption = 'Start Random Hash'
     Font.Color = clWindowText
-    Font.Height = -17
+    Font.Height = -23
     Font.Name = 'Tahoma'
     OnClick = btnRHClick
     ParentFont = False
     TabOrder = 0
   end
   object btnRH2: TButton
-    Left = 216
-    Height = 38
-    Top = 12
-    Width = 195
+    Left = 288
+    Height = 51
+    Top = 16
+    Width = 260
     Caption = 'Start Random Hash 2'
     Font.Color = clWindowText
-    Font.Height = -17
+    Font.Height = -23
     Font.Name = 'Tahoma'
     OnClick = btnRH2Click
     ParentFont = False
     TabOrder = 1
   end
   object txtLog: TMemo
-    Left = 12
-    Height = 236
-    Top = 58
-    Width = 591
+    Left = 16
+    Height = 153
+    Top = 77
+    Width = 503
     Anchors = [akTop, akLeft, akRight, akBottom]
     Font.Color = clWindowText
-    Font.Height = -17
+    Font.Height = -23
     Font.Name = 'Tahoma'
     ParentFont = False
     TabOrder = 2
   end
   object btnRHC: TButton
-    Left = 420
-    Height = 38
-    Top = 12
-    Width = 279
+    Left = 560
+    Height = 51
+    Top = 16
+    Width = 372
     Caption = 'Start Random Hash 2 (Cached)'
     Font.Color = clWindowText
-    Font.Height = -17
+    Font.Height = -23
     Font.Name = 'Tahoma'
     OnClick = btnRHCClick
     ParentFont = False

src/gui-classic/UFRMDiagnosticTool.pas

@@ -1,4 +1,4 @@
-unit UFRMDiagnosticTool;
+unit UFRMDiagnosticTool;
 
 interface
 
@@ -11,27 +11,34 @@ uses
   UCommon;
 
 type
+  TAlgorithmThread = class;
+
   TFRMDiagnosticTool = class(TForm)
     btnRH: TButton;
     btnRH2: TButton;
     txtLog: TMemo;
-    btnRHC: TButton;
+    btnRH2C: TButton;
     btnEntropy: TButton;
     btnRH2NonceScan: TButton;
+    txtScanLevel: TEdit;
+    btnRHC: TButton;
     procedure btnRH2Click(Sender: TObject);
     procedure btnRHClick(Sender: TObject);
     procedure FormCreate(Sender: TObject);
-    procedure btnRHCClick(Sender: TObject);
+    procedure btnRH2CClick(Sender: TObject);
     procedure btnEntropyClick(Sender: TObject);
     procedure btnRH2NonceScanClick(Sender: TObject);
+    procedure btnRHCClick(Sender: TObject);
   private
     { Private declarations }
     FDisposables : TDisposables;
-    FRHThread : TPCThread;
-    FRH2Thread : TPCThread;
-    FRH2CachedThread : TPCThread;
-    FRH2NonceScanThread : TPCThread;
+    FRHThread : TAlgorithmThread;
+    FRHCachedThread : TAlgorithmThread;
+    FRH2Thread : TAlgorithmThread;
+    FRH2CachedThread : TAlgorithmThread;
+    FRH2NonceScanThread : TAlgorithmThread;
     procedure OnReport(const ATitle : String; ATotalHashes : UInt32; const ATimeSpan : TTimeSpan);
+    procedure OnFinish(const ATitle : String; ATotalHashes : UInt32; const ATimeSpan : TTimeSpan; const AMemStats : TStatistics);
   public
     { Public declarations }
   end;
@@ -40,14 +47,20 @@ type
 
   TAlgorithmNotify  = procedure (const ATitle : String; ATotalHashes : UInt32; const ATimeSpan : TTimeSpan) of object;
 
-  { TAlgorithmThread}
+  { TAlgorithmFinishNotify }
+
+  TAlgorithmFinishNotify  = procedure (const ATitle : String; ATotalHashes : UInt32; const ATimeSpan : TTimeSpan; const AMemStats : TStatistics) of object;
+
+  { TAlgorithmThread }
 
   TAlgorithmThread = class(TPCThread)
     private
       FDisposables : TDisposables;
-      FNotifyHashCount : UInt32;
+      FNotifyHashes : UInt32;
       FNotifyDuration : TTimeSpan;
       FNotify : TAlgorithmNotify;
+      FNotifyFinish : TAlgorithmFinishNotify;
+      FExitLoop : Boolean;
       procedure ThreadSafeNotify;
     protected
       FTitle : String;
@@ -55,9 +68,12 @@ type
       procedure BCExecute; override;
       function RandomizeNonce(const AHeader : TBytes): TBytes;
       function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; virtual; abstract;
+      function GetMemStats : TStatistics; virtual; abstract;
     public
       property Notify : TAlgorithmNotify read FNotify write FNotify;
+      property NotifyFinish : TAlgorithmFinishNotify read FNotifyFinish write FNotifyFinish;
       constructor Create(const ATitle : String); virtual;
+      procedure Finish;
   end;
 
   { TRandomHashThread }
@@ -67,6 +83,19 @@ type
       FHasher : TRandomHashFast;
     protected
       function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; override;
+      function GetMemStats : TStatistics; override;
+    public
+      constructor Create; overload;
+  end;
+
+  { TRandomHashCachedThread }
+
+  TRandomHashCachedThread = class(TAlgorithmThread)
+    private
+      FHasher : TRandomHashFast;
+    protected
+      function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; override;
+      function GetMemStats : TStatistics; override;
     public
       constructor Create; overload;
   end;
@@ -78,6 +107,7 @@ type
       FHasher : TRandomHash2;
     protected
       function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; override;
+      function GetMemStats : TStatistics; override;
     public
       constructor Create; overload;
   end;
@@ -89,6 +119,7 @@ type
       FHasher : TRandomHash2;
     protected
       function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; override;
+      function GetMemStats : TStatistics; override;
     public
       constructor Create; overload;
   end;
@@ -98,9 +129,12 @@ type
   TRandomHash2NonceScan = class(TAlgorithmThread)
     private
       FHasher : TRandomHash2;
+      FLevel : Integer;
     protected
       function TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean; override;
+      function GetMemStats : TStatistics; override;
     public
+      property Level : Integer read FLevel write FLevel;
       constructor Create; overload;
   end;
 
@@ -116,36 +150,52 @@ constructor TAlgorithmThread.Create(const ATitle : String);
 begin
   Inherited Create(True);
   FTitle := ATitle;
+  FExitLoop := False;
   SetLength(FLastHash, 32);
 end;
 
+procedure TAlgorithmThread.Finish;
+begin
+  FExitLoop := True;
+end;
+
 procedure TAlgorithmThread.BCExecute;
 var
  LTC : TTickCount;
- LStartTime : TDateTime;
- LTotalHashes : UInt32;
+ LStartTime, LNotifyStartTime  : TDateTime;
+ LTotalHashes, LNotifyHashes : UInt32;
 begin
-  LTotalHashes := 0;
-  LStartTime := Now;
-  LTC := TPlatform.GetTickCount;
   while True do begin
-   if TryNextRound (RandomizeNonce(FLastHash), FLastHash) then
-     inc(LTotalHashes);
-   if TPlatform.GetElapsedMilliseconds(LTC)>2500 then begin
-     FNotifyDuration := TTimeSpan.Subtract(Now, LStartTime);
-     FNotifyHashCount := LTotalHashes;
-     Queue( ThreadSafeNotify );
-     LTotalHashes := 0;
-     LStartTime := Now;
-     LTC := TPlatform.GetTickCount;
-   end;
+    LTotalHashes := 0;
+    LNotifyHashes := 0;
+    LStartTime := Now;
+    LNotifyStartTime := LStartTime;
+    LTC := TPlatform.GetTickCount;
+    while Not FExitLoop do begin
+     if TryNextRound (RandomizeNonce(FLastHash), FLastHash) then begin
+       inc(LTotalHashes);
+       inc(LNotifyHashes);
+     end;
+     if TPlatform.GetElapsedMilliseconds(LTC)>2500 then begin
+       FNotifyHashes := LNotifyHashes;
+       FNotifyDuration := TTimeSpan.Subtract(Now, LNotifyStartTime);
+       LNotifyHashes := 0;
+       LNotifyStartTime := Now;
+       Queue( ThreadSafeNotify );
+       LTC := TPlatform.GetTickCount;
+     end;
+    end;
+    if Assigned(FNotifyFinish) then
+      FNotifyFinish(FTitle, LTotalHashes, TTimeSpan.Subtract(Now, LStartTime), GetMemStats );
+    FExitLoop := False;
+    Suspended := True;
   end;
 end;
 
 procedure TAlgorithmThread.ThreadSafeNotify;
 begin
   if Assigned(FNotify) then
-    FNotify(FTitle, FNotifyHashCount, FNotifyDuration);
+    FNotify(FTitle, FNotifyHashes, FNotifyDuration);
 end;
 
 function TAlgorithmThread.RandomizeNonce(const AHeader : TBytes): TBytes;
@@ -176,6 +226,7 @@ constructor TRandomHashThread.Create;
 begin
   Inherited Create('Random Hash');
   FHasher := TRandomHashFast.Create;
+  FHasher.EnableCache := False;
   FDisposables.AddObject(FHasher);
 end;
 
@@ -185,6 +236,34 @@ begin
    Result := True;
 end;
 
+function TRandomHashThread.GetMemStats : TStatistics;
+begin
+  Result := FHasher.MemStats;
+end;
+
+{ TRandomHashCachedThread }
+
+constructor TRandomHashCachedThread.Create;
+begin
+  Inherited Create('Random Hash (Cached)');
+  FHasher := TRandomHashFast.Create;
+  FDisposables.AddObject(FHasher);
+end;
+
+function TRandomHashCachedThread.TryNextRound(const AInput : TBytes; out AOutput : TBytes) : Boolean;
+begin
+  if Length(FHasher.NextHeader) > 0 then
+    AOutput := FHasher.Hash(FHasher.NextHeader)
+  else
+    AOutput := FHasher.Hash(AInput);
+  Result := True;
+end;
+
+function TRandomHashCachedThread.GetMemStats : TStatistics;
+begin
+  Result := FHasher.MemStats;
+end;
+
 { TRandomHash2Thread }
 
 constructor TRandomHash2Thread.Create;
@@ -200,6 +279,11 @@ begin
   Result := True;
 end;
 
+function TRandomHash2Thread.GetMemStats : TStatistics;
+begin
+  Result := FHasher.MemStats;
+end;
+
 { TRandomHash2CachedThread }
 
 constructor TRandomHash2CachedThread.Create;
@@ -218,6 +302,11 @@ begin
   Result := True;
 end;
 
+function TRandomHash2CachedThread.GetMemStats : TStatistics;
+begin
+  Result := FHasher.MemStats;
+end;
+
 { TRandomHash2NonceScan }
 
 constructor TRandomHash2NonceScan.Create;
@@ -232,11 +321,16 @@ begin
   if FHasher.HasCachedHash then begin
     AOutput := FHasher.PopCachedHash.Hash;
     Result := True;
-  end else if FHasher.TryHash(AInput, TRandomHash2.MIN_N, AOutput) then begin
+  end else if FHasher.TryHash(AInput, FLevel, AOutput) then begin
     Result := True;
   end else Result := False;
 end;
 
+function TRandomHash2NonceScan.GetMemStats : TStatistics;
+begin
+  Result := FHasher.MemStats;
+end;
+
 { TFRMDiagnosicTool }
 
 procedure TFRMDiagnosticTool.FormCreate(Sender: TObject);
@@ -244,6 +338,7 @@ begin
   FRH2CachedThread := TRandomHash2CachedThread.Create;
   FRH2Thread := TRandomHash2Thread.Create;
   FRHThread := TRandomHashThread.Create;
+  FRHCachedThread := TRandomHashCachedThread.Create;
   FRH2NonceScanThread := TRandomHash2NonceScan.Create;
   FDisposables.AddObject(FRHThread);
   FDisposables.AddObject(FRH2Thread);
@@ -251,9 +346,16 @@ begin
   FDisposables.AddObject(FRH2NonceScanThread);
 
   TAlgorithmThread(FRHThread).Notify := OnReport;
+  TAlgorithmThread(FRHCachedThread).Notify := OnReport;
   TAlgorithmThread(FRH2Thread).Notify := OnReport;
   TAlgorithmThread(FRH2CachedThread).Notify := OnReport;
   TAlgorithmThread(FRH2NonceScanThread).Notify := OnReport;
+
+  TAlgorithmThread(FRHThread).NotifyFinish := OnFinish;
+  TAlgorithmThread(FRHCachedThread).NotifyFinish := OnFinish;
+  TAlgorithmThread(FRH2Thread).NotifyFinish := OnFinish;
+  TAlgorithmThread(FRH2CachedThread).NotifyFinish := OnFinish;
+  TAlgorithmThread(FRH2NonceScanThread).NotifyFinish := OnFinish;
 end;
 
 procedure TFRMDiagnosticTool.btnRHClick(Sender: TObject);
@@ -262,11 +364,22 @@ begin
     FRHThread.Suspended := False;
     btnRH.Caption := 'Stop Random Hash';
   end else begin
-    FRHThread.Suspended := True;
+    FRHThread.Finish;
     btnRH.Caption := 'Start Random Hash';
   end;
 end;
 
+procedure TFRMDiagnosticTool.btnRHCClick(Sender: TObject);
+begin
+  if FRHCachedThread.Suspended then begin
+    FRHCachedThread.Suspended := False;
+    btnRHC.Caption := 'Stop Random Hash (Cached)';
+  end else begin
+    FRHCachedThread.Finish;
+    btnRHC.Caption := 'Start Random Hash (Cached)';
+  end;
+end;
+
 procedure TFRMDiagnosticTool.btnEntropyClick(Sender: TObject);
 
   procedure SetLastDWordLE(var ABytes: TBytes;  AValue: UInt32);
@@ -306,30 +419,36 @@ begin
     FRH2Thread.Suspended := False;
     btnRH2.Caption := 'Stop Random Hash 2';
   end else begin
-    FRH2Thread.Suspended := True;
+    FRH2Thread.Finish;
     btnRH2.Caption := 'Start Random Hash 2';
   end;
 end;
 
-procedure TFRMDiagnosticTool.btnRHCClick(Sender: TObject);
+procedure TFRMDiagnosticTool.btnRH2CClick(Sender: TObject);
 begin
   if FRH2CachedThread.Suspended then begin
     FRH2CachedThread.Suspended := False;
     btnRHC.Caption := 'Stop Random Hash 2 (Cached)';
   end else begin
-    FRH2CachedThread.Suspended := True;
+    FRH2CachedThread.Finish;
     btnRHC.Caption := 'Start Random Hash 2 (Cached)';
   end;
 end;
 
 procedure TFRMDiagnosticTool.btnRH2NonceScanClick(Sender: TObject);
+var LLevel : Integer;
 begin
   if FRH2NonceScanThread.Suspended then begin
-    FRH2NonceScanThread.Suspended := False;
-    btnRH2NonceScan.Caption := 'Stop Random Hash 2 (NonceScan)';
+    if TryStrToInt(txtScanLevel.Text, LLevel) then begin
+      TRandomHash2NonceScan(FRH2NonceScanThread).Level := LLevel;
+      FRH2NonceScanThread.Suspended := False;
+      btnRH2NonceScan.Caption := 'Stop Random Hash 2 (NonceScan)';
+      txtScanLevel.Enabled := false;
+    end;
   end else begin
-    FRH2NonceScanThread.Suspended := True;
+    FRH2NonceScanThread.Finish;
     btnRH2NonceScan.Caption := 'Start Random Hash 2 (NonceScan)';
+    txtScanLevel.Enabled := true;
   end;
 end;
 
@@ -341,4 +460,14 @@ begin
   txtLog.Text := txtLog.Text + Format('%s: %n H/S%s', [ATitle, LHPS, sLineBreak]);
 end;
 
+procedure TFRMDiagnosticTool.OnFinish(const ATitle : String; ATotalHashes : UInt32; const ATimeSpan : TTimeSpan; const AMemStats : TStatistics);
+var
+ LHPS : Double;
+ LMemStats : String;
+begin
+  LHPS := Trunc(ATotalHashes) / ATimeSpan.TotalSeconds;
+  LMemStats := Format('Samples: %d, Mean: %n, Std: %n, Min: %n, Max: %n', [AMemStats.SampleCount, AMemStats.Mean, AMemStats.SampleStandardDeviation, AMemStats.Minimum, AMemStats.Maximum]);
+  txtLog.Text := txtLog.Text + Format('FINISH: %s: %n Mean H/S, MemStats: %s%s', [ATitle, LHPS, LMemStats, sLineBreak]);
+end;
+
 end.

src/libraries/sphere10/UCommon.pas

@@ -63,6 +63,9 @@ function IIF(const ACondition: Boolean; const ATrueResult, AFalseResult: variant
 function ClipValue( AValue, MinValue, MaxValue: Integer) : Integer;
 function MinValue(const AArray : array of Cardinal) : Cardinal;
 function MaxValue(const AArray : array of Cardinal) : Cardinal;
+function RoundEx(const AInput: Single; APlaces: Integer): Single; overload;
+function RoundEx(const AInput: Double; APlaces: Integer): Double; overload;
+function RoundEx(const AInput: Currency; APlaces: integer): Currency; overload;
 {$IFDEF FPC}
 function GetSetName(const aSet:PTypeInfo; Value: Integer):string;
 function GetSetValue(const aSet:PTypeInfo; Name: String): Integer;
@@ -413,12 +416,14 @@ type
 
   { TStatistics }
 
-  TStatistics = class
+  { NOTE: this is a running stats keeper that does not keep item set, thus
+    uses estimations which can diverge from real values }
+  TStatistics = record
   private
     FCount : UInt32; // Number of items in the analysis
     FTotal : Double; // Total of data
     FTotal2 : Double; // Sum of sqaures of data
-    FProduct : Double; // Product of data
+//    FProduct : Double; // Product of data
     FRecip : Double; // Sum of reciprocals of data
     FMin : Double;  // Min datum
     FMax : Double;  // Min datum
@@ -426,17 +431,16 @@ type
     property SampleCount : UInt32 read FCount;
     property Sum : Double read FTotal;
     property SquaredSum : Double read FTotal2;
-    property Product : Double read FProduct;
+//    property Product : Double read FProduct;
     property ReciprocalSum : Double read FRecip;
     property Minimum : Double read FMin;
     property Maximum : Double read FMax;
-    constructor Create; overload;
     procedure Reset;
     function Mean : Double; inline;
     function PopulationVariance : Double; inline;
     function PopulationStandardDeviation : Double; inline;
     function PopulationVariationCoefficient : Double; inline;
-    function GeometricMean : Double; inline;
+ //   function GeometricMean : Double; inline;
     function HarmonicMean : Double; inline;
     function MinimumError : Double; inline;
     function MaximumError : Double; inline;
@@ -733,6 +737,59 @@ begin
   end;
 end;
 
+function RoundEx(const AInput: Single; APlaces: Integer): Single;
+var
+  k: Single;
+begin
+  if APlaces = 0 then begin
+    Result := Round(AInput);
+  end else begin
+    if APlaces > 0 then begin
+      k := Power(10, APlaces);
+      Result := Round(AInput * k) / k;
+    end else begin
+      k := Power(10, (APlaces*-1));
+      Result := Round(AInput / k) * k;
+    end;
+  end;
+end;
+
+function RoundEx(const AInput: Double; APlaces: Integer): Double;
+var
+  k: Double;
+begin
+  if APlaces = 0 then begin
+    Result := Round(AInput);
+  end else begin
+    if APlaces > 0 then begin
+      k := Power(10, APlaces);
+      Result := Round(AInput * k) / k;
+    end else begin
+      k := Power(10, (APlaces*-1));
+      Result := Round(AInput / k) * k;
+    end;
+  end;
+end;
+
+function RoundEx(const AInput: Currency; APlaces: integer): Currency;
+var
+  k: Currency;
+begin
+  if APlaces = 0 then begin
+    Result := Round(AInput);
+  end else begin
+    if APlaces > 0 then begin
+      k := Power(10, APlaces);
+      Result := Round(AInput * k) / k;
+    end else begin
+      k := Power(10, (APlaces*-1));
+      Result := Round(AInput / k) * k;
+    end;
+  end;
+end;
+
+
+
 {$IFDEF FPC}
 
 function GetSetName(const aSet:PTypeInfo; Value: Integer):string;
@@ -1959,7 +2016,6 @@ begin
 end;
 
 { TFileStreamHelper }
-
 {$IFNDEF FPC}
 procedure TFileStreamHelper.WriteString(const AString : String);
 begin
@@ -2054,11 +2110,6 @@ end;
 
 { TStatistics }
 
-constructor TStatistics.Create;
-begin
-  Reset;
-end;
-
 function TStatistics.Mean : Double;
 begin
   Result := NaN;
@@ -2072,9 +2123,11 @@ begin
 end;
 
 function TStatistics.PopulationVariance : Double;
+var LSum : Double;
 begin
-  if SampleCount > 0 then
-    Result :=  ((SampleCount * SquaredSum) - Sum * Sum) / (SampleCount * SampleCount)
+  LSum := Sum;
+  if SampleCount > 2 then
+    Result := ((SampleCount * SquaredSum) - (LSum * LSum)) / (SampleCount * SampleCount)
   else
     Result := Nan;
 end;
@@ -2082,18 +2135,18 @@ end;
 function TStatistics.PopulationVariationCoefficient : Double;
 begin
   if SampleCount > 0 then
-    Result :=  (PopulationVariance / Mean) * 100
+    Result :=  (PopulationVariance / Mean) * 100.0
   else
     Result := Nan;
 end;
 
-function TStatistics.GeometricMean : Double;
+(*function TStatistics.GeometricMean : Double;
 begin
   if SampleCount > 0 then
     Result :=  Power(Product, 1.0 / SampleCount)
   else
     Result := Nan;
-end;
+end;*)
 
 function TStatistics.HarmonicMean : Double;
 begin
@@ -2128,9 +2181,11 @@ begin
 end;
 
 function TStatistics.SampleVariance : Double;
+var LSum : Double;
 begin
-  if SampleCount > 0 then
-    Result := ((SampleCount * SquaredSum) - Sum * Sum) / ((SampleCount - 1) * (SampleCount - 1))
+  LSum := Sum;
+  if SampleCount > 2 then
+    Result := ((SampleCount * SquaredSum) - (LSum * LSum)) / ((SampleCount - 1) * (SampleCount - 1))
   else
     Result := Nan;
 end;
@@ -2151,19 +2206,21 @@ begin
   FTotal := 0.0;
   FTotal2 := 0.0;
   FRecip := 0.0;
-  FProduct := 1.0;
+  //FProduct := 1.0;
 end;
 
 procedure TStatistics.AddDatum(ADatum : Double);
 begin
+  if FCount = 0 then
+    Reset;
   Inc(FCount);
   FTotal := FTotal + ADatum;
-  FTotal2 := FTotal + ADatum * ADatum;
+  FTotal2 := FTotal2 + ADatum * ADatum;
   if IsNaN(FRecip) OR ((ADatum * ADatum) < (EPSILON * EPSILON)) then
     FRecip := double.NaN
   else
     FRecip := FRecip + (1.0 / ADatum);
-  FProduct := FProduct * ADatum;
+  //FProduct := FProduct * ADatum;
   if (FCount = 1) then begin
     // first data so set _min/_max
     FMin := ADatum;
@@ -2179,6 +2236,8 @@ end;
 
 procedure TStatistics.AddDatum(ADatum : Double; ANumTimes : UInt32);
 begin
+  if FCount = 0 then
+    Reset;
   FCount := FCount + ANumTimes;
   FTotal := FTotal + ADatum * ANumTimes;
   FTotal2 := FTotal2 + ADatum * ADatum * ANumTimes;
@@ -2186,7 +2245,7 @@ begin
     FRecip := NaN
   else
     FRecip := FRecip + (1.0 / ADatum) * ANumTimes;
-  FProduct := FProduct * Power(ADatum, ANumTimes);
+  //FProduct := FProduct * Power(ADatum, ANumTimes);
   if (FCount = 1) then begin
     // first data so set _min/_max
     FMin := ADatum;
@@ -2202,12 +2261,14 @@ end;
 
 procedure TStatistics.RemoveDatum(ADatum : Double);
 begin
-    Dec(FCount);
-    FTotal := FTotal - ADatum;
-    FTotal2 := FTotal2 - ADatum * ADatum;
-    FRecip := FRecip - (1.0 / ADatum);
-    if ABS(ADatum) > EPSILON then
-     FProduct := FProduct / ADatum;
+  if FCount = 0 then
+    Exit;
+  Dec(FCount);
+  FTotal := FTotal - ADatum;
+  FTotal2 := FTotal2 - ADatum * ADatum;
+  FRecip := FRecip - (1.0 / ADatum);
+  if ABS(ADatum) > EPSILON then
+   //FProduct := FProduct / ADatum;
 end;
 
 initialization

src/pascalcoin_wallet_experimental.dproj

@@ -0,0 +1,128 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <ProjectGuid>{0ACCEC68-E8F4-42A2-8A9E-5321E354837A}</ProjectGuid>
+        <MainSource>pascalcoin_wallet_experimental.dpr</MainSource>
+        <Base>True</Base>
+        <Config Condition="'$(Config)'==''">Debug</Config>
+        <TargetedPlatforms>1</TargetedPlatforms>
+        <AppType>Application</AppType>
+        <FrameworkType>VCL</FrameworkType>
+        <ProjectVersion>18.5</ProjectVersion>
+        <Platform Condition="'$(Platform)'==''">Win32</Platform>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Base)'=='true') or '$(Base_Win32)'!=''">
+        <Base_Win32>true</Base_Win32>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win64' and '$(Base)'=='true') or '$(Base_Win64)'!=''">
+        <Base_Win64>true</Base_Win64>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_1)'!=''">
+        <Cfg_1>true</Cfg_1>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_1)'=='true') or '$(Cfg_1_Win32)'!=''">
+        <Cfg_1_Win32>true</Cfg_1_Win32>
+        <CfgParent>Cfg_1</CfgParent>
+        <Cfg_1>true</Cfg_1>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_2)'!=''">
+        <Cfg_2>true</Cfg_2>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_2)'=='true') or '$(Cfg_2_Win32)'!=''">
+        <Cfg_2_Win32>true</Cfg_2_Win32>
+        <CfgParent>Cfg_2</CfgParent>
+        <Cfg_2>true</Cfg_2>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base)'!=''">
+        <DCC_E>false</DCC_E>
+        <DCC_F>false</DCC_F>
+        <DCC_K>false</DCC_K>
+        <DCC_N>false</DCC_N>
+        <DCC_S>false</DCC_S>
+        <DCC_ImageBase>00400000</DCC_ImageBase>
+        <SanitizedProjectName>pascalcoin_wallet_experimental</SanitizedProjectName>
+        <DCC_Namespace>Vcl;Vcl.Imaging;Vcl.Touch;Vcl.Samples;Vcl.Shell;System;Xml;Data;Datasnap;Web;Soap;$(DCC_Namespace)</DCC_Namespace>
+        <VerInfo_Locale>3081</VerInfo_Locale>
+        <VerInfo_Keys>CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=;CFBundleName=</VerInfo_Keys>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base_Win32)'!=''">
+        <DCC_Namespace>Winapi;System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace)</DCC_Namespace>
+        <BT_BuildType>Debug</BT_BuildType>
+        <VerInfo_IncludeVerInfo>true</VerInfo_IncludeVerInfo>
+        <VerInfo_Keys>CompanyName=;FileDescription=$(MSBuildProjectName);FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=$(MSBuildProjectName);ProductVersion=1.0.0.0;Comments=;ProgramID=com.embarcadero.$(MSBuildProjectName)</VerInfo_Keys>
+        <VerInfo_Locale>1033</VerInfo_Locale>
+        <Manifest_File>$(BDS)\bin\default_app.manifest</Manifest_File>
+        <AppEnableRuntimeThemes>true</AppEnableRuntimeThemes>
+        <UWP_DelphiLogo44>$(BDS)\bin\Artwork\Windows\UWP\delphi_UwpDefault_44.png</UWP_DelphiLogo44>
+        <UWP_DelphiLogo150>$(BDS)\bin\Artwork\Windows\UWP\delphi_UwpDefault_150.png</UWP_DelphiLogo150>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base_Win64)'!=''">
+        <UWP_DelphiLogo44>$(BDS)\bin\Artwork\Windows\UWP\delphi_UwpDefault_44.png</UWP_DelphiLogo44>
+        <UWP_DelphiLogo150>$(BDS)\bin\Artwork\Windows\UWP\delphi_UwpDefault_150.png</UWP_DelphiLogo150>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1)'!=''">
+        <DCC_Define>RELEASE;$(DCC_Define)</DCC_Define>
+        <DCC_DebugInformation>0</DCC_DebugInformation>
+        <DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>
+        <DCC_SymbolReferenceInfo>0</DCC_SymbolReferenceInfo>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1_Win32)'!=''">
+        <AppEnableRuntimeThemes>true</AppEnableRuntimeThemes>
+        <AppDPIAwarenessMode>PerMonitorV2</AppDPIAwarenessMode>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_2)'!=''">
+        <DCC_Define>DEBUG;$(DCC_Define)</DCC_Define>
+        <DCC_Optimize>false</DCC_Optimize>
+        <DCC_GenerateStackFrames>true</DCC_GenerateStackFrames>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_2_Win32)'!=''">
+        <AppEnableRuntimeThemes>true</AppEnableRuntimeThemes>
+        <AppDPIAwarenessMode>PerMonitorV2</AppDPIAwarenessMode>
+    </PropertyGroup>
+    <ItemGroup>
+        <DelphiCompile Include="$(MainSource)">
+            <MainSource>MainSource</MainSource>
+        </DelphiCompile>
+        <BuildConfiguration Include="Debug">
+            <Key>Cfg_2</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Base">
+            <Key>Base</Key>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Release">
+            <Key>Cfg_1</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+    </ItemGroup>
+    <ProjectExtensions>
+        <Borland.Personality>Delphi.Personality.12</Borland.Personality>
+        <Borland.ProjectType/>
+        <BorlandProject>
+            <Delphi.Personality>
+                <Source>
+                    <Source Name="MainSource">pascalcoin_wallet_experimental.dpr</Source>
+                </Source>
+            </Delphi.Personality>
+            <Platforms>
+                <Platform value="Win32">True</Platform>
+                <Platform value="Win64">False</Platform>
+            </Platforms>
+        </BorlandProject>
+        <ProjectFileVersion>12</ProjectFileVersion>
+    </ProjectExtensions>
+    <Import Project="$(BDS)\Bin\CodeGear.Delphi.Targets" Condition="Exists('$(BDS)\Bin\CodeGear.Delphi.Targets')"/>
+    <Import Project="$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj" Condition="Exists('$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj')"/>
+</Project>

src/tests/UCommon.Tests.pas

@@ -57,6 +57,12 @@ type
       procedure TestStringListReleaseOnly;
   end;
 
+  TStatsTests = class(TTestCase)
+    published
+      procedure TestBasic;
+      procedure Test100kData;
+  end;
+
 implementation
 
 uses
@@ -501,10 +507,48 @@ begin
   strList.Free;
 end;
 
+{ TStatsTests }
+
+procedure TStatsTests.TestBasic;
+var
+  LStats : TStatistics;
+begin
+  LStats.Reset;
+  LStats.AddDatum(1);
+  LStats.AddDatum(2);
+  LStats.AddDatum(4);
+  LStats.AddDatum(5);
+  LStats.AddDatum(8);
+
+  AssertEquals(5, LStats.SampleCount);
+  AssertEquals(1, LStats.Minimum);
+  AssertEquals(8, LStats.Maximum);
+  AssertEquals(4, LStats.Mean);
+  AssertEquals(6, LStats.PopulationVariance);
+  AssertEquals(RoundEx(2.4495, 4), RoundEx(LStats.PopulationStandardDeviation, 4));
+  // note: inaccurate estimate, since using running algo
+  AssertEquals(RoundEx(9.3750, 4), LStats.SampleVariance);
+  AssertEquals(RoundEx(3.0619, 4), RoundEx(LStats.SampleStandardDeviation, 4));
+end;
+
+
+procedure TStatsTests.Test100kData;
+var
+  LStats : TStatistics;
+  i : integer;
+begin
+  LStats.Reset;
+  for i := 1 to 100000 do
+    LStats.AddDatum(i);
+  AssertEquals(1, LStats.Minimum);
+  AssertEquals(100000, LStats.Maximum);
+end;
+
 initialization
   RegisterTest(TSortedHashTests);
   RegisterTest(THexStringTests);
   RegisterTest(TResultTests);
   RegisterTest(TVariantToolTests);
+  RegisterTest(TStatsTests);
 end.