public void UpsertNoRefNoDefaultsTest()
{
// Just checking more parameter values so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
string filename = path + "UpsertNoRefNoDefaultsTest" + deviceType.ToString() + ".log";
log = TestUtils.CreateTestDevice(deviceType, filename);
fht = new FasterKV <KeyStruct, ValueStruct>
(128, new LogSettings {
LogDevice = log, MemorySizeBits = 29
});
session = fht.For(new Functions()).NewSession <Functions>();
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(key1, value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(Status.OK, status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
public void UpsertNoRefNoDefaultsTest()
{
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(key1, value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
public void UpsertDefaultsTest([Values] TestUtils.DeviceType deviceType)
{
string filename = path + "UpsertDefaultsTest" + deviceType.ToString() + ".log";
log = TestUtils.CreateTestDevice(deviceType, filename);
fht = new FasterKV <KeyStruct, ValueStruct>
(128, new LogSettings {
LogDevice = log, MemorySizeBits = 22, SegmentSizeBits = 22, PageSizeBits = 10
});
session = fht.For(new Functions()).NewSession <Functions>();
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
Assert.AreEqual(0, fht.EntryCount);
session.Upsert(ref key1, ref value);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(Status.OK, status);
Assert.AreEqual(1, fht.EntryCount);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
public void ReadAtAddressReadFlagsNone()
{
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var readAtAddress = fht.Log.BeginAddress;
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.ReadAtAddress(readAtAddress, ref input, ref output, ReadFlags.None, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
Assert.IsTrue(13 == key1.kfield1);
Assert.IsTrue(14 == key1.kfield2);
}
public void UpsertNoRefNoDefaultsTest()
{
// Just checking more parameter values so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
Setup(128, new LogSettings {
MemorySizeBits = 29
}, deviceType);
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(key1, value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
public void NativeInMemWriteRead()
{
InputStruct input = default(InputStruct);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
fht.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
public void UpsertDefaultsTest([Values] TestUtils.DeviceType deviceType)
{
Setup(128, new LogSettings {
MemorySizeBits = 22, SegmentSizeBits = 22, PageSizeBits = 10
}, deviceType);
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
Assert.AreEqual(0, fht.EntryCount);
session.Upsert(ref key1, ref value);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
Assert.AreEqual(1, fht.EntryCount);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
public void ReadAtAddressReadFlagsNone()
{
// Just functional test of ReadFlag so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
string filename = path + "ReadAtAddressReadFlagsNone" + deviceType.ToString() + ".log";
log = TestUtils.CreateTestDevice(deviceType, filename);
fht = new FasterKV <KeyStruct, ValueStruct>
(128, new LogSettings {
LogDevice = log, MemorySizeBits = 29
});
session = fht.For(new Functions()).NewSession <Functions>();
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var readAtAddress = fht.Log.BeginAddress;
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.ReadAtAddress(readAtAddress, ref input, ref output, ReadFlags.None, Empty.Default, 0);
AssertCompleted(Status.OK, status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
Assert.AreEqual(key1.kfield1, 13);
Assert.AreEqual(key1.kfield2, 14);
}
public void ReadWithoutInput([Values] TestUtils.DeviceType deviceType)
{
Setup(128, new LogSettings {
MemorySizeBits = 22, SegmentSizeBits = 22, PageSizeBits = 10
}, deviceType);
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.Read(ref key1, ref output, Empty.Default, 99);
AssertCompleted(new(StatusCode.Found), status);
// Verify the read data
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
Assert.AreEqual(key1.kfield1, 13);
Assert.AreEqual(key1.kfield2, 14);
}
public void ReadAtAddressReadFlagsNone()
{
// Just functional test of ReadFlag so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
Setup(128, new LogSettings {
MemorySizeBits = 29
}, deviceType);
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
ReadOptions readOptions = new() { StartAddress = fht.Log.BeginAddress };
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.ReadAtAddress(ref input, ref output, ref readOptions, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
Assert.AreEqual(key1.kfield1, 13);
Assert.AreEqual(key1.kfield2, 14);
}
public void ReadWithoutInput()
{
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.Read(ref key1, ref output, Empty.Default, 99);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
// Verify the read data
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
Assert.IsTrue(13 == key1.kfield1);
Assert.IsTrue(14 == key1.kfield2);
}
public unsafe void NativeInMemWriteRead()
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
fht.Upsert(&key1, &value, null, 0);
var status = fht.Read(&key1, null, &output, null, 0);
if (status == Status.PENDING)
{
fht.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
public unsafe void TestShiftHeadAddress()
{
InputStruct input = default(InputStruct);
Random r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
if (fht.Read(ref key1, ref input, ref output, Empty.Default, 0) == Status.PENDING)
{
fht.CompletePending(true);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
// Shift head and retry - should not find in main memory now
fht.ShiftHeadAddress(fht.LogTailAddress, true);
r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
Assert.IsTrue(fht.Read(ref key1, ref input, ref output, Empty.Default, 0) == Status.PENDING);
fht.CompletePending(true);
}
}
public void NativeInMemWriteReadDelete2()
{
// Just set this one since Write Read Delete already does all four devices
deviceType = TestUtils.DeviceType.MLSD;
const int count = 10;
// Setup(128, new LogSettings { MemorySizeBits = 22, SegmentSizeBits = 22, PageSizeBits = 10 }, deviceType);
Setup(128, new LogSettings {
MemorySizeBits = 29
}, deviceType);
InputStruct input = default;
OutputStruct output = default;
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = i, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
session.Delete(ref key1, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = i, vfield2 = 24
};
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.NotFound), status);
session.Upsert(ref key1, ref value, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
}
}
public void NativeInMemWriteReadDelete()
{
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
session.Delete(ref key1, Empty.Default, 0);
status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.NOTFOUND);
}
var key2 = new KeyStruct {
kfield1 = 14, kfield2 = 15
};
var value2 = new ValueStruct {
vfield1 = 24, vfield2 = 25
};
session.Upsert(ref key2, ref value2, Empty.Default, 0);
status = session.Read(ref key2, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value2.vfield1);
Assert.IsTrue(output.value.vfield2 == value2.vfield2);
}
public unsafe void NativeInMemWriteRead2()
{
InputStruct input = default(InputStruct);
Random r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
if (fht.Read(ref key1, ref input, ref output, Empty.Default, 0) == Status.PENDING)
{
fht.CompletePending(true);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
// Clean up and retry - should not find now
fht.ShiftBeginAddress(fht.LogTailAddress);
r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
Assert.IsTrue(fht.Read(ref key1, ref input, ref output, Empty.Default, 0) == Status.NOTFOUND);
}
}
public void BlittableLogCompactionTest1([Values] CompactionType compactionType)
{
using var session = fht.For(new FunctionsCompaction()).NewSession <FunctionsCompaction>();
InputStruct input = default;
const int totalRecords = 2000;
var start = fht.Log.TailAddress;
long compactUntil = 0;
for (int i = 0; i < totalRecords; i++)
{
if (i == 1000)
{
compactUntil = fht.Log.TailAddress;
}
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
session.Upsert(ref key1, ref value, 0, 0);
}
compactUntil = session.Compact(compactUntil, compactionType);
fht.Log.Truncate();
Assert.AreEqual(compactUntil, fht.Log.BeginAddress);
// Read 2000 keys - all should be present
for (int i = 0; i < totalRecords; i++)
{
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = session.Read(ref key1, ref input, ref output, 0, 0);
if (status.IsPending)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status.Found);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
}
}
public void BlittableLogCompactionTest1()
{
using var session = fht.NewSession();
InputStruct input = default;
const int totalRecords = 2000;
var start = fht.Log.TailAddress;
long compactUntil = 0;
for (int i = 0; i < totalRecords; i++)
{
if (i == 1000)
{
compactUntil = fht.Log.TailAddress;
}
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
session.Upsert(ref key1, ref value, 0, 0);
}
fht.Log.Compact(compactUntil);
Assert.IsTrue(fht.Log.BeginAddress == compactUntil);
// Read 2000 keys - all should be present
for (int i = 0; i < totalRecords; i++)
{
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = session.Read(ref key1, ref input, ref output, 0, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
}
public void ReadAtAddressReadFlagsSkipReadCache()
{
InputStruct input = default;
OutputStruct output = default;
long invalidAddress = Constants.kInvalidAddress;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var readAtAddress = fht.Log.BeginAddress;
session.Upsert(ref key1, ref value, Empty.Default, 0);
//**** When Bug Fixed ... use the invalidAddress line
// Bug #136259
// Ah—slight bug here.I took a quick look to verify that the logicalAddress passed to SingleReader was kInvalidAddress(0),
//and while I got that right for the SingleWriter call, I missed it on the SingleReader.
//This is because we streamlined it to no longer expose RecordAccessor.IsReadCacheAddress, and I missed it here.
// test that the record retrieved on Read variants that do find the record in the readCache
//pass Constants.kInvalidAddress as the ‘address’ parameter to SingleReader.
// Reading the same record using Read(…, ref RecordInfo…)
//and ReadFlags.SkipReadCache should return a valid record there.
//For now, write the same test, and instead of testing for address == kInvalidAddress,
//test for (address & Constants.kReadCacheBitMask) != 0.
//var status = session.ReadAtAddress(invalidAddress, ref input, ref output, ReadFlags.SkipReadCache);
var status = session.ReadAtAddress(readAtAddress, ref input, ref output, ReadFlags.SkipReadCache);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
Assert.IsTrue(13 == key1.kfield1);
Assert.IsTrue(14 == key1.kfield2);
}
public void NativeInMemWriteReadDelete([Values] TestUtils.DeviceType deviceType)
{
string filename = path + "NativeInMemWriteReadDelete" + deviceType.ToString() + ".log";
log = TestUtils.CreateTestDevice(deviceType, filename);
fht = new FasterKV <KeyStruct, ValueStruct>
(128, new LogSettings {
LogDevice = log, PageSizeBits = 10, MemorySizeBits = 12, SegmentSizeBits = 22
});
session = fht.For(new Functions()).NewSession <Functions>();
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(Status.OK, status);
session.Delete(ref key1, Empty.Default, 0);
status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(Status.NOTFOUND, status);
var key2 = new KeyStruct {
kfield1 = 14, kfield2 = 15
};
var value2 = new ValueStruct {
vfield1 = 24, vfield2 = 25
};
session.Upsert(ref key2, ref value2, Empty.Default, 0);
status = session.Read(ref key2, ref input, ref output, Empty.Default, 0);
AssertCompleted(Status.OK, status);
Assert.AreEqual(value2.vfield1, output.value.vfield1);
Assert.AreEqual(value2.vfield2, output.value.vfield2);
}
public void UpsertSerialNumberTest()
{
// Simple Upsert of Serial Number test so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
string filename = path + "UpsertSerialNumberTest" + deviceType.ToString() + ".log";
log = TestUtils.CreateTestDevice(deviceType, filename);
fht = new FasterKV <KeyStruct, ValueStruct>
(128, new LogSettings {
LogDevice = log, MemorySizeBits = 29
});
session = fht.For(new Functions()).NewSession <Functions>();
int numKeys = 100;
int keyMod = 10;
int maxLap = numKeys / keyMod;
InputStruct input = default;
OutputStruct output = default;
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var key = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
for (int i = 0; i < numKeys; i++)
{
// lap is used to illustrate the changing values
var lap = i / keyMod;
session.Upsert(ref key, ref value, serialNo: lap);
}
// Now verify
for (int j = 0; j < numKeys; j++)
{
var status = session.Read(ref key, ref input, ref output, serialNo: maxLap + 1);
AssertCompleted(Status.OK, status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
}
public void NativeDiskWriteRead()
{
InputStruct input = default(InputStruct);
Random r = new Random(10);
for (int i = 0; i < 2000; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
fht.CompletePending(true);
r = new Random(10);
for (int i = 0; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
if (fht.Read(ref key1, ref input, ref output, Empty.Default, 0) == Status.PENDING)
{
fht.CompletePending(true);
}
else
{
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
}
public void UpsertSerialNumberTest()
{
int numKeys = 100;
int keyMod = 10;
int maxLap = numKeys / keyMod;
InputStruct input = default;
OutputStruct output = default;
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var key = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
for (int i = 0; i < numKeys; i++)
{
// lap is used to illustrate the changing values
var lap = i / keyMod;
session.Upsert(ref key, ref value, serialNo: lap);
}
// Now verify
for (int j = 0; j < numKeys; j++)
{
var status = session.Read(ref key, ref input, ref output, serialNo: maxLap + 1);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
public void NativeInMemWriteReadDelete([Values] TestUtils.DeviceType deviceType)
{
Setup(128, new LogSettings {
PageSizeBits = 10, MemorySizeBits = 12, SegmentSizeBits = 22
}, deviceType);
InputStruct input = default;
OutputStruct output = default;
var key1 = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
session.Delete(ref key1, Empty.Default, 0);
status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.NotFound), status);
var key2 = new KeyStruct {
kfield1 = 14, kfield2 = 15
};
var value2 = new ValueStruct {
vfield1 = 24, vfield2 = 25
};
session.Upsert(ref key2, ref value2, Empty.Default, 0);
status = session.Read(ref key2, ref input, ref output, Empty.Default, 0);
AssertCompleted(new(StatusCode.Found), status);
Assert.AreEqual(value2.vfield1, output.value.vfield1);
Assert.AreEqual(value2.vfield2, output.value.vfield2);
}
public void UpsertSerialNumberTest()
{
// Simple Upsert of Serial Number test so one device is enough
deviceType = TestUtils.DeviceType.MLSD;
Setup(128, new LogSettings {
MemorySizeBits = 29
}, deviceType);
int numKeys = 100;
int keyMod = 10;
int maxLap = numKeys / keyMod;
InputStruct input = default;
OutputStruct output = default;
var value = new ValueStruct {
vfield1 = 23, vfield2 = 24
};
var key = new KeyStruct {
kfield1 = 13, kfield2 = 14
};
for (int i = 0; i < numKeys; i++)
{
// lap is used to illustrate the changing values
var lap = i / keyMod;
session.Upsert(ref key, ref value, serialNo: lap);
}
// Now verify
for (int j = 0; j < numKeys; j++)
{
var status = session.Read(ref key, ref input, ref output, serialNo: maxLap + 1);
AssertCompleted(new(StatusCode.Found), status);
Assert.AreEqual(value.vfield1, output.value.vfield1);
Assert.AreEqual(value.vfield2, output.value.vfield2);
}
}
public unsafe void NativeInMemWriteRead2()
{
Random r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(&key1, &value, null, 0);
}
r = new Random(10);
for (int c = 0; c < 1000; c++)
{
var i = r.Next(10000);
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
if (fht.Read(&key1, null, &output, null, 0) == Status.PENDING)
{
fht.CompletePending(true);
}
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
public void NativeDiskWriteReadCache()
{
InputStruct input = default(InputStruct);
for (int i = 0; i < 2000; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
fht.CompletePending(true);
// Evict all records from main memory of hybrid log
fht.Log.FlushAndEvict(true);
// Read 2000 keys - all should be served from disk, populating and evicting the read cache FIFO
for (int i = 0; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.PENDING);
fht.CompletePending(true);
}
// Read last 100 keys - all should be served from cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
// Evict the read cache entirely
fht.ReadCache.FlushAndEvict(true);
// Read 100 keys - all should be served from disk, populating cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.PENDING);
fht.CompletePending(true);
}
// Read 100 keys - all should be served from cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
// Upsert to overwrite the read cache
for (int i = 1900; i < 1950; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i + 1, vfield2 = i + 2
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
// RMW to overwrite the read cache
for (int i = 1950; i < 2000; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
input = new InputStruct {
ifield1 = 1, ifield2 = 1
};
var status = fht.RMW(ref key1, ref input, Empty.Default, 0);
if (status == Status.PENDING)
{
fht.CompletePending(true);
}
}
// Read 100 keys
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i + 1, vfield2 = i + 2
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
public void NativeDiskWriteReadCache2()
{
InputStruct input = default(InputStruct);
for (int i = 0; i < 2000; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
fht.Upsert(ref key1, ref value, Empty.Default, 0);
}
fht.CompletePending(true);
// Dispose the hybrid log from memory entirely
fht.Log.DisposeFromMemory();
// Read 2000 keys - all should be served from disk, populating and evicting the read cache FIFO
for (int i = 0; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.PENDING);
fht.CompletePending(true);
}
// Read last 100 keys - all should be served from cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
// Evict the read cache entirely
fht.ReadCache.FlushAndEvict(true);
// Read 100 keys - all should be served from disk, populating cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.PENDING);
fht.CompletePending(true);
}
// Read 100 keys - all should be served from cache
for (int i = 1900; i < 2000; i++)
{
OutputStruct output = default(OutputStruct);
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
var value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
var status = fht.Read(ref key1, ref input, ref output, Empty.Default, 0);
Assert.IsTrue(status == Status.OK);
Assert.IsTrue(output.value.vfield1 == value.vfield1);
Assert.IsTrue(output.value.vfield2 == value.vfield2);
}
}
public unsafe void NativeInMemRMWNoRefKeys()
{
InputStruct input = default;
var nums = Enumerable.Range(0, 1000).ToArray();
var rnd = new Random(11);
for (int i = 0; i < nums.Length; ++i)
{
int randomIndex = rnd.Next(nums.Length);
int temp = nums[randomIndex];
nums[randomIndex] = nums[i];
nums[i] = temp;
}
for (int j = 0; j < nums.Length; ++j)
{
var i = nums[j];
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
input = new InputStruct {
ifield1 = i, ifield2 = i + 1
};
session.RMW(ref key1, ref input, Empty.Default, 0);
}
for (int j = 0; j < nums.Length; ++j)
{
var i = nums[j];
var key1 = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
input = new InputStruct {
ifield1 = i, ifield2 = i + 1
};
session.RMW(key1, input); // no ref and do not set any other params
}
OutputStruct output = default;
Status status;
KeyStruct key;
for (int j = 0; j < nums.Length; ++j)
{
var i = nums[j];
key = new KeyStruct {
kfield1 = i, kfield2 = i + 1
};
ValueStruct value = new ValueStruct {
vfield1 = i, vfield2 = i + 1
};
status = session.Read(ref key, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
Assert.IsTrue(output.value.vfield1 == 2 * value.vfield1, "found " + output.value.vfield1 + ", expected " + 2 * value.vfield1);
Assert.IsTrue(output.value.vfield2 == 2 * value.vfield2);
}
key = new KeyStruct {
kfield1 = nums.Length, kfield2 = nums.Length + 1
};
status = session.Read(ref key, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.NOTFOUND);
}
}
public void NativeInMemWriteReadDelete2()
{
const int count = 10;
InputStruct input = default;
OutputStruct output = default;
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = i, vfield2 = 24
};
session.Upsert(ref key1, ref value, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
session.Delete(ref key1, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var value = new ValueStruct {
vfield1 = i, vfield2 = 24
};
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.NOTFOUND);
}
session.Upsert(ref key1, ref value, Empty.Default, 0);
}
for (int i = 0; i < 10 * count; i++)
{
var key1 = new KeyStruct {
kfield1 = i, kfield2 = 14
};
var status = session.Read(ref key1, ref input, ref output, Empty.Default, 0);
if (status == Status.PENDING)
{
session.CompletePending(true);
}
else
{
Assert.IsTrue(status == Status.OK);
}
}
}
