Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
Лекция №5 Процессы
План лекции:
Процесс— основной функциональный компонент системы, определяющий ее поведение. С точки зрения SDL процесс — это обобщение понятия автомата с конечным числом состояний.
Под автоматом с конечным числом состояний понимают объект, обладающий следующими свойствами. Автомат может находиться в одном из дискретных состояний, которые мы обозначим через Р1, P2,...,PR.
На вход автомата поступают (извне) некоторые сигналы (говорят также «наступают события») El, E2,...,EL.
Кроме того, автомат обладает набором выходных сигналов II, I2,...,Im. Под влиянием входных сигналов автомат мгновенно переходит из одного состояния в другое (которое может совпадать с предыдущим), выдавая одновременно выходной сигнал. При этом для каждого состояния Pi и для каждого входного сигнала Ej однозначно известно, в какое состояние Рк перейдет автомат и какой выходной сигнал он при этом выдаст.
Процесс является обобщением этого понятия в нескольких направлениях. Прежде всего (и главным образом на взгляд авторов) переход из состояния в состояние происходит не мгновенно, как у автомата, а занимает некоторый промежуток времени. Это немедленно приводит к тому, что у входа в процесс (здесь принято говорить «в порту» процесса) образуется очередь сигналов, а следовательно, нужна дисциплина обработки сигналов («восприятия» сигналов процессом), стоящих в очереди.
Далее, процесс обладает переменными, которыми он может манипулировать во время перехода из состояния в состояние (например, присваивать значения или проверять эти значения).
Кроме того, при переходе процесс может совершать целый ряд других действий, таких как сброс и установка таймеров, экспортно-импортные операции, выдача выходных сигналов, порождение других процессов, вызов процедур и др.
Наконец, совершая переход, процесс может проверить выполненность или невыполненность некоторых условий и в зависимости от результата проверки совершить те или иные действия и перейти в то или иное состояние.
Итак, процесс — это объект, который:
обладает конечным числом состояний;
обладает портом, в котором образуется очередь входных сигналов;
находясь в некотором состоянии, извлекает из очереди очередной сигнал и воспринимает его;
под влиянием этого переходит из одного состояния в другое;
за время перехода выполняет целый ряд действий, в частности определяет свое следующее состояние.
На SDL описание процесса распадается на три части: заголовок процесса; декларативная (описательная) часть процесса; тело процесса.
В заголовке процесса указывается имя процесса, условия возникновения процесса, число возможных параллельно действующих экземпляров этого процесса и так называемые формальные параметры процесса.
Декларативная часть содержит описание средств, используемых данным процессом (и не описанных на более высоких уровнях), а именно:
определение сигналов (которыми обмениваются различные экземпляры данного процесса), списков этих сигналов, данных, таймеров, избирания;
описание переменных, обозревания, импорта, процедур, макрокоманд.
Тело процесса описывает те действия, которые совершает процесс под влиянием входных сигналов.
определение процесса имеет вид:
<определение процесса>::=
PROCESS <имя процесса>
[<число экземпляров> ];
<формальные параметры>
<формальные параметры>::=
FPAR <имя переменной>{,<имя переменной;»} *<сорт>{,<имя переменной>{,<имя переменной>}* <сорт>}*
<запрос на создание>::=
CREATE <имя процесса> [<фактические параметры>]
<фактические параметры>::=
([<выражение> ]{, [<выражение> ]}*)
2. Возникновение и исчезновение процессов
Процессы возникают (т. е. начинают функционировать) одним из двух способов: либо процесс порождается в момент инициации системы, либо один процесс порождает другой.
Порождение одного процесса другим совершается с помощью операции, которая называется «запрос на порождение» и выдается процессом в период перехода из одного состояния в другое. Процесс не может породить процесс в другом блоке. Следовательно, в каждом блоке должен быть хоть один «процесс-производитель», возникающий в момент инициации системы. Этот процесс может порождать другие процессы, но только в своем блоке. Если процесс в одном блоке хочет породить какой-то процесс в другом блоке, то он должен послать соответствующий сигнал процессу-производителю этого блока. В силу этого процесс-производитель создаст в своем блоке экземпляр заказанного ему процесса.
Но если в каком-то блоке в некоторый момент времени не окажется ни одного действующего процесса, то «оживить» этот блок уже не будет никакой возможности.
Порождение процесса по запросу от другого процесса (в отличие от создания процесса при инициации системы) называется динамическим.
Очень важно уяснить различие между типом объекта и отдельными экземплярами объектов этого типа. Описание процесса (независимо от того, помещено ли оно внутрь описания блока или вынесено за пределы описания системы) вводит лишь тип процесса. По этому описанию (по этому типу), как по шаблону, может быть создано любое число экземпляров процессов этого типа. Каждый экземпляр данного типа обладает всеми характеристиками, присущими данному типу. Различаются они только личными идентификаторами.
Возможность инициации и порождения процесса регламентируется конструкцией «число процессов», входящей в заголовок процесса. Заголовок имеет вид
PROCESS <имя процесса> <число экземпляров>, <формальные параметры>;
Конструкция <число экземпляров> — это пара целых чисел, разделенных запятой и взятых в круглые скобки (m , n). Первое из этих чисел m указывает число создаваемых экземпляров процессов данного типа в момент инициации системы. Оно называется начальным числом. Если оно равно нулю, то при инициации системы не будет создано ни одного экземпляра этого процесса: они могут быть созданы только по запросу от другого процесса. Таким образом, каждый блок должен обладать хоть одним процессом, чье начальное число больше нуля.
Второе (из пары) число n задает максимальное число экземпляров процессов этого типа, которые могут существовать одновременно в блоке. Если второй параметр п отсутствует, то, по умолчанию, считается, что n равно бесконечности..
С момента своего возникновения (как при инициации системы, так и по запросу от другого процесса) экземпляры процесса начинают функционировать независимо друг от друга и асинхронно один по отношению ко всем другим (образно говоря, они начинают «самостоятельную и независимую жизнь»). Эти экземпляры могут общаться между собой, посылая друг другу сигналы. Но так как нет маршрутов, которые связывали бы между собой два экземпляра процесса одного и того же типа, то сигнал, посланный одним экземпляром другому (своему «брату»), помещается непосредственно в порт «брата».
Так как по одному описанию процесса может быть создано несколько экземпляров, то имени процесса, стоящего в заголовке описания, совершенно недостаточно для отличия одного экземпляра от другого (для «персонификации» экземпляров процесса). Поэтому каждый экземпляр должен получить свой личный идентификатор. Присвоение процессам личных идентификаторов осуществляется не средствами SDL, а средствами того комплекса, который реализует конкретную SDL-систему. Для этого у каждого экземпляра процесса имеется переменная SELF (сам), которой указанный комплекс присваивает уникальное значение. Оно и является личным («персональным») идентификатором экземпляра процесса. Следовательно, любой экземпляр процесса всегда может узнать свой идентификатор (и, например, сообщить его другому экземпляру), опросив для этого свою переменную SELF.
Личные идентификаторы формируются следующим способом. Считается, что указанный выше комплекс обладает некоторым множеством, содержащим потенциально неограниченное число попарно различных элементов (все равно какой природы), и каждый раз, когда комплексу требуется присвоить личный идентификатор вновь создаваемому экземпляру процесса, он берет какой-то элемент из множества и присваивает этот элемент переменной SELF создаваемого экземпляра в качестве его личного идентификатора. Фактическая природа личных идентификаторов зависит, естественно, от конкретной реализации. Таким образом, сам проектировщик никогда не «видит» личных идентификаторов, но ведь он и вообще не «видит» реальной системы — он «видит» только «образ» (тип) системы,
Помимо переменной SELF каждый экземпляр процесса обладает
еще двумя переменными: OFFSPRING (отпрыск) и PARENT (родитель).
Если некоторый экземпляр процесса породил другой экземпляр, то переменной PARENT порожденного процесса присваивается значение переменной SELF родительского процесса (т. е. значение личного идентификатора того экземпляра, который породил данный). Наоборот, переменной OFFSPRING родительского процесса присваивается значение переменной SELF его последнего отпрыска (процесс может создать не один, а много экземпляров процессов различных типов). Таким образом, каждый процесс всегда знает личный идентификатор его родителя и личный идентификатор своего последнего отпрыска
Значение переменной OFFSPRING некоторого экземпляра, еще не породившего никакого другого экземпляра, равно Null. Таким же будет значение переменной PARENT того экземпляра процесса, который был создан при инициации системы. Значение Null — единственное значение личных идентификаторов, которое проектировщик «видит» явно.
Процесс перестает существовать, когда при переходе он входит в состояние STOP (состояния и переходы описаны в следующем параграфе). Если один процесс хочет «уничтожить» другой, то он может послать ему такой сигнал, под влиянием которого процесс переходит в состояние STOP.
Фрагмент: запрос на создание другого процесса
BLOCK В;
PROCESS P2(1,1);
CREATE PI (3, 5, true);
ENDPROCESS P2;
PROCESS PI (0,5); FPAR (x, у Integer, u Boolean);
ENDPOCESS PI;
ENDBLOCK B;
Процесс либо находится в одном из своих состояний, либо
совершает переход. При этом каждое состояние должно иметь свое уникальное (по отношению к данному процессу) имя.
Немедленно после создания процесса (независимо от того, при инициации ли системы или динамически) начинается функционирование процесса (говорят также «реализация» процесса), которое заключается в том, что совершается переход, следующий за стартовой вершиной. Этот переход совершается не под влиянием входного сигнала, а в результате возникновения процесса.
Совершив этот начальный переход, процесс входит в одно из своих состояний. Дальнейшие переходы из состояния в состояние возможны только под воздействием входных сигналов, и только находясь в одном из своих состояний, процесс может воспринять входной сигнал.
Осуществляется это так. Все сигналы, включая и сигналы от таймеров, прибывшие в порт процесса, образуют в нем очередь, порядок в которой определяется только временем прибытия: сигнал, прибывший в порт раньше, оказывается впереди прибывшего позже. Процесс, находясь в одном из своих состояний, обращается к очереди сигналов, скопившихся в его порту.
Если порт пуст, то процесс ждет (т. е. не совершает никаких действий и не меняет своего состояния), пока в порту не появится сигнал.
Если же порт не пуст (либо если в нем появился сигнал, пока процесс находился в одном из своих состояний в ожидании появления сигнала), то для каждого состояния S в теле процесса однозначно указано, как должен реагировать процесс на любой сигнал Е, который сейчас стоит первым в очереди. Здесь возможны три ситуации:
1. Указано (явно), какой переход должен совершить процесс, если он находился в состоянии S и первым в очереди стоит" сигнал Е. Процесс удаляет из очереди сигнал Е (говорят также, что процесс «воспринял» (consumed) сигнал) и начинает указанный переход.
2. Указано (явно), что восприятие сигнала Е должно быть отсрочено до того, как процесс войдет в следующее состояние. Этот механизм называется сохранением сигнала. Процесс оставляет этот сигнал на его месте в очереди и переходит к обработке следующего сигнала, при которой все повторяется.
3. Если, наконец, нет никакого явного указания на то, как должен реагировать процесс на сигнал Е, находясь в данном состоянии S, то сигнал Е удаляется из очереди и процесс переходит к обработке следующего сигнала.
Рис 1. Пример сохранения сигналов
Фрагмент к рис.1
STATE S_l;
INPUT A;
NEXTSTATE S_2;
STATE S 2;
SAVE B;
INPUT G;
NEXTSTATE S_6;
INPUT C;
NEXTSTATE S_3;
STATE S_6;
INPUT B;
Рис.2 Пример сохранения сигналов
Фрагмент к рис. 2
STATE Sl;
SAVE B,C;
INPUT A;
NEXTSTATE S2;
STATE S2;
INPUT C;
NEXTSTATE S3;
INPUT B;
STATE S3;
INPUT B;
STATE S_3;
SAVE D,E;
INPUT F;
NEXTSTATE S_4;
STATE S_4;
SAVE D;
INPUT E;
NEXTSTATE S_5;
STATE S_5;
INPUT D;
NEXTSTATE S_l;
INPUT B;
NEXTSTATE S_4;
3.Переходы
При переходе процесс может выполнить следующие действия:
принятие решения (выбор последовательности действий, выполняемых во время перехода);
безусловный переход к другой последовательности действий;
работа (присвоить значения переменным или неформальный текст);
запрос на создание другого процесса;
выдача выходных сигналов;
экспортная операция;
установка таймера;
сброс таймера;
вызов процедуры.
Принятие решения. Последовательность действий, выполняемых процессом во время перехода, может разветвляться точно так же, как ход вычислений в языках программирования
Средство это называется принятием решения (decision). Оно состоит из вопроса (question) и не менее двух ответов (answer).
Вопрос — это выражение, содержащее переменное (или переменные), а ответ — это взятое в круглые скобки значение (или диапазон значений), которое может принять указанное выражение.
Диапазон значений — это разделенное двоеточием верхнее и нижнее значения выражения. Кроме того, это может быть некоторое значение, перед которым стоит один из знаков =, /=, <, >, <=, >=. За каждым ответом указывается та последовательность действий (та ветвь перехода), которые должен выполнить процесс в данном случае.
Если после нескольких ответов должна быть выполнена одна и та же ветвь, то эти ответы объединяют вместе, отделив их друг от друга (внутри скобок) запятыми.
Наконец, возможен только один ответ ELSE (иначе, в остальных случаях), который охватывает все значения выражения (стоящего в вопросе), не учтенные во всех остальных ответах. Вопрос и ответы на него могут быть выражены взятым в апострофы неформальным текстом.
На графическом языке вопрос помещают внутрь ромба, а ответы — справа от выходящих из него линий потока (или в разрыве этих линий). Несколько примеров такого описания.
Работа. TASK (работа), с помощью которого описывается преобразование переменных. Каждый процесс обладает своими (внутренними по отношению к нему) переменными и только он один имеет право присваивать им какие-либо значения.
Все переменные процесса должны быть объявлены в его декларативной (описательной) части с помощью ключевого слова DCL (от declare — объявить). Каждая переменная может принимать значения только одного определенного сорта, называемого сортом переменной. При объявлении переменной непосредственно после ее имени пишется имя ее сорта. Если несколько переменных имеют один и тот же сорт, то имена переменных можно написать подряд (разделив их запятыми), а имя сорта написать один раз. После имени сорта, если есть еще объявляемые переменные, ставится запятая, а после последнего сорта — точка с запятой. Объявление
PROCESS Р;
DCL х,у Integer;
v,w Boolean;
ENDPROCESS Р;
Это означает, что процесс Р обладает переменными х, у целого сорта и переменными v, w — Булевского.
При запуске процесса переменные могут быть инициализированы, т. е. им могут быть присвоены начальные значения. Это начальное значение пишется после имени сорта. Например, объявление
DCL х,у Integer := 0;
v Boolean := True;
w Boolean := False;
Это означает, что при возникновении процесса переменным х, у будет присвоено значение 0, переменной v — значение True и переменной w — значение False. Если при возникновении процесса переменным не были присвоены значения, то их значения считаются неопределенными.
На графическом языке объявление переменных осуществляется точно так же, но только объявление помещается внутрь символа текста (конверта).
STATE S1;
INPUT I;
TASK х := x+y,
w := w AND v;
NEXTSTATES2;
ENDSTATES1;
5.1. Выходные сигналы
Основным средством общения между процессами, находящимися как в одном, так и в разных блоках, является отправка выходных сигналов, вместе с которыми могут посылаться некоторые значения. Осуществляется это с помощью действия, называемого выдачей выходного сигнала. На линейном языке это действие описывается с помощью ключевого слова OUTPUT (вывод) и, по большей части, ключевого слова ТО (кому):
OUTPUT <имя сигнала> «фактические параметры> ТО <личный идентификатор процесса>
Разберем эти конструкции. В первых двух указываются имя посылаемого сигнала и значения, посылаемые с этим сигналом. При описании сигнала после имени сигнала в скобках могут быть указаны сорта тех значений, которые можно посылать с этим сигналом. Например, описание
SIGNAL I (Intereger, Intereger, Boolean)
означает, что с сигналом I можно послать три значения, из которых первые два — целые, а третье — Булевское.
Посылаемые значения задаются с помощью фактических параметров так же, как передаются значения при создании процесса.
Например, предложение
OUTPUT I (30,40, True)
означает, что с сигналом I посылаются значения 30, 40 и True. Если х и у — переменные целого сорта, a w — Булевского, то то же самое можно было бы выполнить с помощью предложения
TASK х := 30, у := 40, w := True;
OUTPUT I (x, у, w);
или
TASK x :=10, у :=10:
OUTPUT I (x+20, y+30, True);
В общем случае на месте фактических параметров можно поместить любое выражение, если только:
в текущий момент может быть вычислено значение этого выражения (т.е. в него не входят переменные, значения которых в данный момент не определены);
сорт выражения совпадает с соответствующим (в смысле порядка следования) сортом, указанным в описании сигнала.
Чтобы процесс, которому адресован сигнал, мог его воспринять, он должен иметь предложение, в котором этот сигнал задан как входной. Например, для указанного сигнала I процесс-адресат должен содержать предложение INPUT I.
Чтобы воспринять значения, посылаемые с сигналом, процесс-адресат должен после имени сигнала указать в круглых скобках имена тех его переменных, которым присваиваются присылаемые значения (точно так же, как формальным параметрам создаваемого процесса присваиваются значения фактических параметров, заданных в операторе CREATE). Сорта этих переменных должны соответствовать сортам присылаемых значений.
Например, предложение
INPUT I (tl, t2, p)
означает, что переменным tl, t2, p будут присвоены значения 30, 40, True соответственно, а предложение INPUT I (tl,, p)
означает, что переменным tl и p будут присвоены значения 30 и True соответственно, а второе из присылаемых значений процесс-получатель игнорирует (оно будет утрачено). Аналогично предложение
INPUT I (, t2, p)
означает, что процесс-получатель игнорирует первое из трех присылаемых ему значений.
По одному описанию может быть создано несколько экземпляров процессов. Следовательно, посылая выходной сигнал, процесс-отправитель должен указать личный идентификатор, а не имя описания процесса-получателя. Кроме того, процесс-получатель должен знать, который экземпляр послал ему сигнал. Для этого каждый процесс помимо SELF, PARENT и OFFSPRING обладает еще одной переменной — SENDER (отправитель). В момент, когда процесс-получатель воспринимает входной сигнал, его переменной SENDER присваивается личный идентификатор того процесса, который послал этот сигнал (т.е. переменной SENDER процесса-получателя присваивается значение переменной SELF процесса-отправителя последнего воспринятого сигнала). Такое присвоение осуществляет комплекс, реализующий систему (как и все, что связано с личными идентификаторами).
Таким образом, каждому процессу всегда известны личные идентификаторы его самого, его родителя, его последнего отпрыска, отправителя последнего воспринятого им сигнала.
Личные идентификаторы всех других потенциальных процессов-адресатов ему должны быть сообщены. Достигается это одним из двух способов:
в момент создания процесса его формальным параметрам передаются (с помощью фактических параметров) значения личных идентификаторов интересующих его процессов;
личные идентификаторы присылаются процессу вместе с сигналом (как это было только что описано).
Пусть, например, при инициации системы в некотором блоке В был создан процесс Р, который потом породил процессы А,В,С в указанном порядке Предположим далее, что процесс Р должен сообщить процессу В личные идентификаторы процессов А и С. Так как В создается после А, то Р может передать формальному параметру процесса В личный идентификатор процесса А в момент создания процесса В, но так как процесс С создается после создания процесса В, то личный идентификатор процесса С может быть сообщен процессу В только вместе с сигналом. Осуществить это можно так, как это сделано в следующем фрагменте :
BLOCK В;
SIGNAL I (PId);
PROCESS Р;
CREATE A;
TASK x:=OFFSPRING;
CREATE В (х);
TASK y:=OFFSPRING;
CREATE C;
OUTPUT I (OFFSPRING) TO y;
ENDPROCESS Р;
PROCESS B; FPAR (ta PId);
INPUT I (tc);
ENDPROCESS B;
PROCESS C;
ENDOPROGESS С;
ENDBLOCK B;
В результате работы процессов Р и В формальному параметру ta процесса В будет присвоено значение личного идентификатора процесса А, а переменной tc процесса В — значение личного идентификатора процесса С. Теперь процесс В может послать сигнал СТ процессам А и С. Для этого ему надо выдать операторы
OUTPUT СТ ТО ta;
OUTPUT СТ ТО tc;
соответственно.
В частности, с помощью указанных механизмов каждый из двух
экземпляров одного и того же процесса может узнать личный идентификатор другого. Следовательно, они могут обмениваться сигналами.
5.2. Экспортно-импортная операция
В SDL предусмотрен сокращенный способ передачи значения некоторой переменной с помощью так называемой экспортно-импортной операции.
<определение импорта>::= IMPORTED <имя импорта>{,<имя импорта>}*
< сорт> {,<имя импорта>{,<имя импорта>}*<сорт>}*
Например, экземпляр процесса типа А хочет сообщить различным экземплярам других процессов значение некоторой своей переменной d, не прибегая к выдаче сигналов. Для этого он должен :
1. При объявлении переменной указать, что ее значение он в дальнейшем будет экспортировать (мы предположим, что переменная d целого сорта);
DCL d EXPORTED Integer;
2. Выполнить экспортную операцию (как одно из действий, осуществляемых при переходе):
EXPORT (d)
<экспорт>::=
EXPORT (<имя переменной>{,<имя переменной >}*<сорт>}{,<имя переменной >{,<имя переменной >}*<сорт>}* )
Если процесс В хочет получить экспортированное значение переменной (значение, а не саму переменную!), то он должен:
IMPORTED d Integer;
2. Там, где процессу В нужно получить значение переменной d, он выдает оператор присвоения (говорят «выполняет импортную операцию» или, кратко, «импортирует»)
х:= IMPORT (d, IDA);
где через IDA обозначен личный идентификатор того экземпляра процесса типа А, от которого процесс В хочет получить значение переменной d.
х := IMPORT (d, IDA)+10;
<импортирующее выражение::=
IMPORT (<имя импopтa>,<PId-выpaжeниe»
может сообщить другому процессу, но только находящемуся в том же блоке, значение некоторой своей переменной. Это так называемое совместное использование значения переменной (shared value).
Если некоторый экземпляр хочет сделать значение некоторой своей переменной доступным другим процессам, он при описании этой переменной объявляет, что раскрывает (reveal) значения этой переменной и что тем самым другие процессы могут обозревать (view) эту переменную:
DCL <имя переменной> REVEALED <сорт>;
Процесс, который хочет иметь доступ к значениям этой переменной, должен описать ее в своей описательной части как обозреваемую. Делается это с помощью предложения
<определение обозревания>::=
VIEWED <имя переменной>{,<имя переменной>}*<сорт>
{,<имя переменной>{,<имя переменной>}* <сорт>
Теперь процесс, получивший таким образом доступ к обозреванию «чужой» переменной, может получить значение этой переменной, выдав оператор (как действие, выполняемое при переходе)
<обозревающее выражение>::=VIEW (<имя переменной>,
<Рld-выражение>)
х := VIEW (<имя переменной;»,<личный идентификатор процесса>);
Это предложение аналогично предложению EXPORT — в нем должны быть указаны имя обозреваемой переменной и личный идентификатор процесса, являющегося владельцем обозреваемой переменной.
Подчеркнем, что с помощью конструкции VIEW процесс получает доступ только к значению переменной: изменить значение этой переменной он не может. Так же, как конструкция IMPORT, конструкция VIEW может быть использована в любых выражениях.
Между этими двумя механизмами (экспортно-импортной операцией и обозреванием чужой переменной) есть существенная разница. Обозревание совершается «мгновенно», т.е. процесс-обозреватель получает текущее значение обозреваемой переменной. Между тем экспортно-импортная операция осуществляется с помощью пересылки сигналов и, следовательно, длится определенный промежуток времени.
Таким образом, процесс-импортер получает то значение переменной, которое эта переменная имела тогда, когда процесс-экспортер совершил в последний раз экспортную операцию (т.е. в момент выдачи оператора IMPORT), а не то, которое эта переменная имеет в настоящий момент. Эта разница хорошо иллюстрируется на рис.. На нем процесс Р1 порождает процессы Р2 и РЗ. Свою переменную d процесс Р1 объявляет и экспортируемой, и доступной обозреванию. Процесс Р2 объявляет, что он будет обозревать переменную d, а процесс РЗ — что он будет импортировать значения этой переменной. Оба они дважды, но одновременно выдают: один — VIEW, а другой — IMPORT. В первый раз оба получают одно и то же значение переменной d, но во второй раз — различные, так как со времени выдачи оператора EXPORT процесс Р2 изменил значение d, но новой экспортной операции еще не совершил (он совершит ее после того, как процесс РЗ выдаст IMPORT).