public void TestNoWriteThrough()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 2, false);
Tuple <int, int>[] tuples = new Tuple <int, int> [100];
for (int i = 0; i < 100; i++)
{
tuples[i] = Tuple.Create(i + 1, i + 1);
memoryAccess.Put(i + 1, i + 1);
}
int[] oldValues = cache.PutAll(tuples);
for (int i = 0; i < 100; i++)
{
if (oldValues[i] != 0)
{
if (memoryAccess.Contains(i + 1))
{
memoryAccess.Remove(i + 1);
}
memoryAccess.Put(i + 1, oldValues[i]);
}
}
cache.Get(100);
}
public void Test_AddFirstSecond()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
["key2"] = "data2",
};
Assert.AreEqual(2, target.Entries.Where(e => !e.IsUsed).Count());
var entries = target.Entries.Where(e => e.IsUsed).OrderBy(e => e.Key).ToArray();
Assert.AreEqual(2, entries.Length);
Assert.AreEqual("data1", entries[0].Value);
Assert.AreEqual("key1", entries[0].Key);
Assert.AreEqual("key1".GetHashCode(), entries[0].KeyHash);
Assert.IsTrue(entries[0].UsageStamp == 1);
Assert.AreEqual("data2", entries[1].Value);
Assert.AreEqual("key2", entries[1].Key);
Assert.AreEqual("key2".GetHashCode(), entries[1].KeyHash);
Assert.IsTrue(entries[1].UsageStamp == 2);
Assert.AreEqual(2, target.Count());
}
public void Test_Enumerator()
{
var target = new NWaySetAssociativeCache <int, string>(2, 2)
{
[2] = "data2",
[3] = "data3",
[4] = "data4",
[5] = "data5",
};
var keys = new HashSet <int> {
2, 3, 4, 5,
};
var values = new HashSet <string> {
"data2", "data3", "data4", "data5",
};
foreach (var kv in target)
{
Assert.IsTrue(keys.Contains(kv.Key));
Assert.IsTrue(values.Contains(kv.Value));
keys.Remove(kv.Key);
values.Remove(kv.Value);
}
Assert.IsTrue(!keys.Any());
Assert.IsTrue(!values.Any());
}
public void Test_CopyTo()
{
var target = new NWaySetAssociativeCache <int, string>(2, 2)
{
[2] = "data2",
[3] = "data3",
[4] = "data4",
[5] = "data5",
};
var array = new KeyValuePair <int, string> [4];
target.CopyTo(array, 0);
var keys = new HashSet <int> {
2, 3, 4, 5,
};
var values = new HashSet <string> {
"data2", "data3", "data4", "data5",
};
foreach (var kv in array)
{
Assert.IsTrue(keys.Contains(kv.Key));
Assert.IsTrue(values.Contains(kv.Value));
keys.Remove(kv.Key);
values.Remove(kv.Value);
}
Assert.IsTrue(!keys.Any());
Assert.IsTrue(!values.Any());
}
public void TestConstructor_4setsOf2Mru()
{
var target = new NWaySetAssociativeCache <string, string>(4, 2);
Assert.AreEqual(4, target.NumberOfSets);
Assert.AreEqual(2, target.SetSize);
Assert.AreEqual(8, target.Size);
Assert.IsInstanceOfType(target.Entries, typeof(Entry <string, string>[]));
Assert.AreEqual(8, target.Entries.Length);
Assert.IsInstanceOfType(target.Sets, typeof(EntrySet <string, string>[]));
Assert.AreEqual(4, target.Sets.Length);
var beginIndex = 0;
foreach (var set in target.Sets)
{
var wrappedSet = new PrivateObject(set);
Assert.IsNotNull(wrappedSet.GetProperty("Lock"));
Assert.IsInstanceOfType(wrappedSet.GetProperty("Lock"), typeof(ReaderWriterLockSlim));
Assert.AreEqual(target, wrappedSet.GetField("_cache"));
Assert.AreEqual(beginIndex, (int)wrappedSet.GetField("_entriesBegin"));
Assert.AreEqual(beginIndex + target.SetSize, (int)wrappedSet.GetField("_entriesEnd"));
Assert.AreEqual(0L, (long)wrappedSet.GetField("_nextUsage"));
beginIndex += target.SetSize;
}
}
/**
* GetLowestMissN Method
* Parametrized by the generic TKey,TValue, which are set at runtime.
* Inputs: cacheSize, test entries (keys,values, and which operations to call on them), and a replacementPolicy.
* Outputs: int optimalN, which corresponds to the N-way with the lowest miss rate.
**/
/// <include file='documentation.xml' path='docs/members[@name="Utility"]/SetOptimizer/GetLowestMissN/*'/>
public static int GetLowestMissN(int cacheSize, Tuple <TKey, TValue, NWaySetAssociativeCache <TKey, TValue> .CacheOperation>[] testEntries, ReplacementPolicy <TKey, TValue> replacementPolicy)
{
//The N-way with the lowest miss rate
int optimalN = 1;
//Int keeping track of the minimum amount of misses
int minCount = -1;
//Loop, which initializes a cache for each N value from 1 to the cache size.
for (int i = 1; i <= cacheSize; i++)
{
//Initialize the MemoryAccess subclass to keep track of misses.
MemoryNode <TKey, TValue> memory = new MemoryNode <TKey, TValue>();
NWaySetAssociativeCache <TKey, TValue> cache;
cache = new NWaySetAssociativeCache <TKey, TValue>(memory, replacementPolicy, cacheSize, i, true);
//For each tuple (key,value,operation), call the InvokeReflected method of the cache, which will use the defined operation upon the key-value pair.
foreach (Tuple <TKey, TValue, NWaySetAssociativeCache <TKey, TValue> .CacheOperation> entry in testEntries)
{
cache.InvokeReflected(entry);
}
//If minCount has not been changed, set it to the first miss rate value.
if (minCount == -1)
{
minCount = memory.getCount; optimalN = i;
}
//Else if the current miss rate is lower than the lowest miss rate, set the lowest miss rate to the current one.
else if (memory.getCount < minCount)
{
minCount = memory.getCount; optimalN = i;
}
}
return(optimalN);
}
public void TestInitialization()
{
LRUReplacementPolicy <string, int> lruReplacement = new LRUReplacementPolicy <string, int>();
MyMemory <string, int> memoryAccess = new MyMemory <string, int>();
NWaySetAssociativeCache <string, int> cache;
cache = new NWaySetAssociativeCache <string, int>(memoryAccess, lruReplacement, 100, 10, true);
}
public void TestAddingEntry()
{
LRUReplacementPolicy <string, int> lruReplacement = new LRUReplacementPolicy <string, int>();
MyMemory <string, int> memoryAccess = new MyMemory <string, int>();
NWaySetAssociativeCache <string, int> cache;
cache = new NWaySetAssociativeCache <string, int>(memoryAccess, lruReplacement, 100, 10, true);
cache.Put("Hello", 5);
}
public void TestGettingNonExistentEntryString()
{
LRUReplacementPolicy <string, string> lruReplacement = new LRUReplacementPolicy <string, string>();
MyMemory <string, string> memoryAccess = new MyMemory <string, string>();
NWaySetAssociativeCache <string, string> cache;
cache = new NWaySetAssociativeCache <string, string>(memoryAccess, lruReplacement, 100, 10, true);
cache.Put("Hello", 3 + "");
Assert.AreEqual(cache.Get("Bye"), default(string));
}
public void TestContainsKeyString()
{
LRUReplacementPolicy <string, string> lruReplacement = new LRUReplacementPolicy <string, string>();
MyMemory <string, string> memoryAccess = new MyMemory <string, string>();
NWaySetAssociativeCache <string, string> cache;
cache = new NWaySetAssociativeCache <string, string>(memoryAccess, lruReplacement, 100, 10, true);
cache.Put("Hello", 3 + "");
Assert.IsTrue(cache.ContainsKey("Hello"));
}
public void TestMissingValueRetrievalFromMemory()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 2, true);
memoryAccess.Put(5, 6);
Assert.AreEqual(cache.Get(5), 6);
}
public void Test_IndexFirst()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
};
Assert.AreEqual("data1", target["key1"]);
Assert.AreEqual(1, target.Count());
}
public void Test_IndexEmpty()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
["key2"] = "data2",
};
Assert.AreEqual(2, target.Count());
var s = target["key3"];
}
public void GetShouldReturnTheValidDataIfKeyExists()
{
INWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> > cache = new NWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> >(1, new BoundedCacheIndexer <int>(1));
var key = 2;
var expectedVal = 4;
cache.Add(key, expectedVal);
var val = cache.Get(2);
Assert.That(val == expectedVal);
}
public void TestPutRemoveGet()
{
LRUReplacementPolicy <string, string> lruReplacement = new LRUReplacementPolicy <string, string>();
MyMemory <string, string> memoryAccess = new MyMemory <string, string>();
NWaySetAssociativeCache <string, string> cache;
cache = new NWaySetAssociativeCache <string, string>(memoryAccess, lruReplacement, 100, 10, true);
cache.Put("A", "B");
cache.Remove("A");
Assert.AreEqual(cache.Get("A"), default(string));
}
public void Test_GetFirst()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
};
Assert.IsTrue(target.TryGetValue("key1", out var value));
Assert.AreEqual("data1", value);
Assert.AreEqual(1, target.Count());
}
public void GetShouldReturnTheValidDataIfKeyExistsWith2WayCacheContainingTwoItemsInTheSameLine()
{
INWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> > cache = new NWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> >(2, new BoundedCacheIndexer <int>(1));
var key = 2;
var expectedVal = 4;
cache.Add(key, expectedVal);
cache.Add(3, 5);
var val = cache.Get(2);
Assert.That(val == expectedVal);
}
public void Test_GetEmpty()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
["key2"] = "data2",
};
Assert.IsFalse(target.TryGetValue("key3", out var value));
Assert.IsNull(value);
Assert.AreEqual(2, target.Count());
}
public void AddShouldThrowIfDuplicateKey()
{
Mock <ICacheIndexer <int> > BoundedCacheIndexer = new Mock <ICacheIndexer <int> >();
BoundedCacheIndexer.Setup(i => i.GetCacheIndex(2)).Returns(0);
INWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> > cache = new NWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> >(2, BoundedCacheIndexer.Object);
cache.Add(3, 30);
Assert.That(cache.Count == 1);
Assert.Throws <ArgumentException>(() => cache.Add(3, 40));
}
public void Test_ContainsKey()
{
var target = new NWaySetAssociativeCache <string, string>(2, 2)
{
["key1"] = "data1",
["key2"] = "data2",
};
Assert.AreEqual(2, target.Count());
Assert.IsTrue(target.ContainsKey("key1"));
Assert.IsTrue(target.ContainsKey("key2"));
Assert.IsFalse(target.ContainsKey("key3"));
}
public void TestPutAllString()
{
LRUReplacementPolicy <string, string> lruReplacement = new LRUReplacementPolicy <string, string>();
MyMemory <string, string> memoryAccess = new MyMemory <string, string>();
NWaySetAssociativeCache <string, string> cache;
cache = new NWaySetAssociativeCache <string, string>(memoryAccess, lruReplacement, 100, 10, true);
Tuple <string, string>[] tuples = new Tuple <string, string> [2];
tuples[0] = Tuple.Create("a", "b");
tuples[1] = Tuple.Create("c", "d");
cache.PutAll(tuples);
Assert.AreEqual(cache.Get("c"), "d");
}
public void Test_ParametersValidationCopyTo3()
{
var target = new NWaySetAssociativeCache <int, string>(2, 2)
{
[2] = "data2",
[3] = "data3",
[4] = "data4",
[5] = "data5",
};
var array = new KeyValuePair <int, string> [4];
target.CopyTo(array, 1);
}
public void Test_Reset()
{
var target = new NWaySetAssociativeCache <int, string>(2, 2)
{
[2] = "data2",
[3] = "data3",
[4] = "data4",
[5] = "data5",
};
Assert.AreEqual(4, target.Count());
target.Clear();
Assert.AreEqual(0, target.Count());
}
public void TestCustomReplacementOverCapacity()
{
RandomReplacementPolicy <int, int> ranReplacement = new RandomReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, ranReplacement, 8, 2, true);
Tuple <int, int>[] tuples = new Tuple <int, int> [100];
for (int i = 0; i < 100; i++)
{
tuples[i] = Tuple.Create(i + 1, i + 1);
}
cache.PutAll(tuples);
cache.Get(1);
}
public void CountShouldReportCorrectNumberOfItemsAdded()
{
Mock <ICacheIndexer <int> > BoundedCacheIndexer = new Mock <ICacheIndexer <int> >();
BoundedCacheIndexer.Setup(i => i.GetCacheIndex(2)).Returns(0);
INWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> > cache = new NWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> >(2, BoundedCacheIndexer.Object);
cache.AddOrUpdate(2, 20);
Assert.That(cache.Get(2) == 20);
cache.AddOrUpdate(4, 40);
Assert.That(cache.Get(4) == 40);
Assert.That(cache.Count == 2);
}
public void TestIncongruentNWay()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 3, true);
Tuple <int, int>[] tuples = new Tuple <int, int> [100];
for (int i = 0; i < 100; i++)
{
tuples[i] = Tuple.Create(i + 1, i + 1);
}
cache.PutAll(tuples);
cache.Get(1);
}
public void AddOrUpdateShouldUpdateOnDuplicateKey()
{
Mock <ICacheIndexer <int> > BoundedCacheIndexer = new Mock <ICacheIndexer <int> >();
BoundedCacheIndexer.Setup(i => i.GetCacheIndex(2)).Returns(0);
INWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> > cache = new NWaySetAssociativeCache <int, int, LRUEvictionPolicy <int, int> >(2, BoundedCacheIndexer.Object);
cache.AddOrUpdate(2, 20);
Assert.That(cache.Get(2) == 20);
cache.AddOrUpdate(2, 40);
Assert.That(cache.Get(2) == 40);
Assert.That(cache.Count == 1);
}
public void TestConstructorError()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
try
{
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 9, true);
Assert.Fail();
}
catch (ConstructorParameterException e)
{
Console.WriteLine(e);
}
}
public void TestKeyError()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
try
{
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 2, false);
cache.Put(0, 5);
Assert.Fail();
}
catch (KeyValueUsesDefaultValueException <Int32> e)
{
Console.WriteLine(e);
}
}
public void TestRemoveNonExistent()
{
LRUReplacementPolicy <int, int> lruReplacement = new LRUReplacementPolicy <int, int>();
MyMemory <int, int> memoryAccess = new MyMemory <int, int>();
NWaySetAssociativeCache <int, int> cache;
cache = new NWaySetAssociativeCache <int, int>(memoryAccess, lruReplacement, 8, 2, false);
try
{
cache.Remove(5);
Assert.Fail();
}
catch (EntryNotFoundException e)
{
Console.WriteLine(e);
}
}