Programming technology in ansi c

Operators

T414 (memory=1M) grid[4];

– here is declared 4-element array of T414 processors with 1M of the RAM memory.

edge freelink [4];

–here is defined 4-elements array of hardware edges

OPERATORS IN CDL (CONT 1)

Replicator and conditional operators are used to define regular connections and irregular parts of them.:

rep i=0 to 2 –replicator operator

{connect grid[i].link[2] to grid [i+1].link[3] // connects 2^nd link of i-th

//processor with the 3^rd link of (i+1)-st processor

if (i= =0)

connect grid[1].link[1] to host

else

}

It is possible to introduce new nodes types with the help of operator DEFINE using previously defined types, for example:

Here new type is obtained by specifying of the value of the attribute TYPE of the PROCESSOR type; other attributes of this type are array LINKS and MEMORY.

Attribute LINKS is available only for reading and determines number of physical links (it may be obtained by size (links)).

New processes types are defined similarly:

define process (stacksize = 10K,

interface (INT count, input command, output result)) work package;

Here is defined process type with stack of 10К and with 3 parameters: first is integer, 2^nd is input channel, 3^rd is output channel.

OPERATORS IN CDL (CONT 2)

Networks of processes are defined as follows. Statement

connect control.command to work_package.command –

declares connection (program channel). For naming of the declared channel may be used optional part by connection:

connect item to item [by connection];

Connection’s name can be used for mapping of program channel on hardware channel with the help of operator place:

place channel on link;

The same operator is also used to map processes on processors:

place process on processor;

Configurator automatically maps program channels on links basing on mapping of processes on processors. Explicit mapping of channels on links is required in special cases, for example, if it is desirable to increase rate of information transfer by using separate links for input and output.

To receive parameters declared in the interface of a process by program code it may be used function get_param, for example, get_param(1) will return value of the 1^st parameter count; to work with channels (2^nd and 3^rd parameters) it is necessary to use the following C code:

{

channel *ch;

If we shall output information into channel ch in the program corresponding message will be transferred via channel given in the configuration file for processes connections. CDL has operator USE intended for binding processes defined in configuration file with program processes represented by C codes:

filter x, y, z;

use "filter.lku" for filter

– binds configuration processes of the type filter with program file filter.lku obtained from C file filter.c; the same as previous may be declared by separate statements:

use "filter.lku" for x;

use "filter.lku" for y;

use "filter.lku" for z;

Let’s consider example in which 2 processes are to be mapped on 2-processor network:

One process (controller) performs interaction with the host, the 2^nd performs calculations. Name host is predefined by default and denotes hardware edge intended for communication with the host-computer:

T425 (memory=1m) root;

T800(memory=1m) worker;

connect root.link[1] to host;

connect root.link[2] to worker.link[1];

Iinput from_server; // input edge

output to_server; // output edge

process (stacksize=8k, heapsize=50k, interface(

input command, output reply, output feed, input response))

controller;

connect from_server to controller.command;

connect to_server to controller.reply;

process (stacksize=16k, heapsize=512k, interface(input feed, output

response)) task;

connect controller.feed to task.feed; //output with input

use “compute.lku” for task;

place controller on root;

connect task.response to controller.response;

use “control.lku” for controller;

place task on worker;

place from_server on host;

place to_server on host;

Example of the full program

Let’s consider example of the full ANSI C program including C-codes and configuration file for 4 processes and 2 processors application providing transmission of the message along the ring of processes and printing sent message on the terminal display.

On figure above are shown in one rectangle processes which are to mapped on the corresponding processor, for each process represented by circle there are given as callouts program files (*.lku) from which these processes are originated.

File pr0.c:

#include

#include

#include

#include

#include

#include “common.h”

int main(){

channel *c_in1=NULL, *c_out1=NULL;

char buffer[LenCadr];

c_in1=(channel *)get_param(3); //1^st and 2^nd parameters are got by default

c_out1=(channel*)get_param(4);// and are used by functions

strcpy(buffer, “Hello!”); // printf, scanf, getchar и т.п.

printf(“\nBegin process”);

ChanOut(c_out1,buffer,LenCadr);

printf(“\nmessage out”);

ChanIn(c_in1,buffer,LenCadr);

printf(“\n%s”,buffer);

printf(“end process”);

}

EXAMPLE OF THE FULL PROGRAM (CONT 2)

File pr3.c has the same header files, we shall give only function main:

int main(){

Channel*c_in1=NULL, *c_out1=NULL;

Char buffer[LenCadr];

c_in1=(Channel *)get_param(1);

c_out1=(Channel*)get_param(2);

ChanIn(c_in1,buffer,LenCadr);

ChanOut(c_out1,buffer,LenCadr);

}

For file pr.c we give also only function main:

Channel*c_in1=NULL, *c_out1=NULL, *c_in2=NULL, *c_out2=NULL;

Char buffer[LenCadr];

int i;

c_out1=(Channel*)get_param(2);

c_in2=(Channel *)get_param(3);

c_out2=(Channel*)get_param(4);

while(1){

i=ProcAlt(c_in1,c_in2,NULL);

switch(i){

case 0: ChanIn(c_in1,buffer,LenCadr);

ChanOut(c_out1,buffer,LenCadr);

break;

ChanOut(c_out2,buffer,LenCadr);

break;

}

}

#include “setup.inc”

T805(memory=1M)Tr[2]

connect tr[0].link[0] to host;

connect Tr[0].link[1] to Tr[1].link[1];

input from_server;

output to_server;

process(interface(input FromHost, output ToHost, input From1, output To1)) Pr0;

process(interface(input From0, output To2, input From2, output To0)) Pr1;

process(interface(input From1, output To3, input From3, output To1)) Pr2;

process(interface(input From2, output To2)) Pr3;

connect from_server to pr0.FromHost;

connect To_server to Pr0.ToHost;

connect Pr0.To1 to Pr1.From0;

connect Pr0.From1 to Pr1.To0;

connect Pr1.From2 to Pr2.To1;

connect Pr2.From1 to Pr1.To2;

connect Pr2.From3 to Pr3.To2;

connect Pr3.From2 to Pr2.To3;

use “pr0.lku” for Pr0;

use “pr.lku” for Pr1

EXAMPLE OF THE FULL PROGRAM (CONT 3)

use “pr.lku” for Pr2;

use “pr3.lku” for Pr3;

place Pr0 on Tr[0];

place Pr1 on Tr[0];

place Pr2 on Tr[1];

place Pr3 on Tr[1];

place from_server on host;

place to_server on host;
File “common.h”:

#define LenCadr 2047

val Bootlink 0;