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

Характеристика особенностей виртуальной памяти, основанной на страничной организации и сегментации. Анализ модифицированной версии системы двойников, которая используется для распределения памяти ядром 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

Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д.
PPT, PPTX и PDF-файлы представлены только в архивах.
Рекомендуем скачать работу.