/// <summary>
/// Remove the given key
/// </summary>
/// <param name="key">The key to remove</param>
/// <param name="hash">The entity hash</param>
protected virtual void RemoveKey(TKey key, int hash, bool validate)
{
if (validate && ValidateConfiguration)
{
IsValidConfiguration(Configuration.IdHash(key), hash);
}
_data.Set((int)Configuration.Probe(BlockSize, _hashFunctionCount, hash).First(), false);
ItemCount--;
}
public void Test_ConstIterator()
{
uint[] bitCounts = { 1, 2, 3, 100, 1000 };
for (int run = 0; run < bitCounts.Length; ++run)
{
uint bitCount = bitCounts[run];
FastBitArray fba = new FastBitArray(bitCount);
// Fill with a pattern 1111...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, true);
}
// Verify
FastBitArray.ConstIterator ci = new FastBitArray.ConstIterator(fba, 0);
for (uint i = 0; i < bitCount; ++i, ci.Next())
{
Assert.AreEqual(true, ci.Value, i.ToString());
}
// Fill with a pattern 00000...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, false);
}
// Verify
ci = new FastBitArray.ConstIterator(fba, 0);
for (uint i = 0; i < bitCount; ++i, ci.Next())
{
Assert.AreEqual(false, ci.Value);
}
// Fill with a pattern 010101...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, i % 2 == 0);
}
// Verify
ci = new FastBitArray.ConstIterator(fba, 0);
for (uint i = 0; i < bitCount; ++i, ci.Next())
{
Assert.AreEqual(i % 2 == 0, ci.Value);
}
// Fill with a pattern 101010...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, i % 2 == 1);
}
// Verify
ci = new FastBitArray.ConstIterator(fba, 0);
for (uint i = 0; i < bitCount; ++i, ci.Next())
{
Assert.AreEqual(i % 2 == 1, ci.Value);
}
}
}
public void Test_Set_Get()
{
uint [] bitCounts = { 0, 1, 3, 100, 1000 };
for (int run = 0; run < bitCounts.Length; ++run)
{
uint bitCount = bitCounts[run];
FastBitArray fba = new FastBitArray(bitCount);
// Fill with a pattern 1111...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, true);
}
// Verify
for (uint i = 0; i < bitCount; ++i)
{
Assert.AreEqual(true, fba.Get(i));
}
// Fill with a pattern 00000...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, false);
}
// Verify
for (uint i = 0; i < bitCount; ++i)
{
Assert.AreEqual(false, fba.Get(i));
}
// Fill with a pattern 010101...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, i % 2 == 0);
}
// Verify
for (uint i = 0; i < bitCount; ++i)
{
Assert.AreEqual(i % 2 == 0, fba.Get(i));
}
// Fill with a pattern 101010...
for (uint i = 0; i < bitCount; ++i)
{
fba.Set(i, i % 2 == 1);
}
// Verify
for (uint i = 0; i < bitCount; ++i)
{
Assert.AreEqual(i % 2 == 1, fba.Get(i));
}
}
}
/// <summary>
/// Convert the slots to a bit array that only includes the specificied number of bits per slot.
/// </summary>
/// <param name="slots">The hashed values.</param>
/// <param name="bitSize">The bit size to be used per slot.</param>
/// <returns></returns>
internal static FastBitArray ConvertToBitArray(this int[] slots, byte bitSize)
{
if (slots == null || bitSize <= 0)
{
return(null);
}
var hashValues = new FastBitArray((int)(bitSize * slots.LongLength));
var allDefault = true;
var idx = 0;
for (var i = 0; i < slots.LongLength; i++)
{
allDefault = allDefault && slots[i] == int.MaxValue;
var byteValue = BitConverter.GetBytes(slots[i]);
var byteValueIdx = 0;
for (var b = 0; b < bitSize; b++)
{
hashValues.Set(idx + b, (byteValue[byteValueIdx] & (1 << (b % 8))) != 0);
if (b > 0 && b % 8 == 0)
{
byteValueIdx = (byteValueIdx + 1) % byteValue.Length;
}
}
idx += bitSize;
}
if (allDefault)
{
return(null);
}
return(hashValues);
}
public void Benchmark_Read_ConstIterator()
{
uint BIT_COUNT = 100000000;
int REP_COUNT = 10;
FastBitArray ba = new FastBitArray(BIT_COUNT);
// Fill with a pattern 0101...
for (uint i = 0; i < BIT_COUNT; ++i)
{
ba.Set(i, (i % 2) == 0);
}
bool checksum = false;
var startTime = DateTime.Now;
for (int r = 0; r < REP_COUNT; ++r)
{
FastBitArray.ConstIterator ci = new FastBitArray.ConstIterator(ba, 0);
for (uint i = 0; i < BIT_COUNT; ++i, ci.Next())
{
checksum ^= ci.Value;
}
}
var runTime = (DateTime.Now - startTime).TotalSeconds;
double totalBitCount = (double)REP_COUNT * BIT_COUNT;
Console.WriteLine("Reading bits: count: {0:#,#}, time: {1:0.000} s, {2:#,#} b/s, cs: {0}",
totalBitCount, runTime, totalBitCount / runTime, checksum);
}
