ForSyDe: System Design Using a Functional Language and Models of Computation

Abstract

The ForSyDe methodology aims to push system design to a higher level of abstraction by combining the functional programming paradigm with the theory of Models of Computation (MoCs). A key concept of ForSyDe is the use of higher-order functions as process constructors to create processes. This leads to well-defined and well-structured ForSyDe models and gives a solid base for formal analysis. The book chapter introduces the basic concepts of the ForSyDe modeling framework and presents libraries for several MoCs and MoC interfaces for the modeling of heterogeneous systems, including support for the modeling of run-time reconfigurable processes.

The formal nature of ForSyDe enables transformational design refinement using both semantic-preserving and nonsemantic-preserving design transformations. The chapter also introduces a general synthesis concept based on process constructors, which is exemplified by means of a hardware synthesis tool for synchronous ForSyDe models. Most examples in the chapter are modeled with the Haskell version of ForSyDe. However, to illustrate that ForSyDe is language-independent, the chapter also contains a short overview of SystemC-ForSyDe.

Appendix: Introduction to Haskell

This section gives a short introduction to functional languages and Haskell to give readers who are not familiar with functional programming additional background information. For more information on Haskell, visit the Haskell home page [61].

A functional program is a function that receives the program’s input as argument and delivers the program’s output as result. The main function of a program is defined in terms of other functions, which can be composed of still other functions until at the bottom of the functional hierarchy the functions are language primitives. Haskell is a pure functional language, where each function is free from side-effects. This means given the same inputs, which in case of ForSyDe could be a set of input signals, a Haskell function will always produce identical outputs. Thus the whole functional program is free from side-effects and thus behaves totally deterministic. Since all functions are free from side-effects, the order of evaluation is only given by data dependencies. But this means also that there may exist several possible orders for the execution of a functional program.

Considering the function

$$\displaystyle{ \begin{array}{lcl} f(x,y)& =&u(h(x),g(y)) \end{array} }$$

the data dependencies imply that the functions h(x) and g(y) have to be evaluated before u((h(x), g(y)) can be evaluated. However, since there is no data dependency between the functions h and g, there are the following possible orders of execution:

• h(x) is evaluated before g(y);

• g(y) is evaluated before h(x);

• h(x) and g(y) are evaluated in parallel.

Thus functional programs contain implicit parallelism, which is very useful when dealing with embedded system applications, since they typically have a considerable amount of built-in parallelism. Of course it is also possible to parallelize imperative languages like C++, but it is much more difficult to extract parallelism from programs in such languages, since the flow of control is also expressed by the order of statements.

In addition to common data types, such as Bool, Int, and Double, Haskell also defines lists and tuples. An example for a list is [1,2,3,4] :: [Integer], which is a list of integers. The notation “::” means “has type.” An example for a tuple, which is a structure of different types is (’A’, 3) :: (Char, Integer) where the first element is a character and the second one is an integer. Haskell has adopted the Hindley-Milner type system [38], which is not only strongly typed but also uses type inference to determine the type of every expression instead of relying on explicit-type declarations.

Haskell is based on the lambda-calculus and allows to write functions in curried form, where the arguments are written by juxtaposition. The following Haskell function add is written in curried form.

add :: Num a => a -> a -> a add x y = x + y

Since ‘->’ associates from right to left, the type of add can also be read as

add :: Num a => a -> (a -> a)

This means that given the first argument, which is of a numeric type a, it returns a function from a to a. This enables partial application of a curried function. New functions can then be defined by applying the first argument, e.g., 

inc x = add 1 dec x = dec 1

These functions only have one argument and the following type

inc :: Num a => a -> a dec :: Num a => a -> a

Another powerful concept in functional languages is the higher-order function , which is adopted in ForSyDe for process constructors. A higher-order function is a function that takes functions as argument and/or produces a function as output. An example of a higher-order function is map, which takes a function and a list as argument and applies (“maps”) the function f on each value in the list. The function map is defined as follows

map f []     = []                   -- Pattern 1 (empty list) map f (x:xs) = f x : map f xs -- Pattern 2 (all other lists)

The higher-order function map uses an additional feature of Haskell, which is called pattern matching and is illustrated by the evaluation of map (+1) [1,2,3].

	map (+1) [1,2,3]
⇒	map (+1) (1:[2,3])	Pattern 2 matches
⇒	1+1: map (+1) [2,3]	Evaluation of Pattern 2
⇒	2: map (+1) (2:[3])	Pattern 2 matches
⇒	2: 2+1: map (+1) [3]	Evaluation of Pattern 2
⇒	2: 3: map (+1) (3:[])	Pattern 2 matches
⇒	2: 3: 3+1: map (+1) []	Evaluation of Pattern 2
⇒	2: 3: 4: map (+1) []	Pattern 1 matches
⇒	2: 3: 4: []	Evaluation of Pattern 2
⇒	[2,3,4]

During an evaluation the patterns are tested from the top to the bottom. If a pattern, the left-hand side, matches, the corresponding right-hand side is evaluated. The expression map (+1) [1,2,3] does not match the first pattern since the list is not empty ([]). The second pattern matches, since (x:xs) matches a list that is constructed of a single value and a list. Since the second pattern matches, the right-hand side of this pattern is evaluated. This procedure is repeated recursively until the first pattern matches, where the right-hand side does not include a new function call. As this example shows, lists are constructed and processed from head to tail.

The higher-order function map can now be used with all functions and lists that fulfill the type declaration for map, which Haskell infers as

map :: (a -> b) -> [a] -> [b]

Another important higher-order function is function composition, which is expressed by the composition operator ‘.’.

(.)        :: (b -> c) -> (a -> b) -> (a -> c) f . g     =  \x -> f (g x)

This definition uses “lambda abstractions” and is read as follows. The higher-order function f . g produces a function that takes a value x as argument and produces the value f(g(x)). The expression f = (+3) . (*4) creates a function f that performs f(x) = 4x + 3. Function composition is extremely useful in ForSyDe since it allows to merge processes in a structured way.

Haskell allows to define own data types using a data declaration. It allows for recursive and polymorphic declarations. A data type for a list could be recursively defined as

data AList a = Empty                     | Cons a (AList a)

The declaration has two data constructors. The data constructor Empty constructs the empty list and Cons constructs a list by adding a value of type a to a list. Thus Cons 1 (Cons 2 (Cons 3 Empty)) constructs a list of numbers. The term type constructor denotes a constructor that yields a type. In this case AList is a type constructor. As mentioned before, the list data type is predefined in Haskell. Here [] corresponds to Empty and : to Cons. [a] corresponds to AList a. The ForSyDe Signal is defined in the same way as the data type AList, see Sect. 4.2.1.