avoids alloc in hash() functions

- avoids ToArray()
- avoids Action<> closure

Author: jakubmisek

src/Peachpie.Library/Hash.cs

@@ -1212,6 +1212,8 @@ protected void CloneHashState(HashPhpResource clone)
             private byte[] buffer = null;
             private int bufferUsage = 0;
 
+            internal delegate void ProcessBlockedDelegate(HashPhpResource self, ReadOnlySpan<byte> data);
+
             /// <summary>
             /// Returns blocks of data, using buffered data stored before.
             /// Provided data can be too small to fit the block, so they are buffered and processed when more data comes.
@@ -1220,7 +1222,7 @@ protected void CloneHashState(HashPhpResource clone)
             /// <param name="blockSize">Block size, when buffered data fits this, they are returned.</param>
             /// <param name="callback">Called for each block.</param>
             /// <returns>Packs of block, as a pair of byte array and index of first element.</returns>
-            internal void ProcessBlocked(ReadOnlySpan<byte>/*!*/newData, int blockSize, Action<byte[], int> callback)
+            internal void ProcessBlocked(ReadOnlySpan<byte>/*!*/newData, int blockSize, ProcessBlockedDelegate callback)
             {
                 Debug.Assert(blockSize > 0);
 
@@ -1242,7 +1244,7 @@ internal void ProcessBlocked(ReadOnlySpan<byte>/*!*/newData, int blockSize, Acti
                     }
 
                     newData.Slice(0, bytesToFitBuffer).CopyTo(buffer.AsSpan(bufferUsage, bytesToFitBuffer));
-                    callback(buffer, 0); // use the data from buffer
+                    callback(this, buffer); // use the data from buffer
 
                     bufferUsage = 0;            // buffer is empty now
                     index += bytesToFitBuffer;  // part of newData was used
@@ -1251,7 +1253,7 @@ internal void ProcessBlocked(ReadOnlySpan<byte>/*!*/newData, int blockSize, Acti
                 // returns blocks from the newData
                 while (index + blockSize <= newData.Length)
                 {
-                    callback(newData.ToArray(), index);
+                    callback(this, newData.Slice(index));
                     index += blockSize;
                 }
 
@@ -1728,16 +1730,16 @@ public override void Init()
                     Array.Clear(this.checksum, 0, this.checksum.Length);
                 }
 
-                private void TransformBlock(byte[]/*!*//*byte[16+startIndex]*/block, int startIndex)
+                private void TransformBlock(ReadOnlySpan<byte>/*!*//*byte[16+startIndex]*/block)
                 {
                     Debug.Assert(block != null);
-                    Debug.Assert(block.Length >= 16 + startIndex);
+                    Debug.Assert(block.Length >= 16);
 
                     byte i, j, t = 0;
 
                     for (i = 0; i < 16; i++)
                     {
-                        state[16 + i] = block[i + startIndex];
+                        state[16 + i] = block[i];
                         state[32 + i] = (byte)(state[16 + i] ^ state[i]);
                     }
 
@@ -1757,15 +1759,15 @@ private void TransformBlock(byte[]/*!*//*byte[16+startIndex]*/block, int startIn
                     t = checksum[15];
                     for (i = 0; i < 16; i++)
                     {
-                        t = checksum[i] ^= MD2_S[block[i + startIndex] ^ t];
+                        t = checksum[i] ^= MD2_S[block[i] ^ t];
                     }
                 }
 
                 public override bool Update(ReadOnlySpan<byte> data)
                 {
-                    ProcessBlocked(data, 16, (block, index) =>
+                    ProcessBlocked(data, 16, (self, block) =>
                     {
-                        TransformBlock(block, index);
+                        ((MD2)self).TransformBlock(block);
                     });
 
                     return true;
@@ -1785,8 +1787,8 @@ public override byte[] Final()
                         buffer[i] = remainingBytes;
 
                     //
-                    TransformBlock(buffer, 0);
-                    TransformBlock(checksum, 0);
+                    TransformBlock(buffer.AsSpan());
+                    TransformBlock(checksum.AsSpan());
 
                     //
                     byte[] hash = new byte[16];
@@ -1815,18 +1817,17 @@ public sealed class MD4 : HashPhpResource
                 private static void MD4_R1(ref uint a, uint b, uint c, uint d, uint xk, byte s) { unchecked { a = ROTL32(s, a + MD4_F(b, c, d) + xk); } }
                 private static void MD4_R2(ref uint a, uint b, uint c, uint d, uint xk, byte s) { unchecked { a = ROTL32(s, a + MD4_G(b, c, d) + xk + 0x5A827999); } }
                 private static void MD4_R3(ref uint a, uint b, uint c, uint d, uint xk, byte s) { unchecked { a = ROTL32(s, a + MD4_H(b, c, d) + xk + 0x6ED9EBA1); } }
-                private static uint[] Decode(byte[] block, int startIndex, int bytesCount)
+                private static uint[] Decode(ReadOnlySpan<byte> block)
                 {
-                    Debug.Assert(bytesCount > 0);
-                    Debug.Assert((bytesCount % 4) == 0);
+                    Debug.Assert(block.Length > 0);
+                    Debug.Assert((block.Length % 4) == 0);
 
-                    uint[] result = new uint[bytesCount / 4];
+                    uint[] result = new uint[block.Length / 4];
                     int index = 0;
-                    while (bytesCount > 0)
+                    while (block.Length > 0)
                     {
-                        result[index++] = BitConverter.ToUInt32(block, startIndex);
-                        startIndex += 4;
-                        bytesCount -= 4;
+                        result[index++] = BitConverter.ToUInt32(block);
+                        block = block.Slice(4);
                     }
 
                     return result;
@@ -1847,11 +1848,10 @@ private static byte[] Encode(uint[] nums, int startIndex, int bytesCount)
 
                     return result;
                 }
-                private void MD4Transform(byte[] block, int startIndex)
+                private void MD4Transform(ReadOnlySpan<byte> block)
                 {
                     uint a = state[0], b = state[1], c = state[2], d = state[3];
-                    uint[] x = Decode(block, startIndex, 64);
-
+                    uint[] x = Decode(block.Slice(0, 64));
 
                     /* Round 1 */
                     MD4_R1(ref a, b, c, d, x[0], 3);
@@ -1948,9 +1948,9 @@ public override bool Update(ReadOnlySpan<byte> data)
                         ++count[1];
                     count[1] += ((uint)data.Length >> 29);
 
-                    ProcessBlocked(data, 64, (block, index) =>
+                    ProcessBlocked(data, 64, (self, block) =>
                     {
-                        MD4Transform(block, index);
+                        ((MD4)self).MD4Transform(block);
                     });
 
                     return true;
@@ -2075,18 +2075,17 @@ private static void II(ref uint a, uint b, uint c, uint d, uint x, byte s, uint
                     }
                 }
 
-                private static uint[] Decode(byte[] block, int startIndex, int bytesCount)
+                private static uint[] Decode(ReadOnlySpan<byte> block)
                 {
-                    Debug.Assert(bytesCount > 0);
-                    Debug.Assert((bytesCount % 4) == 0);
+                    Debug.Assert(block.Length > 0);
+                    Debug.Assert((block.Length % 4) == 0);
 
-                    uint[] result = new uint[bytesCount / 4];
+                    uint[] result = new uint[block.Length / 4];
                     int index = 0;
-                    while (bytesCount > 0)
+                    while (block.Length > 0)
                     {
-                        result[index++] = BitConverter.ToUInt32(block, startIndex);
-                        startIndex += 4;
-                        bytesCount -= 4;
+                        result[index++] = BitConverter.ToUInt32(block);
+                        block = block.Slice(4);
                     }
 
                     return result;
@@ -2112,12 +2111,11 @@ private static byte[] Encode(uint[] nums, int startIndex, int bytesCount)
                 /// MD5 basic transformation. Transforms state based on block.
                 /// </summary>
                 /// <param name="block"></param>
-                /// <param name="startIndex"></param>
-                private void MD5Transform(byte[]/*[64]*/block, int startIndex)
+                private void MD5Transform(ReadOnlySpan<byte>/*[64]*/block)
                 {
                     uint a = state[0], b = state[1], c = state[2], d = state[3];
 
-                    uint[] x = Decode(block, startIndex, 64);   // [16]
+                    uint[] x = Decode(block.Slice(0, 64));   // [16]
                     Debug.Assert(x.Length == 16);
 
                     /* Round 1 */
@@ -2234,9 +2232,9 @@ public override bool Update(ReadOnlySpan<byte>/*!*/data)
                     count[1] += ((uint)data.Length >> 29);
 
                     // Transform blocks of 64 bytes
-                    ProcessBlocked(data, 64, (block, index) =>
+                    ProcessBlocked(data, 64, (self, block) =>
                     {
-                        MD5Transform(block, index);
+                        ((MD5)self).MD5Transform(block);
                     });
 
                     return true;