public void CouldConsumeMapAsync()
{
var count = 10;
var sm = new SortedMap <int, int>();
var zipMap = sm.Map(x => x * x).Zip(sm.Map(x => x * x), (l, r) => l + r);
var t1 = Task.Run(async() =>
{
for (int i = 0; i < count; i++)
{
await Task.Delay(250);
var _ = await sm.TryAdd(i, i);
}
await sm.Complete();
});
var cnt = 0;
var t2 = Task.Run(async() =>
{
var c = zipMap.GetAsyncCursor();
while (await c.MoveNextAsync())
{
cnt++;
Console.WriteLine($"{c.CurrentKey} - {c.CurrentValue}");
}
});
Task.WhenAll(t1, t2).Wait();
Assert.AreEqual(count, cnt);
}
public async Task AddSpeed()
{
const int count = 5_000_000;
for (int r = 0; r < 10; r++)
{
var sl = new SortedList <int, int>();
var sm = new SortedMap <int, int>();
var scm = new SortedChunkedMap <int, int>();
var c = sm.GetCursor();
sm._isSynchronized = false;
scm._isSynchronized = false;
using (Benchmark.Run("SL", count))
{
for (int i = 0; i < count; i++)
{
if (i != 2)
{
sl.Add(i, i);
}
}
}
using (Benchmark.Run("SM", count))
{
for (int i = 0; i < count; i++)
{
if (i != 2)
{
await sm.TryAdd(i, i);
}
}
}
using (Benchmark.Run("SCM", count))
{
for (int i = 0; i < count; i++)
{
if (i != 2)
{
await scm.TryAdd(i, i);
}
}
}
scm.Dispose();
}
Benchmark.Dump();
}
public async Task CouldEnumerateSMUsingCursor()
{
var map = new SortedMap <int, int>();
var count = 1_000_000;
for (int i = 0; i < count; i++)
{
await map.TryAdd(i, i);
}
#pragma warning disable HAA0401 // Possible allocation of reference type enumerator
var ae = map.GetAsyncEnumerator();
#pragma warning restore HAA0401 // Possible allocation of reference type enumerator
var t = Task.Run(async() =>
{
using (Benchmark.Run("SCM.AsyncEnumerator", count))
{
var cnt = 0;
while (await ae.MoveNextAsync())
{
cnt++;
}
await ae.DisposeAsync();
Assert.AreEqual(count * 2, cnt);
}
Benchmark.Dump();
});
for (int i = count; i < count * 2; i++)
{
await map.TryAdd(i, i);
}
await map.Complete();
t.Wait();
}
public async Task NotificationWorksWhenCursorIsNotWating()
{
var sm = new SortedMap <int, int>();
sm.Add(1, 1);
sm.Add(2, 2);
// sm.Flush();
var cursor = sm.GetAsyncEnumerator();
Assert.True(await cursor.MoveNextAsync());
Assert.True(await cursor.MoveNextAsync());
Assert.IsTrue(cursor.MovePrevious());
await sm.TryAdd(3, 3);
await Task.Delay(250);
Assert.AreEqual(1, cursor.CurrentKey);
Assert.AreEqual(1, cursor.CurrentValue);
}
public async Task CouldEnumerateSCMUsingCursor()
{
Settings.SCMDefaultChunkLength = Settings.SCMDefaultChunkLength * 4;
var scm = new SortedMap <int, int>();
var count = 1_000_000; // Settings.SCMDefaultChunkLength - 1;
for (int i = 0; i < count; i++)
{
await scm.TryAdd(i, i);
}
Console.WriteLine("Added first half");
#pragma warning disable HAA0401 // Possible allocation of reference type enumerator
var ae = scm.GetAsyncEnumerator();
#pragma warning restore HAA0401 // Possible allocation of reference type enumerator
var t = Task.Run(async() =>
{
using (Benchmark.Run("SCM.AsyncEnumerator", count))
{
try
{
var cnt = 0;
while (await ae.MoveNextAsync())
{
if (cnt != ae.Current.Key)
{
ThrowHelper.ThrowInvalidOperationException();
}
cnt++;
}
await ae.DisposeAsync();
}
catch (Exception ex)
{
Console.WriteLine("EXCEPTION: " + ex.ToString());
throw;
}
// Assert.AreEqual(scm.Count, cnt);
}
Benchmark.Dump();
});
// Thread.Sleep(1000);
for (int i = count; i < count * 2; i++)
{
await scm.TryAdd(i, i);
//Thread.SpinWait(50);
}
// Thread.Sleep(2000);
await scm.Complete();
t.Wait();
}
