Параллельный Паскаль

Параллельный Паскаль

Парадигмы	Императивный , структурированный , параллельный
Семья	Вирт Паскаль
Разработано	Пер Бринч Хансен
Впервые появился	апрель 1974 г ( 1974-04 )
Дисциплина набора текста	Статический и динамичный , сильный , безопасный
Платформа	Декабрьский ПРП 11
Под влиянием
Алгол 60 , Симула 67, Паскаль

Concurrent Pascal — это язык программирования, разработанный Пером Бринчом Хансеном для написания программ параллельных вычислений , таких как операционные системы и системы мониторинга вычислений в реальном времени на компьютерах с общей памятью .

Отдельный язык Sequential Pascal используется в качестве языка прикладных программ, запускаемых операционными системами, написанными на Concurrent Pascal. Оба языка являются расширениями языка Никлауса Вирта и Паскаль используют общий интерпретатор многопоточного кода . Ниже описывается, чем Concurrent Pascal отличается от Pascal Вирта.

Описание языка

Некоторые конструкции Паскаля были удалены из Concurrent Pascal для простоты и безопасности:

• Варианты записей
• Оператор Goto и метки
• Процедуры как параметры
• Упакованные массивы
• Типы указателей
• Типы файлов и связанные стандартные ввода/вывода . процедуры

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

Concurrent Pascal включает типы данных класса, монитора и процесса. Экземпляры этих типов объявляются как переменные и инициализируются в init заявление.

Классы и мониторы схожи: как частные переменные, так и процедуры упаковываются в общедоступные процедуры (называемые записями процедур). Экземпляр класса может использоваться только одним процессом, тогда как экземпляр монитора может совместно использоваться процессами. Мониторы предоставляют единственный механизм межпроцессного взаимодействия в программе Concurrent Pascal.

В пределах данного экземпляра монитора одновременно может выполняться только один процесс. Встроенный тип данных, очередь, вместе с операциями. delay и continue, используются для планирования внутри мониторов. Каждая переменная типа очередь может содержать один процесс. Если в мониторе необходимо задержать большое количество процессов, необходимо предоставить несколько переменных очереди, обычно организованных в виде массива. Единственная переменная очереди процесса дает монитору полный контроль над среднесрочным планированием, но за разблокировку правильного процесса отвечает программист.

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

Конфигурация процессов, мониторов и классов в программе Concurrent Pascal обычно устанавливается в начале выполнения и в дальнейшем не изменяется. Пути связи между этими компонентами устанавливаются переменными, передаваемыми в init операторы, поскольку переменные экземпляра класса и монитора не могут использоваться в качестве параметров процедуры.

Пример

В следующем примере показано объявление простого монитора и его использование двумя взаимодействующими процессами.

type
    "Bounded buffer monitor"
    buffer = Monitor
        var
            saved         : Integer;  "saved item is an integer"
            fullq, emptyq : Queue;    "used by only two processes"
            full          : Boolean;  "true if an item is saved:"

        "Puts item in buffer"
        procedure entry put(item : Integer);
            begin
               if full then
                   delay(fullq);      "block if full"
               saved := item;         "save the item"
               full := true;          "mark as full"
               continue(emptyq)       "unblock consumer"
            end;

        "Gets item from the buffer"
        procedure entry get(var item : Integer);
            begin
               if not full then
                   delay(emptyq);     "block if empty"
               item := saved;         "get the item"
               full := false;         "mark as not full"
               continue(fullq)        "unblock producer"
            end;

        "Initialize the monitor"
        begin
            full := false
        end;

    "Producer uses a buffer"
    producer = process(pass : Buffer);
        var item : Integer;
        begin
            cycle                     "execute in a loop forever"
                "produce an item"
                pass.put(item)        "pass an item to the monitor"
            end
        end;

    "Consumer uses a buffer"
    consumer = process(pass : Buffer);
        var item : Integer;
        begin
            cycle
                pass.get(item);       "get an item from the monitor"
                "consume the item"
            end
        end;

"declare instances of the monitor, producer, and consumer"
"give the producer and consumer access to the monitor"
var
   pass : Buffer;
   prod : Producer;
   cons : Consumer;
begin
   init pass,        "initialize the monitor"
        prod(pass),  "start the producer process"
        cons(pass)   "start the consumer process"
end.