Система двойников

Canvas.SetLeft(myRect, indeptLeft);

_element.Children.Add(myRect);

PrintText(indeptLeft + myRect.Width/2, y: _element.ActualHeight / 2 - _height / 2,

text: block.Value.Size.ToString(CultureInfo.InvariantCulture));

if(block.Value.Process != null)

PrintText(indeptLeft + myRect.Width / 2, y: _element.ActualHeight / 2 + _height / 2,

text: block.Value.Process.Id.ToString());

indeptLeft += (int)myRect.Width+5;

}

}

private void PrintText(double x, double y, string text)

{

var textBlock = new TextBlock {Text = text};

Canvas.SetLeft(textBlock, x);

Canvas.SetTop(textBlock, y);

_element.Children.Add(textBlock);

}

static readonly Random Rand = new Random();

private Brush GetColor()

{

var r = (byte)Rand.Next(127, 255);

var g = (byte)Rand.Next(127, 255);

var b = (byte)Rand.Next(127, 255);

var mySolidColorBrush = new SolidColorBrush {Color = Color.FromArgb(255, r, g, b)};

return mySolidColorBrush;

}

}

Memory.cs

public class Memory

{

public Memory(int size, int minimalBlockSize, Units units)

{

Size = size;

MinimalBlockSize = minimalBlockSize;

Units = units;

Map = new LinkedList<BlockMemory>();

Map.AddFirst(new BlockMemory(0, size, null));

}

public int Size { get; set; }

public int MinimalBlockSize { get; set; }

public Units Units { get; set; }

public LinkedList<BlockMemory> Map { get; set; }

}

Process.cs

[Serializable]

public class Process

{

public Process()

{

Id = GenerateIdProcess.GetProcessId();

}

public Process(string name, int size)

{

Id = GenerateIdProcess.GetProcessId();

Name = name;

Size = size;

}

[XmlIgnore]

public int Id { get; private set; }

public string Name { get; set; }

public int Size { get; set; }

public override string ToString()

{

return String.Format("Id: {0}\nName: {1}\nSize: {2}\n",Id,Name,Size);

}

}

Units.cs

public enum Units

{

[Description("B")]

B = 0,

[Description("KB")]

Kb = 1,

[Description("MB")]

Mb = 2,

[Description("GB")]

Gb = 3,

[Description("TB")]

Tb = 4

}

GenerateIdProcess.cs

public static class GenerateIdProcess

{

private static int _id = -1;

public static int GetProcessId()

{

_id++;

return _id;

}

}

BlockMemory.cs

public class BlockMemory

{

public BlockMemory()

{

IsFree = true;

}

public BlockMemory(int address, int size, Process process)

{

Address = address;

Size = size;

Process = process;

if (process == null) IsFree = true;

}

public int Address { get; private set; }

public int Size { get; private set; }

public Process Process { get; set; }

public bool IsFree { get; private set; }

public void Free()

{

Process = null;

IsFree = true;

}

public void LoadProcess(Process process)

{

if(process == null) throw new ArgumentNullException("process");

if(Size < process.Size) throw new ArgumentException("Size of process is greater than size of block");

Process = process;

IsFree = false;

}

}

IMemoryManager.cs

public interface IMemoryManager

{

void Allocate(Process process);

void Deallocate(int processId);

}

Bma.cs

public class Bma : IMemoryManager

{

public Bma(Memory memory)

{

_memory = memory;

_freeBlocks.Add(memory.Map.First.Value);

}

private readonly Memory _memory;

private readonly List<BlockMemory> _freeBlocks = new List<BlockMemory>();

public void Allocate(Process process)

{

if (process.Size > _memory.Size)

throw new ArgumentException(String.Format("Size process({0}) greater than size of memory({1})!",

process.Size, _memory.Size));

if (process.Size < 1)

throw new ArgumentException(String.Format("Size process({0}) less than size of minimal block memory 1!"

, process.Size));

BlockMemory freeBlock = null;

for (var i = _freeBlocks.Count - 1; i >= 0 && _freeBlocks[i].Size >= process.Size; i--)

{

freeBlock = _freeBlocks[i];

}

if (freeBlock == null) throw new OutOfMemoryException();

_freeBlocks.RemoveAll(b => b.Address == freeBlock.Address);

BlockMemory tempBlock = freeBlock;

while (tempBlock.Size/2 >= process.Size && tempBlock.Size/2 >= _memory.MinimalBlockSize)

{

var listBlock = SplitBlock(tempBlock, tempBlock.Size/2);

_freeBlocks.Add(listBlock.Last());

tempBlock = listBlock.First();

}

LoadProcess(tempBlock, process);

SortedListBlock(_freeBlocks);

}

public void Deallocate(int processId)

{

BlockMemory newFreeBlock = null;

for (var node = _memory.Map.First; node != null; node = node.Next)

{

if (node.Value.IsFree) continue;

if (node.Value.Process.Id == processId)

{

node.Value.Free();

newFreeBlock = node.Value;

break;

}

}

if(newFreeBlock == null) throw new NullReferenceException("Can't free process");

while (true)

{

var addressBuddy = newFreeBlock.Address ^ newFreeBlock.Size;

var buddyBlock = _freeBlocks.Find(b => b.Address == addressBuddy);

if (buddyBlock == null)

{

break;

}

newFreeBlock = JoinBlock(newFreeBlock, buddyBlock);

_freeBlocks.Remove(newFreeBlock);

_freeBlocks.Remove(buddyBlock);

}

_freeBlocks.Add(newFreeBlock);

SortedListBlock(_freeBlocks);

}

private List<BlockMemory> SplitBlock(BlockMemory blockMemory, int size)

{

var blockMap = _memory.Map.Find(blockMemory);

var newBlocks = new List<BlockMemory>();

newBlocks.Add(_memory.Map.AddBefore(blockMap,

new BlockMemory(blockMemory.Address, size, null)).Value);

newBlocks.Add(_memory.Map.AddAfter(blockMap,

new BlockMemory(blockMemory.Address + size, blockMap.Value.Size - size, null)).Value);

_memory.Map.Remove(blockMemory);

return newBlocks;

}

private BlockMemory JoinBlock(BlockMemory firstBlock, BlockMemory secondBlock)

{

var firstBlockMemory = firstBlock.Address < secondBlock.Address ? firstBlock : secondBlock;

var nodeFirstBlock = _memory.Map.Find(firstBlockMemory);

if (nodeFirstBlock == null)

throw new NullReferenceException("The block doesn't allocated in memory");

var newFreeBlock = new BlockMemory(

firstBlockMemory.Address,

firstBlockMemory.Size*2,

null);

_memory.Map.AddBefore(nodeFirstBlock, newFreeBlock);

_memory.Map.Remove(firstBlock);

_memory.Map.Remove(secondBlock);

return newFreeBlock;

}

private void LoadProcess(BlockMemory blockMemory, Process process)

{

if(blockMemory == null || process == null) throw new ArgumentNullException();

_memory.Map.Find(blockMemory).Value.LoadProcess(process);

}

private void SortedListBlock(List<BlockMemory> listBlockMemories)

{

listBlockMemories.Sort((memory, blockMemory) => memory.Size.CompareTo(blockMemory.Size));

}

}

IStorage.cs

public interface IStorage<T>

{

List<T> Read(string pathFile);

void Write(IList<T> list, string pathFile);

}

StorageFileXml.cs

public class StorageFileXml<T> : IStorage<T> where T : class

{

public List<T> Read(string pathFile)

{

if(!File.Exists(pathFile)) throw new FileNotFoundException("Don't find file");

var list = new List<T>();

var deserializor = new XmlSerializer(typeof(List<T>));

using (Stream fStream = new FileStream(pathFile,

FileMode.Open, FileAccess.Read, FileShare.None))

{

list = (List<T>)deserializor.Deserialize(fStream);

}

return list;

}

public void Write(IList<T> list, string pathFile)

{

Type listType = typeof(IList<T>);

var listT = list.GetType();

var serializor = new XmlSerializer(listT);

using (Stream fStream = new FileStream(pathFile,

FileMode.Create, FileAccess.Write, FileShare.None))

{

serializor.Serialize(fStream, list);

}

}

}

Размещено на Allbest.ru

...