History and development
SuperPascal is based onFeatures
The key ideas in the design of SuperPascal was to provide a ''secure'' programming, with abstract concepts for parallelism.Security
SuperPascal is ''secure'' in that it should enable its compiler andgoto
statements, pointers and forward declarations.
Parallelism
The parallel features of SuperPascal are a subset of occam 2, with the added generality of dynamic process arrays and recursive parallel processes. Aparallel
statement denotes that the fixed number of statements it contains must be executed in parallel. For example:
parallel source() , sink() endA
forall
statement denotes the parallel execution of a statement by a dynamic number of processes, for example:
forall i := 0 to 10 do something()
Channels and communication
Parallel processes communicate by sending typed messages through channels created dynamically. Channels are not variables in themselves, but are identified by a unique value known as the ''channel reference'', which are held by ''channel variables''. A channel is declared, for example, by the declarationopen
statement:
open(c)Message communication is then achieved with the
send(channel, value)
and receive(channel, variable)
statements. The expression or variable providing the value for send
, and the variable in receive
, must both be of the same type as the first channel argument. The following example shows the use of these functions in a process that receives a value from the ''left'' channel and outputs it on the ''right'' one.
send
and receive
can both take multiple input and output arguments respectively:
send(channel, e1, e2,..., en); receive(channel, v1, v2,..., vn)The following runtime communication errors can occur: * ''Channel contention'' occurs when two parallel processes both attempt to send or receive on the same channel simultaneously. * A ''message type error'' occurs when two parallel processes attempt to communicate through the same channel and the output expression and input variable are of different types. * ''Deadlock'' occurs when a send or receive operation waits indefinitely for completion.
Parallel recursion
Recursive procedures can be combined withparallel
and forall
statements to create parallel recursive processes. The following example shows how a ''pipeline'' of processes can be recursively defined using a parallel
statement.
Interference control
The most difficult aspect of concurrent programming is ''unpredictable'' or ''non-reproducible'' behaviour caused by ''time-dependent'' errors. Time-dependent errors are caused by ''interference'' between parallel processes, due to variable updates or channel conflicts. If processes sharing a variable, update it at unpredictable times, the resulting behaviour of the program is time-dependent. Similarly, if two processes simultaneously try to send or receive on a shared channel, the resulting effect is time-dependent. SuperPascal enforces certain restrictions on the use of variables and communication to minimise or eliminate time-dependent errors. With variables, a simple rule is required: parallel processes can only update disjoint sets of variables. For example, in aparallel
statement a ''target'' variable cannot be updated by more than a single process, but an ''expression'' variable (which can't be updated) may be used by multiple processes. In some circumstances, when a variable such as an array is the ''target'' of multiple parallel processes, and the programmer knows its element-wise usage is ''disjoint'', then the disjointness restriction may be overridden with a preceding ic/code> statement.
Structure and syntax
SuperPascal is a block structured language, with the same basic syntax as Pascal. A program consists of a ''header'', ''global variable definitions'', ''function'' or ''procedure'' definitions and a ''main'' procedure. Functions and procedures consists of ''blocks'', where a block is a set of ''statements''. Statements are ''separated'' by semicolons, as opposed to languages like C or Java
Java is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea (a part of Pacific Ocean) to the north. With a population of 156.9 million people (including Madura) in mid 2024, proje ...
, where they are ''terminated'' by semicolons.
The following is an example of a complete SuperPascal program, which constructs a ''pipeline'' communication structure with 100 nodes. A master node sends an integer token to the first node, this is then passed along the pipeline and incremented at each step, and finally received by the master node and printed out.
program pipeline;
const
len = 100;
type
channel = *(integer);
var
left, right: channel;
value: integer;
procedure node(i: integer; left, right: channel);
var value: integer;
begin
receive(left, value);
send(right, value+1)
end;
procedure create(left, right: channel);
type row = array ..lenof channel;
var c: row; i: integer;
begin
c := left;
c en:= right;
for i := 1 to len-1 do
open(c ;
forall i := 1 to len do
node(i, c -1 c
end;
begin
open(left, right);
parallel
send(left, 0) ,
create(left, right) ,
receive(right, value)
end;
writeln('The resulting value is ', value)
end.
Implementation
The SuperPascal software can be accessed freely from the Brinch Hansen Archive. It consists of a compiler and interpreter, which are both written in normal, sequential Pascal (ISO Level 1 standard Pascal). This is supported by the GNU Pascal compiler and newer versions of the Free Pascal
Free Pascal Compiler (FPC) is a compiler for the closely related programming-language dialects Pascal and Object Pascal. It is free software released under the GNU General Public License, witexception clausesthat allow static linking against it ...
compiler (2.7.1+) with the -Miso
switch, with the following respective small modifications to the code.
For GPC, the file interpret.p
uses the non-standard clock
function (line 1786), which is used to obtain the system time. Instead, the Extended Pascal getTimeStamp
function can be used (which is supported by the GNU Pascal compiler), by declaring a variable of type TimeStamp
, setting that with the current time using getTimeStamp
and assigning the Second
field of the TimeStamp
to the variable t
.
Free Pascal also needs a solution to the above "clock" problem (On windows, just declare gettickcount as external with "clock" as name). Further, the reset/rewrites that are marked as non-standard in the source code must be changed to assign/reset (or rewrite) pairs. (GPC probably only errors on this if you enable strict flags), and the C preprocessor commands #include 'xx' must be changed to .
Function FpTime(var tloc : integer): integer; external name 'FPC_SYSC_TIME';
procedure readtime(
var t: integer);
begin
t:=fptime(t);
end;
References
External links
* , Brinch Hansen Archive, a set of his papers and the SuperPascal software which can be downloaded in a compressed file; contains the full language specification and useful documentation.
* , Christopher Long's modified version of the original SuperPascal implementation; compiles and runs under modern Free Pascal; program execution is faster than Perl 5 or 6, nearly as fast as Python 3
{{Pascal programming language family
Concurrent programming languages
Procedural programming languages
Pascal programming language family
Programming languages created in 1993