M/D/1 queue

SequenceL is a general purpose functional programming language, whose primary design objectives are performance on multicore hardware, ease of programming, and code clarity/readability. Its primary advantage is that it can be used to write straightforward code that automatically takes full advantage of all the processing power available, without the developer having to concern themselves with identifying parallelisms, avoiding race conditions, and the like.

Programs written in SequenceL can be compiled to multithreaded code that runs in parallel with no explicit indications from the programmer of how or what to parallelize. (Current versions of the SequenceL compiler generate C++ and OpenCL code, though other languages may also be supported.) An OS-specific runtime manages the threads safely, automatically providing parallel performance according to the cores available.

History

SequenceL was developed over a 20 year period beginning in 1989, primarily at Texas Tech University. Primary funding was provided by NASA, which originally wanted to develop a requirements language which was “self-verifying” - that is, once written, the requirements could be “executed,” and the results verified against the desired outcome.

The principal researcher on the project was initially Dr. Daniel Cooke, who was soon joined by Dr. Nelson Rushton (another Texas Tech professor) and later Dr. Brad Nemanich (then a PhD student under Dr. Cooke). The goal of creating a language that was simple enough to be readable, but unambiguous enough to be executable, drove the inventors to settle on a declarative language approach, where the programmer describes desired results, rather than the means of achieving them. The language is then free to solve the problem in the most efficient manner it can find.

As the language evolved, the researchers developed new computational approaches, including Consume-Simplify-Produce (CSP). In 1998 research began to apply SequenceL to parallel programming. This culminated in 2004 when it took its current form with the addition of the Normalize-Transpose (NT) semantic. NT is the semantic work-horse, being used to simplify and decompose structures, based upon a dataflow like execution strategy similar to GAMMA and NESL. The NT semantic achieves a goal similar to that of the Lämmel and Peyton-Jones’ boilerplate elimination. All other features of the language are definable from these two laws - including recursion, subscripting structures, function references, and evaluation of function bodies.

Though it had not been the original intent, these new approaches allowed the language to parallelize a large percentage of the operations it performed, transparently to the programmer. In 2006 a prototype auto-parallelizing compiler was developed at Texas Tech University. In 2009, Texas Tech licensed the intellectual property to Texas Multicore Technologies, Inc. (TMT), for follow-on commercial development. Texas Tech continues research into SequenceL via additional research grants, as well as through collaboration with TMT.

SequenceL has been used in commercial-scale applications where code transparency, and/or multi-processor support, have been crucial. These applications have included space craft navigation, aviation decision support, target tracking, network scheduling, database processing, and industrial control systems.

Design

SequenceL is designed to be as simple as possible to learn and use. For example, the complete language reference for SequenceL is only 40 pages (including copious examples), and its formal grammar has around 15 production rules.

SequenceL is strictly evaluated (like Lisp), statically typed with type inference (like Haskell), and uses a combination of infix and prefix operators that resemble standard, informal mathematical notation (like C, Pascal, Python, etc.). It is a purely declarative language, meaning that the programmer defines functions, in the mathematical sense, without giving instructions for their implementation. As an example, the mathematical definition of matrix multiplication is as follows

The product of the m×p matrix A with the p×n matrix B is the m×n matrix whose (i,j)'th entry is

$\sum _{k=1}^{p}A(i,k)B(k,j)$

The SequenceL definition mirrors that definition more or less exactly:

   matmul(A(2), B(2)) [i,j] := 
       let k := 1...size(B); 
       in  sum( A[i,k] * B[k,j] );

The subscripts following each parameter A and B on the left hand side of the definition indicate that A and B are depth-2 structures (i.e., lists of lists of scalars), which are here thought of as matrices. From this formal definition, SequenceL infers the dimensions of the defined product from the formula for it's (i, j)'th entry (as the set of pairs (i, j) for which the right hand side is defined) and computes each entry by the same formula as in the informal definition above. Notice there are no explicit instructions for iteration in this definition, or for the order in which operations are to be carried out. Because of this, the SequenceL compiler can perform operations in any order (including parallel order) which satisfies the defining equation. In this particular example, computation of coordinates in the product will be parallelized in a way that, for large matrices, scales linearly with the number of processors.

SequenceL has no built-in constructs for I/O. However, since it can be compiled to multithreaded C++ with the SequenceL compiler, it can easily be used to create standalone applications by linking the resulting code with other code which performs I/O tasks. SequenceL functions can also be queried from an interpreter with given inputs, like Python and other interpreted languages.

Normalize-Transpose

The main non-scalar construct of SequenceL is the sequence, which is essentially a list. Sequences may be nested to any level. To avoid the routine use of recursion common in many purely functional languages, SequenceL uses a technique known as normalize-transpose, in which scalar operations are automatically distributed over elements of a sequence. For example, in SequenceL we have

$[1,2,3]+10==[11,12,13]$

This results not from overloading the '+' operator, but from the effect of normalize-transpose (NT) that extends to all operations, both built-in and user-defined. As another example, if f() is a 3-argument function whose arguments are scalars, then for any appropriate x and z we will have

$f(x,[1,2,3],z)==[f(x,1,z),f(x,2,z),f(x,3,z)]$

The NT construct can be used for multiple arguments at once, as in, for example

$[1,2,3]+[10,20,30]==[11,22,33]$

It also works when the expected argument is a non-scalar of any type T, and the actual argument is a list of objects of type T (or, in greater generality, any data structure whose coordinates are of type T). For example, if A is a matrix and X_s is a list of matrices [X₁, ... , X_n], and given the above definition of matrix multiply, in SequenceL we would have

   matmul(A,Xs) = [matmul(A,X1),...,matmul(A,Xn)]

As a rule, NTs eliminate the need for iteration, recursion, or high level functional operators to

1. do the same things to every member of a data structure, or to
2. process corresponding parts of similarly shaped structures together.

This tends to account for the majority of uses of iteration and recursion.

Example – Prime numbers

A good example that demonstrates the above concepts would be in finding prime numbers. A prime number is defined as

An integer greater than 1, with no positive divisors other than itself and 1.

So a positive integer z is prime if no numbers from 2 through z-1, inclusive, divide evenly. SequenceL allows this problem to be programmed by literally transcribing the above definition into the language.

In SequenceL, a sequence of the numbers from 2 through z-1, inclusive, is just (2...(z-1)), so a program to find all of the primes between 100 and 200 can be written:

   prime(z) := z when none(z mod (2...(z-1)) = 0);

Which, in English just says,

...return the argument if none of the numbers between 2, and 1 less than the argument itself, divide evenly into it.

Note that if that condition isn’t met, the function doesn’t return anything. As a result, running this program yields

   cmd:>prime(17)
   17
   cmd:>prime(18)
   empty

Note also that “between 100 and 200” doesn’t appear in the program. Rather, a programmer will typically pass that part in as the argument. Since the program expects a scalar as an argument, passing it a sequence of numbers instead will cause SequenceL to perform the operation on each member of the sequence automatically. Since the function returns empty for failing values, the result will be the input sequence, but filtered to return only those numbers that satisfy the criteria for primes:

   cmd:>prime(100...200)
   [101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199]

In addition to solving this problem with a very short, and very readable program, SequenceL’s evaluation of the nested sequences would all be performed in parallel.

Components

The following software components have been released by TMT for use by developers writing SequenceL code. With the exception of the Visual Studio plug-in, all components (including the compiled runtime library) are available for Mac, Windows, and most varieties of Linux, including 32-/64-bit variants of CentOS, OpenSUSE, and Ubuntu.:

Interpreter

A command-line interpreter allows developers to write code directly into a command shell, or to load code from pre-written text files. This code can be executed, and the results evaluated, to assist in checking code correctness, or finding a quick answer. Code executed in the interpreter does not run in parallel – it executes in a single thread.

Compiler

A command-line compiler reads SequenceL code and generates highly-parallelized C++, which must be linked with the SequenceL runtime library to execute.

Runtime

The runtime is a pre-compiled set of libraries which the compiled C++ code links to in order to execute in parallel. It handles things such as work queues, memory management, and performance monitoring.

Eclipse Debugger / IDE

An Eclipse plug-in provides standard editing capabilities (function rollup, chromacoding, etc.), as well as a debugging environment. This plug-in runs against the SequenceL Interpreter, so cannot be used to debug the multi-threaded code – however, by providing automatic parallelization, debugging of parallel SequenceL code is really verifying correctness of sequential SequenceL code. That is, if it runs correctly sequentially, it should run correctly in parallel – so debugging in the interpreter is sufficient.

Visual Studio Plug-in / IDE

A Visual Studio plug-in is available for Windows. This provides the same sort of editing and test execution environment as the Eclipse IDE, but does not provide debugging capabilities.

Libraries

Various math and other standard function libraries are available to streamline the programming process. These may be imported, in much the same way that C or C++ libraries are #included.

Using SequenceL

Typically, SequenceL development is done in one of the IDEs, or a text editor, and debugged/verified for correctness using the interpreter. When complete, the code is then passed through the SequenceL compiler, which outputs highly parallelized C++ code. The developer then adds this code to their project, linking to the runtime library at compile time, generating a single, parallelized, executable.

See also

• List of concurrent and parallel programming languages
• Simon Peyton Jones

External links

• Texas Multicore Technologies
• Normalize, Transpose and Distribute: An Automatic Approach for Handling Nonscalars

References

43 year old Petroleum Engineer Harry from Deep River, usually spends time with hobbies and interests like renting movies, property developers in singapore new condominium and vehicle racing. Constantly enjoys going to destinations like Camino Real de Tierra Adentro.