public void Test(SpeedTestDataSourceRow a_row)
{
if (a_row.HashFunction is ICrypto)
MeasureBytesPerCycle(a_row);
Measure(a_row);
}
public SpeedTestElement(SpeedTestDataSourceRow a_row)
{
Algorithm = a_row.HashFunction.Name;
StringSpeed = a_row.StringSpeed;
BytesSpeed = a_row.BytesSpeed;
BytesPerCycle = a_row.BytesPerCycle;
CharsSpeed = a_row.CharsSpeed;
ShortsSpeed = a_row.ShortsSpeed;
UShortsSpeed = a_row.UShortsSpeed;
IntsSpeed = a_row.IntsSpeed;
UIntsSpeed = a_row.UIntsSpeed;
LongsSpeed = a_row.LongsSpeed;
ULongsSpeed = a_row.ULongsSpeed;
FloatsSpeed = a_row.FloatsSpeed;
DoublesSpeed = a_row.DoublesSpeed;
ByteSpeed = a_row.ByteSpeed;
CharSpeed = a_row.CharSpeed;
ShortSpeed = a_row.ShortSpeed;
UShortSpeed = a_row.UShortSpeed;
IntSpeed = a_row.IntSpeed;
UIntSpeed = a_row.UIntSpeed;
LongSpeed = a_row.LongSpeed;
ULongSpeed = a_row.ULongSpeed;
FloatSpeed = a_row.FloatSpeed;
DoubleSpeed = a_row.DoubleSpeed;
}
private void Measure(SpeedTestDataSourceRow a_row)
{
MersenneTwister r = new MersenneTwister();
{
var ar = r.NextBytes(BYTES_ARRAY_LENGTH);
a_row.BytesSpeed = Measure(ar.Length, () =>
{
a_row.HashFunction.ComputeBytes(ar);
});
}
IFastHash32 hash = a_row.HashFunction as IFastHash32;
if (hash == null)
return;
{
var ar = r.NextBytes(BYTES_ARRAY_LENGTH / SINGLE_ELEMENT_RATIO);
a_row.ByteSpeed = Measure(ar.Length, () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeByteFast(ar[i]);
});
}
{
var ar = r.NextChars(BYTES_ARRAY_LENGTH / sizeof(char));
a_row.CharsSpeed = Measure(ar.Length * sizeof(char), () =>
{
hash.ComputeCharsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.CharSpeed = Measure(ar.Length * sizeof(char), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeCharFast(ar[i]);
});
}
{
var ar = r.NextShorts(BYTES_ARRAY_LENGTH / sizeof(short));
a_row.ShortsSpeed = Measure(ar.Length * sizeof(short), () =>
{
hash.ComputeShortsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.ShortSpeed = Measure(ar.Length * sizeof(short), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeShortFast(ar[i]);
});
}
{
var ar = r.NextUShorts(BYTES_ARRAY_LENGTH / sizeof(ushort));
a_row.UShortsSpeed = Measure(ar.Length * sizeof(ushort), () =>
{
hash.ComputeUShortsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.UShortSpeed = Measure(ar.Length * sizeof(ushort), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeUShortFast(ar[i]);
});
}
{
var ar = r.NextInts(BYTES_ARRAY_LENGTH / sizeof(int));
a_row.IntsSpeed = Measure(ar.Length * sizeof(int), () =>
{
hash.ComputeIntsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.IntSpeed = Measure(ar.Length * sizeof(int), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeIntFast(ar[i]);
});
}
{
var ar = r.NextUInts(BYTES_ARRAY_LENGTH / sizeof(uint));
a_row.UIntsSpeed = Measure(ar.Length * sizeof(uint), () =>
{
hash.ComputeUIntsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.UIntSpeed = Measure(ar.Length * sizeof(uint), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeUIntFast(ar[i]);
});
}
{
var ar = r.NextLongs(BYTES_ARRAY_LENGTH / sizeof(long));
a_row.LongsSpeed = Measure(ar.Length * sizeof(long), () =>
{
hash.ComputeLongsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.LongSpeed = Measure(ar.Length * sizeof(long), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeLongFast(ar[i]);
});
}
{
var ar = r.NextULongs(BYTES_ARRAY_LENGTH / sizeof(ulong));
a_row.ULongsSpeed = Measure(ar.Length * sizeof(ulong), () =>
{
hash.ComputeULongsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.ULongSpeed = Measure(ar.Length * sizeof(ulong), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeULongFast(ar[i]);
});
}
{
var ar = r.NextFloatsFullSafe(BYTES_ARRAY_LENGTH / sizeof(float));
a_row.FloatsSpeed = Measure(ar.Length * sizeof(float), () =>
{
hash.ComputeFloatsFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.FloatSpeed = Measure(ar.Length * sizeof(float), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeFloatFast(ar[i]);
});
}
{
var ar = r.NextDoublesFullSafe(BYTES_ARRAY_LENGTH / sizeof(double));
a_row.DoublesSpeed = Measure(ar.Length * sizeof(double), () =>
{
hash.ComputeDoublesFast(ar);
});
ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO);
a_row.DoubleSpeed = Measure(ar.Length * sizeof(double), () =>
{
for (int i = 0; i < ar.Length; i++)
hash.ComputeDoubleFast(ar[i]);
});
}
{
var ar = r.NextString(BYTES_ARRAY_LENGTH / sizeof(char));
a_row.StringSpeed = Measure(ar.Length * sizeof(char), () =>
{
hash.ComputeStringFast(ar);
});
}
}
private void MeasureBytesPerCycle(SpeedTestDataSourceRow a_row)
{
Stopwatch sw = new Stopwatch();
IHash hash = a_row.HashFunction;
MersenneTwister r = new MersenneTwister();
hash.Initialize();
var msg = r.NextBytes(BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND);
RDTSC.rdtsc();
hash.ComputeBytes(msg);
int repeats = 0;
ulong min_delta = UInt64.MaxValue;
for (; ; )
{
HighPriority();
try
{
sw.Start();
ulong before = RDTSC.rdtsc();
hash.ComputeBytes(msg);
ulong after = RDTSC.rdtsc();
sw.Stop();
ulong delta = after - before;
min_delta = Math.Min(min_delta, delta);
}
finally
{
NormalPriority();
}
repeats++;
if (sw.ElapsedMilliseconds > MEASURE_TIME)
if (repeats > MIN_REPEATS)
break;
}
a_row.BytesPerCycle = ((double)min_delta / BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND).ToString("F2");
}
public void Add(SpeedTestDataSourceRow a_row)
{
BaseRemove(a_row.HashFunction.Name);
base.BaseAdd(new SpeedTestElement(a_row));
}
public void CopyTo(SpeedTestDataSourceRow a_row)
{
a_row.StringSpeed = StringSpeed;
a_row.BytesSpeed = BytesSpeed;
a_row.BytesPerCycle = BytesPerCycle;
a_row.CharsSpeed = CharsSpeed;
a_row.ShortsSpeed = ShortsSpeed;
a_row.UShortsSpeed = UShortsSpeed;
a_row.IntsSpeed = IntsSpeed;
a_row.UIntsSpeed = UIntsSpeed;
a_row.LongsSpeed = LongsSpeed;
a_row.ULongsSpeed = ULongsSpeed;
a_row.FloatsSpeed = FloatsSpeed;
a_row.DoublesSpeed = DoublesSpeed;
a_row.ByteSpeed = ByteSpeed;
a_row.CharSpeed = CharSpeed;
a_row.ShortSpeed = ShortSpeed;
a_row.UShortSpeed = UShortSpeed;
a_row.IntSpeed = IntSpeed;
a_row.UIntSpeed = UIntSpeed;
a_row.LongSpeed = LongSpeed;
a_row.ULongSpeed = ULongSpeed;
a_row.FloatSpeed = FloatSpeed;
a_row.DoubleSpeed = DoubleSpeed;
}
public void Add(SpeedTestDataSourceRow a_row)
{
BaseRemove(a_row.Algorithm);
base.BaseAdd(new SpeedTestElement(a_row));
}
public void Test(IHash a_hash, SpeedTestDataSourceRow a_row, bool a_bFast)
{
Random r = new Random();
int length = 10000000;
{
byte[] ar = new byte[length];
r.NextBytes(ar);
if (a_bFast)
{
a_hash.ComputeByte(ar[0]);
a_row.ByteSpeed = Measure(ar.Length, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeByte(ar[i]);
});
}
a_hash.ComputeBytes(ar.Take(100).ToArray());
a_row.BytesSpeed = Measure(ar.Length, () =>
{
a_hash.ComputeBytes(ar);
});
}
{
if (a_bFast)
{
char[] ar = (from n in Enumerable.Range(0, length / 2) select (char)r.Next()).ToArray();
a_hash.ComputeChar(ar[0]);
a_row.CharSpeed = Measure(ar.Length * 2, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeChar(ar[i]);
});
a_hash.ComputeChars(ar.Take(100).ToArray());
a_row.CharsSpeed = Measure(ar.Length * 2, () =>
{
a_hash.ComputeChars(ar);
});
}
}
{
if (a_bFast)
{
short[] ar = (from n in Enumerable.Range(0, length / 2) select (short)r.Next()).ToArray();
a_hash.ComputeShort(ar[0]);
a_row.ShortSpeed = Measure(ar.Length * 2, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeShort(ar[i]);
});
a_hash.ComputeShorts(ar.Take(100).ToArray());
a_row.ShortsSpeed = Measure(ar.Length * 2, () =>
{
a_hash.ComputeShorts(ar);
});
}
}
{
if (a_bFast)
{
ushort[] ar = (from n in Enumerable.Range(0, length / 2) select (ushort)r.Next()).ToArray();
a_hash.ComputeUShort(ar[0]);
a_row.UShortSpeed = Measure(ar.Length * 2, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeUShort(ar[i]);
});
a_hash.ComputeUShorts(ar.Take(100).ToArray());
a_row.UShortsSpeed = Measure(ar.Length * 2, () =>
{
a_hash.ComputeUShorts(ar);
});
}
}
{
if (a_bFast)
{
int[] ar = (from n in Enumerable.Range(0, length / 4) select r.Next()).ToArray();
a_hash.ComputeInt(ar[0]);
a_row.IntSpeed = Measure(ar.Length * 4, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeInt(ar[i]);
});
a_hash.ComputeInts(ar.Take(100).ToArray());
a_row.IntsSpeed = Measure(ar.Length * 4, () =>
{
a_hash.ComputeInts(ar);
});
}
}
{
if (a_bFast)
{
uint[] ar = (from n in Enumerable.Range(0, length / 4) select (uint)r.Next()).ToArray();
a_hash.ComputeUInt(ar[0]);
a_row.UIntSpeed = Measure(ar.Length * 4, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeUInt(ar[i]);
});
a_hash.ComputeUInts(ar.Take(100).ToArray());
a_row.UIntsSpeed = Measure(ar.Length * 4, () =>
{
a_hash.ComputeUInts(ar);
});
}
}
{
if (a_bFast)
{
long[] ar = (from n in Enumerable.Range(0, length / 8) select (long)(((ulong)r.Next() + (ulong)r.Next() * (ulong)Math.Pow(2, 32)))).ToArray();
a_hash.ComputeLong(ar[0]);
a_row.LongSpeed = Measure(ar.Length * 8, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeLong(ar[i]);
});
a_hash.ComputeLongs(ar.Take(100).ToArray());
a_row.LongsSpeed = Measure(ar.Length * 8, () =>
{
a_hash.ComputeLongs(ar);
});
}
}
{
if (a_bFast)
{
ulong[] ar = (from n in Enumerable.Range(0, length / 8) select ((ulong)r.Next() + (ulong)r.Next() * (ulong)Math.Pow(2, 32))).ToArray();
a_hash.ComputeULong(ar[0]);
a_row.ULongSpeed = Measure(ar.Length * 8, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeULong(ar[i]);
});
a_row.ULongsSpeed = Measure(ar.Length * 8, () =>
{
a_hash.ComputeULongs(ar);
});
}
}
{
if (a_bFast)
{
float[] ar = (from n in Enumerable.Range(0, length / 8) select (float)(r.NextDouble() * r.Next())).ToArray();
a_hash.ComputeFloat(ar[0]);
a_row.FloatSpeed = Measure(ar.Length * 4, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeFloat(ar[i]);
});
a_hash.ComputeFloats(ar.Take(100).ToArray());
a_row.FloatsSpeed = Measure(ar.Length * 4, () =>
{
a_hash.ComputeFloats(ar);
});
}
}
{
if (a_bFast)
{
double[] ar = (from n in Enumerable.Range(0, length / 8) select r.NextDouble() * r.Next()).ToArray();
a_hash.ComputeDouble(ar[0]);
a_row.DoubleSpeed = Measure(ar.Length * 8, () =>
{
for (int i = 0; i < ar.Length; i++)
a_hash.ComputeDouble(ar[i]);
});
a_hash.ComputeDoubles(ar.Take(100).ToArray());
a_row.DoublesSpeed = Measure(ar.Length * 8, () =>
{
a_hash.ComputeDoubles(ar);
});
}
}
{
if (a_bFast)
{
byte[] a = new byte[length];
r.NextBytes(a);
string ar = new String((from b in a select (char)(b / 2 + 32)).ToArray());
a_hash.ComputeString(ar.Substring(0, 100));
a_row.StringSpeed = Measure(ar.Length * 2, () =>
{
a_hash.ComputeString(ar);
});
}
}
}
public void Test(SpeedTestDataSourceRow a_row)
{
Test(a_row.HashFunction, a_row, a_row.HashFunction is IFastHashCodes);
}
