nedoPC.org

RW1 КАК ЯЗЫК ПРОГРАММИРОВАНИЯ ПАРАЛЛЕЛЬНЫХ ПРОЦЕССОВ
----------------------------------------------------

Александр Шабаршин (shaos@mail.ru)
http://robots.shaos.ru

В статье затрагивается возможность использования языка
программирования роботов RW1 в качестве языка
параллельных процессов (агентов).

Язык RW1 к версии 2.1 прошел путь от ассемблероподобного
языка к языку типа Си (http://shaos.ru/main_rus/rw1_r.htm).
Чтобы представить специфику языка, приведем пример простой
программы:

 robot "Program 1"
 author "A.Shabarshin"
 +rw1_std.rwi
 main()
 {
  while(1)
  {
   // вечный цикл
  }
 }

Данная программа не делает ничего, но в ней можно увидеть
то, что должно быть обязательно в любой RW1 программе.
Это ключевое слово ROBOT, за которым следует имя программы
в кавычках. Слово AUTHOR, за которым идет имя автора
программы в кавычках. Основная функция программы main(),
которая должна быть самой первой функцией программы.
Кроме того, внутри программы организуется вечный цикл.
В файле RW1_STD.RWI определены некоторые полезные макросы.

Будем подразумевать, что мы используем подход RW1P1 -
Robot Warfare 1 Platform 1, что может быть перенесено и
на RW1P2 (см. http://shaos.ru/main_rus/rw1_r.htm#RW1P1).

В среде исполнения может быть запущено несколько роботов
(программ или агентов), которые могут взаимодействовать
друг с другом посредством сообщений. Каждый робот в
системе имеет свой уникальный идентификационный номер,
который можно узнать, прочитав регистр I. Например, так:

 id=I; say "ID=&id "

Идентификаторы присваиваются начиная с 1. Идентификатор
0 обозначает всех роботов в системе (для широковещательных
сообщений).

Самым простым типом сообщений является передача одного
числового значения с помощью команды SEND, которое
может быть принято командой RECV. Пример:

 send -13 10 // отправить роботу с номером 10 число -13
 recv info   // если буфер не пуст, принять число и
             // сохранить его в переменной info

Команда RECV является очень информативной - кроме
сохранения принятого числа, она располагает некоторую
информацию в регистрах робота: регистр N - порядковый
номер робота-передатчика (если N равен 0, то буфер
принятых сообщений пуст); в регистрах X и Y записываются
относительные координаты робота-передатчика (в случае,
если пространственная привязка имеет смысл); в регистр
K помещается значение времени, в которое был отправлен код.

Такое почисловое взаимодействие не слишком информативно.
Более мощным средством межпроцессного обмена языка RW1,
появившемся в версии 2.1, является прием/передача "пакетов".
Итак, что же такое "пакет" в языке RW1? Пакет - это массив
чисел, первое из которых обозначает количество оставшихся.
Например:

 def pack1[5] = {4, 1,2,3,4}

В данном случае создается массив pack1, который является
RW1-пакетом с длиной 4. Этот пакет можно передать в
качестве сообщения другому роботу с помощью команды SENDP:

 sendp pack1 10    // отправить пакет роботу 10, или
 sendp pack1[0] 10 // то же самое

Если вы смогли догадаться, можно отправить и часть массива,
и даже не с нулевого элемента. Пример:

 sendp pack1[2] 10 // отправляем пакет c ячейки 2 - в ней
 // мы имеем число 2, поэтому отправляется только 2 числа

Прием пакета осуществляется командой RECVP:

 def pack0[10]
 recvp pack0
 if(n) say "принят пакет размером &k ячеек"
 else  say "ошибка приема"

Для копирования пакетов используется команда COPYP:

 copyp target source // копирование пакета из source

Интересно отметить, что пара SEND и RECVP совместимы.
Только при этом одно число будет превращаться в пакет
(массив с двумя элементами), первое из которых будет 1.
Вторая пара SENDP и RECV совместима лишь частично - при
этом происходит потеря всех данных за исключением первого
числа. Так что если вы решили использовать для
межпроцессного взаимодействия пакеты, не пользуйтесь
командой RECV. Командой SEND пользоваться можно, так как
приходящие отдельные сообщения успешно принимаются пакетной
командой RECVP (как было указано выше).

Итак, типовая программа-робот будет выглядеть так:

 robot "Program 2"
 author "A.Shabarshin"
 +rw1_std.rwi
 main()
 {
   // определение и инициализация массивов
   def buff[256]
   time = 0 // определение момента активности
   while(1)
   { // вечный цикл
     if(time>=T)
     { // некие действия
       send 111 // послать широковещательное сообщение
       // возможно тут будет переназначение time
     }
     recvp buff // получение сообщения
     if(n)
     { // анализ полученного сообщения
       say "> &n &x &y &k received"
     }
   }
 }

Следует разъяснить что у нас будет храниться в переменной
TIME. Здесь мы будет сохранять метку времени, по достижению
которой наш робот должен проявить некую самостоятельную
активность. Регистр T используется для контроля времени -
в нем хранится количество тиков от момента старта системы.
Если мы имеем привязку к реальному времени (+RW1P1.RWI),
то в T хранится время в десятых долях секунды (другое
значение делителя может быть установленно отдельно).
Кроме того, активность будет проявляться при получении
какого-либо сообщения извне.

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

 robot "Program 3 - count me"
 author "A.Shabarshin"
 +rw1_std.rwi
 +rw1p1.rwi
 main()
 {
   def buff[256]
   def robots[100] // надеюсь их будет не больше 100 ;)
   nrobot = 0  // начальное значение счетчика
   time = 10 // определение момента активности
   say "I'm &I "
   while(1)
   { // вечный цикл
     if(time>=T)
     { // некие действия
       // вывести список найденных роботов
       for(ii=0;ii<nrobot;ii++)
       {
         jj = ii+1
         say "&jj id=&robots[ii] "
       }
       nrobot = 0 // обнуляем
       send 111 // послать широковещательное сообщение
       time = time + @TIME_SEC(5) // повторить через 5 секунд
     }
     recv buff[0] // получение сообщения
     if(n)
     { // анализ полученного сообщения
       if(buff[0]==111) // это кто-то наш :)
       {
         robots[nrobot] = n
         nrobot = nrobot+1
       }
     }
   }
 }

Copyright (c) 2002, Alexander Shabarshin

 for(expr1,expr2,expr3)
 {
                        expr1
                        l1:
                        (expr2);IFN L l2
                  -->
  continue              GOTO l1

  break                 GOTO l2

                        expr3;
                        GOTO l1
 }                      l2:

 for(expr1,expr2,expr3)
 {
                        expr1
                        l1:
                        (expr2);IFN L l2
                  -->
  continue              GOTO l3 <<<<<<<

  break                 GOTO l2

                >>>>>>> l3: expr3;
                        GOTO l1
 }                      l2:

 for(expr1,expr2,expr3)
 {
                        expr1
                        l1:
                        (expr2);IFN L l3
                  -->
  continue              GOTO l2

  break                 GOTO l3

                        l2:
                        expr3;
                        GOTO l1
 }                      l3: