VAL

Steven NicholsMark Taylor

Will Cecil

A data flow language

Outline

What are VAL? Why do I care? What does VAL do? How does VAL do? How do I VAL? (Syntax)

What are VAL

Data Flow Language Do you remember that? (Those really cool graphs)

Created by MIT (1979) Inherently Concurrent “Value-oriented Algorithmic Language” “VAL was intended to be a small research

language that would give everyone an opportunity to experiment with data flow computing.”

Why do I care?

Automatic Parallelism “it is totally unreasonable to ask programmers to

state which operations can proceed together” Lets the hardware decide what type of concurrency

Vectorization or Pipelining determined by compiler

Experimental Language Designed for experimenting with Data Flow

Language. Dead (1982)

No compilers, nothing.

Why do I care? (2)

Very well defined Gehani and Wetherell wrote denotational semantic

definition Brock applied operational semantics to a subset of

VAL Ackerman applied axiomatic semantics to a VAL-

like toy language. (Yes a toy of an experiment)

What does VAL do?

Automatic Parallelism Lets the hardware decide what type of concurrency

Experimental Language Small research language, with many features

unimplemented (Including I/O) Massively Scalable

Split up tasks to run on any number of CPUs

What does VAL do?

Functions can return multiple values. Interesting Error Handling

No mid-calculation aborts like typical languages Error type returned rather than expected result Domain of functions defined to include errors Every VAL function will finish.

Algebraic syntax (INFIX) Immutable “Values” not “Variables”

“Single Assignment”/”Defined Constants” Terrible on arrays.

What does VAL do? (2)

Anything and Everything that can be concurrent will be.

Functions can return multiple values No recursion Tree Calculation

Can sum an array in O(log n) time.

How does VAL do?

Data Flow Computing As we learned in-class

Compiler decided vectorization and pipeline Function as pipelines

Data types:PrimitivesArraysRecordsOne of

Assignments

Expressions

Functions

If-then-else

For loop

Forall loop

Error handling

How do I Val? (VAL Syntax)

Four primitive types:BooleanintegerrealCharacter

Each of these types carries an appropriate set of operators (e.g., +, - , &, I, - (not}, >,=).

Data type: Primitives

• Every data type has its own special error values

• Automatic type conversions are never made

• However, each type has functions to do conversions to all “reasonable cases”

Data type: Primitives

Arrays in VAL are unusual because array bounds are not part of the type definition:

type Integer__list = array[integer];

Since the length of the array is not part of the type, this one type describes all finite-length, ordered sequences of integers.

Data type: Array

An array in VAL is actually an arbitrarily long list of ordered pairs. For example,

[1: elementOne; 2: elementTwo]

Is an array with two items.

Data type: Array

Data type: Array

• VAL's unusual array definitions allow us to do some interesting things:

– shift the origin

– add elements at either end

– delete elements at either end

– change array bounds

Data type: Array

Array Concurrency

• All elements of an array can be specified simultaneously, thus allowing all of the evaluations of array entries to proceed together.

Data type: Record

Record construction is patterned after the array construction scheme to promote concurrency.

record[x_low : low; Fx_low: lowv;

x_high: high; Fx_high: highv]

The above expression builds a record with four fields. Each field name is followed by an expression representing the value to be entered in the record.

Data Type: OneOf

• Sometimes it is advantageous to allow a value to appear to be different types at different times

• Consider a search function that should return an array of results if there are any, but NIL if there are none

type Result = oneof[none: null;

more: integer_list];

Assignments

• The noninterference property requires that language features be incapable of producing side effects.

• The concept of updating memory (i.e., modifying variables) must be thrown away.

• There are no variables in VAL, everything is more like a constant.

• Values can be defined and used in many places, but no value can ever be modified

Assignments

• The syntax for associating a value with a name is pretty straight forward:

myValue: integer := 22;

myBoolVal: boolean := true

MyReal: real := 1.4

Expressions

• Expression are written with standard infix operators, to make things easy for programmer

• Values for the two operands for any infix operator can always be computed in parallel. So in the expression

(right - mid) * (rightv + midv) * 0.5

+ (mid - left) * (midv + leftv) * 0.5

all operations inside parentheses can execute simultaneously.

Functions

• Functions and expression in VAL have been modified to allow multiple return values. The following function takes in 3 reals and returns 2 reals.

function Stats(X, Y, Z: real returns real, real)

let

Mean real := ( X + Y + Z)/3;

SD real := SQRT ( ( X^2 + y^2 + Z^2)/3 - Mean^2);

in

Mean, SD

endlet

endfun

Sequencing Expressions

• Some expression should not be run in parallel

• Sequencing is imposed either to insure logical correctness or to avoid initiating operations whose results will never be used.

• Expression with forced sequencing

– If-then-else

– For-iter loop

If-then-else

• Behaves just as you would expect

If <boolean condition>

Then <expressions>

Else <more expressions>

For-iter Loop

• The for-iter loop is for when one pass of a loop depend on the results of the previous pass (impossible to execute in parallel)

• A for expression has two separate structural parts: loop initialization and loop body.

• Loop initialization appears between the reserved words for and do.

– All loop parameters (identifiers that can carry information from one pass to the next) must be declared and given initial values here.

For-iter Loop

The loop body appears between the do and endfor

The decision concerning loop iteration takes place inside some form of conditional expression (IF statement in our example)

The keyword iter causes the loop to initiate another pass

Loop termination happens when an expression is returned

For-iter Loop Example

# Compute sum of all elements in the array, “list”

for

sum: integer := 0;

index: integer := array_liml(list);

do

if index > array_limh(list)

then sum

else iter

sum := sum + list[index];

index := index + 1;

enditer

endfor

Forall

• One of the most important forms of concurrency available in VAL comes from the forall expression.

• If the calculations do not depend on each other, the array could be built in one highly parallel, non-looping expression.

• In conventional languages vector sums are performed by having each pass of a loop add one element to a running sum. This approach requires linear time. Faster execution can be achieved by eliminating the loop and organizing the calculation as a binary tree of partial sums. This approach requires log time.

• Both of these types of concurrency are representable in VAL through one language feature called forall.

Forall

We compute the sum of all the elements in an array (in log n time) with the following:

forall i in [array_liml(list), array_limh(list)]

eval plus

endall

Other merge operators include:

times, max, min, and, and or.

Error Handling

Error values provide accurate information about the cause of a problem

All operators are defined over the error values, allowing error information to propagate

VAL's error prorogation rules provide absolute accuracy, sometimes at the cost of providing less information

Error Handling

pos_over – positive overflow (greater magnitude) neg_over – negative overflow pos_under – positive underflow (greater

precision) neg_under – negative underflow zero_divide – division by zero miss_elt – access undefined array element unknown – combination of over/under-flow undef – all other errors

Error Handling

Propagation pos_over + pos_over yields pos_over pos_over - 1 yields unknown

Special cases Logic expression “undef = undef” produces “undef” (not

true)

Test functions VAL provides functions to test for errors. Example:

if under( value ) # tests for underflow

if is_error ( value ) # tests for any errors

Conclusions

Note: this is not the cool “VAL”, the one used for programming robots.

VAL is worse than LISP No I/O at all! No assignment statements No globals Ugly for loops

VAL

Steven NicholsMark Taylor

Will Cecil

A data flow language

THIS IS SLIDE n