Федеральное государственное образовательное
Учреждения высшего профессионального образования
Национальный исследовательский технологический университет
«МИСиС»
Институт ИТАСУ
Кафедр Инженерной кибернетики
КУРСОВАЯ РАБОТА
по дисциплине «Операционные системы и среды»
Вариант 8
Выполнил:
Раевский Михаил
Группа: И8-12-1
Проверил:
Крыков Д.В.
Москва 2013 г.
Оглавление
Текст задания………………………………………………………………………………………………………………………………………...2
Теоретическая часть. 4
1.Функции ОС по управлению памятью. 5
2.Распределение памяти. 6
3.Распределение памяти фиксированными разделами. 11
Практическая часть. 11
1.Постановка задачи. 11
3.Исходные данные. 12
4.Код программы. 13
5.Результат. 20
Список источников и литературы.. 18
Задание: модель распределения памяти фиксированными разделами с отдельными очередями предполагает, что до начала загрузки программ вся память разделяется на непрерывные участки одинакового размера (блоки). Для каждой поступающей программы определен один участок, в который она должна быть загружена.
Исходные данные:
- общий объем памяти;
- размер блока;
- поток заявок на размещения в памяти (номер заявки, объем требуемой памяти, время поступления, продолжительность обработки заявки, номер раздела обслуживающего заявку).
Результаты работы модели, отображаемые на дисплее должны включать графическую интерпретацию загруженности памяти.
Пример набора исходных данных и результата работы программы.
- общий объем памяти – 32 Мб;
- размер блока – 8 Мб;
- номер заявки, объем требуемой памяти, время поступления, продолжительность обработки заявки, номер раздела обслуживающего заявку: (1,6,0,10, 1); (2,4,2,10, 2); (3,8,3,10, 3), (4,7,5,10, 1), (5,6,8,10, 4).
Теоретическая часть.
Многозадачность (англ. multitasking) — свойство операционной системы или среды программирования обеспечивать возможность параллельной (или псевдопараллельной) обработки нескольких процессов. Истинная многозадачность операционной системы возможна только в распределённых вычислительных системах.
Существует 2 типа многозадачности:
· Процессная многозадачность (основанная на процессах — одновременно выполняющихся программах). Здесь программа — наименьший элемент кода, которым может управлять планировщик операционной системы. Более известна большинству пользователей (работа в текстовом редакторе и прослушивание музыки).
· Поточная многозадачность (основанная на потоках). Наименьший элемент управляемого кода — поток (одна программа может выполнять 2 и более задачи одновременно).
Распределение памяти в многозадачных вычислительных системах может быть как с фиксированными (статическими) или с динамическими (то есть процесс выделения нового раздела памяти происходит непосредственно при появлении новой задачи) разделами. Под разделами мы будем понимать ту область памяти, которая не занята ядром операционной системы. Разделы характеризуются именем, типом, границами (обычно, указывается начало раздела и его длина) [1].
· Статическое распределение памяти бывает двух видов:
· а) с разделами с фиксированными разделами;
· б) с разделами с подвижными границами.
Функции ОС по управлению памятью.
Основная память разделяется на две части в однопрограммных операционных системах. Одна часть для операционной системы (резидентный монитор, ядро), а вторая – для выполняющейся в текущий момент времени программы. В лекциях «Современные операционные системы» сказано: «В многопрограммных ОС "пользовательская" часть памяти – важнейший ресурс вычислительной системы – должна быть распределена для размещения нескольких процессов, в том числе процессов ОС. Эта задача распределения выполняется операционной системой динамически специальной подсистемой управления памятью. Эффективное управление памятью жизненно важно для многозадачных систем. Когда в памяти находится небольшое число процессов, то значительное время процессы находится в состоянии ожидания ввода-вывода и загрузка процессора будет минимальной.
Намного усложнились задачи ОС, связанные с распределением имеющейся памяти между несколькими одновременно выполняющимися программами, с тех пор как появилось мультипрограммирование.
Функции ОС, которые управляют памятью в мультипрограммных системах это: 1) отслеживание (учет) свободной и занятой памяти;2) настройка адресов программы на конкретную область физической памяти; 3) первоначальное и динамическое выделение памяти процессам приложений и самой операционной системе и освобождение памяти по завершении процессов;4) дефрагментация памяти;5) полное или частичное вытеснение кодов и данных процессов из ОП на диск, когда размеры ОП недостаточны для размещения всех процессов, и возвращение их в ОП;6) защита памяти, выделенной процессу, от возможных вмешательств со стороны других процессов.
Распределение памяти.
В различных ОС управление памятью осуществляются по-разному.
На сайте дается классификация методов распределения памяти, в которой выделено два класса методов – с перемещением сегментов процессов между ОП и ВП (диском) и без перемещения, т.е. без привлечения внешней памяти (рис. 3). Данная классификация учитывает только основные признаки методов. Для каждого метода может быть использовано несколько различных алгоритмов его реализации.
Рис. 3. Классификация методов распределения памяти
На рис. 4 показаны два примера фиксированного распределения. Одна возможность состоит в использовании разделов одинакового размера. В этом случае любой процесс, размер которого не превышает размера раздела, может быть загружен в любой доступный раздел. Если все разделы заняты и нет ни одного процесса в состоянии готовности или работы, ОС может выгрузить процесс из любого раздела и загрузить другой процесс, обеспечивая тем самым процессор работой.
Рис. 4. Варианты фиксированного распределения памяти
При использовании разделов с одинаковым размером имеются две проблемы.
1. Программа может быть слишком велика для размещения в разделе. В этом случае программист должен разрабатывать программу, использующую оверлеи, чтобы в любой момент времени требовался только один раздел памяти. Когда требуется модуль, отсутствующий в данный момент в ОП, пользовательская программа должна сама его загрузить в раздел памяти программы. Таким образом, в данном случае управление памятью во многом возлагается на программиста.
2. Использование ОП крайне неэффективно. Любая программа, независимо от ее размера, занимает раздел целиком. При этом могут оставаться неиспользованные участки памяти большого размера. Этот феномен появления неиспользованной памяти называется внутренней фрагментацией (internal fragmentation).
Бороться с этими трудностями можно посредством использования разделов разных размеров. В этом случае программа размером до 8 Мбайт может обойтись без оверлеев (метод программирования, позволяющий создавать программы, занимающие больше памяти, чем установлено в системе), а разделы малого размера позволяют уменьшить внутреннюю фрагментацию при загрузке небольших программ.
В том случае, когда разделы имеют одинаковый раздел, процессы размещаются в любой свободный раздел. Если все разделы заняты процессами, которые не готовы к немедленной работе, один из процессов может быть выгружен для освобождения памяти для нового процесса.
В целом можно отметить, что схемы с фиксированными разделами относительно просты, предъявляют минимальные требования к операционной системе; накладные расходы работы процессора на распределение памяти невелики. Однако у этих схем имеются серьезные недостатки.
1. Количество разделов, определенное в момент генерации системы, ограничивает количество активных процессов (т.е. уровень мультипрограммирования).
2. Поскольку размеры разделов устанавливаются заранее во время генерации системы, небольшие задания приводят к неэффективному использованию памяти. В средах, где заранее известны потребности в памяти всех задач, применение рассмотренной схемы может быть оправдано, но в большинстве случаев эффективность этой технологии крайне низка.
Для преодоления сложностей, связанных с фиксированным распределением, был разработан альтернативный подход, известный как динамическое распределение. При динамическом распределении образуется перемененное количество разделов переменной длины. При размещении процесса в основной памяти для него выделяется строго необходимое количество памяти. В качестве примера рассмотрим использование 64 Мбайт (рис. 5) основной памяти. Изначально вся память пуста, за исключением области, задействованной ОС. Первые три процесса загружаются в память, начиная с адреса, где заканчивается ОС, и используют столько памяти, сколько требуется данному процессу. После этого в конце ОП остается свободный участок памяти, слишком малый для размещения четвертого процесса. В некоторый момент времени все процессы в памяти оказываются неактивными, и операционная система выгружает второй процесс, после чего остается достаточно памяти для загрузки нового, четвертого процесса.
Рис. 5. Вариант использования памяти
Поскольку процесс 4 меньше процесса 2, появляется еще свободный участок памяти. После того как в некоторый момент времени все процессы оказались неактивными, но стал готовым к работе процесс 2, свободного места в памяти для него не находится, а ОС вынуждена выгрузить процесс 1, чтобы освободить необходимое место и разместить процесс 2 в ОП. Как показывает данный пример, этот метод хорошо начинает работу, но плохо продолжает. В конечном счете, он приводит к наличию множества мелких свободных участков памяти, в которых нет возможности разместить какой-либо новый процесс. Это называется внешней фрагментацией, что отражает тот факт, что сильно фрагментированной становится память, внешняя по отношению ко всем разделам.
3.Распределение памяти фиксированными разделами.
Самым простым способом управления оперативной памятью, о котором написано на сайте является разделение ее на несколько разделов фиксированной величины. Это может быть выполнено вручную оператором во время старта системы или во время ее генерации. Очередная задача, поступившая на выполнение, помещается либо в общую очередь (рисунок 2.9,а), либо в очередь к некоторому разделу (рисунок 2.9,б).
Рис. 2.9. Распределение памяти фиксированными разделами:
а - с общей очередью; б - с отдельными очередями Подсистема управления памятью в этом случае выполняет следующие задачи:
- сравнивая размер программы, поступившей на выполнение, и свободных разделов, выбирает подходящий раздел,
- осуществляет загрузку программы и настройку адресов.
При очевидном преимуществе - простоте реализации - данный метод имеет существенный недостаток - жесткость. Так как в каждом разделе может выполняться только одна программа, то уровень мультипрограммирования заранее ограничен числом разделов не зависимо от того, какой размер имеют программы. Даже если программа имеет небольшой объем, она будет занимать весь раздел, что приводит к неэффективному использованию памяти. С другой стороны, даже если объем оперативной памяти машины позволяет выполнить некоторую программу, разбиение памяти на разделы не позволяет сделать этого.
Практическая часть.
1.Постановка задачи.
Модель распределения памяти фиксированными разделами с отдельными очередями предполагает, что до начала загрузки программ вся память разделяется на непрерывные участки одинакового размера (блоки). Для каждой поступающей программы определен один участок, в который она должна быть загружена. Поступающие программы не должны превышать размера блока. Если блок, в котором программ должна быть обработана, занят, то программа ожидает его освобождения.
3. Исходные данные.
- общий объем памяти;
- размер блока;
- поток заявок на размещения в памяти (номер заявки, объем требуемой памяти, время поступления, продолжительность обработки заявки, номер раздела обслуживающего заявку).
Пример исходных данных:
- общий объем памяти – 32 Мб;
- размер блока – 8 Мб;
- номер заявки, объем требуемой памяти, время поступления, продолжительность обработки заявки, номер раздела обслуживающего заявку: (1,6,0,10, 1); (2,4,2,10, 2); (3,8,3,10, 3), (4,7,5,10, 1), (5,6,8,10, 4).
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.IO;
namespace Вариант_8
{
public partial class Form1: Form
{
public int vajno = 0;
public int crash = 0;
public Form1()
{
InitializeComponent();
label25.Text = ("Очередь пуста");
}
private void button1_Click(object sender, EventArgs e)
{
string put; //объявление пути до файла источника
openFileDialog1.ShowDialog(); //запуск диалогового окна для выбора исходного файла
put = openFileDialog1.FileName; //определение пути до файл-источника
textBox1.Text = put; //отображение на экране полного путь до файла
crash = 1;
}
private void button2_Click(object sender, EventArgs e)
{
if (crash!= 0)
{
Queue number = new Queue(); //объявление очереди, которая будет содержать номер заявки
Queue rem = new Queue(); //объявление очереди, которая будет содержать необходимый объем памяти для заявок
Queue input = new Queue(); //объявление очереди, которая будет содержать время поступления заявок
Queue timing = new Queue(); //объявление очереди, которая будет содержать время исполнения заявок
Queue razd = new Queue(); //объявление очереди, которая будет содержать номера обслуживающих разделов
int n = 0; //инициализация счетчика
string put; //объявление пути до файла источника
put = openFileDialog1.FileName; //определение пути до файл-источника
StreamReader str = new StreamReader(put); //открытие файлового потока вода
int razm = 8; //инициализация переменной, содержащей размер блока памяти
while (!str.EndOfStream) //ввод исходных данных
{
if (n % 5 == 0)
number.Enqueue(str.ReadLine());
else if (n % 5 == 1)
rem.Enqueue(str.ReadLine());
else if (n % 5 == 2)
input.Enqueue(str.ReadLine());
else if (n % 5 == 3)
timing.Enqueue(str.ReadLine());
else if (n % 5 == 4)
razd.Enqueue(str.ReadLine());
n += 1;
}
progressBar1.Maximum = razm; //определение максимального состояния нагрузки блока памяти
progressBar2.Maximum = razm;
progressBar3.Maximum = razm;
progressBar4.Maximum = razm;
int[] poryadok = new int[number.Count]; //определение массива, который будет содержать номер заявки
int[] remember = new int[rem.Count]; //определение массива, который будет содержать требуемый объем памяти
int[] vhod = new int[input.Count]; //определение массива, который будет содержать время поступления заявки
int[] during = new int[timing.Count]; //определение массива, который будет содержать продолжительность обработки заявки
int[] member = new int[razd.Count]; //объявление массива, который будет содержать номер обслуживающего раздела
n = 0;
while (razd.Count > 0) //определение значений массивов данных
{
poryadok[n] = int.Parse(number.Dequeue().ToString());
remember[n] = int.Parse(rem.Dequeue().ToString());
vhod[n] = int.Parse(input.Dequeue().ToString());
during[n] = int.Parse(timing.Dequeue().ToString());
member[n] = int.Parse(razd.Dequeue().ToString());
n += 1;
}
if (vajno!= 3) //отображение на экране результатов работы программы
{
if (vajno == 0)
{
progressBar1.Value = remember[vajno];
label1.Text = ("Заявка").ToString();
label2.Text = (vajno + 1).ToString();
label3.Text = ("Занято памяти").ToString();
label4.Text = (remember[vajno]).ToString();
label5.Text = ("Свободно памяти").ToString();
label6.Text = (8 - remember[vajno]).ToString();
}
else if (vajno == 1)
{
progressBar2.Value = remember[vajno];
label7.Text = ("Заявка").ToString();
label8.Text = (vajno + 1).ToString();
label9.Text = ("Занято памяти").ToString();
label10.Text = (remember[vajno]).ToString();
label11.Text = ("Свободно памяти").ToString();
label12.Text = (8 - remember[vajno]).ToString();
}
else if (vajno == 2)
{
progressBar3.Value = remember[vajno];
label13.Text = ("Заявка").ToString();
label14.Text = (vajno + 1).ToString();
label15.Text = ("Занято памяти").ToString();
label16.Text = (remember[vajno]).ToString();
label17.Text = ("Свободно памяти").ToString();
label18.Text = (8 - remember[vajno]).ToString();
}
else if (vajno == 4)
{
progressBar4.Value = remember[vajno];
label19.Text = ("Заявка").ToString();
label20.Text = (vajno + 1).ToString();
label21.Text = ("Занято памяти").ToString();
label22.Text = (remember[vajno]).ToString();
label23.Text = ("Свободно памяти").ToString();
label24.Text = (8 - remember[vajno]).ToString();
}
else if (vajno == 5)
{
progressBar1.Value = 0;
progressBar1.Value = remember[vajno - 2];
label1.Text = ("Заявка").ToString();
label2.Text = (vajno - 1).ToString();
label3.Text = ("Занято памяти").ToString();
label4.Text = (remember[vajno - 2]).ToString();
label5.Text = ("Свободно памяти").ToString();
label6.Text = (8 - remember[vajno - 2]).ToString();
label25.Text = ("Очередь пуста");
label26.Text = "";
}
else if (vajno == 10)
{
label25.Text = ("Угомони свой талант").ToString();
label26.Text = "";
}
}
else
{
label25.Text = ("Очередь занята, необходимы раздел").ToString();
label26.Text = (member[vajno]).ToString();
}
vajno = vajno + 1;
}
else
{
textBox1.Text = "Выберите файл";
}
}
private void label1_Click(object sender, EventArgs e)
{
}
}
}
Пример работы программы (программа отражает конечное состояние системы для исходных данных, приведенных в примере):
Список источников и литературы:
1. дом МИСиС,, 2010,Гордеев А.В. Операционные системы: Учебник для вузов. 2-е изд. – СПб.: Питер, 2007. – 416 с.: ил.
2.Олифер В.Г., Олифер Н.А. Сетевые операционные системы. СПб.: Питер, 2007.
3. http:// http://ru.wikipedia.org/
4. http://life-prog.ru/view_os.php?id=65
5. http://www.osys.ru/os/1/ponyatie_operatsionnoy_sistemy.shtml
6.http://www.studarhiv.ru/dir/cat32/subj120/file1237/view1237.html
7. http://www.intuit.ru/department/os/modernos/6/2.html
8. http://citforum.ru/operating_systems/sos/glava_7.shtml
