Разработка подсистемы управления процессами с невытесняющей многозадачностью на python

Python
#14 
print('Модель подсистемы управления процессами с невытесняющей многозадачностью')
print('prod. by ALEX')
desc_list = []

def CreateProc(quant):
	description = {
		'id': len(desc_list),
		'quant': quant
	}
	desc_list.append(description)

def start():
	print('start')

	max_quant = 0
	flag = 0
	for x in desc_list:
		if x['quant'] > max_quant:
			max_quant = x['quant']
	print('Количество квантов ', max_quant)

	while flag - 1 != max_quant:
		flag+=1
		print('__________ИТЕРАЦИЯ №',flag,'__________')
		for x in desc_list:
			x['quant'] -= 1
			print('Выполнение процесса №', x['id'], 'Осталось квантов - ', x['quant'])

			if x['quant'] == 0:
				print('до удаления', desc_list)
				desc_list.remove(x)
				print('Удаляем', x)
				print('После удаления', desc_list)
				#print('Процесс №', x['id'], ' завершен')

		print('_______________________________')
		

while True:
	command = input('>>> ')

	if command == 'add':
		quant = input('Введите квант >>> ')
		CreateProc(int(quant))

	if command == 'desc_list':
		for x in desc_list:
			print(x)

	if command == 'start':
		start()

у меня вот есть с вытесняющей многозадачностью,но вот что с невытесняющий делать хз,точнее как из этого,переделать под неё

#15

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

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

Как примитивный вариант наверно можно в описание процесса

добавить свойства

  • на каком он сейчас кванте своей работы (изначально 0)
  • список номеров квантов, на которых он будет передавать управление

и гонять это в бесконечном цикле пока все не завершатся.

#16

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

#17

можешь помочь с этим?

#18

Да вот же примитивный пример из учебника. Работы на 15 минут вместе с чтением главы.

Не вытесняющая многозадачность 
# Non-crowding multitasking
import time
import random
import asyncio

async def waiter(name):
    for _ in range(4):
        time_to_sleep = random.randint(1, 3) / 4
        time.sleep(time_to_sleep)
        print(
            "{} waited {} seconds"
            "".format(name, time_to_sleep)
        )
        
async def main():
    await asyncio.wait([waiter("first"), waiter("second")])
    
if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()
Вытесняющая многозадачность 
# Pre-supplanting multitasking
import time
import random
import asyncio

async def waiter(name):
    for _ in range(4):
        time_to_sleep = random.randint(1, 3) / 4
        await asyncio.sleep(time_to_sleep)
        print(
            "{} waited {} seconds"
            "".format(name, time_to_sleep)
        )
        
async def main():
    await asyncio.wait([waiter("first"), waiter("second")])
    
if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()
#19

Выше ж написано что можно сделать в том примере

(первое свойство можно не добавлять если отнимать от quant как в примере было)

#20

Чот не похоже.
Имеется в виду, что ожидание считать работой? (если нет, то тогда тут вообще ничего нет)
Для наглядности ставим паузу 5 сек time_to_sleep = 5, и видим, что оба процесса завершают ожидание одновременно, то есть никто никого не блокирует.

Вообще тут просто сравнение синхронного и асинхронного ожидания.

Тогда уж скорее первый пример невытесняющий:

second waited 3 seconds
second waited 3 seconds
second waited 3 seconds
second waited 3 seconds
first waited 3 seconds
first waited 3 seconds
first waited 3 seconds
first waited 3 seconds

но получается совсем уж примитивно, один процесс тупо ждет полного завершения другого, никто никогда не передает управление.

#21

взять 2 код и это вся работа?

#22

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

#23

Можно взять первый пример.
Вся это работа или нет, решайте сами.
Если это лаба тогда да, этого будет достаточно.
Для курсовой работы этого примитива не достаточно. Нужно усложнять код.

#24

Учитывая

Первый пример можно даже упростить до такого ))

import random
import time


def run_proc(name):
    time_to_sleep = random.randint(1, 4) / 4
    time.sleep(time_to_sleep)
    print(
        "{} worked for {} seconds"
        "".format(name, time_to_sleep)
    )


run_proc('process 1')
run_proc('process 2')
#25

Наверное нет.
Тогда это уже действительно будет простое последовательное выполнение.

#26

Так а в первом примере по сути ж и есть оно.

#27

Там приведены примеры асинхронного выполнения.

#28

да,нужно именно для курсовой,я тоже смотрю,как-то слишком просто

#29

Тогда здесь работает метод как сказал Алекс:

Над курсовой работой нужно работать. Курсовая работа это производная от работать.
Мне например будет не интересно, нет необходимости в данное время писать на Python нечто подобное.

#30

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

#31

на фриланс размещал,0 отклика,больше месяца прошло

#32

Так а нам что, должно было как-то впечатлить?
Писал выше, не интересно.
Повезло бы в случае, если в данное время кто работал бы над похожей задачей и поделился бы. И то не факт.

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

P. S.
В свое время обучения один раз обращался к фрилансерам.
А в остальном делал все самостоятельно, цель была обучение самого себя.

P. P. S.
Python не моя стихия.
Но даже исходя из этого, лабу приведенную выше превратил бы в курсовую работу за две недели с нолевыми знаниями темы работы. Неделя на описательную часть, неделя на код.

#33

были бы в доступе ещё эти 2 недели)