/// <summary>
/// Ecrit un élément sur le disque.
/// </summary>
/// <param name="element">Element à écrire.</param>
/// <param name="key">Clef de l'element.</param>
private void WriteElement(Element element, object key)
{
try {
int bufferLength;
long expirationTime = element.ExpirationTime;
byte[] buffer = null;
try {
buffer = this.SerializeEntry(element);
bufferLength = buffer.Length;
DiskElement diskElement = this.CheckForFreeBlock(bufferLength);
_randomAccessFile.Seek(diskElement.Position, SeekOrigin.Begin);
_randomAccessFile.Write(buffer, 0, bufferLength);
buffer = null;
diskElement.PayloadSize = bufferLength;
diskElement.Key = key;
diskElement.ExpiryTime = expirationTime;
diskElement.HitCount = element.HitCount;
_totalSize += bufferLength;
_lastElementSize = bufferLength;
lock (_diskElements) {
_diskElements.Add(key, diskElement);
}
} catch (OutOfMemoryException me) {
_log.Error("OutOfMemoryError on serialize: " + key, me);
}
} catch (IOException e) {
_log.Error(
_name + "Cache: Failed to write element to disk '" + key
+ "'. Initial cause was " + e.Message, e);
}
}
/// <summary>
/// Marks a block as free.
/// </summary>
/// <param name="diskElement">The DiskElement to move to the free space list.</param>
private void FreeBlock(DiskElement diskElement)
{
_totalSize -= diskElement.PayloadSize;
diskElement.PayloadSize = 0;
diskElement.Key = null;
diskElement.HitCount = 0;
diskElement.ExpiryTime = 0;
lock (_freeSpace) {
_freeSpace.Add(diskElement);
}
}
/// <summary>
/// Evict an element.
/// </summary>
private void EvictLfuDiskElement()
{
lock (_diskElements) {
DiskElement diskElement = this.FindRelativelyUnused();
if (diskElement != null)
{
_diskElements.Remove(diskElement.Key);
this.NotifyEvictionListeners(diskElement);
this.FreeBlock(diskElement);
}
}
}
/// <summary>
/// Recherche ou crée un block de données.
/// </summary>
/// <param name="bufferLength">Taille du block.</param>
/// <returns>Block.</returns>
private DiskElement CheckForFreeBlock(int bufferLength)
{
DiskElement diskElement = this.FindFreeBlock(bufferLength);
if (diskElement == null)
{
diskElement = new DiskElement();
diskElement.Position = _randomAccessFile.Length;
diskElement.BlockSize = bufferLength;
}
return(diskElement);
}
/// <summary>
/// Notify Element Eviction.
/// </summary>
/// <param name="diskElement">Evicted Disk element.</param>
private void NotifyEvictionListeners(DiskElement diskElement)
{
if (_cache.NotificationService.HasElementEvictedListeners())
{
Element element = null;
try {
element = LoadElementFromDiskElement(diskElement);
_cache.NotificationService.NotifyElementEvicted(element, false);
} catch (IOException e) {
_log.Error(
_name + "Cache: Could not notify disk store eviction of " + element.Key +
". Error was " + e.Message, e);
}
}
}
/// <summary>
/// Remove the old entry, if any.
/// </summary>
/// <param name="key">Key of element to remove.</param>
private void RemoveOldEntryIfAny(object key)
{
DiskElement oldBlock = null;
lock (_diskElements) {
if (_diskElements.TryGetValue(key, out oldBlock))
{
_diskElements.Remove(key);
}
}
if (oldBlock != null)
{
this.FreeBlock(oldBlock);
}
}
/// <summary>
/// Allocates a free block.
/// </summary>
/// <param name="length">Taille nécessaire.</param>
/// <returns>DiskElement.</returns>
private DiskElement FindFreeBlock(int length)
{
lock (_freeSpace) {
for (int i = 0; i < _freeSpace.Count; i++)
{
DiskElement element = _freeSpace[i];
if (element.BlockSize >= length)
{
_freeSpace.RemoveAt(i);
return(element);
}
}
return(null);
}
}
private void okButton_Click(object sender, EventArgs e)
{
FloppyElement floppy;
DiskElement disk;
DialogResult = DialogResult.OK;
SystemConfig.Machine.MemorySize = memoryTrack.Value;
SystemConfig.Machine.Floppies.Clear();
SystemConfig.Machine.Disks.Clear();
floppy = new FloppyElement();
floppy.Id = 0;
floppy.Image = primaryFloppy.Text;
SystemConfig.Machine.Floppies.Add(floppy);
floppy = new FloppyElement();
floppy.Id = 1;
floppy.Image = secondaryFloppy.Text;
SystemConfig.Machine.Floppies.Add(floppy);
disk = new DiskElement();
disk.Id = 0;
disk.Image = primaryMaster.Text;
disk.Type = (DriveType)primaryMasterType.SelectedIndex;
SystemConfig.Machine.Disks.Add(disk);
disk = new DiskElement();
disk.Id = 1;
disk.Image = primarySlave.Text;
disk.Type = (DriveType)primarySlaveType.SelectedIndex;
SystemConfig.Machine.Disks.Add(disk);
disk = new DiskElement();
disk.Id = 2;
disk.Image = secondaryMaster.Text;
disk.Type = (DriveType)secondaryMasterType.SelectedIndex;
SystemConfig.Machine.Disks.Add(disk);
disk = new DiskElement();
disk.Id = 3;
disk.Image = secondarySlave.Text;
disk.Type = (DriveType)secondarySlaveType.SelectedIndex;
SystemConfig.Machine.Disks.Add(disk);
SystemConfig.Save();
}
/// <summary>
/// Uses random numbers to sample the entire map.
/// </summary>
/// <param name="diskElements">Elements.</param>
/// <returns>An array of sampled elements.</returns>
private static IMetaData[] SampleElements(Dictionary <object, DiskElement> diskElements)
{
int[] offsets = LfuPolicy.GenerateRandomSample(diskElements.Count);
DiskElement[] elements = new DiskElement[offsets.Length];
Dictionary <object, DiskElement> .Enumerator enumerator = diskElements.GetEnumerator();
for (int i = 0; i < offsets.Length; i++)
{
for (int j = 0; j <= offsets[i]; j++)
{
enumerator.MoveNext();
}
elements[i] = enumerator.Current.Value;
}
return(elements);
}
/// <summary>
/// Charge un élément depuis le disque.
/// </summary>
/// <param name="diskElement">Disk Element to load.</param>
/// <returns>Element.</returns>
private Element LoadElementFromDiskElement(DiskElement diskElement)
{
// Load the element
_randomAccessFile.Seek(diskElement.Position, SeekOrigin.Begin);
byte[] buffer = new byte[diskElement.PayloadSize];
_randomAccessFile.Read(buffer, 0, buffer.Length);
MemoryStream ms = new MemoryStream(buffer);
Element element = null;
try {
BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.All));
element = (Element)formatter.Deserialize(ms);
} finally {
ms.Close();
}
return(element);
}
