Размещено на http://www.allbest.ru/

СОДЕРЖАНИЕ

• ВВЕДЕНИЕ
• 1. ПОСТАНОВКА ЗАДАЧИ
• 1.1 Цель и задачи работы
• 1.2 Обоснование выбора средства программирования
• 1.3 Входная и выходная информация
• 1.4 Требования к аппаратному обеспечению
• 1.5 Требования к программному обеспечению
• 2. СВЕДЕНИЯ ИЗ ТЕОРИИ
• 3. АЛГОРИТМ РЕШЕНИЯ ЗАДАЧИ
• 4. ОПИСАНИЕ ПРОГРАММЫ
• 4.1 Функциональное назначение программы
• 4.2 Глобальные переменные и константы
• 4.3 Внутренняя структура программы
• 5. Руководство пользователя
• ЗАКЛЮЧЕНИЕ
• ЛИТЕРАТУРА
• ПРИЛОЖЕНИЕ
• ВВЕДЕНИЕ
• В данной работе исследуется программное изделие для сравнения алгоритмов. Данная тема избранна потому, что она актуальна и будет полезна в работе. Работа включает в себя пояснительную записку, дистрибутив программы, исходный код. Данная тема актуальна потому, что данное программное позволяет понять какие алгоритмы быстродейственнее.
• Объект исследования - алгоритм гарантированного и приоритетного планирования.
• Предмет - среда разработки на языке C#.

Задачи: Исследование алгоритмов гарантированного и приоритетного планирования вычислительного процесса мультипроцессорных систем при пакетной обработке задач.

1. ПОСТАНОВКА ЗАДАЧИ

1.1 Цель и задачи работы

Основной целью данной работы является разработка программы «Сравнение алгоритмов», а также закрепление практических навыков программирования в среде C#.

Задачи курсовой работы:

- изучить основные алгоритмы гарантированного и приоритетного планирования;

- сделать вывод о работе алгоритмов;

- осуществить программную реализацию и протестировать разработанное приложение.

1.2 Обоснование выбора средства программирования

Для написания программы была выбрана среда программирования С. Данная среда, выгодно отличается эффективностью и надежностью по сравнению с другими инструментальными средами.

1.3 Входная и выходная информация

Входными данными для программы является выбор количества элементов, выбор вида алгоритма сортировки и выбор количества процессоров.

Выходными данными являются сгенерированный массив и отчёт о проделанной процессорной работе.

1.4 Требования к аппаратному обеспечению

Требования к аппаратному обеспечению указанны в таблице 1.

Компьютер и процессор	Компьютер с процессором, работающим на тактовой частоте не менее 233 МГц (рекомендуется процессор Pentium)
Память	Не менее 32 mb of RAM
Дисковод	Дисковод для компакт-дисков (если установка производится с компакт-диска)
Дисплей	Монитор Super VGA с разрешением (800 x 600) или более высоким при цветности в 256 цветов
Периферийное оборудование	Модем или подключение к Интернету;

1.5 Требования к программному обеспечению

Для функционирования данного программного продукта на компьютере должна быть установлена операционная система Windows 9X или более поздняя версия.

2. СВЕДЕНИЯ ИЗ ТЕОРИИ

Важнейшей частью операционной системы, непосредственно влияющей на функционирование вычислительной машины, является подсистема управления процессами. Процесс (или по-другому, задача) - абстракция, описывающая выполняющуюся программу. Для операционной системы процесс представляет собой единицу работы, заявку на потребление системных ресурсов.

Операционная система поддерживает обособленность процессов: у каждого процесса имеется свое виртуальное адресное пространство, каждому процессу назначаются swap ресурсы -- файлы, окна, семафоры и т. д. Такая обособленность нужна для того, чтобы защитить один процесс от другого, поскольку они, совместно используя все ресурсы вычислительной системы, конкурируют друг с другом. В общем случае процессы просто никак не связаны между собой и могут принадлежать даже разным пользователям, разделяющим одну вычислительную систему.

Планирование - обеспечение поочередного доступа процессов к процессору.

Планировщик - часть операционной системы использующий алгоритм планирования.

Существуют два вида планирования в вычислительных системах (различные уровни планирования процессов):

· планирование заданий - процедура выбора очередного задания для загрузки в машину для порождения соответствующего процесса;

· планирование использования процессора - процедура выбора процесса находящегося в состоянии готовности и перевод его в состояние исполнения;

Планирование заданий появилось в пакетных системах после того, как для хранения сформированных пакетов заданий начали использоваться магнитные диски. Магнитные диски, являясь устройствами прямого доступа, позволяют загружать задания в компьютер в произвольном порядке, а не только в том, в котором они были записаны на диск. Изменяя порядок загрузки заданий в вычислительную систему, можно повысить эффективность ее использования.

Планирование использования процессора впервые возникает в мультипрограммных вычислительных системах, где в состоянии готовности могут одновременно находиться несколько процессов.

Рисунок № 1 Планирование процессов.

программный аппаратный константа

Ситуации, когда необходимо планирование:

· Когда создается процесс;

· Когда процесс завершает работу;

· Когда процесс блокируется на операции ввода/вывода, семафоре, и т.д.

· При прерывании ввода/вывода.

Долгосрочное планирование

Планировщик доступа выбирает задачи оптимальным образом (например: процессы, ограниченные процессором и вводом/выводом).

Если процессов в памяти слишком много, планировщик памяти выгружает и загружает некоторые процессы на диск. Количество процессов находящихся в памяти, называется степенью многозадачности.

Планирование заданий используется в качестве долгосрочного планирования процессов. Оно отвечает за порождение новых процессов в системе, определяя ее степень мультипрограммирования, т. е. количество процессов, одновременно находящихся в ней. Если степень мультипрограммирования системы поддерживается постоянной, т. е. среднее количество процессов в компьютере не меняется, то новые процессы могут появляться только после завершения ранее загруженных. Поэтому долгосрочное планирование осуществляется достаточно редко, между появлением новых процессов могут проходить минуты и даже десятки минут. Решение о выборе для запуска того или иного процесса оказывает влияние на функционирование вычислительной системы на протяжении достаточно длительного времени. В некоторых операционных системах долгосрочное планирование сведено к минимуму или отсутствует вовсе.

Краткосрочное планирование

Планирование использования процессора применяется в качестве краткосрочного планирования процессов (выбор нового процесса для исполнения). Оно проводится, к примеру, при обращении исполняющегося процесса к устройствам ввода-вывода или просто по завершении определенного интервала времени. Поэтому краткосрочное планирование осуществляется, как правило, не реже одного раза в 100 миллисекунд.

Среднесрочное планирование

В некоторых вычислительных системах бывает выгодно для повышения производительности временно удалить какой-либо частично выполнившийся процесс из оперативной памяти на диск, а позже вернуть его обратно для дальнейшего выполнения. Когда и какой из процессов нужно перекачать на диск и вернуть обратно, решается дополнительным промежуточным уровнем планирования процессов - среднесрочным.

Критерии планирования и требования к алгоритмам

Для каждого уровня планирования процессов можно предложить много различных алгоритмов. Выбор конкретного алгоритма определяется классом задач, решаемых вычислительной системой, и целями, которых мы хотим достичь, используя планирование. К числу таких целей можно отнести следующие:

Справедливость - гарантировать каждому заданию или процессу определенную часть времени использования процессора в компьютерной системе, стараясь не допустить возникновения ситуации, когда процесс одного пользователя постоянно занимает процессор, в то время как процесс другого пользователя фактически не начинал выполняться.

Эффективность - постараться занять процессор на все 100% рабочего времени, не позволяя ему простаивать в ожидании процессов, готовых к исполнению. В реальных вычислительных системах загрузка процессора колеблется от 40 до 90%.

Сокращение полного времени выполнения (turnaround time) - обеспечить минимальное время между стартом процесса или постановкой задания в очередь для загрузки и его завершением.

Сокращение времени ожидания (waiting time) - сократить время, которое проводят процессы в состоянии готовность и задания в очереди для загрузки.

Сокращение времени отклика (response time) - минимизировать время, которое требуется процессу в интерактивных системах для ответа на запрос пользователя.

Алгоритм планирования без переключений (неприоритетный) - не требует прерывание по аппаратному таймеру, процесс останавливается только когда блокируется или завершает работу.

Алгоритм планирования с переключениями (приоритетный) - требует прерывание по аппаратному таймеру, процесс работает только отведенный период времени, после этого он приостанавливается по таймеру, чтобы передать управление планировщику.

Необходимость алгоритма планирования зависит от задач, для которых будет использоваться операционная система.

Системы планирования:

Системы пакетной обработки - могут использовать неприоритетный и приоритетный алгоритм (например: для расчетных программ).

Интерактивные системы - могут использовать только приоритетный алгоритм, нельзя допустить чтобы один процесс занял надолго процессор (например: сервер общего доступа или персональный компьютер).

Системы реального времени - могут использовать неприоритетный и приоритетный алгоритм (например: система управления автомобилем).

Невытесняющее планирование:

Невытесняющее планирование используется, например, в MS Windows 3.1 и ОС Apple Macintosh. При таком режиме планирования процесс занимает столько процессорного времени, сколько ему необходимо. При этом переключение процессов возникает только при желании самого исполняющегося процесса передать управление (для ожидания завершения операции ввода-вывода или по окончании работы). Этот метод планирования относительно просто реализуем и достаточно эффективен, так как позволяет выделить большую часть процессорного времени для работы самих процессов и до минимума сократить затраты на переключение контекста. Однако при невытесняющем планировании возникает проблема возможности полного захвата процессора одним процессом, который вследствие каких-либо причин (например, из-за ошибки в программе) зацикливается и не может передать управление другому процессу. В такой ситуации спасает только перезагрузка всей вычислительной системы.

Вытесняющее планирование

Вытесняющее планирование обычно используется в системах разделения времени. В этом режиме планирования процесс может быть приостановлен в любой момент исполнения. Операционная система устанавливает специальный таймер для генерации сигнала прерывания по истечении некоторого интервала времени - кванта. После прерывания процессор передается в распоряжение следующего процесса. Временные прерывания помогают гарантировать приемлемое время отклика процессов для пользователей, работающих в диалоговом режиме, и предотвращают "зависание" компьютерной системы из-за зацикливания какой-либо программы.

Состояния процесса

В многозадачной (многопроцессной) системе процесс может находиться в одном из трех основных состояний:

ВЫПОЛНЕНИЕ - активное состояние процесса, во время которого процесс обладает всеми необходимыми ресурсами и непосредственно выполняется процессором;

ОЖИДАНИЕ - пассивное состояние процесса, процесс заблокирован, он не может выполняться по своим внутренним причинам, он ждет осуществления некоторого события, например, завершения операции ввода-вывода, получения сообщения от другого процесса, освобождения какого-либо необходимого ему ресурса;

ГОТОВНОСТЬ - также пассивное состояние процесса, но в этом случае процесс заблокирован в связи с внешними по отношению к нему обстоятельствами: процесс имеет все требуемые для него ресурсы, он готов выполняться, однако процессор занят выполнением другого процесса.



Рисунок № 2 Состояние процесса

FIFO (First In Fist Out, FCFS First Come First Serve)

«Первый пришел - первым обслужен»

Процессы ставятся в очередь по мере поступления.

Преимущества:

· Простата

· Справедливость (как в очереди покупателей, кто последний пришел, тот оказался в конце очереди)

Недостатки:

Процесс, ограниченный возможностями процессора может затормозить более быстрые процессы, ограниченные устройствами ввода/вывода



Рисунок № 3 Прямой порядок выполнения (оказался неэффективным -- процессы долго находятся в состоянии готовности).

Рисунок № 4 Прямой порядок выполнения (более эффективный чем первый).

Циклическое планирование RR (Round Robin)

Самый простой алгоритм планирования и часто используемый.

Каждому процессу предоставляется квант времени процессора. Когда квант заканчивается процесс переводится планировщиком в конец очереди. При блокировке процессор выпадает из очереди.

Преимущества:

· Простота

· Справедливость (как в очереди покупателей, каждому только по килограмму) Недостатки:

· Если частые переключения (квант - 4мс, а время переключения равно 1мс), то происходит уменьшение производительности.

· Если редкие переключения (квант - 100мс, а время переключения равно 1мс), то происходит увеличение времени ответа на запрос.



Рисунок № 5 Циклическое планирование RR (Round Robin)

На производительность алгоритма RR сильно влияет величина кванта времени. Рассмотрим тот же самый пример с порядком процессов p0, p1, p2 для величины кванта времени, равной 1. Время ожидания для процессаp0 составит 5 единиц времени, для процесса p1 - тоже 5 единиц, для процесса p2 - 2 единицы. В этом случае среднее время ожидания получается равным (5 + 5 + 2)/3 = 4 единицам времени. Среднее полное время исполнения составит (18 + 9 + 3)/3 = 10 единиц времени.

Shortest-Job-First (SJF)

«Кратчайшая задача - первая»

Преимущества:

· Уменьшение оборотного времени

· Справедливость (как в очереди покупателей, кто без сдачи проходит в перед)

Недостатки:

· Длинный процесс занявший процессор, не пустит более новые краткие процессы, которые пришли позже (в случае невытесняющего).

SJF-алгоритм краткосрочного планирования может быть как вытесняющим, так и невытесняющим. При невытесняющем SJF-планировании процессор предоставляется избранному процессу на все необходимое ему время, независимо от событий, происходящих в вычислительной системе. При вытесняющем SJF-планировании учитывается появление новых процессов в очереди готовых к исполнению (из числа вновь родившихся или разблокированных) во время работы выбранного процесса. Если CPU burst нового процесса меньше, чем остаток CPU burst у исполняющегося, то исполняющийся процесс вытесняется новым.

При использовании невытесняющего алгоритма SJF первым для исполнения будет выбран процесс p3, имеющий наименьшее значение продолжительности очередного CPU burst. После его завершения для исполнения выбирается процесс p1, затем p0 и, наконец, p2.

Пример вытесняющего SJF планирования : взят ряд процессов p0, p1, p2 и p3 с различными временами CPU burst и различными моментами их появления в очереди процессов, готовых к исполнению. Если приходит новый процесс, его полное время выполнения сравнивается с оставшимся временем выполнения текущего процесса.

Приоритетное планирование

Алгоритмы SJF и гарантированного планирования представляют собой частные случаи приоритетного планирования. При приоритетном планировании каждому процессу присваивается определенное числовое значение - приоритет, в соответствии с которым ему выделяется процессор. Процессы с одинаковыми приоритетами планируются в порядке FCFS. Для алгоритма SJF в качестве такого приоритета выступает оценка продолжительности следующего CPU burst.

Планирование с использованием приоритетов может быть как вытесняющим, так и невытесняющим. При вытесняющем планировании процесс с более высоким приоритетом, появившийся в очереди готовых процессов, вытесняет исполняющийся процесс с более низким приоритетом. В случае невытесняющего планирования он просто становится в начало очереди готовых процессов. Рассмотрим примеры использования различных режимов приоритетного планирования.

Предположим, что большее значение соответствует меньшему приоритету, т. е. наиболее приоритетным в нашем примере является процесс p3, а наименее приоритетным - процесс p0.

3. АЛГОРИТМ РЕШЕНИЯ ЗАДАЧИ

Алгоритм решения представим в словесной форме:

1. Выбирается количество элементов в исходном массиве, 10, 100, 1000 или 10000.

2. Генерируется массив случайных чисел, с исходным количеством элементов.

3. Выбирается алгоритм по которому будет идти сортировка.

4. Выбирается количество ядер процессора.

5. Далее идет сортировка.

6. Просчитывается количество тактов сделанных каждым процессором, ожидание и работа соответственно.

7. Далее выводиться в RichTextBox для каждого процессора количество тактов, ожидание и работа соответственно.

4. ОПИСАНИЕ ПРОГРАММЫ

4.1 Функциональное назначение программы

Данная программа предназначена для определения более эффективного алгоритма сортировки мультипроцессорного планирования, при разных объемах заявок.

4.2 Глобальные переменные и константы

· Form1 - главное окно программы;

· MenuStrip - меню информации и управления.

· ToolStripMenuItem - конкретные меня информации и управления.

· ComboBox - управление полем со списком.

· RichNextBox - поле управления форматированным текстом.

· Button - это простая командная кнопка.

· Label - текстовая строка.

4.3 Внутренняя структура программы

Так как при нажатии какой-либо кнопки вызывается обработчик события нажатия этой кнопки, то для каждой кнопки необходимо написать свой обработчик, который оформляется в виде соответствующей процедуры.

Для ввода адреса сайта, по которому необходимо перейти, отображения адреса странички, которая просматривается пользователем используется стандартный компонент TEdit.

Важно отметить, что программа состоит из следующих файлов:

- файла проекта (файл с расширением .bpr);

- файла описания класса формы, с расширением .h;

- файла исходного текста (с расширением .cpp);

- файла с описанием окон формы (с расширением .dfm);

В файле проекта находится информация о модулях, составляющих данный проект.

Руководство пользователя

Запускаем приложение:

В окне выбора количества элементов, выбираем 10, 100, 1000 или 10000:

Далее нажимаем, сгенерировать случайны массив:

Выбираем алгоритм управления и количество ядер процессора:

Получаем итоговую информацию о работе проделанной процессорами:



ЗАКЛЮЧЕНИЕ

Алгоритм управления процессором	Количество заявок	Количество ядер процессора	Общее количество тактов	Общее ожидание
FCFS	10	1	73	554
		2	62	457
		4	61	455
	100	1	702	5279
		2	665	4965
		4	649	4854
	1000	1	6630	49474
		2	6860	51202
		4	6713	50089
	10000	1	66571	496835
		2	67373	503397
		4	66651	497516
SJF	10	1	75	469
		2	70	228
		4	56	82
	100	1	696	44642
		2	701	22825
		4	708	11442
	1000	1	6635	4098361
		2	6647	2041347
		4	6703	1047815
	10000	1	66760	413499020
		2	67088	208016914
		4	67376	104774012
RR	10	1	65	391
		2	49	143
		4	50	78
	100	1	682	45716
		2	677	22225
		4	629	10213
	1000	1	6586	4325472
		2	6967	2308646
		4	6700	1085642
	10000	1	67804	446809515
		2	67695	222239629
		4	67756	223235128

ЛИТЕРАТУРА

1. Лойко В.И., Барановская Т.П. и д.р. Архитекрура компьютерных систем и сетей, М.: Финансы и статистика, 2003г.

2. Таненбаум Э Архитектура компьютера, С.-Петербург, 2003г.

3. Вентцель Е.С. Исследование операций: задачи, принципы, методология. - М.: Наука, 1990.

4. Библиографический аппарат издания //Справочная книга редактора и корректора. 2-е изд., прераб. М., 1985.

5. Государственный образовательный стандарт высшего профессионального образования. Специальность 351400 "Прикладная информатика (по областям)". Квалификация - информатик (квалификация по областям) /Утверждена МО РФ 12.3.2000г., номер государственной регистрации 52мжд/сп. - M., 2000. - 28с.

6. ГОСТ 2. 105-79. Общие требования к текстовым документам. М.,1979

7. ГОСТ 7.1-84. Библиографическое описание документа. Общие требования и правила оформления. М., 1984

8. ГОСТ 7.1-85. Библиографическое описание документа: Инструктивно-методические указания к внедрению. М., 1985

9. ГОСТ 7.12-77. Сокращение русских слов и словосочетаний в библиографических описаниях произведений печати. М., 1982

10. ГОСТ 7.32-81. Отчет о научно-исследовательской работе. Общие требования и правила оформления. М., 1981.

11. ГОСТ 7.9-77. Реферат и аннотация. М., 1978.

12. Группировка литературы //Соловьева Е.П. Правила оформления библиографического анализа курсовых и дипломных работ: Методические указания для студентов государственных университетов. М.,1980.

ПРИЛОЖЕНИЕ

Листинг основного модуля

void rr()

{

switch (Convert.ToInt32(comboBox2.SelectedItem))

{

case 1:

a.mas = new List<int>(array);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

int tt, kol = 0;

tt = 8;

int el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

string waitts = "";

int sigma = 0;

string work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

string dash;

//переменная всё из масседж бокса

dash = "Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

Вывод blyat = new Вывод(dash);

blyat.ShowDialog();

//MessageBox.Show("Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times);

break;

case 2:

List<int> first = new List<int>();

List<int> second = new List<int>();

for (int i = 0; i < array.Length; i++)

{

if (i % 2 == 0)

{

first.Add(array[i]);

}

else

{

second.Add(array[i]);

}

}

string resultat_1;

string resultat_2;

//pervii proc

a.mas = new List<int>(first);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_1="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//second proc

a.mas = new List<int>(second);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_2="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//переменная всё из масседж бокса

dash = resultat_1 + "\n\n\n" + resultat_2;

Вывод blyat2 = new Вывод(dash);

blyat2.ShowDialog();

//MessageBox.Show(resultat_1 + "\n\n\n" + resultat_2);

break;

case 4:

first = new List<int>();

second = new List<int>();

string resultat_3;

string resultat_4;

List<int> tret = new List<int>();

List<int> chet = new List<int>();

List<int> tem1 = new List<int>();

List<int> tem2 = new List<int>();

for (int i = 0; i < array.Length; i++)

{

if (i % 2 == 0)

{

tem1.Add(array[i]);

}

else

{

tem2.Add(array[i]);

}

}

for (int i = 0; i < tem1.Count; i++)

{

if (i % 2 == 0)

{

first.Add(tem1[i]);

}

else

{

second.Add(tem1[i]);

}

}

for (int i = 0; i < tem2.Count; i++)

{

if (i % 2 == 0)

{

tret.Add(tem2[i]);

}

else

{

chet.Add(tem2[i]);

}

}

//proc 1

a.mas = new List<int>(first);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_1="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//second

a.mas = new List<int>(second);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_2="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//tretiy

a.mas = new List<int>(tret);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_3="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//chetvert

a.mas = new List<int>(chet);

a.masi = new List<int>();

b.masi = new List<int>();//время ожидания каждого процессора

b.mas = new List<int>();//время ожидания общее

for (int i = 0; i < a.mas.Count; i++)

{

a.masi.Add(i);

b.masi.Add(0);

b.mas.Add(0);

}

kol = 0;

tt = 8;

el = 0;

while (a.mas.Count != 0)

{

el = a.mas[0];

a.mas.RemoveAt(0);

b.masi[a.masi[0]] += 1;

el -= tt;

if (el > 0)

{

a.mas.Add(el);

a.masi.Add(a.masi[0]);

a.masi.RemoveAt(0);

}

else

{

b.mas[a.masi[0]] = kol;

a.masi.RemoveAt(0);

}

kol += 1;

}

kol = 0;

waitts = "";

sigma = 0;

work_times = "";

for (int i = 0; i < b.mas.Count; i++)

{

waitts += "Ожидание " + (i + 1).ToString() + " процесса = " + b.mas[i].ToString() + "\n";

sigma += b.mas[i];

work_times += "\nРабота " + (i + 1).ToString() + " процесса = " + b.masi[i].ToString();

kol += b.masi[i];

}

resultat_4="Количество тактов сделанных процессором: " + kol.ToString() + "\nОжидание: " + sigma.ToString() + "\n" + waitts + "\nРабота по процессам: " + work_times;

//переменная всё из масседж бокса

dash = resultat_1 + "\n\n\n" + resultat_2 + "\n\n\n" + resultat_3 + "\n\n\n" + resultat_4;

Вывод blyat4 = new Вывод(dash);

blyat4.ShowDialog();

//MessageBox.Show(resultat_1 + "\n\n\n" + resultat_2 + "\n\n\n" + resultat_3 + "\n\n\n" + resultat_4);

break;

}

}

private void gen_Click(object sender, EventArgs e)

{

if (comboBox1.Text == "FCFS")

fcfs();

else

{

if (comboBox1.Text == "SJF")

sjf();

else

rr();

}

//////////////////////////////////////////////////////////////

Главная frm = new Главная();

frm.Owner = this; //Передаём вновь созданной форме её владельца.

frm.Show();

Close();

}

}

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