public async Task Manage_OneTrans_BeginInvoke()
{
await GeneratePerfRangesForRealm(async (cache, size) =>
{
var toWrite = PerfHelper.GenerateRandomDatabaseContents(size);
var st = new Stopwatch();
st.Start();
await Task.Run(() =>
{
using (var realmThread = new RealmThread(cache.Config))
{
realmThread.BeginTransaction();
realmThread.BeginInvoke((threadSafeRealm) =>
{
foreach (var kvp in toWrite)
{
var obj = new KeyValueRecord();
obj.Key = kvp.Key;
obj.Value = kvp.Value;
threadSafeRealm.Add(obj);
}
});
realmThread.CommitTransaction();
}
});
st.Stop();
return(st.ElapsedMilliseconds);
});
}
public async Task Manage_OneTrans_InvokeAsync()
{
await GeneratePerfRangesForRealm(async (cache, size) =>
{
var toWrite = PerfHelper.GenerateRandomDatabaseContents(size);
var st = new Stopwatch();
st.Start();
using (var realmThread = new RealmThread(cache.Config))
{
await realmThread.InvokeAsync(async(threadSafeRealm) =>
{
// Mock something using an await in this lamba
await Task.FromResult(true);
threadSafeRealm.Write(() =>
{
foreach (var kvp in toWrite)
{
var obj = new KeyValueRecord();
obj.Key = kvp.Key;
obj.Value = kvp.Value;
threadSafeRealm.Add(obj);
}
});
});
}
st.Stop();
return(st.ElapsedMilliseconds);
});
}
public async Task ThreadInvokeAsync_SingleContinuation()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
await t.InvokeAsync(async r =>
{
await Task.FromResult(true); // Simulate some Task, i.e. a httpclient request....
r.Write(() =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
});
});
t.Invoke(r =>
{
Assert.NotNull(r.Find <KeyValueRecord>("key"));
});
fixture.Refresh();
Assert.NotNull(fixture.Find <KeyValueRecord>("key"));
}
}
public void ThreadInvoke_Transaction_ViaCapturedVariable()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
Transaction trans = null;
t.Invoke(r =>
{
trans = r.BeginWrite();
});
t.Invoke(r =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
});
fixture.Refresh();
Assert.Null(fixture.Find <KeyValueRecord>("key")); // Should not be available yet
t.Invoke(r =>
{
if (trans != null)
{
trans.Commit();
}
});
fixture.Refresh();
Assert.NotNull(fixture.Find <KeyValueRecord>("key")); // Should now be available
}
}
public async Task ThreadInvokeAsync()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
await t.InvokeAsync(async r =>
{
await r.WriteAsync((aNewRealm) =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
aNewRealm.Add(obj);
});
});
t.Invoke(r =>
{
Assert.NotNull(r.Find <KeyValueRecord>("key"));
});
fixture.Refresh();
Assert.NotNull(fixture.Find <KeyValueRecord>("key"));
}
}
public void ThreadInvoke_InTransaction_AutoCommit()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
{
using (var realmThread = new RealmThread(fixture.Config, true))
{
realmThread.BeginTransaction();
var keyValueRecord = new KeyValueRecord(); // a captured variable
realmThread.Invoke(r =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
keyValueRecord.Key = obj.Key;
});
Console.WriteLine($"{keyValueRecord.Key}:{keyValueRecord.Value}");
Assert.Equal("key", keyValueRecord.Key);
}
fixture.Refresh();
Assert.NotNull(fixture.Find <KeyValueRecord>("key"));
}
}
protected static async Task <List <string> > GenerateRealmDB(Realms.Realm targetCache, int size)
{
var ret = new List <string>();
// Write out in groups of 4096
while (size > 0)
{
var toWriteSize = Math.Min(4096, size);
var toWrite = PerfHelper.GenerateRandomDatabaseContents(toWriteSize);
await targetCache.WriteAsync((Realms.Realm realm) =>
{
foreach (var item in toWrite)
{
var c = new KeyValueRecord();
c.Key = item.Key;
c.Value = item.Value;
realm.Manage <KeyValueRecord>(c); // update: false
}
});
foreach (var k in toWrite.Keys)
{
ret.Add(k);
}
size -= toWrite.Count;
}
return(ret);
}
protected static async Task <List <string> > GenerateRealmDB(Realms.Realm targetCache, int size)
{
var ret = new List <string>();
// Write out in groups of 4096
while (size > 0)
{
var toWriteSize = Math.Min(4096, size);
var toWrite = PerfHelper.GenerateRandomDatabaseContents(toWriteSize);
using (var rt = new RealmThread(targetCache.Config))
{
await rt.InvokeAsync(async(Realms.Realm arg) =>
{
await arg.WriteAsync((r) =>
{
foreach (var item in toWrite)
{
var c = new KeyValueRecord {
Key = item.Key, Value = item.Value
};
r.Add(c); // update: false
}
});
});
}
foreach (var k in toWrite.Keys)
{
ret.Add(k);
}
size -= toWrite.Count;
}
return(ret);
}
public async Task Manage_updateTrue_OneTrans()
{
await GeneratePerfRangesForRealm(async (cache, size) =>
{
var toWrite = PerfHelper.GenerateRandomDatabaseContents(size);
var st = new Stopwatch();
st.Start();
using (var realmThread = new RealmThread(cache.Config))
{
realmThread.Invoke((realm) =>
{
realm.Write(() =>
{
foreach (var kvp in toWrite)
{
var c = new KeyValueRecord {
Key = kvp.Key, Value = kvp.Value
};
realm.Add(c, update: true);
}
});
});
}
st.Stop();
await Task.Delay(1); // cheap hack
return(st.ElapsedMilliseconds);
});
}
public static async Task <List <string> > GenerateDatabase(Realms.Realm targetCache, int size)
{
var ret = new List <string>();
// Write out in groups of 4096
while (size > 0)
{
var toWriteSize = Math.Min(4096, size);
var toWrite = GenerateRandomDatabaseContents(toWriteSize);
await targetCache.WriteAsync(realm =>
{
foreach (var item in toWrite)
{
var obj = new KeyValueRecord();
obj.Key = item.Key;
obj.Value = item.Value;
realm.Add(obj);
}
});
foreach (var k in toWrite.Keys)
{
ret.Add(k);
}
size -= toWrite.Count;
}
return(ret);
}
public void ThreadInvoke_InTransaction_AutoRollback()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
{
using (var t = new RealmThread(fixture.Config, false))
{
t.BeginTransaction();
t.Invoke(r =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
});
}
fixture.Refresh();
Assert.Null(fixture.Find <KeyValueRecord>("key"));
}
}
public void ThreadInvoke_AutoRefresh()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
// Add a record on the current thread
fixture.Write(() =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
fixture.Add(obj);
});
t.Invoke(r =>
{
// Before each action a Refresh is performed so the record should be automaticially available to this thread
Assert.NotNull(r.Find <KeyValueRecord>("key"));
});
}
}
public void ThreadInvoke()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
// Add a record on a thread
t.Invoke(r =>
{
r.Write(() =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
});
});
fixture.Refresh();
Assert.NotNull(fixture.Find <KeyValueRecord>("key"));
}
}
public void ThreadInvoke_Transaction_Begin_RollBack()
{
string path;
using (Utility.WithEmptyDirectory(out path))
using (var fixture = CreateRealmsInstance(path))
using (var t = new RealmThread(fixture.Config))
{
t.BeginTransaction();
t.Invoke(r =>
{
var obj = new KeyValueRecord();
obj.Key = "key";
r.Add(obj);
});
fixture.Refresh();
Assert.Null(fixture.Find <KeyValueRecord>("key")); // Should not be available yet
t.RollbackTransaction();
fixture.Refresh();
Assert.Null(fixture.Find <KeyValueRecord>("key")); // Should not be available
}
}
public async Task Manage_updateTrue_OneTrans()
{
await GeneratePerfRangesForRealm(async (cache, size) =>
{
var toWrite = PerfHelper.GenerateRandomDatabaseContents(size);
var st = new Stopwatch();
st.Start();
await cache.WriteAsync((r) =>
{
foreach (var kvp in toWrite)
{
var c = new KeyValueRecord();
c.Key = kvp.Key;
c.Value = kvp.Value;
r.Manage(c, update: true);
}
});
st.Stop();
return(st.ElapsedMilliseconds);
});
}
public async Task Write_Read_Parallel_On_Different_Threads()
{
await GeneratePerfRangesForRealm(async (cache, size) =>
{
using (var rt = new RealmThread(cache.Config))
{
rt.Invoke((Realms.Realm r) =>
{
r.Write(() => { r.RemoveAll(); });
});
}
var toWrite = PerfHelper.GenerateRandomDatabaseContents(size);
var st = new Stopwatch();
st.Start();
await Task.Run(() =>
{
using (var blockingQueue = new BlockingCollection <string>())
using (var realmThreadWrite = new RealmThread(cache.Config))
using (var realmThreadRead = new RealmThread(cache.Config))
{
Parallel.Invoke(() =>
{
realmThreadWrite.Invoke(threadSafeWriteRealm =>
{
foreach (var kvp in toWrite)
{
// Individual record write transactions so the other RealmThread can read asap
threadSafeWriteRealm.Write(() =>
{
var obj = new KeyValueRecord();
obj.Key = kvp.Key;
obj.Value = kvp.Value;
threadSafeWriteRealm.Add(obj);
});
blockingQueue.Add(kvp.Key);
}
blockingQueue.CompleteAdding();
});
},
() =>
{
realmThreadRead.Invoke((threadSafeReadRealm) =>
{
foreach (var key in blockingQueue.GetConsumingEnumerable())
{
// Refresh() is automatically called at the beginning of each BeginInvoke,
// so if we are within the RealmPump block and need to see the latest changes
// from other Realm instances, call Refresh manually
threadSafeReadRealm.Refresh();
var record = threadSafeReadRealm.Find <KeyValueRecord>(key);
Assert.NotNull(record);
Assert.Equal(key, record.Key);
}
});
});
}
});
st.Stop();
return(st.ElapsedMilliseconds);
});
}