Добавил:
Studfiles2
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Расчетно-графическая работа №5 / ATK sapr230 Manaev / expSub
.py #-*- coding: cp1251 -*-
# -----------------------------------------------------
# Программа parATKvXXX.py
# Модуль expSub.py
#
# Модуль учебных (экспериментальных) подпрограмм
#
# Данный модуль содержит подпрограммы дополонительных циклов
# конфигурации АТК12 (двенадцать силовых головок)
# автоматизированного технологического комлпекса АТК.
# Модуль предназначен для упрощения экспериментов
# по многопоточному программированию
# с групповыми циклами силовых головок в конфигурации АТК12.
# Для программных экспериментов на основе данного модуля
# в блок переключателей рабочего режима на пульте управления
# дополнительно введены
# второй и третий ряды перецелючателей циклов (радио-кнопки).
#
# ----------------------------------------------------
# Разработчик программы parATK Житников А.П.
# ноябрь 2005г.
# -----------------------------------------------------
import ConfigParser
import tkFileDialog
import thread
import threading
import math, time
import expSub
# -------------------------------------
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э2: Этап 2: Тренаж: Простые примеры
# Первичный тренаж - упаковка в паралльеные потоки отдельных команд
# Используется второй ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A001: Пустой алгоритм - проходная интерпретация
# СФА: Структурная формула алгоритма
# A001 = () = (-) = (->) = (R) = -> = R
# ССА: Структурная схема алгоритма
# A211: R
# ----------> = ------+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = () = R
# A001 = R
# РТА: Рабочий текст алгоритма
# alg A001(): pass
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001():
# = ( ( | R pass
# ( R | R
# R ) )
# )
# ТПР: Текст программной реализации алгоритма
def eA001(ccrt, hCycles): # alg A001():
pass # пустой оператор: R = ->
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A002: Пустой алгоритм - непроходная интерпретация
# Для сведения
# СФА: Структурная формула алгоритма
# A002 = (|)
# #-----------------------------------------
# Пример A101: Единичный алгоритм
# СФА: Структурная формула алгоритма
# A101 = (Z8) = Z8
# ССА: Структурная схема алгоритма
# A211: Z8
# ------+----->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = (Z8) = Z8
# A001 = Z8
# РТА: Рабочий текст алгоритма
# alg A001(): Zh8()
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001( ):
# = ( ( | Z8 Zh8( )
# ( Z8 | Z8
# Z8 ) )
# )
def eA101(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head8) # Zh8() - типовой цикл СГ8
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A211: Последовательность двух команд
# СФА: Структурная формула алгоритма
# A211 = (Z8-Z3)
# ССА: Структурная схема алгоритма
# A211: Z8 Z3
# ------+--+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A211 = (Z8-Z3) = Z8-Z3
# A211 = Z8-Z3
# РТА: Рабочий текст алгоритма
# alg A211(): Zh8( ); Zh3( )
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A211 A211= A211= A211= A211= alg A211( ):
# = ( ( | Z8 - | Z8 Zh8( )
# ( Z8 - | Z8 - | Z3 | Z3 Zh3( )
# Z8 Z3 | Z3
# - ) )
# Z3
# )
# ТПР: Текст программной реализации алгоритма
def eA211(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head8) # Zh8() - типовой цикл СГ8
hCycles.Zh(ccrt.techsys.head5) # Zh3() - типовой цикл СГ3
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A222: Параллельная конъюнкция двух команды (#&).
# Одна команда (Z3) выносится в поток.
# СФА: Структурная формула алгоритма
# A222 = (Z8 & Z3) = (Z8 #& Z3) = #(Z8, Z3)& = #Z8,Z3&
# ССА: Структурная схема алгоритма // Исходная формула
# Исходная схема
# A222: # Z8 &
# ------+--+--+---->
# | Z3 |
# +--+--+
# Модификация схемы
# A222: FZ3 Z8 J&Z3
# ------+-----+-----+---->
# Z3
# |-----+-----| команда Z3, упакованная в поток (thread)
# FZi = F(Zi) = Fork(Zi) - оператор узла вилки:
# кпаковка в поток и вызов команды Zi в потоке
# J&Zi = J&(Zi) = Join_&(Zi) - оператор узла сборки:
# ожижание (wait) завершения команды Zi
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222 = #(Z8, Z3)& = # Z8, Z3 & = # Z8 Z3 & = FZ3 Z8 JZ3 = FZ3-Z8-J&Z3
# * * * метки
# РТА: Рабочий текст алгоритма
# alg A222(): Fork(Zh3()); Zh8(); Join_&(Zh3())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222 = alg A222():
# | FZ3 Fork(Zh3())
# | Z8 Zh8()
# | J&Z3 Join_&(Zh3())
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def eA222a(ccrt, hCycles): # alg A222():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
pass # пустой оператор тела цикла
def fffff(ccrt, hCycles):
hCycles.Zh(ccrt.techsys.head5)
def eA222b(ccrt, hCycles): # alg A222():
print '1111111111111111111111'
thread = threading.Thread(target = fffff(ccrt, hCycles))
# tttttt = hCycles.Zh(ccrt.techsys.head3)
# thread = threading.Thread(target = tttttt)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3))
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3,)) thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3,),)
# thread = threading.Thread(None, hCycles.Zh(ccrt.techsys.head3), None, args=(), kwargs =())
thread.start() # Fork(Zh3())
print '2222222222222222222222'
hCycles.Zh(ccrt.techsys.head8) # Zh8()
thread.join() # Fork(Zh3())
# Модификация 1: Задержка в цикле - разгрузка процессора
def eA222(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# Модификация 2: Задержка в цикле и вывод сообщения (для отладки)
def eA222e(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
print 'yzh3 = 0' # вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_2: Параллельная конъюнкция двух команд (#&):
# обе команды (Z3, Z8) выносятся в поток.
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма
# A222_2 = (Z8 & Z3) = (R &(Z8 & Z3)) = (R #& (Z8 #& Z3)) = #(R, #(Z8, Z3)&)& =
# = (R & Z8 & Z3) = (R #& Z8 #& Z3) = #(R, Z8, Z3)&
# R = -> - пустой оператор (повторитлеь),
# эквивалентный линии простой связи " -> "
# ССА: Структурная схема алгоритма
# Исходная схема
# A222_2: # Z8 & A222_2: # -> = R & A222_2: # (R) &
# --------+--+--+----> = --------+-----------+----> = --------+--+--+---->
# | Z3 | | # Z8 & | | Z8 |
# +--+--+ +--+--+--+--+ +--+--+
# | Z3 | | Z3 |
# +--+--+ +--+--+
# СФА: Структурная формула алгоритма // Продолжение
# A222_2 = (Z8 & Z3) = (R & Z8 & Z3) = ((R & Z8) & Z3))=
# = ((R #& Z8) #& Z3) = #(#(R, Z8)&, Z3)&
# ССА: Структурная схема алгоритма // Продолжение
# Исходная схема
# A222_2: # Z8 & A222_2: # # (R) & & A222_2: # # & &
# --------+--+--+----> = --------+--+--+--+--+----> = --------+--+-----+--+-->
# | Z3 | | | Z8 | | | | Z8 | |
# +--+--+ | +--+--+ | | +--+--+ |
# | Z3 | | Z3 |
# +-----+-----+ +-----+-----+
# Модификация схемы
# A2221: FZ3 FZ8 (R) J&Z8 J&Z3 A2221: FZ3 FZ8 J&Z8 J&Z3
# --------+-----+-----+-----+-----+------> = --------+-----+-----+------+------>
# Z8
# |-----+-----| команда Z8, упакованная в поток (thread)
# Z3
# |-----------+------------| команда Z3, упакованная в поток (thread)
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222_2 = #(#(R, Z8)&, Z3)& = # # R, Z8 &, Z3 & =
# = # # R Z8 & Z3 & = FZ3 # R Z8 & J&Z3 =
# * * * * * *
# = FZ3 FZ8 R J&Z8 J&Z3
# РТА: Рабочий текст алгоритма
# alg A222_2(): Fork(Zh3()); Fork(Zh8()); pass; Join_&(Zh()); Join_&(Zh3())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_1= alg A222_1():
# | FZ3 Fork(Zh3())
# | FZ8 Fork(Zh8(
# | J&Z8 Join_&(Zh8())
# | J&Z3 Join_&(Zh3())
# ТПР: Текст программной реализации алгоритма
def eA222_2(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not ccrt.techsys.head8.yzh: # Join(Zh8(): ожидание (head8.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh3 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_3: Параллельная конъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма // Продолжение
# A222_3 = (Z8 & Z3) = (R & Z8 & Z3) = ((R & Z8) & Z3))=
# = ((R #& Z8) #& Z3) = #(#(R, Z8)&, Z3)&
# ССА: Структурная схема алгоритма // Модификация
# A222_3: # Z8 & A222_3: # # & &
# --------+--+--+----> = --------+--+-----+--+--> =
# | Z3 | | | Z8 | |
# +--+--+ | +--+--+ |
# | Z3 |
# +-----+-----+
#
# A222_3: # # &
# = --------+--+---------+--> =
# | | |
# | | ----& Дополнительный узел &-сборки
# | | Z8 | |
# | +--+--+ |
# | Z3 |
# +------+-----+
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма // Модификация
# A222_2 = #(#(R, Z8)&, Z3)& = # # R, Z8 &, Z3 & =
# = # # R Z8 & Z3 & = FZ3 # R Z8 & J&Z3 =
# * * * * * *
# A222_3 = FZ3 FZ8 R J&Z8 J&Z3 = FZ3 FZ8 R J&(Z8' & Z3')
#
# РТА: Рабочий текст алгоритма
# alg A222_3(): Fork(Zh3()); Fork(Zh8()); pass; Join_&(Zh()'and (Zh3()')
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_3= alg A222_3():
# | FZ3 Fork(Zh3())
# | FZ8 Fork(Zh8(
# | J&(Z8'& Z3') Join_&(Zh8()' and (Zh3()')
# ТПР: Текст программной реализации алгоритма
def eA222_3(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not(ccrt.techsys.head5.yzh and ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
pass
# #-----------------------------------------
# Пример A232: Параллельная дизъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# СФА: Структурная формула алгоритма
# A232 = (Z8 V Z3) = (R & (Z8 V Z3)) = (R #& (Z8 #V Z3)) = #(R, #(Z8, Z3)V)& =
# = (R & Z8 & Z3) = (R #& Z8 #& Z3) = #(R, Z8, Z3)&
# ССА: Структурная схема алгоритма // Модификация
# ССА: Структурная схема алгоритма
# A232: # Z8 V A232: # -> = R &
# --------+--+--+----> = --------+--------------+----> =
# | Z3 | | # Z8 V |
# +--+--+ +--+--+--+--+
# | Z3 |
# +--+--+
# ССА: Структурная схема алгоритма // Модификация
# A232: # # &
# = --------+--+---------+--> =
# | | |
# | | ----V Дополнительный узел V-сборки
# | | Z8 | |
# | +--+--+ |
# | Z3 |
# +-----+-----+
#
# ТПР: Текст программной реализации алгоритма
def eA232(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head6, ))
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not(ccrt.techsys.head3.yzh or ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A323: Параллельная дизъюнкция трех команд (#&).
# Две команды выносятся в поток.
def eA323(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head6, ))
time.sleep(1)
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
while not ccrt.techsys.head6.yzh: # Join(Zh5(): ожидание (head5.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# #-----------------------------------------
# Пример A343: Параллельный алгоритм:
def eA342(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
time.sleep(1) # спец. задержка
while not(ccrt.techsys.head2.yzh or ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
hCycles.Zh(ccrt.techsys.head5) # цикл силовой головки
while not(ccrt.techsys.head2.yzh and ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э3: Этап 3: Работа: Самостоятельные разработки
# Применяется упаковка попрограмм в паралльеные потоки
# Используется третий ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A581: Опорный пример: Параллельная конъюнкция
# СФА: Структурная формула алгоритма
# A581 = (Z7-((Z1 & (Z6-(Z0&(Z3-Z6)))) & (Z7-(Z4 & Z5)-Z7)))
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def A40(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za40 = 0 # Введение индикации окончания A40
hCycles.Zh(ccrt.techsys.head5) # СГ5 - типовой цикл
hCycles.za40 = 1 # Окончание процесса A40
def A30(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za30 = 0 # Введение индикации окончания A30
hCycles.Zh(ccrt.techsys.head7) # СГ7 - типовой цикл
thread.start_new(expSub.A40, (ccrt, hCycles, )) # поток A40
hCycles.Zh(ccrt.techsys.head4) # СГ4 - типовой цикл
while not hCycles.za40: # Контроль окончания A40
time.sleep(0.1) # задержка в цикле ожидания
hCycles.za30 = 1 # Окончание процесса A30
def A20(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za20 = 0 # Введение индикации окончания A20
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head6) # СГ6 - типовой цикл
hCycles.za20 = 1 # Окончание процесса A20
def A10(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za10 = 0 # Введение индикации окончания A10
hCycles.Zh(ccrt.techsys.head6) # СГ6 - типовой цикл
thread.start_new(expSub.A20, (ccrt, hCycles, )) # поток A20
hCycles.Zh(ccrt.techsys.head1) # СГ0 - типовой цикл
while not hCycles.za20: # Контроль окончания A20
time.sleep(0.3) # задержка в цикле ожидания
hCycles.za10 = 1 # Окончание процесса A10
def eAxx1(ccrt, hCycles): # alg A581() программа основного потока
hCycles.Zh(ccrt.techsys.head7) # СГ7 - типовой цикл
thread.start_new(expSub.A30, (ccrt, hCycles, )) # поток A30
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток A10
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
while not hCycles.za10: # Контроль окончания A10
time.sleep(0.3) # задержка в цикле ожидания
while not hCycles.za30: # Контроль окончания A30
time.sleep(0.1) # задержка в цикле ожидания
# -----------------------------------------------------
# Программа parATKvXXX.py
# Модуль expSub.py
#
# Модуль учебных (экспериментальных) подпрограмм
#
# Данный модуль содержит подпрограммы дополонительных циклов
# конфигурации АТК12 (двенадцать силовых головок)
# автоматизированного технологического комлпекса АТК.
# Модуль предназначен для упрощения экспериментов
# по многопоточному программированию
# с групповыми циклами силовых головок в конфигурации АТК12.
# Для программных экспериментов на основе данного модуля
# в блок переключателей рабочего режима на пульте управления
# дополнительно введены
# второй и третий ряды перецелючателей циклов (радио-кнопки).
#
# ----------------------------------------------------
# Разработчик программы parATK Житников А.П.
# ноябрь 2005г.
# -----------------------------------------------------
import ConfigParser
import tkFileDialog
import thread
import threading
import math, time
import expSub
# -------------------------------------
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э2: Этап 2: Тренаж: Простые примеры
# Первичный тренаж - упаковка в паралльеные потоки отдельных команд
# Используется второй ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A001: Пустой алгоритм - проходная интерпретация
# СФА: Структурная формула алгоритма
# A001 = () = (-) = (->) = (R) = -> = R
# ССА: Структурная схема алгоритма
# A211: R
# ----------> = ------+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = () = R
# A001 = R
# РТА: Рабочий текст алгоритма
# alg A001(): pass
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001():
# = ( ( | R pass
# ( R | R
# R ) )
# )
# ТПР: Текст программной реализации алгоритма
def eA001(ccrt, hCycles): # alg A001():
pass # пустой оператор: R = ->
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A002: Пустой алгоритм - непроходная интерпретация
# Для сведения
# СФА: Структурная формула алгоритма
# A002 = (|)
# #-----------------------------------------
# Пример A101: Единичный алгоритм
# СФА: Структурная формула алгоритма
# A101 = (Z8) = Z8
# ССА: Структурная схема алгоритма
# A211: Z8
# ------+----->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = (Z8) = Z8
# A001 = Z8
# РТА: Рабочий текст алгоритма
# alg A001(): Zh8()
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001( ):
# = ( ( | Z8 Zh8( )
# ( Z8 | Z8
# Z8 ) )
# )
def eA101(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head8) # Zh8() - типовой цикл СГ8
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A211: Последовательность двух команд
# СФА: Структурная формула алгоритма
# A211 = (Z8-Z3)
# ССА: Структурная схема алгоритма
# A211: Z8 Z3
# ------+--+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A211 = (Z8-Z3) = Z8-Z3
# A211 = Z8-Z3
# РТА: Рабочий текст алгоритма
# alg A211(): Zh8( ); Zh3( )
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A211 A211= A211= A211= A211= alg A211( ):
# = ( ( | Z8 - | Z8 Zh8( )
# ( Z8 - | Z8 - | Z3 | Z3 Zh3( )
# Z8 Z3 | Z3
# - ) )
# Z3
# )
# ТПР: Текст программной реализации алгоритма
def eA211(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head8) # Zh8() - типовой цикл СГ8
hCycles.Zh(ccrt.techsys.head5) # Zh3() - типовой цикл СГ3
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A222: Параллельная конъюнкция двух команды (#&).
# Одна команда (Z3) выносится в поток.
# СФА: Структурная формула алгоритма
# A222 = (Z8 & Z3) = (Z8 #& Z3) = #(Z8, Z3)& = #Z8,Z3&
# ССА: Структурная схема алгоритма // Исходная формула
# Исходная схема
# A222: # Z8 &
# ------+--+--+---->
# | Z3 |
# +--+--+
# Модификация схемы
# A222: FZ3 Z8 J&Z3
# ------+-----+-----+---->
# Z3
# |-----+-----| команда Z3, упакованная в поток (thread)
# FZi = F(Zi) = Fork(Zi) - оператор узла вилки:
# кпаковка в поток и вызов команды Zi в потоке
# J&Zi = J&(Zi) = Join_&(Zi) - оператор узла сборки:
# ожижание (wait) завершения команды Zi
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222 = #(Z8, Z3)& = # Z8, Z3 & = # Z8 Z3 & = FZ3 Z8 JZ3 = FZ3-Z8-J&Z3
# * * * метки
# РТА: Рабочий текст алгоритма
# alg A222(): Fork(Zh3()); Zh8(); Join_&(Zh3())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222 = alg A222():
# | FZ3 Fork(Zh3())
# | Z8 Zh8()
# | J&Z3 Join_&(Zh3())
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def eA222a(ccrt, hCycles): # alg A222():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
pass # пустой оператор тела цикла
def fffff(ccrt, hCycles):
hCycles.Zh(ccrt.techsys.head5)
def eA222b(ccrt, hCycles): # alg A222():
print '1111111111111111111111'
thread = threading.Thread(target = fffff(ccrt, hCycles))
# tttttt = hCycles.Zh(ccrt.techsys.head3)
# thread = threading.Thread(target = tttttt)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3))
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3,)) thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head3,),)
# thread = threading.Thread(None, hCycles.Zh(ccrt.techsys.head3), None, args=(), kwargs =())
thread.start() # Fork(Zh3())
print '2222222222222222222222'
hCycles.Zh(ccrt.techsys.head8) # Zh8()
thread.join() # Fork(Zh3())
# Модификация 1: Задержка в цикле - разгрузка процессора
def eA222(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# Модификация 2: Задержка в цикле и вывод сообщения (для отладки)
def eA222e(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, )) # Fork(Zh3())
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
print 'yzh3 = 0' # вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_2: Параллельная конъюнкция двух команд (#&):
# обе команды (Z3, Z8) выносятся в поток.
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма
# A222_2 = (Z8 & Z3) = (R &(Z8 & Z3)) = (R #& (Z8 #& Z3)) = #(R, #(Z8, Z3)&)& =
# = (R & Z8 & Z3) = (R #& Z8 #& Z3) = #(R, Z8, Z3)&
# R = -> - пустой оператор (повторитлеь),
# эквивалентный линии простой связи " -> "
# ССА: Структурная схема алгоритма
# Исходная схема
# A222_2: # Z8 & A222_2: # -> = R & A222_2: # (R) &
# --------+--+--+----> = --------+-----------+----> = --------+--+--+---->
# | Z3 | | # Z8 & | | Z8 |
# +--+--+ +--+--+--+--+ +--+--+
# | Z3 | | Z3 |
# +--+--+ +--+--+
# СФА: Структурная формула алгоритма // Продолжение
# A222_2 = (Z8 & Z3) = (R & Z8 & Z3) = ((R & Z8) & Z3))=
# = ((R #& Z8) #& Z3) = #(#(R, Z8)&, Z3)&
# ССА: Структурная схема алгоритма // Продолжение
# Исходная схема
# A222_2: # Z8 & A222_2: # # (R) & & A222_2: # # & &
# --------+--+--+----> = --------+--+--+--+--+----> = --------+--+-----+--+-->
# | Z3 | | | Z8 | | | | Z8 | |
# +--+--+ | +--+--+ | | +--+--+ |
# | Z3 | | Z3 |
# +-----+-----+ +-----+-----+
# Модификация схемы
# A2221: FZ3 FZ8 (R) J&Z8 J&Z3 A2221: FZ3 FZ8 J&Z8 J&Z3
# --------+-----+-----+-----+-----+------> = --------+-----+-----+------+------>
# Z8
# |-----+-----| команда Z8, упакованная в поток (thread)
# Z3
# |-----------+------------| команда Z3, упакованная в поток (thread)
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222_2 = #(#(R, Z8)&, Z3)& = # # R, Z8 &, Z3 & =
# = # # R Z8 & Z3 & = FZ3 # R Z8 & J&Z3 =
# * * * * * *
# = FZ3 FZ8 R J&Z8 J&Z3
# РТА: Рабочий текст алгоритма
# alg A222_2(): Fork(Zh3()); Fork(Zh8()); pass; Join_&(Zh()); Join_&(Zh3())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_1= alg A222_1():
# | FZ3 Fork(Zh3())
# | FZ8 Fork(Zh8(
# | J&Z8 Join_&(Zh8())
# | J&Z3 Join_&(Zh3())
# ТПР: Текст программной реализации алгоритма
def eA222_2(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not ccrt.techsys.head8.yzh: # Join(Zh8(): ожидание (head8.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh3 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_3: Параллельная конъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма // Продолжение
# A222_3 = (Z8 & Z3) = (R & Z8 & Z3) = ((R & Z8) & Z3))=
# = ((R #& Z8) #& Z3) = #(#(R, Z8)&, Z3)&
# ССА: Структурная схема алгоритма // Модификация
# A222_3: # Z8 & A222_3: # # & &
# --------+--+--+----> = --------+--+-----+--+--> =
# | Z3 | | | Z8 | |
# +--+--+ | +--+--+ |
# | Z3 |
# +-----+-----+
#
# A222_3: # # &
# = --------+--+---------+--> =
# | | |
# | | ----& Дополнительный узел &-сборки
# | | Z8 | |
# | +--+--+ |
# | Z3 |
# +------+-----+
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма // Модификация
# A222_2 = #(#(R, Z8)&, Z3)& = # # R, Z8 &, Z3 & =
# = # # R Z8 & Z3 & = FZ3 # R Z8 & J&Z3 =
# * * * * * *
# A222_3 = FZ3 FZ8 R J&Z8 J&Z3 = FZ3 FZ8 R J&(Z8' & Z3')
#
# РТА: Рабочий текст алгоритма
# alg A222_3(): Fork(Zh3()); Fork(Zh8()); pass; Join_&(Zh()'and (Zh3()')
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_3= alg A222_3():
# | FZ3 Fork(Zh3())
# | FZ8 Fork(Zh8(
# | J&(Z8'& Z3') Join_&(Zh8()' and (Zh3()')
# ТПР: Текст программной реализации алгоритма
def eA222_3(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not(ccrt.techsys.head5.yzh and ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
pass
# #-----------------------------------------
# Пример A232: Параллельная дизъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# СФА: Структурная формула алгоритма
# A232 = (Z8 V Z3) = (R & (Z8 V Z3)) = (R #& (Z8 #V Z3)) = #(R, #(Z8, Z3)V)& =
# = (R & Z8 & Z3) = (R #& Z8 #& Z3) = #(R, Z8, Z3)&
# ССА: Структурная схема алгоритма // Модификация
# ССА: Структурная схема алгоритма
# A232: # Z8 V A232: # -> = R &
# --------+--+--+----> = --------+--------------+----> =
# | Z3 | | # Z8 V |
# +--+--+ +--+--+--+--+
# | Z3 |
# +--+--+
# ССА: Структурная схема алгоритма // Модификация
# A232: # # &
# = --------+--+---------+--> =
# | | |
# | | ----V Дополнительный узел V-сборки
# | | Z8 | |
# | +--+--+ |
# | Z3 |
# +-----+-----+
#
# ТПР: Текст программной реализации алгоритма
def eA232(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head6, ))
hCycles.Zh(ccrt.techsys.head8) # Zh8()
while not(ccrt.techsys.head3.yzh or ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh8 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A323: Параллельная дизъюнкция трех команд (#&).
# Две команды выносятся в поток.
def eA323(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head6, ))
time.sleep(1)
while not ccrt.techsys.head5.yzh: # Join(Zh3(): ожидание (head3.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
while not ccrt.techsys.head6.yzh: # Join(Zh5(): ожидание (head5.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# #-----------------------------------------
# Пример A343: Параллельный алгоритм:
def eA342(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head8, ))
time.sleep(1) # спец. задержка
while not(ccrt.techsys.head2.yzh or ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
hCycles.Zh(ccrt.techsys.head5) # цикл силовой головки
while not(ccrt.techsys.head2.yzh and ccrt.techsys.head8.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э3: Этап 3: Работа: Самостоятельные разработки
# Применяется упаковка попрограмм в паралльеные потоки
# Используется третий ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A581: Опорный пример: Параллельная конъюнкция
# СФА: Структурная формула алгоритма
# A581 = (Z7-((Z1 & (Z6-(Z0&(Z3-Z6)))) & (Z7-(Z4 & Z5)-Z7)))
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def A40(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za40 = 0 # Введение индикации окончания A40
hCycles.Zh(ccrt.techsys.head5) # СГ5 - типовой цикл
hCycles.za40 = 1 # Окончание процесса A40
def A30(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za30 = 0 # Введение индикации окончания A30
hCycles.Zh(ccrt.techsys.head7) # СГ7 - типовой цикл
thread.start_new(expSub.A40, (ccrt, hCycles, )) # поток A40
hCycles.Zh(ccrt.techsys.head4) # СГ4 - типовой цикл
while not hCycles.za40: # Контроль окончания A40
time.sleep(0.1) # задержка в цикле ожидания
hCycles.za30 = 1 # Окончание процесса A30
def A20(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za20 = 0 # Введение индикации окончания A20
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head6) # СГ6 - типовой цикл
hCycles.za20 = 1 # Окончание процесса A20
def A10(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za10 = 0 # Введение индикации окончания A10
hCycles.Zh(ccrt.techsys.head6) # СГ6 - типовой цикл
thread.start_new(expSub.A20, (ccrt, hCycles, )) # поток A20
hCycles.Zh(ccrt.techsys.head1) # СГ0 - типовой цикл
while not hCycles.za20: # Контроль окончания A20
time.sleep(0.3) # задержка в цикле ожидания
hCycles.za10 = 1 # Окончание процесса A10
def eAxx1(ccrt, hCycles): # alg A581() программа основного потока
hCycles.Zh(ccrt.techsys.head7) # СГ7 - типовой цикл
thread.start_new(expSub.A30, (ccrt, hCycles, )) # поток A30
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток A10
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
while not hCycles.za10: # Контроль окончания A10
time.sleep(0.3) # задержка в цикле ожидания
while not hCycles.za30: # Контроль окончания A30
time.sleep(0.1) # задержка в цикле ожидания