public void constructor_expected_list_not_null()
{
const int expectedLimit = 6;
LRU sut = new LRU(expectedLimit);
Assert.That(sut.Elements, Is.Not.Null);
}
public async Task LruRemoveExpired()
{
const int n = 10;
const int maxSize = n * 2;
var maxAge = TimeSpan.FromMilliseconds(500);
LRU <string, string> .FetchValueDelegate f = null;
var flushCounter = 0;
var target = new LRU <string, string>(maxSize, maxAge, f);
target.RaiseFlushEvent += (object o, LRU <string, string> .FlushEventArgs args) => flushCounter++;
for (int i = 0; i < n; i++)
{
var s = i.ToString();
target.Add(s, $"item {s}");
}
target.RemoveExpired();
Assert.Equal(0, flushCounter);
Assert.Equal(n, target.Count);
await Task.Delay(maxAge.Add(maxAge));
target.Add("expected", "value");
target.RemoveExpired();
Assert.Equal(n, flushCounter);
Assert.Equal(1, target.Count);
Assert.True(target.TryGetValue("expected", out var value));
Assert.Equal("value", value);
}
public void put(T key, F value)
{
if (elements.ContainsKey(key))
{
elements[key].put(key, value);
moveForward(key);
}
else
{
if (!chains.ContainsKey(1))
{
chains[1] = new LRU <T, F>();
minCount = 1;
}
chains[1].put(key, value);
elements[key] = chains[1];
counter[key] = 1;
count++;
while (count > capacity)
{
deleteLastOne();
count--;
}
}
}
public void constructor_expected_limit()
{
const int expectedLimit = 6;
LRU sut = new LRU(expectedLimit);
Assert.That(sut.Limit, Is.EqualTo(expectedLimit));
}
public void add_element_should_contains_in_list()
{
LRU sut = new LRU();
sut.Add(5);
Assert.That(sut.Elements.First(), Is.EqualTo(5));
}
private void AddLRUEntry(BufferEntry buffer)
{
if (LRU.Count >= Options.LRULimit)
{
//FLUSH
}
LRU.AddFirst(buffer);
}
public void every_element_should_be_first_item()
{
LRU sut = new LRU();
sut.Add(5);
sut.Add(6);
Assert.That(sut.Elements.First(), Is.EqualTo(6));
}
public void overload_shoul_keep_same_lenght()
{
LRU sut = new LRU(1);
sut.Add(5);
sut.Add(6);
Assert.That(sut.Elements.Count, Is.EqualTo(1));
}
private int _removeRate = 1;//比例
public LRUCaching(int maxitem, int rate)
{
this._maxitem = maxitem;
this._removeRate = rate;
this._linklist = new LRU <TKey>(this._maxitem, this._removeRate, new Action <LinkedListNode <TKey> >(s =>
{
_mapping.Remove(s.Value);
}));
}
public AdaptiveGrainDirectoryCache(TimeSpan initialExpirationTimer, TimeSpan maxExpirationTimer, double exponentialTimerGrowth, int maxCacheSize)
{
cache = new LRU <GrainId, GrainDirectoryCacheEntry>(maxCacheSize, TimeSpan.MaxValue, null);
this.initialExpirationTimer = initialExpirationTimer;
this.maxExpirationTimer = maxExpirationTimer;
this.exponentialTimerGrowth = exponentialTimerGrowth;
IntValueStatistic.FindOrCreate(StatisticNames.DIRECTORY_CACHE_SIZE, () => cache.Count);
}
public void Constructor_Defatult_Limit()
{
//ARRANGE
const int defaultLimit = 12;
//ACT
LRU sut = new LRU();
//ASSERT
Assert.That(sut.Limit, Is.EqualTo(defaultLimit));
}
internal void Close()
{
lock (this)
{
file.Close();
hashTable = null;
dirtyPages = null;
lru = null;
freePages = null;
}
}
public void Add_ExistValut_Should_Move_To_Top()
{
LRU sut = new LRU(4);
sut.Add(5);
sut.Add(4);
sut.Add(3);
sut.Add(5);
Assert.That(sut.Elements.Last, Is.Not.EqualTo(5));
}
public void overload_should_no_keep_last_element()
{
LRU sut = new LRU(1);
sut.Add(5);
sut.Add(6);
List <object> expected = new List <object>()
{
6
};
CollectionAssert.AreEqual(sut.Elements, expected);
}
public static void Init(TwitterAccountManager mgr)
{
LRU <Uri, BitmapImage> .CreateDelegate create = delegate(Uri key) { return(new BitmapImage(key)); };
_friendsCache = new LRU <Uri, BitmapImage> (create, 2048);
_nonfriendCache = new LRU <Uri, BitmapImage> (create, 1024);
mgr.AccountsPropertyChanged += delegate(object sender, EventArgs e) {
TwitterAccount[] accounts = mgr.Accounts;
for (int i = 0; i < accounts.Length; i++)
{
accounts[i].TwitterClient.PropertyChanged -= TwitterClient_PropertyChanged;
accounts[i].TwitterClient.PropertyChanged += TwitterClient_PropertyChanged;
}
};
}
public void LruCountTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
LRU<string, string>.FetchValueDelegate f = null;
var target = new LRU<string, string>(maxSize, maxAge, f);
Assert.Equal(0, target.Count); // "Count wrong after construction"
target.Add("1", "one");
Assert.Equal(1, target.Count); // "Count wrong after adding one item"
target.Add("2", "two");
Assert.Equal(2, target.Count); // "Count wrong after adding two items"
}
public void LruCountTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
var target = new LRU <string, string>(maxSize, maxAge);
Assert.Equal(0, target.Count); // "Count wrong after construction"
target.Add("1", "one");
Assert.Equal(1, target.Count); // "Count wrong after adding one item"
target.Add("2", "two");
Assert.Equal(2, target.Count); // "Count wrong after adding two items"
}
public void LruCountTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
LRU <string, string> .FetchValueDelegate f = null;
var target = new LRU <string, string>(maxSize, maxAge, f);
Assert.AreEqual(0, target.Count, "Count wrong after construction");
target.Add("1", "one");
Assert.AreEqual(1, target.Count, "Count wrong after adding one item");
target.Add("2", "two");
Assert.AreEqual(2, target.Count, "Count wrong after adding two items");
}
public void TestMethod1()
{
var MyPeople = new List<Person>(); // moya bol'shaya pamyat'
MyPeople.Add(new Person(321, "Alex"));
MyPeople.Add(new Person(324, "Avi"));
MyPeople.Add(new Person(345, "Fillip"));
MyPeople.Add(new Person(348, "Grisha"));
LRU<Person> lru = new LRU<Person>(3);
lru.Push(MyPeople[0].Id, new Person(MyPeople[0].Id, MyPeople[0].Name));
lru.Push(MyPeople[1].Id, new Person(MyPeople[1].Id, MyPeople[1].Name));
lru.Push(MyPeople[2].Id, new Person(MyPeople[2].Id, MyPeople[2].Name));
lru.Push(MyPeople[3].Id, new Person(MyPeople[3].Id, MyPeople[3].Name));
lru.Push(MyPeople[2].Id, new Person(MyPeople[2].Id, MyPeople[2].Name)); // dobavit' Fillipa
var t = lru.Get(345);
}
public void LruMaximumSizeTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
var target = new LRU <string, string>(maxSize, maxAge);
for (var i = 1; i <= maxSize + 5; i++)
{
var s = i.ToString();
target.Add(s, "item " + s);
Thread.Sleep(10);
}
Assert.Equal(maxSize, target.Count); // "LRU grew larger than maximum size"
for (var i = 1; i <= 5; i++)
{
var s = i.ToString();
Assert.False(target.ContainsKey(s), "'Older' entry is still in cache");
}
}
public void LruMaximumSizeTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
LRU<string, string>.FetchValueDelegate f = null;
var target = new LRU<string, string>(maxSize, maxAge, f);
for (var i = 1; i <= maxSize + 5; i++)
{
var s = i.ToString();
target.Add(s, "item " + s);
Thread.Sleep(10);
}
Assert.Equal(maxSize, target.Count); // "LRU grew larger than maximum size"
for (var i = 1; i <= 5; i++)
{
var s = i.ToString();
Assert.False(target.ContainsKey(s), "'Older' entry is still in cache");
}
}
public void LruUsageTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
LRU <string, string> .FetchValueDelegate f = null;
var target = new LRU <string, string>(maxSize, maxAge, f);
// Fill the LRU with "1" through "10"
for (var i = 1; i <= maxSize; i++)
{
var s = i.ToString();
target.Add(s, "item " + s);
Thread.Sleep(10);
}
// Use "10", then "9", etc.
for (var i = maxSize; i >= 1; i--)
{
var s = i.ToString();
string val;
target.TryGetValue(s, out val);
}
// Add a new item to push the least recently used out -- which should be item "10"
var s1 = (maxSize + 1).ToString();
target.Add(s1, "item " + s1);
Assert.Equal(maxSize, target.Count); // "Cache has exceeded maximum size"
var s0 = maxSize.ToString();
Assert.False(target.ContainsKey(s0), "Least recently used item was not expelled");
for (var i = 1; i < maxSize; i++)
{
var s = i.ToString();
Assert.True(target.ContainsKey(s), "Recently used item " + s + " was incorrectly expelled");
}
}
protected void moveForward(T key)
{
var lru = elements[key];
var value = elements[key].Get(key);
lru.remove(key);
if (lru.Count == 0)
{
chains.Remove(counter[key]);
if (counter[key] == minCount)
{
minCount++;
}
}
counter[key]++;
if (!chains.ContainsKey(counter[key]))
{
chains[counter[key]] = new LRU <T, F>(capacity);
}
chains[counter[key]].put(key, value);
elements[key] = chains[counter[key]];
}
static void Main(String[] args)
{
string[] tokens = Console.ReadLine().Split();
int N = int.Parse(tokens[0]);
int S = int.Parse(tokens[1]);
int pfCount = 0; // page fault count
LRU lruObj = new LRU();
for (int T = N; T > 0;)
{
tokens = Console.ReadLine().Split();
T -= tokens.Length;
for (int i = 0; i < tokens.Length; i++)
{
int item = int.Parse(tokens[i]);
ListNode pos = lruObj.find(item);
if (pos == null)
{
if (lruObj.Count == S)
{
lruObj.Dequeue();
}
lruObj.Enqueue(item);
pfCount++;
}
else
{
lruObj.UpdateAsMRU(pos);
}
}
}
Console.WriteLine(pfCount);
Console.WriteLine(lruObj.GetAllItems());
}
public void LruUsageTest()
{
const int maxSize = 10;
var maxAge = new TimeSpan(0, 1, 0, 0);
LRU<string, string>.FetchValueDelegate f = null;
var target = new LRU<string, string>(maxSize, maxAge, f);
// Fill the LRU with "1" through "10"
for (var i = 1; i <= maxSize; i++)
{
var s = i.ToString();
target.Add(s, "item " + s);
Thread.Sleep(10);
}
// Use "10", then "9", etc.
for (var i = maxSize; i >= 1; i--)
{
var s = i.ToString();
string val;
target.TryGetValue(s, out val);
}
// Add a new item to push the least recently used out -- which should be item "10"
var s1 = (maxSize + 1).ToString();
target.Add(s1, "item " + s1);
Assert.Equal(maxSize, target.Count); // "Cache has exceeded maximum size"
var s0 = maxSize.ToString();
Assert.False(target.ContainsKey(s0), "Least recently used item was not expelled");
for (var i = 1; i < maxSize; i++)
{
var s = i.ToString();
Assert.True(target.ContainsKey(s), "Recently used item " + s + " was incorrectly expelled");
}
}
public LRUBasedGrainDirectoryCache(int maxCacheSize, TimeSpan maxEntryAge)
{
cache = new LRU <GrainId, TValue>(maxCacheSize, maxEntryAge, null);
}
private void MoveLRUEntry(BufferEntry buffer)
{
LRU.MoveToFirst(buffer);
}
public void Add_null_Should_Throw_ArgumentNullException()
{
LRU sut = new LRU();
Assert.Throws <ArgumentNullException>(() => sut.Add(null));
}
internal void Open(IFile f)
{
file = f;
hashTable = new Page[poolSize];
dirtyPages = new Page[poolSize];
nDirtyPages = 0;
lru = new LRU();
freePages = null;
if (!autoExtended)
{
for (int i = poolSize; --i >= 0; )
{
Page pg = new Page();
pg.next = freePages;
freePages = pg;
}
}
}
public LRUBasedGrainDirectoryCache(int maxCacheSize, TimeSpan maxEntryAge)
{
cache = new LRU <GrainId, IReadOnlyList <Tuple <SiloAddress, ActivationId> > >(maxCacheSize, maxEntryAge, null);
}
internal SocketManager(IMessagingConfiguration config)
{
cache = new LRU<IPEndPoint, Socket>(MAX_SOCKETS, config.MaxSocketAge, SendingSocketCreator);
cache.RaiseFlushEvent += FlushHandler;
}
private static void FlushHandler(Object sender, LRU<IPEndPoint, Socket>.FlushEventArgs args)
{
if (args.Value == null) return;
CloseSocket(args.Value);
NetworkingStatisticsGroup.OnClosedSendingSocket();
}
