BolgenOS-Sim — учебный симулятор операционной системы (Python)

BolgenOS-Sim — это учебный проект по курсу «Операционные системы».

Это не настоящая загрузочная ОС, а лёгкий симулятор ядра на Python, который показывает:

• как операционная система представляет и планирует процессы;
• как работают классические алгоритмы планирования CPU (FCFS, Round Robin);
• как простая файловая система может управлять файлами и свободным местом;
• как всё это демонстрировать через консольный интерфейс.

Проект реализован на Python в виде консольного приложения.

“And? Now.” — a student-engineer inside a cascade of screens, code and noise. BolgenOS-Sim is one possible answer to that question.

_{Cover art generated with my own predictive model.}

---

Проект можно использовать как:

• индивидуальную лабораторную / зачётную работу по ОС;
• демонстрацию понимания внутренних механизмов ОС в портфолио.

---

1. Цели и учебный контекст

Цель BolgenOS-Sim:

• дать наглядную модель процессов, планировщика и файловой системы;
• позволить студенту играть с параметрами (время прихода, длительность задач, квант RR);
• показать, как меняются:
  • время ожидания процессов;
  • время полного выполнения (turnaround time);
  • поведение системы при разных алгоритмах.

Проект можно предъявить:

• преподавателю по курсу «Операционные системы» как индивидуальный проект;
• рекрутёрам и коллегам как небольшой, но честный учебный «kernel-simulator».

---

2. Структура проекта

Полное дерево репозитория:

bolgenos-os-sim/
├─ README.md              # английский обзор (по умолчанию)
├─ README_RU.md           # этот файл — README на русском (опционально)
├─ CHANGELOG.md           # история версий
├─ LICENSE                # лицензия MIT
├─ requirements.txt       # внешних зависимостей нет, только стандартная библиотека
├─ pyproject.toml         # метаданные проекта (имя, версия и т.п.)
├─ .gitignore             # стандартные правила для Python
├─ docs/
│  ├─ overview.md         # теория ОС + подробное описание симулятора
│  └─ figures/
│     └─ .gitkeep
│     └─ bolgenos_cover_and_now.png   # обложка/арт (по желанию)
├─ src/
│  ├─ __init__.py
│  ├─ processes.py        # модель процессов и их состояний
│  ├─ scheduler.py        # алгоритмы планирования CPU (FCFS, Round Robin)
│  ├─ fs.py               # учебная файловая система в памяти
│  ├─ cli.py              # основной CLI-демо (планировщик + ФС)
│  └─ fs_shell.py         # интерактивная оболочка файловой системы (fs> ...)
├─ examples/
│  └─ scenario_01.py      # пример сценария нагрузки для планировщика
└─ tests/
   ├─ test_scheduler.py   # тесты для планировщика (FCFS, RR)
   └─ test_fs.py          # тесты для файловой системы

Подробная теория о процессах, алгоритмах планирования и файловой системе — в docs/overview.md.

3. Основные компоненты

3.1. Модель процесса

Модуль: src/processes.py

Класс Process описывает процесс:

• pid — идентификатор процесса;

• arrival_time — момент входа в систему;

• burst_time — требуемое «количество квантов CPU»;

• priority — приоритет (зарезервировано для будущих алгоритмов);

• state — одно из состояний:

• NEW, READY, RUNNING, WAITING, TERMINATED.

Для симуляции используются поля:

• remaining_time — оставшееся время выполнения;

• start_time, finish_time;

• waiting_time — общее время ожидания в очереди READY.

Состояния задаются с помощью ProcessState и моделируют типичный жизненный цикл процесса в ОС.

3.2. Планировщик CPU

Модуль: src/scheduler.py

Реализованные алгоритмы:

• FCFS (First-Come, First-Served — «первым пришёл — первым обслужен»);

• Round Robin (RR) с настраиваемым квантом времени.

Оба алгоритма:

• принимают список Process;

• пошагово моделируют работу процессора (квант = 1);

• строят «диаграмму Ганта» — список (time, pid) (кто выполнял задачу в каждый момент времени);

• вычисляют:

• время ожидания waiting_time для каждого процесса;

• время полного выполнения (время обработки);

• средние значения по системе через объект ScheduleResult:

• avg_waiting_time();

• avg_turnaround_time().

3.3. Учебная файловая система

Модуль: src/fs.py

Модель в оперативной памяти файловой системы (всё хранится в оперативной памяти):

• FileEntry:

• name — имя файла;

• owner_pid — PID процесса-владельца (или None);

• size — логический размер в байтах;

• content — содержимое в виде строки.

• FileSystem предоставляет операции:

• create_file(name, owner_pid, content);

• write_file(name, content);

• read_file(name);

• delete_file(name);

• list_files(owner_pid=None);

• info() — краткая сводка: занято / свободно / количество файлов.

Контроль ёмкости:

• max_size — общий объём «диска»;

• used_size, free_size.

Собственные исключения:

• FileSystemError (базовое),

• FileExistsError,

• FileNotFoundError,

• NotEnoughSpaceError.

3.4. Демонстрационное ядро CLI

Модуль: src/cli.py

Точка входа: BolgenOS-Sim CLI.

Запуск:

python -m src.cli

CLI последовательно показывает:

1. демонстрация планировщика (demo_scheduler());

2. демонстрация файловой системы (demo_fs()).

3.5. Интерактивная FS-оболочка (fs-shell)

Модуль: src/fs_shell.py

Предоставляет простой текстовый интерфейс:

fs> info fs> ls [pid] fs> create [pid] fs> write fs> cat fs> rm fs> help fs> exit

Запуск:

python -m src.fs_shell

Это удобно демонстрировать на защите как «консоль учебной ОС».

4. Установка и запуск

4.1. Требования

• Python 3.10+

• Внешние библиотеки не требуются (используется только стандартная библиотека).

4.2. Клонирование репозитория

git clone https://github.com//bolgenos-os-sim.git cd bolgenos-os-sim

(при необходимости можно создать и активировать виртуальное окружение venv).

5. Примеры запуска и вывода данных в консоль

5.1. Основной демонстрационный режим (планировщик + ФС)

Запуск:

python -m src.cli

Пример ожидаемого вывода (фрагмент):

=== BolgenOS-Sim CLI ===
=== Scheduler demo (BolgenOS-Sim) ===

--- FCFS (First-Come, First-Served) ---
Gantt chart:
  0: P1
  1: P1
  2: P1
  3: P1
  4: P1
  5: P2
  6: P2
  7: P2
  8: P3
  9: P3
 10: P3
 11: P3
Avg waiting time   = 2.33
Avg turnaround time= 6.33

--- Round Robin (q = 2) ---
Gantt chart:
  0: P1
  1: P1
  2: P2
  3: P2
  4: P1
  5: P1
  6: P3
  7: P3
  8: P2
  9: P1
 10: P3
 11: P3
Avg waiting time   = 4.33
Avg turnaround time= 8.33

(точные числа зависят от сценария и реализации, здесь приведён типичный пример).

Далее — демо файловой системы:

=== FileSystem demo (BolgenOS-Sim) ===
BolgenOS FS: used 0 / 64 bytes, files: 0

После создания файлов:
BolgenOS FS: used 32 / 64 bytes, files: 2
- hello.txt (pid=1, size=16)
- log.txt   (pid=2, size=16)

Содержимое hello.txt:
Hello, BolgenOS!

Обновлённое содержимое log.txt:
Started.
Step 1 done.
Step 2 done.

После удаления hello.txt:
BolgenOS FS: used 16 / 64 bytes, files: 1
- log.txt   (pid=2, size=16)

=== End of BolgenOS-Sim demo ===

Это можно переписать в отчёт как «пример работы программы».

5.2. Интерактивная оболочка файловой системы

Запуск:

python -m src.fs_shell

Пример диалога:

=== BolgenOS-Sim FS Shell ===
Logical disk size: 256 bytes
Type 'help' for available commands.

fs> info
BolgenOS FS: used 0 / 256 bytes, files: 0

fs> create notes.txt 1
Enter content (single line): hello from BolgenOS
File 'notes.txt' created.

fs> ls
notes.txt           size= 20 pid=1

fs> cat notes.txt
hello from BolgenOS

fs> write notes.txt
Enter new content (single line): updated content
File 'notes.txt' updated.

fs> cat notes.txt
updated content

fs> rm notes.txt
File 'notes.txt' deleted.

fs> ls
(no files)

fs> exit

Такую сессию удобно вставить в отчёт, показывая, что файловая система не просто «декларирована», а реально работает.

5.3. Пример сценария нагрузки (examples/scenario_01.py)

Отдельный пример для планировщика:

python examples/scenario_01.py

Скрипт:

• создаёт несколько процессов с разными временем прихода и длительностью;

• сравнивает FCFS и Round Robin (q = 2);

• выводит диаграмму Ганта и средние времена.

Это можно использовать как отдельный эксперимент для контрольной/курсовой.

6. Метрики, используемые в симуляторе

Для каждого процесса i:

• Время ожидания (waiting time):

для простых алгоритмов (FCFS):

Wi = start_time_i − arrival_time_i

для Round Robin Wi — суммарное время, проведённое процессом в состоянии READY между квантами.

• Время полного выполнения (turnaround time):

Ti = finish_time_i − arrival_time_i

Для системы с n процессами:

• среднее время ожидания:

W̄ = (1 / n) · Σ_{i=1..n} Wi

• среднее время полного выполнения:

T̄ = (1 / n) · Σ_{i=1..n} Ti

Эти величины рассчитываются в ScheduleResult и выводятся в CLI-демо.

7. Использование в учебной работе

BolgenOS-Sim удобно использовать как:

• индивидуальный проект по ОС, заменяющий несколько лабораторных:

• «Планирование процессов»;

• «Файловые системы»;

• источник примеров для отчёта:

• диаграммы Ганта;

• таблицы с метриками (Wi, Ti, средние значения);

• фрагменты диалога FS-оболочки.

Проект показывает:

• понимание базовой теории ОС;

• умение реализовать учебную модель на Python;

• аккуратную структуру кода и документации (README, docs, tests).

В дальнейшем можно добавить:

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

SJF / SRTF;

визуализацию диаграммы Ганта (matplotlib);

простую модель памяти и файловой системы.

8. Автор

Светлана Романова (SvetLuna) Python / ML инженер (student), исследователь учебных моделей операционных систем и ИИ.