Система двойников
Характеристика особенностей виртуальной памяти, основанной на страничной организации и сегментации. Анализ модифицированной версии системы двойников, которая используется для распределения памяти ядром unix. Изучение системного программного обеспечения.
Рубрика | Программирование, компьютеры и кибернетика |
Вид | курсовая работа |
Язык | русский |
Дата добавления | 04.05.2016 |
Размер файла | 1,3 M |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
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
...Подобные документы
Архитектура компьютеров и возможности операционной системы по управлению памятью. Суть концепции виртуальной памяти. Аппаратно-независимые и аппаратно-зависимые средства управления виртуальной памятью. Сегментно-страничная организации виртуальной памяти.
презентация [355,2 K], добавлен 27.12.2010- Управление памятью. Страничная организация памяти. Сегментная организация памяти. Виртуальная память
Как осуществляется трансляция адресов при страничной организации. Что такое компактировка и как с ее помощью избавиться от внешней фрагментации. Что такое регистр таблицы страниц, сегментация. Методы распределения памяти в виде отдельных сегментов.
контрольная работа [236,2 K], добавлен 23.12.2016 Распределение виртуальной памяти. Страничная и сегментная организации виртуальной памяти. Сегментно-страничная организация виртуальной памяти. Преобразование виртуального адреса в физический. Упрощение адресации памяти клиентским программным обеспечением.
курсовая работа [440,7 K], добавлен 04.03.2014Понятие виртуальной памяти, ее реализация. Особенности страничной организации по требованию. Этапы обработки ситуации отсутствия страницы в памяти. Стратегии (алгоритмы) замещения страниц. Особенности некоторых операционных систем: Windows NT и Solaris.
презентация [2,2 M], добавлен 24.01.2014Объем двухпортовой памяти, расположенной на кристалле, для хранения программ и данных в процессорах ADSP-2106x. Метод двойного доступа к памяти. Кэш-команды и конфликты при обращении к данным по шине памяти. Пространство памяти многопроцессорной системы.
реферат [28,1 K], добавлен 13.11.2009Схема распределения памяти, соответствующая пользовательской трактовке распределения памяти. Перемещение с помощью таблицы сегментов. Аппаратная поддержка сегментного распределения памяти. Сегментно-страничная организация памяти с двухуровневой схемой.
лекция [1,5 M], добавлен 24.01.2014Стратегии размещения информации в памяти. Алгоритмы распределения адресного пространства оперативной памяти. Описание характеристик модели и ее поведения, классов и элементов. Выгрузка и загрузка блоков из вторичной памяти. Страничная организация памяти.
курсовая работа [708,6 K], добавлен 31.05.2013Динамическое распределение памяти. Анализ виртуальной памяти, алгоритм ее обращения, общие принципы защиты. Страничная организация. Особенности переключения в мультизадачный режим. Режим системного управления. Расширение размера адресного пространства.
презентация [1,3 M], добавлен 14.12.2013Память для вычислительных систем ее создание и характеристика особенностей. Создание устройств памяти и основные эксплуатационные характеристики. Функциональные схемы и способ организации матрицы запоминающих элементов. Виды магнитной и флеш памяти.
презентация [184,9 K], добавлен 12.01.2009Характеристика флэш-памяти, особого вида энергонезависимой перезаписываемой полупроводниковой памяти. Исследование особенностей организации флэш-памяти. Общий принцип работы ячейки. Обзор основных типов карт памяти. Защита информации на флеш-накопителях.
презентация [9,3 M], добавлен 12.12.2013История развития ОС UNIX, ее достоинства. Управление компьютером под управлением UNIX. Интерпретация командной строки и структура файловой системы. Команды управления процессами. Средства системного администрирования и учетные записи пользователей.
презентация [78,1 K], добавлен 12.05.2014Разработка структурной схемы и алгоритма функционирования микропроцессорного модуля программного обеспечения автоматизированной информатизационно-измерительной системы. Характеристика принципиальной схемы модуля, распределения памяти и задание портов.
курсовая работа [1,2 M], добавлен 28.08.2012Создание программы, которая создает набор данных в динамической памяти компьютера и позволяет корректировать его. Описание программного комплекса. Обзор особенностей реализации программы с использованием модулей. Добавление данных в конец текущего набора.
курсовая работа [455,2 K], добавлен 28.08.2017Описание файловой системы Unix. Работа основных команд ls, cmp, comm, их ключей. Разработка программного продукта, работающего в среде Windows и представляющего собой эмулятора командного процессора операционной системы Unix. Выбор средств реализации.
курсовая работа [183,0 K], добавлен 29.04.2015Разработка драйвера под Linux, отслеживающего выделение и освобождение процессами виртуальной памяти и выделение физических страниц при страничных отказах. Компиляция драйвера и работа с ним. Экспериментальная проверка работоспособности драйвера.
курсовая работа [43,5 K], добавлен 18.06.2009Внутренний кэш. Смешанная и разделенная кэш-память. Статическая и динамическая память. TLB как разновидность кэш-памяти. Организация кэш-памяти. Отображение секторов ОП в кэш-памяти. Иерархическая модель кэш-памяти. Ассоциативность кэш-памяти.
курсовая работа [229,1 K], добавлен 04.11.2006История появления операционной системы Unix. Перекомпиляция Unix в коды любой аппаратной платформы, ее многозадачность и многотерминальность. Основные отличия Unix от других операционных систем. Использование Unix в качестве сервера и рабочей станции.
реферат [28,1 K], добавлен 05.04.2010Сравнительный анализ статической и динамической памяти. Быстродействие и потребление энергии статической памятью. Объем памяти микросхем. Временные диаграммы чтения и записи памяти. Микросхемы синхронной и асинхронной памяти. Режимы модулей памяти.
презентация [114,2 K], добавлен 27.08.2013Распределение оперативной памяти фиксированными, динамическими и перемещаемыми разделами. Распределение с использованием внешней памяти. Принципы рaботы матричного принтера. Проектирование символов и разработка программы, реализующей их вывод на печать.
курсовая работа [241,3 K], добавлен 01.07.2011Понятие программного обеспечения, вопросы его разработки и использования. Общая характеристика системного программного обеспечения и работа операционной системы. Специфика процесса управления разработкой программного обеспечения и его особенности.
курсовая работа [636,2 K], добавлен 23.08.2011