Structural, Behavioural and Declarative

Three main forms of design entry and programing.

We also add regular expressions.

Structural

Subroutine call to anonymous instance or component instantiation:

       comp0(a, b, c, f);
       {
         decl d;
         comp1(a, b, c, d);
         comp2(b, c, f);
       }

Can use a thread of control to activate or always be active. A return value used sometimes or else have bi-directional ports.

Each of the variables can be complete interfaces with bi-directional data flows and handshakes for flow control.

Behavioural

Behavioural is very familiar to us and uses a thread of control to perform operations in turn.

A functional style gives the tool more freedom over order of execution.

      thread { i = 0; while (1) { foo(g(i)+k(i)); i++ } 

Many systems communicate between threads using shared variables. Process algebras use named channels with read and write primitives

         x = R(ch)             R: ch -> exp
         W(ch, x)              W: ch * exp -> unit

Low-level hardware design using behavioural constructs uses an infinite process loop with wait statements. Can wait() for a clock edge or other handshake signal.

Standard denotational semantics can take a section of behavioural code and convert it to a massively-parallel, next state function using symbolic evaluation.

Hence, functional and imperative behavioural specification is useful, well-understood and easy.

Declarative

We provide a list of specifications that the system must achieve.

Any algorithm or combinatorial structure can be used to generate the design.

       always s1 \/ s2 \/ s3;
       always s1 -> X(s2);
       s2 = N == q*D + r;