public void compute_hash_of_hello_world()
{
var buf = Encoding.UTF8.GetBytes("Hello, world!");
var h = BlockHasher.ComputeHash(buf);
Assert.Equal(new Hash("307EA73B830D76AD85ED617FADBD655C"), h);
}
public bool IsNewBlockValid(Block newBlock, Block previousBlock)
{
if (newBlock != null && previousBlock != null)
{
if (previousBlock.Index + 1 != newBlock.Index)
{
return(false);
}
if (
newBlock.PreviousHash == null
||
!newBlock.PreviousHash.Equals(previousBlock.Hash)
)
{
return(false);
}
if (newBlock.Hash == null ||
!BlockHasher.calculateHash(newBlock).Equals(newBlock.Hash))
{
return(false);
}
return(true);
}
return(false);
}
public void write_blocks()
{
const int ba = BlockAddress.BlockAlignment;
var raw = Encoding.UTF8.GetBytes("Hello, world!");
var h = BlockHasher.ComputeHash(raw);
using (var data = new VolatileMemory(2 * ba))
{
var(read, write) = FileWriter.CreateReaderWriterPair(data, 1);
var writesPerformed = 0;
write.TryScheduleWrite(1337, h, raw.Length,
span =>
{
raw.AsSpan().CopyTo(span);
++writesPerformed;
});
write.TryScheduleWrite(1338, h, raw.Length,
span =>
{
raw.AsSpan().CopyTo(span);
++writesPerformed;
});
Assert.Equal(0, writesPerformed);
var blocks = read.EnumerateBlocks().ToArray();
Assert.Equal(2, blocks.Length);
Assert.Equal(1337U, blocks[0].realm);
Assert.Equal(h, blocks[0].hash);
Assert.Equal(1U, blocks[0].address.File());
Assert.Equal(0L, blocks[0].address.FirstByteOffset());
Assert.Equal(1338U, blocks[1].realm);
Assert.Equal(h, blocks[1].hash);
Assert.Equal(1U, blocks[1].address.File());
Assert.Equal(ba, blocks[1].address.FirstByteOffset());
Assert.True(read.TryWithBlockAtAddress(
blocks[1].address,
blocks[1].realm,
blocks[1].hash,
span =>
{
var bytes = new byte[span.Length];
span.CopyTo(bytes);
return(Encoding.UTF8.GetString(bytes));
},
out var hello));
Assert.Equal(1, writesPerformed);
Assert.Equal("Hello, world!", hello);
}
}
public void iterated_of_hello_world()
{
var buf = Encoding.UTF8.GetBytes("Hello, world!");
var hasher = BlockHasher.Create();
hasher.Update(buf.AsSpan(0, 8));
hasher.Update(buf.AsSpan(8));
var h = hasher.Final();
Assert.Equal(new Hash("307EA73B830D76AD85ED617FADBD655C"), h);
}
public void write_block()
{
var raw = Encoding.UTF8.GetBytes("Hello, world!");
var h = BlockHasher.ComputeHash(raw);
using (var data = new VolatileMemory(8192))
{
var(read, write) = FileWriter.CreateReaderWriterPair(data, 1);
var writePerformed = false;
var addr = write.TryScheduleWrite(1337, h, raw.Length,
span =>
{
raw.AsSpan().CopyTo(span);
writePerformed = true;
});
Assert.False(writePerformed);
var blocks = read.EnumerateBlocks().ToArray();
Assert.Single(blocks);
Assert.Equal(1337U, blocks[0].realm);
Assert.Equal(h, blocks[0].hash);
Assert.Equal(1U, blocks[0].address.File());
Assert.Equal(0L, blocks[0].address.FirstByteOffset());
Assert.True(read.TryWithBlockAtAddress(
blocks[0].address,
blocks[0].realm,
blocks[0].hash,
span =>
{
var bytes = new byte[span.Length];
span.CopyTo(bytes);
return(Encoding.UTF8.GetString(bytes));
},
out var hello));
Assert.True(writePerformed);
Assert.Equal("Hello, world!", hello);
}
}
public bool IsFirstBlockValid()
{
Block firstBlock = Chain.Blocks.ElementAt(0);
if
(
firstBlock.Index != 0
||
firstBlock.PreviousHash != null
||
firstBlock.Hash == null
||
!BlockHasher.calculateHash(firstBlock).Equals(firstBlock.Hash)
)
{
return(false);
}
return(true);
}
public static void Run(string[] folders, int files, long size)
{
var scratch = new Scratch(
new DiskFileSource(folders, files / folders.Length, size),
CancellationToken.None);
Console.WriteLine(
"Found {0} values in existing files",
scratch.Count);
var pool = ArrayPool <int> .Create();
const int Length = 1 << 24;
var i = 0;
var sw = Stopwatch.StartNew();
Task.WaitAll(Enumerable.Range(0, 8).Select(_ => Task.Run(Act)).ToArray());
void Act()
{
var available = new List <Hash>();
var left = new int[Length];
var right = new int[Length];
var rand = new Random(100);
void LoadRandomInto(int[] array)
{
while (true)
{
if (available.Count == 0)
{
for (var s = 0; s < Length; ++s)
{
array[s] = rand.Next();
}
return;
}
var pos = rand.Next(available.Count);
var hash = available[pos];
try
{
scratch.Read(1, hash, span =>
{
if (!BlockHasher.ComputeHash(span).Equals(hash))
{
Console.WriteLine("Bad hash!");
}
MemoryMarshal.Cast <byte, int>(span).CopyTo(array);
return(true);
});
return;
}
catch (MissingBlockException)
{
Console.WriteLine("{0} Missing {1}", sw.Elapsed, hash);
available[pos] = available[available.Count - 1];
available.RemoveAt(available.Count - 1);
}
}
}
int j = 0;
while (j < 10000)
{
j = Interlocked.Increment(ref i);
var result = pool.Rent(Length);
LoadRandomInto(left);
LoadRandomInto(right);
for (var c = 0; c < Length; ++c)
{
result[c] = left[c] + right[c];
}
var hash = BlockHasher.ComputeHash(
MemoryMarshal.Cast <int, byte>(result.AsSpan(0, Length)));
available.Add(hash);
scratch.Write(1, hash, Length * sizeof(int), span =>
{
MemoryMarshal.Cast <int, byte>(result.AsSpan(0, Length)).CopyTo(span);
pool.Return(result);
});
var total = j * sizeof(int) * (long)Length;
Console.WriteLine(
"i = {3} {0} Wrote {1} MB ({2:F2} MBps)",
sw.Elapsed.TotalSeconds,
total >> 20,
total / sw.Elapsed.TotalSeconds / 1024 / 1024,
j);
}
}
}
public void compute_hash_of_empty()
{
var h = BlockHasher.ComputeHash(Array.Empty <byte>());
Assert.Equal(new Hash("696695F3118DAB5A86F33ACECB67EBE0"), h);
}
public BlittableWriter(Scratch scratch, uint realm)
{
_scratch = scratch;
_realm = realm;
_hasher = BlockHasher.Create();
}
