MPD Tutorial and Sample Programs

"Hello world." Description. Program.
Summing the elements of an array. Description. Program.
Quadrature. Description. Iterative program. Recursive program. Parallel recursive program.
Quicksort. Description. Program.
Matrix multiplication. Description. Sequential program. Using co statements. Using processes.
Distributed matrix multiplication. Description. Program using message passing.
Finding patterns in a file. Description. Program.
Concurrent file search. Description. Program. Using virtual machines.
Critical section simulation using rendezvous. Description. Program.
Readers/writers simulation using "monitors" and semaphores. Description. Program.
Programming graphical user interfaces. Description. Program to draw a simple window.

Many of these applications are also discussed in the MPD book. Section references are given below.

The Big Picture

The most general MPD program consists of multiple virtual machines, each of which contains resources and globals. A virtual machine is an address space. A resource is similar to a Java class: It declares a pattern for a class of objects, each is of which is created dynamically. A resource exports operations; its body contains variables, procedures, and processes that implement the operations and/or perform background tasks. A global is a collection of variables and operations that are shared by all resources (and other globals) in the same virtual machine (address space).

Virtual machines are created dynamically and placed on physical machines, such as those in a local-area network. An MPD program that uses virtual machines is called a distributed program. Instances of resources (i.e., objects) are also created dynamically; they are placed on virtual machines. A global is created once when it is first imported.

Every MPD program contains at least one resource. The simplest MPD program consists of a single resource. One resource in every program is treated as the "main" resource. The main resource can have any name the programmer chooses; it does not have to be named main. The main resource is typically the last one that is compiled and must be the last one linked. It may not be imported by any other resource nor have any parameters.

Before an MPD program is executed, the MPD runtime system automatically creates one virtual machine and one instance of the main resource. The virtual machine is located on the physical machine that is used to start the MPD program. The instance of the main resource is placed in that virtual machine. The MPD program is then executed beginning with the first declaration or statement in the body of the main resource. After the program terminates, the final block in the main resource is executed, if there is one. (See the Matrix Multiplication section below for an example.)

Operations are the most important mechanism in MPD (and its predecessor SR). They give the language its power and uniqueness. An operation can be invoked synchronously by means of the call statement or asynchronously by means of the send statement. An operation can be implemented by a proc (procedure) or by an input statement. The four combinations of these mechanisms provide the following functionality:

MPD also provides several mechanisms that are abbreviations of common combinations of the above mechanisms. A procedure declaration is simply an operation plus a proc. The fork statement is an abbreviation for send. The receive statement is an abbreviation for an input statement that merely receives a message. A semaphore is an abbreviation for a parameterless operation. Finally, the V() and P() operations on semaphores are abbreviations for parameterless send and receive statements, respectively. The example programs in this tutorial illustrate all of these language mechanisms.

General Guidelines

The syntax and semantics of MPD are based on a few simple principles, which help make it easy to read or to write MPD programs.

• The main components, resources and globals, begin with resource identifier and global identifier, respectively. Both components end with end identifier. The ending identifier is optional (and often omitted).

• Semicolons are required to separate declarations or statements that appear on the same line, but semicolons can always be replaced by newline characters.

• Names (identifiers) must be declared before they are used.

• Declarations and statements may be intermixed. Thus, declarations can appear close to where the declared variables are used and they can appear inside any block.

• Declarations and statements are executed in the order they appear. Even declarations are executed in the sense that the space for a variable is allocated and initialized when the variable's declaration is encountered.

• Blocks of declarations and statements are always enclosed by braces { ... }. This applies to the bodies of procedures, procs, and processes; the arms of if/else statements; the bodies of loops; and the bodies of final blocks. Unlike C or Java, MPD does not allow braces to be omitted when an arm of an if or else statement or the body of a loop consists of a single statement.

• If a component may have parameters, then parentheses are required, even if the parameter list is empty. This applies to resources, procedures, and procs.

• Commas are used uniformly as list separators in conjunction with formal parameters, actual parameters, declarations, subscripts, and quantifiers.

• Array subscripts are enclosed by brackets, as in a[i]. Matrices (and other multiple-dimension arrays) can use either matrix notation, as in a[i,j], or vector-of-vector notation, as in a[i][j].

• Quantifiers are also enclosed by brackets, as in [i = 1 to 100], because they are normally used in conjunction with arrays. Quantifiers are used in for loops and (optionally) in process declarations and co statements.

A Simple Example

The program below and in hello.mpd illustrates a single-resource program:

   # a simple MPD program with a single resource
   # it prints a string followed by a newline character

   resource hello()
     write("Hello world.")
   end

The name of the resource is followed by parentheses, hello(), because in general resources can have parameters. MPD employs the consistent rule that whenever a component can have parameters, then the declaration contains parentheses, even if the parameter list is empty.

When the above program is executed, the MPD runtime system creates one instance of hello. The body of that instance writes the string "Hello world." (without quote marks) followed by a newline character; then the program terminates. In general write converts its arguments to strings, prints them on one line separated by blanks, and appends a newline.

MPD also provides C's printf statement, so the above program would have the exact same effect if the write statement were replaced by

   printf("Hello world.\n")

   writes("Hello "); write("world.")

Sequential Array Summation

The program below, and in file sum.mpd, illustrates command-line arguments, intermixed declarations and statements, dynamic arrays, and simple for loops.

  # iterative program to sum elements of an array

  # store in a file such as "sum.mpd"
  # compile by executing "mpd sum.mpd"
  # run by executing "a.out size"

  resource sum()
    # declare and read first command-line argument
    int size; getarg(1,size);

    # declare and initialize array a
    int a[1:size];         # same as int a[size]
    for [i = 1 to size] {
      a[i] = i;
    }

    # calculate then print a[1] + ... + a[size]
    int total = 0;
    for [i = 1 to size] {
      total = total + a[i];   # same as total += a[i]
    }
    write("the sum of 1 ...", size, "is", total);

  end

Declarations and statements can appear in any order in MPD. The only requirement is that an identifier be declared before it is used. By allowing declarations to follow statements, it is possible to have array sizes depend on input values. Above, the upper bound for array a is the value size of the first command-line argument. This value must be an integer, because the declared type of size is int.

The declaration of an array can specify both the lower and upper bounds for subscripts, as in a[1:size] above. The bounds can be values of any ordered type, such as int. The lower bound is optional; the default is 1, not 0 as in C. Hence, int a[1:size] is equivalent to int a[size].

The for statements in the above program are also different than those in C. In particular, an MPD for statement uses what is called a quantifier to specify a bound variable and the range of values over which to iterate. Above, the single quantifier [i = 1 to size] is used to iterate over all elements of array a. The bound variable, i above, is a new variable that is declared implicitly; its scope extends to the end of the for statement. Quantifiers are enclosed in brackets [ ... ] rather than parentheses because they are most commonly used in conjunction with arrays. In general, quantifiers can specify more than one bound variable and associated range, as in

  for [i = 1 to N, j = 1 to N] ...

The write statement in the above program prints four items. These are written on the same line separated by single blank characters, and followed by a newline character. The same effect could be achieved using the printf function as follows:

  printf("the sum of 1 ... %d is %d\n", size, total);

The Quadrature Problem

Now consider the quadrature problem described in Section 1.5 of the MPD book. The goal is to approximate the integral of a function f(x) from a to b, namely to approximate the area between f(x) and the x axis from x equals a to x equals b. Below we describe three programs that solve the problem in different ways, then we discuss the tradeoffs between the programs.

Iterative Program. The first program, quad.iter.mpd, uses an iterative algorithm. In particular, the program uses a fixed number of subintervals, approximates the area of each using a trapezoid, then sums the areas to approximate the total area.

The first two lines in the resource declare and read three command-line arguments, as follows:

  int intervals; getarg(1, intervals);
  real a, b; getarg(2, a); getarg(3, b);

Next, we have the declaration of the function to integrate.

  procedure f(real x) returns real fx {
    fx = sin(x) * exp(x);
  }

The main part of the resource calculates the area as follows using the trapezoidal rule:

  real width = (b-a)/intervals;    # distance between intervals
  real fleft = f(a), fright, area = 0.0;
      # fleft is used to compute f(x) just once per value of x

  int start = age();    # start time, in milliseconds
  for [x = (a + width) to b by width ] {
      fright = f(x);
      area += (fleft + fright) * width / 2;  # trapezoidal rule
      fleft = fright;
  }
  int finish = age();   # finish time, in milliseconds

Finally, the resource writes two lines. The first contains the command-line arguments, the second contains the calculated area and elapsed time.

  write("intervals =", intervals," a =", a, " b = ", b);
  write(" area =", area, " time = ",finish-start);

Recursive Program. The second program, quad.recurse.mpd, uses recursion. It implements the adaptive quadrature algorithm using the divide-and-conquer paradigm as described in the MPD book.

The command-line arguments and function f(x) are declared as in the first program. However, the area is computed using the following recursive function:

  procedure quad(real left, real right, real fleft, real fright, real lrarea)
                          returns real area {
    real mid = (left+right)/ 2;
    real fmid = f(mid);
    real larea = (fleft + fmid) * (mid-left) / 2;     # left area
    real rarea = (fmid + fright) * (right-mid) / 2;   # right area
    if (abs((larea+rarea) - lrarea) > epsilon) {
      # recurse to integrate both halves
      larea = quad(left, mid, fleft, fmid, larea);
      rarea = quad(mid, right, fmid, fright, rarea);
    }
    area = larea + rarea;
  }

  int start = age();    # start time, in milliseconds
  real area = quad(a, b, f(a), f(b), (f(a)+f(b))*(b-a)/2);
  int finish = age();   # finish time, in milliseconds

  write("epsilon =", epsilon," a =", a, " b = ", b);
  write(" area =", area, " time = ",finish-start);

Parallel Recursive Program. The third program, quad.co.mpd, uses recursive parallelism. It uses same algorithm as the second program, but the recursive calls are executed in parallel because they are independent. For this it uses the co statement as follows:

  co larea = quad(left, mid, fleft, fmid, larea)
  // rarea = quad(mid, right, fmid, fright, rarea)
  oc;

Performance and Accuracy Tradeoffs. The iterative program will execute faster than the recursive program for the same input -- unless the function is smooth -- because for loops are faster than function calls. However, the recursive program will in general compute a better result because it adapts to the shape of the curve defined by f(x).

On a single processor, the recursive program will be faster than the parallel recursive program, because it takes longer to fork a process than to call a function. Moreover, the parallel program might cause the MPD runtime system to run out of memory and hence to abort the program. This is because the parallel recursive program can create a large number of processes, each process needs its own stack, and the default stack size is 40,000 bytes. (Execute the MPD linker command "mpdl -l" to see the MPD runtime defaults for the maximum number of processes and the size of process stacks. These limits can be changed; see the mpdl man page for how to do so.)

Despite these limitations, the third program can run faster than the second program on a shared-memory multiprocessor. Or one could use a combination of the three programs. For example, try dividing the problem into a fixed number of intervals -- one per processor -- and using the recursive algorithm (program two) for each interval. Exercises 1.7 and 1.8 in the MPD book explore these tradeoffs and describe how to limit the number of processes in the parallel recursive program.

Quicksort

Quicksort is a classic sorting algorithm. It can be implemented in MPD by the recursive program in quick.mpd. That program also illustrates several additional features of MPD: operation headers, proc declarations, var parameters, file access, string variables, and string comparison.

The first line in the body of the resource declares two "constants", using the C convention of upper-case identifiers. The next line contains what is called an op declaration:

  op sort(var string[*] a[1:*])  # forward declaration for sort()

In the op declaration above, the maximum size of the strings and the upper bound for the array are both unspecified, which is denoted by *; Each time sort is called, these will take on actual values as determined by the type of the actual parameter in a call.

The next few lines read the name of an input file and then open the file:

  # read input file name, then open the file
  string[20] fname; getarg(1,fname);
  file fd = open(fname, READ);
  if (fd == null)
    { write("cannot open file", fname); stop(1); }

After reading the filename, the above code attempts to open the file in READ mode. The open() function returns a file pointer (descriptor) or a null pointer if the file cannot be opened. Assuming the file could be opened, it is read as shown in the third line of the following code:

  # declare input array and read input file
  int size = 1;
  string[MAXLINE] data[MAXFILE];
  while(size <= MAXFILE & read(fd, data[size]) != EOF) { size++ }
  if (size > 10000)
    { write("input file is longer than", MAXFILE, "lines"); stop(1); }
  size--;

The next few lines in the program call the sort() procedure and then write the results to standard output:

  # sort the file, then print the result
  sort(data[1:size]);
  for [i = 1 to size] {
    write(data[i]);
  }

  proc sort(a) {
    if (ub(a) <= 1) { return; }   # base case
    string[MAXLINE] pivot = a[1];
    int lx = 2, rx = ub(a);
    while(lx <= rx) {    # partition the array based on the pivot
      if (a[lx] <= pivot) { lx++ }
      else { a[lx] :=: a[rx]; rx-- }
    }
    a[rx] :=: a[1];      # swap pivot line into place
    sort(a[1:rx-1]);     # sort "left" half
    sort(a[lx:ub(a)]);   # sort "right" half
  }

Procedure declarations are closely related to op and proc declarations. In particular, a procedure in MPD is simply an abbreviation for an op immediately followed by a proc.

Matrix Multiplication

Sequential Program. File mm.seq.mpd contains a complete sequential program for multiplying two n by n matrices. After reading a command-line argument for the size n of the matrices, the program declares and initializes the matrices as follows:

  real a[n,n] = ([n] ([n] 1.0)),
       b[n,n] = ([n] ([n] 1.0)),
       c[n,n];

Matrices can be declared and referenced as above, or they can be declared and referenced as vectors of vectors, as in C. For example, the following declaration is also legal in MPD:

  real m[n][n];         # same as:  real m[1:n][1:n]

The next part of the program performs the computation proper:

  for [i = 1 to n, j = 1 to n] {  # compute n**2 inner products
    real sum = 0.0;
    for [k = 1 to n]
      { sum += a[i,k]*b[k,j]; }
    c[i,j] = sum;
  }

The body of the outer for loop declares and initializes sum. The declaration could be placed outside the loop, but the initialization has to occur each time the loop body is entered. The inner for loop computes the inner product of row a[i,*] and column b[*,j].

The last piece of code in the program prints the results on the standard output file. It uses writes() to print a row on one line, then uses write() with no parameters to append a newline.

  # print result, by rows
  for [i = 1 to n] {
    for [j = 1 to n] { writes(c[i,j], " "); }  # one line per row
    write();   # append a newline
  }

Parallel Program Using co Statements. File mm.co.mpd contains a parallel program that computes each inner product in parallel using a co statement. The first and last parts of the program are identical to those for the sequential program. The difference between the two programs is that the nested for loops in the sequential program are replaced by a procedure declaration and a co statement, as follows:

  # compute inner product of a[i,*] * b[*,j]
  procedure inner(int i, int j) {
    real sum = 0.0;
    for [k = 1 to n]
      { sum += a[i,k] * b[k,j] }
    c[i,j] = sum;
  }

  # compute n**2 inner products concurrently
  co [i = 1 to n, j = 1 to n] inner(i,j) oc

The co statement calls the procedure n² times, in parallel. The quantifier in the co statement is exactly the same as the quantifier on the outer for loop in the sequential program.

The co statement causes n² processes to be created. Each gets a different pair of values for i and j and each executes one call inner(i,j). When the processes all quit, the co statement terminates, and the results are printed.

Parallel Program Using Processes. The third program, in mm.process.mpd, also computes n² inner products in parallel. However, it uses a process declaration that combines the procedure declaration and co statement of the previous program.

  process inner[i = 1 to n, j = 1 to n] {
    real sum = 0.0;
    for [k = 1 to n]
      { sum += a[i,k] * b[k,j] }
    c[i,j] = sum;
  }

Although an array of processes is very similar to a co statement plus the procedure called by the co statement, there is an important semantic difference. A process is a declaration. When the declaration is processed, the new processes are created and started, then the main process (the one which processes the declaration) continues to execute. In particular, the above process declaration is implemented essentially as follows:

  for [i = 1 to n, j = 1 to n] {
    fork inner(i,j);  # fork a new instance of procedure inner()
  }

If there is something to be done after all processes have been terminated, you can can either program synchronization code to have the outer process wait for all the new processes to terminate, or better yet, you can use a final block as in the third matrix multiplication program.

  # wait for processes to terminate, then print result, by rows
  final {
    for [i = 1 to n] {
      for [j = 1 to n] { writes(c[i,j], " "); }  # one line per row
      write();   # append a newline
    }
  }

In general, any resource may have a final block. That block is executed when the resource is destroyed. In fact, this is what happens for the main resource. Recall that the MPD runtime system implicitly creates an instance of the main resource. The MPD runtime system also destroys that instance when the program terminates; that destroy causes the final code, if any, to be executed. When that code terminates, the program ceases to exist.

Distributed Matrix Multiplication

File mm.dist.mpd contains a distributed program that uses the coordinator/worker paradigm. The program illustrates the use of message passing in MPD. We have put all the processes in the same resource for convenience. This means that the program as listed can only be executed on a single processor or a shared-memory multiprocessor. However, the program can readily be modified to use multiple resources and virtual machines and hence to execute on a distributed collection of machines, such as a cluster of workstations. We show how to construct a distributed program in the section below on concurrent file search.

The header comment in mm.dist.mpd uses MPD's multi-line comment /* ... */. The start of the resource declares and reads the command-line arguments; these values are global to the processes in the resource.

The message channels are created using op declarations as follows:

  op data[numWorkers] (real m[*,*]);      # channels to Workers
  op result[numWorkers] (real m[*,*]);    # channels to Coordinator

The program uses an array of Worker processes. Each Worker computes a strip of the result matrix c. The Coordinator process first sends strips of matrix a and all of matrix b to each worker, then it receives results from each worker. We use an array of result channels to ensure that each strip of results is stored in the correct strip of matrix c. Notice the use of array slices and * in the send and receive statements. For example,

  send data[w] (a[startRow:endRow,*]);

  receive result[w](c[startRow:endRow,*]);

The matrices in each Worker are declared to be just as big as necessary. Hence, the send and receive statements in the Workers transfer entire matrices. In the case of local matrices a and c, these are strips of the corresponding full matrices in the Coordinator.

Finding Patterns in a File

  global defs           # shared definitions
    const int MAXPATTERN = 20
    const int MAXFILENAME = 20
    const int MAXLINE = 120
  end

Program execution begins, as usual, with the main resource (named grep in this case). The first thing that resource does is to import defs. This causes the constants in global def to be initialized and makes their names visible in the remainder of the resource. A subsequent import of defs (on the same virtual machine) will be ignored, because a global is only created once per virtual machine. In particular, a global is created the first time that it is imported by a resource or another global.

The find procedure uses several of MPD's string processing operations.

  procedure find(string[*] pattern, string[*] line) {
    # if line contains pattern, write out line
    int i = 1, plen = length(pattern)
    while (i <= (length(line) - plen + 1)) {
      if (pattern == line[i:i+plen-1]) {
          write(filename || ":", line); return
      }
      i++
    }
  }

The co statement in the resource is programmed as follows:

  co find(pattern, line[ln])
  // result = doread(3-ln)
  oc

Concurrent File Search

Suppose we want to search for a pattern in multiple files. The files are independent, so they can be searched in parallel by using one process for each file. File cgrep.mpd contains an MPD program that implements this strategy. The program contains a global component and two resources. The global component defines constants as in the previous example.

The first resource, grep, finds all occurrences of string pattern in file filename. These values are parameters to the resource, and hence they are declared in the resource header.

  resource grep(string[*] pattern, string[*] filename)
    import defs
    file  fd = open(filename, READ)

    procedure find(string[*] pattern, string[*] line)  {
      # if line contains pattern, write out line
      int i = 1
      int plen = length(pattern)
      while (i <= (length(line) - plen + 1)) {
        if (pattern == line[i:i+plen-1]) {
	    write(filename || ":", line); return
        }
        i++
      }
    }

    process search  {
      # find all instances of pattern in filename
      string[MAXLINE] line
      while (read(fd, line) != EOF) {
        find(pattern, line)
      }
    }
  end grep

The second resource, main, is the last one that is compiled (and linked), and hence it is the main resource in the program.

  resource main()
    import defs, grep
    # read command line arguments and create instances
    # of resource grep
    string[MAXPATTERN] pattern; getarg(1, pattern)
    string[MAXFILENAME] filename
    for [i = 2 to numargs()] {
        getarg(i, filename)
        create grep(pattern, filename)
    }
  end

Program cgrep.mpd can readily be extended to use virtual machines and hence to allow the different resources to execute on different processors. File cgrep.vm.mpd contains a distributed version.

Only three changes are required to use virtual machines: (1) declare one or more capabilities for virtual machines, (2) create one or more virtual machines, and (3) create resources on those virtual machines. All three of these changes are in the main resource in program cgrep.vm.mpd. The first two are in the lines

  cap vm vc
  vc = create vm() on "paloverde"

   create grep(pattern, filename) on vc

The program in cgrep.vm.mpd also illustrates the use of an external operation. In particular, we have added the following four lines to the top of resource grep:

  external gethostname(res string[*] s, int namelen)
  string[30] hname
  gethostname(hname, maxlength(hname))
  write("vm host:", hname)

External operations can be used to access many functions in libraries that are written in C and that are accessible to the MPD linker. These include the Unix system libraries and window systems. For example, MPDWin is a very useful package for creating graphical user interfaces.

Critical Section Simulation

File cs.simulation.mpd contains a simulation of the critical section problem. (Figure 8.20 of the MPD book contains an SR version of the program.) The program illustrates one use of MPD's rendezvous primitives, operation restrictions, a global component with a body, and MPD's random() and nap() functions.

The global component exports two operations that are invoked when a "user" process enters and exits a critical section. The body of the global contains a background process that repeatedly waits for an invocation of CSenter() and then waits for an invocation of CSexit(). The operation restriction {call} indicates that CSenter() must be called. There is no restriction on the CSexit() operation, so it can be invoked by call or send statements. (The program uses send.)

  global CS
    op CSenter(int id) {call},    # must be called
       CSexit()    # may be invoked by call or send
  body CS
    process arbitrator {
      while (true) {
        in CSenter(id) by id ->
            write("user", id, "in its CS at", age())
        ni
        receive CSexit()
      }
    }
  end

The main resource reads the command line arguments, then forks an array of user processes.

  resource main()
    import CS
    int numusers, rounds; getarg(1, numusers); getarg(2, rounds)

    process user[i = 1 to numusers] {
      for [j = 1 to rounds] {
        call CSenter(i)
        nap(int(random()*100))
        send CSexit()
        nap(int(random()*1000))
      }
    }
  end

  nap(int(random()*100))

Readers/Writers Simulation

File rw.simulation.mpd contains a simulation of the readers/writers problem. The program illustrates one way to implement a monitor in MPD, in this case using a global component and semaphores.

The global component encapsulates the "database" (here, simply an integer). The interface (spec) part of the global exports two operations. The body of the global implements these operations using proc declarations. The body also contains two internal procedures, startread() and endread(), which are called by the read() proc. Semaphores are used as shown in Figure 4.10 of the MPD book to synchronize reads and writes.

global DataBase
  op read(var int data)      # read a value
  op write(val int data)     # write a value
body DataBase
  int database = 0     # the "value" of the database

  sem rw = 1, mutexR = 1
  int nr = 0

  procedure startread() {
    P(mutexR); nr++; if (nr == 1) { P(rw) }; V(mutexR)
  }

  procedure endread() {
    P(mutexR); nr--; if (nr == 0) { V(rw) }; V(mutexR)
  }

  proc read(data) {
    startread(); nap(500); data = database; endread()
  }

  proc write(data) {
    P(rw); nap(1000); database = data; V(rw)
  }
end DataBase

The main resource in the program is similar to the one in the critical section program described above. The main difference is that there are two arrays of background processes, one for readers and one for writers.

resource main()
  import DataBase

  int numReaders; getarg(1, numReaders)
  int numWriters; getarg(2, numWriters)
  int rounds; getarg(3, rounds)

  process Reader[i = 1 to numReaders] {
    int myvalue
    nap(int(random()*1000))   # to let everybody get created
    for [j = 1 to rounds] {
      DataBase.read(myvalue)
      write("reader", i, "read", myvalue)  
      nap(int(random()*1000))
    }
  }

  process Writer[i = 1 to numWriters] {
    int myvalue = i
    nap(int(random()*1000))   # to let everybody get created
    for [j = 1 to rounds] {
      DataBase.write(myvalue)
      write("writer", i, "wrote", myvalue)  
      nap(int(random()*1000))
    }
  }
end

Programming Graphical User Interfaces

Here we describe a simple use of the MPDWin package. The program in file window.hello.mpd opens a small window on the programmer's workstation and writes the message "Hello World" in that window. The header comment indicates how to compile and link the package into an MPD program.

  resource hello()
    import MPDWin;      # access the global defining MPDWin

    int interval; getarg(1, interval);   # seconds to display window

    winWindow mywin = WinOpen("", "Hello", null, UseDefault, 100, 30);
    if (mywin == null)
      { write("Sorry, cannot open window"); stop(1); }

    WinSetForeground(mywin, "yellow");   # set foreground color
    WinDrawString(mywin, winPoint(10,20), "Hello World");
    WinFlush(mywin);

    nap(interval*1000);     # sleep for interval seconds
    WinClose(mywin);
  end

The MPDWin package contains dozens of functions that support sophisticated graphics programming. The MPD distribution contains larger examples that illustrate the use of many of these. The implementation of MPDWin also has two interesting attributes that make it relatively easy to create complex interfaces. First, MPDWin makes the X11 library "thread safe", so that the MPD programmer can use multiple processes to control one or more windows. Second, MPDWin converts asynchronous external events, such as mouse button pushes, into a stream of messages; the MPD programmer services external events by receiving messages from the event channel.


Last updated February 8, 2001

MPD home page