ClearSpeed Programming Language Cn

1
ClearSpeed Programming Language Cn
2
References

• Primary Reference
• ClearSpeed Introductory Programming Manual,
  Version 3.0, January 2008
• Additional References
• ClearSpeed Software Development Kit Reference
  Manual, Version 3.0, January 2003.
• ClearSpeed Technical Training Slides for
  ClearSpeed Accelerator 620, software version 3.0,
  Slide Sets 1-2, December 2007
• Acknowledgement Some slides from Slide Sets 1
  3 have been used in part or completely.

3
Basics of the Cn Language

• The Cn language is strongly based on ANSI C.
• Cn accepts C block style comments (/ ... /)
  and the C syntax (// ...) for line comments.
• The goto statement is not supported.
• Both break and continue statements can be used
  with a label to control what loop they apply to.
• Cn uses two new keywords called multiplicity
  specifiers
• mono indicates a variable which has one instance,
  which is stored in the mono memory.
• poly indicates a variable has many instances
  with one stored in each processing element (PE).

4
Example
5
Cn Language Data Types

• Basic Types
• char, unsigned char, signed char, short, unsigned
  short, signed short
• int, unsigned int, signed int
• long, unsigned long, signed long
• float, double, long double
• Derived Types
• struct
• union
• pointers
• arrays
• Note These are exactly the same as for ANSI C.

6
Basic Types with Mono or Poly

• Basic types used with a multiplicity specifier.
• poly int counter // A different instance of
  counter exists on each PE
• mono unsigned char initial // A single instance
  of initial exists in mono memory
• Note The default multiplicity is mono.

7
Comments about Complex Data Types

• There are many data type possibilities, and some
  are fairly complex.
• We will only provide an brief overview of these.
• If one of the more complex types is needed, you
  will need to study details carefully at that
  point.
• It is probably best to minimize use of more
  complex constructs initially.
• Recall in ASC language, the use of pointers is
  avoided altogether by use of the associative
  functions.

8
Pointers Type

• Pointer declarations consist of the base type on
  the left of and the pointer object to the
  right.
• In traditional C, it is possible to make either
  of these entities constant.
• const int const foo / const pointer to const
  int /
• int const bar / const pointer to
  non-const int /
• const int bing / non-const pointer to
  const int /
• Multiplicity specifiers work in similar way
• poly int poly foo / poly pointer
  to poly int /
• int poly bar / poly
  pointer to mono int (equiv to mono int poly
  bar) /
• poly int bing / mono
  pointer to poly int (equiv to poly int mono
  bing) /
• mono int mono p / mono pointer to
  mono int /

9
Pointers to mono data

• Mono pointer to mono data

• Poly pointer to mono data

10
Pointers to Poly Data

• For poly data, the same two types of pointers
  exist
• mono pointer points to the same address in every
  PEs memory.
• This is the most frequently used pointer in Cn
• poly pointer can hold a different address on
  each PE (pointing to data on the same PE).

11
Mono Pointer to Poly Data(Most common type
pointer in Cn)

• Example Count nr bytes with 0 value in a
  buffer on each PE
• poly char bufferBUFFER_SIZE
• poly char mono ptr
• poly int count
• int i
• ptr buffer // Initialize
• count 0
• // Interate over the buffer
• for (i 0 i lt BUFFER_SIZE i)
• if (ptr 0) //check value pointed to each PE
• count // increment the counter
• ptr // move the pointer to next byte

12
Poly Pointer to Poly Data

• Example
• // prototype for poly version of strchr()
• poly char poly strchrp(const poly char mono
  s1, poly char c)
• poly char str256 // variable str is actually
  a poly mono pointer
• poly char poly ptr // a pointer into string
• ......... // initialize string on each PE
• ptr strchrp(str, z) // search for first
  occurrence of z different on each PE

• Mono pointer to poly data
• The type is (poly poly)

13
Illegal Cast Problem

• Since mono and poly data are in completely
  separate memory space, it is not legal to cast
  (i.e., assign) a mono pointer to a poly pointer
  or vice-versa.
• First reason for this problem is that mono and
  poly pointer sizes are not guaranteed to be the
  same.
• poly memory is typically quite small and may use
  16-bit pointers, while mono pointers may be 32 or
  64 bits
• Second reason for this problem is that a pointer
  to data in poly memory will not necessarily point
  to anything meaningful if cast to a pointer to
  mono memory.
• it could point to arbitrary data or even code

14
Arrays in Cn

• The multiplicity specifier for an array type
  defines the domain for the base type.
• Example poly int buffer20
• This declaration will create an array of 20
  elements in mono memory and an array of 20
  corresponding poly memory variables
• The poly specifier indicates the base type (i.e.,
  type of elements) in mono array. In this case,
  the array elements are poly int.
• The declaration will also create 20 rows of
  elements of type int in poly memory.
• Think of 20 copies of slide picture of mono
  pointer to poly data.
• The address of each of these arrays in poly space
  will be same .
• This is effectively the same as poly int mono
  
• See diagram of this type two slides back.
• Warning It is not possible to create a poly int
  poly pointer using array notation as an array
  only specifies the base type of the array
• The implicit pointer multiplicity class of base
  array elements is always mono.
• Multi dimension array are supported in Cn
  language as we have done in ANSI C.
• Reference For Example above, see SDK Reference
  Manual 11.5.3

15
Structure and Union

• They are same as ANSI C .
• But multiplicity specifiers have strict rules for
  use inside the structure /union.
• Objects inside a structure /union definition have
  no multiplicity class. Example
• struct _A
• int a
• char b // Multiplicity class
  not defined in struct definition
• float c
• poly struct _A my_struct // All
  objects within the struct are poly
• mono struct _A my_struct_2 // All objects
  within the struct are mono
• But
• poly struct _B
• int a // Not
  allowed to declare multiplicity inside defn
  
  
• int b // (but
  statement also declares a poly object)
• my_struct_3

16
Structure and Union Cont .

• Even the following syntax is also wrong
• union _B
• poly int a
  // Illegal use of multiplicity
  specifier
• mono char b
  // Illegal use of multiplicity
  specifier
• float c
• mono union _B my_union //
  Multiplicity of declaration would conflict with
  definition
• Only at the time of pointer declaration in
  structure/union the poly and mono can be used.
• Due to fact that the member itself (the pointer)
  cannot have a multiplicity specifier, but the
  object pointed to can
• Without this capability it would not be possible
  to have a pointer to a poly object as a member of
  a structure or union.

17
Structure and Union (cont)

• Example A pointer inside a struct/union can
  point to an object with multiplicity specifier,
• struct _C
• mono int a //
  pointer to a mono int
• poly char b //
  pointer to a poly char
• struct _C my_struct2 // Note this is an
  implicit mono object
• // a is
  mono pointer to mono int
• // b is
  mono pointer to poly char
• struct _C poly my_struct3 // Poly object of
  the same type
• //
  a is poly pointer to mono int
• //
  b is poly pointer to poly char
• The first object my_struct2 contains two members
  which are mono int mono a and poly char mono
  b.
• The second object my_struct3 contains two members
  which are mono int poly a and poly char poly b

18
Typedefs

• Cn supports typedefs as in ANSI C
• Typedef causes compiler to add type to list of
  types it recognizes. Type names can be used in
  same way as the built-in type names, as in
  variable declaration, cast expressions, etc.
• The typedef statement cannot use multiplicity
  specifiers to define the multiplicity of the
  type.
• But as with structs and unions, it can define
  pointers to mono or poly types.
• Example
• typedef short Bool
  // Bool variables are of type short
• typedef poly int p_int
  // illegal use of multiplicity specifier
• typedef poly int p_ptr //
  p_ptr is a pointer to poly int
• typedef mono int m_ptr //
  m_ptr is a pointer to mono int
• p_ptr a
  // poly int mono a
• poly p_ptr a
  // poly int poly a
• m_ptr a
  // mono int mono a
• poly m_ptr a
  // mono int poly a

19
Mixing Mono Poly Variables

• Generally legal to mix mono and poly variables in
  expressions.
• A mono value can be assigned to a poly variable.
  Below expression results in 1 being copied to all
  instances of x.
• poly int x 1
• An expression can mix mono and poly variables.
  Below statements result in y being added to
• poly int x
• Int y
• x x y
• Above results in y being promoted to a poly
  variable and added to x.
• It is not legal or meaningful to assign a poly to
  a mono variable.

20
Flow Control Statements

• Cn has the same flow control statements as C.
• If statements
• for loops
• while loops
• do .... while loops
• Switch statements (not supported for poly
  expressions)
• The difference in the Cn flow control statements
  is that the conditional expression evaluated can
  be either a mono or poly expression.
• It is important to understand how these work and
  how they differ from the statements for C.

21
If Statement

• When the expression evaluated in the control
  statement is a mono expression, the if statement
  branching is the same as in standard C.
• Consider the case below where the expression
  evaluated in control statement is a poly
  conditional
• poly short penum( )
• mono int i 0
• / Each PE now contains a different value in the
  penum variable /
• if (penum lt 32)
• . . . / do some work /
• else
• . . . / do some different work /
• Note all PEs less than 32 execute the first
  branch while all other PEs execute the second
  branch.
• The use of else in this construct is optional.

22
If Statement (cont)

• The execution of mono operations inside an if
  statement with a poly conditional requires
  additional consideration
• poly short penum( )
• mono int i 0
• / Each PE now contains a different value in the
  penum variable /
• if (penum lt 32)
• . . . / do some work /
• i / increment mono variable i /
• else
• . . . / do some different work /
• i
• Mono actions are executed first for if branch
  then else branch, even if there are no PEs
  responding to one of the branches.
• The value of i is changed to 1 in if branch and
  to 2 in else branch, so final value of i is 2.
• This action in Cn is different that for ASC
  language.
• Mono statements in vacuous PE branches in ASC are
  not executed

23
For, while, and do...while loops

• These loops can be covered together, due to
  similarity
• A loop with a poly control expression (i.e., poly
  loop) will be executed until all PEs evaluate
  conditional as false.
• Before a loop terminates, any PE that evaluates
  the conditional as false is disabled for all
  remaining iterations
• Mono expressions are executed every pass through
  loop
• A loop may execute zero times. In this case, mono
  statements inside loop are not executed.
• This feature differs from IF statement.
• Break and continue can be used inside loops to
  control the flow of the program

24
For, while, and do...while loops (cont)

• Consider following code
• poly int i
• mono int max_loop_count 0
• poly int this_loop_count 0
• . . . / In this code, i is set so that it has a
  different value in each PE /
• while (i gt 0)
• i-- / decrement poly loop control /
• max_loop_count / increment mono loop_count
  each loop /
• this_loop_count / increment poly loop_count
  while i gt0 /
• At the end of this code, each PE will have a
  different value in this_loop_count (i.e., the
  initial value of i for this PE).
• The value of max_loop_count will be the value of
  the largest i across PEs.
• This value might be useful for debugging purposes.

25
Goto Statements

• Are selectively supported in Cn
• Must meet restriction that goto statement does
  not cross a poly boundary
• Prohibits anything that changes the enable
  state of PEs such as a poly if or poly while.
• As a result, not too useful.
• Use labeled break statements instead

26
Labeled Breaks

• To provide the functionality of the goto, the
  break and continue statement are provided in Cn.
• Labels are permitted in Cn but only on loop
  constructs.
• E.g., for, while, do...while.
• The break and continue statements can specify a
  label, allowing the program to break out of
  heavily nested loops.
• Example
• for_i
• for (i 0 i lt 10000 i)
• // Label for_i is associated with this for
  loop
• while(j gt 100)
• do
• // . . . Code for do ... while
• if (foo bar)
• break for_i
• // . . . More code for do ... while

27
Switch Statements

• Switch statements are supported in Cn and provide
  the same functionality as in ANSI C
• Switch statements must be mono expressions.
• Example
• int val
• . . . . / Some code which sets up the value in
  val /
• switch (val) / only mono expressions are
  valid for switch /
• case 0
• case 1
• . . . . / Do some work /
• break
• case 2
• . . . . / do other work /
• break
• default
• . . . . / etc /

28
Switch Statement

• Equivalent code for poly expressions using nested
  if statements.
• poly int val
• .... / some code to set up values in val /
• if ((val 0) (val 1))
• / Select operations to be done on each PE
  /
• else if (val 2)
• . . . . / do other work /
• else
• . . . . / etc. /

29
Functions

• Functions are fundamentally the same in Cn as in
  ANSI C.
• Cn supports function pointers.
• Multiplicity specifiers can be used to specify
  the return type of a function, as well as the
  types of any arguments.
• Functions with a mono return type are called mono
  functions.
• Mono functions terminate (like C) when a return
  is executed
• Functions with a poly return type are poly
  functions
• Poly functions only end when all PEs have
  executed a return statement.
• Additionally, execution continues to the end of
  the code, so that any mono code is executed.

30
Function (2 out of 3)

• Consider the following example

poly int bar(poly int p1, p2) if (p1)
if (p2) return -1 //
disable appropriate PEs and save the return value
of -1 else return 0 //
disable appropriate PEs and save the return value
of 0 . . . . (1)
return 0 // PEs which are still enabled save
0 as a return value and are disabled . . .
. (2) / return saved poly values here /
31
Functions (3 out of 3)

• Comments on Code
• All PEs for which condition p1 is true will
  return a value (either 0 or -1, depending on p2.
• These PEs will be disabled until the end of the
  function.
• All other PEs will continue to execute the rest
  of the poly code in the function.
• Note that poly code at (1) will be executed by
  those PEs which have not already specified a
  return value of 0 or -1
• This is followed by an unconditional return, so
  any poly code at (2) will not be executed.
• All mono code in the function will always be
  executed.
• Reference SDK Reference manual, pg 120-121.

32
Summary on Function Returns
33
Data Transfers Between Mono and Poly

• The following coverage will provide an short
  overview of what transfers are possible
• Additionally, some information about the speed of
  transfers is included.
• However, this is primarily just a light overview.
• Additional investigations will be needed before
  using these transfer functions.

34
(No Transcript)
35
(No Transcript)
36
(No Transcript)
37
Strided Data Transfer

• memcpym2p_strided
• This function transfers data from mono to poly
  using strided mode
• the starting address in mono memory is specified
  this is then incremented by the specified stride
  value for each PEs data.
• Every enabled PE transfers the same amount of
  data to the same location in poly memory
  disabled PEs do not take part in the transfer.
• memcpyp2m_strided
• As above, but transferring data from poly to mono
  memory.

38
(No Transcript)
39
Caution on Caching and I/O

• It is important to be aware of the way that the
  cache is used for mono data when using the I/O
  functions.
• Normally, accesses by a program to mono memory
  are cached to provide faster access to frequently
  used data.
• However, I/O transfers to and from the PEs do not
  go via the cache this could lead to unexpected
  behavior unless efforts are made to keep the
  contents of the cache and external memory
  consistent.
• The memcpy functions described above do this
  automatically however, the asynchronous versions
  do not.
• The function dcache_flush can be used to ensure
  that the contents of the data cache are
  consistent with mono memory. This should be used
  if your program mixes normal accesses to mono
  memory with the I/O functions.

40
(No Transcript)
41
(No Transcript)
42
(No Transcript)
43
Semaphores

• A semaphore is a non-negative number and two
  associated operations Signal and Wait.
• A signal is a atomic operation that increases the
  semaphores value.
• Wait is a atomic operation that decrements the
  semaphores value.
• Valid user semaphore numbers are 0-92
• 93-127 are reserved for system use
• An atomic operation is one that can not be
  interrupted.

44
Further Information

• See the ClearSpeed Standard Library Reference
  Manual for further details

45
(No Transcript)
46
(No Transcript)
47
(No Transcript)
48
Running Debugging Cn Programs
49
Executing Cn Programs

• The Quick Start Guide will be covered at this
  point
• It is posted separately on the course website.
• Slides in this section provide a brief summary of
  Quick Start Guide.
• Another important reference is Chapters 3 4 of
  the ClearSpeed Introductory Programming Manual
• This reference is also posted on the course
  website.

50
Executing a Cn Program

• Log into the server called simd while in your
  Kent CS account using SSH as follows
• ssh username_at_simd.cs.kent.edu
• CSHOME should be set as in Quick Start Guide.
• The Cn program to be executed should be moved to
  a subdirectory of your home directory.
• You could use any program example located in
  CSHOME/examples
• We will use the Cn version of Hello World in the
  file
• CSHOME/examples/sdk/hello_world

51
Executing a Cn Program (cont)

• Resetting, Compiling, and Running
• The command csreset must be used to reset the
  clearspeed board before running programs
• csreset
• The command cscn is used to compile.
• cscn hello_world.cn
• Preceding command will produce the executable
  program a.csx
• As with C, the output can be renamed using the
  -o option.
• The command csrun is used to run executable code
• csrun a.csx
• Only one program can be compiled and run at a
  time.
• If the resource is being used, an error message
  will indicate this.

52
Executing a Cn Program on the Simulator

• When developing code, it is better to use the
  simulator instead of the hardware.
• The command isim is used to start the simulator
• The program is run in another SSH window in which
  you are logged into clearspeed.
• Before starting, the simulator must first be
  reset
• csrun -s A
• To run your program on the simulator, use
  following command
• Csrun s hello_world.cn
• Until you perform a CTRL C in the first ssh
  window, no one else can use the simulator.
• Please exit the simulator as soon as you are done
  with it.

53
Overview of Activating Debugger

• To use the debugger, the code has to be compiled
  with the g option.
• cscn -g o hello_world.csx hello_world.cn
• Start the debugger with command
• csgbd hello_world.csx
• Connect debugger to simulator or hardware
• (gdb) connect
• Next, the program source can be listed and break
  points set at locations where you want to examine
  values of mono and poly variables.
• Finally, start the program running
• (gbd) run
• A slightly more complex program will better
  illustrate how to use the debugger.

54
Example Cn Parallel program

• include ltstdiop.hgt
• include ltmathp.hgt
• include ltlib_ext.hgt
• define SAMPLES 96
• int main()
• poly float sine, angle
• poly int i
• // get PE number 0...n-1
• i get_penum()
• // convert to an angle in // the range 0 to Pi
• angle i M_PI / SAMPLES
• // calculate sine on each PE
• sine sinp(angle)
• // print out values
• printfp("d 0.3f\n", i, sine)
• return 0

55
Using the Debugger

• Compile program with debug support
• cscn -o -g sine_poly.csx sine_poly.cn
• Next, start the debugger
• csgdb sine_poly.csx
• A message is displayed along with the debugger
  prompt (gdb).
• Use connect command to connect to hardware or
  simulator.
• When, connected, the current location of the
  program counter is displayed
• To view the program source, enter list
• (gbd) list
• Type a return at the prompt to display more of
  the program ---- Next slide shows the effect of
  this

56
(No Transcript)
57
Using the Debugger (cont)

• Setting break point before print statement
• (gbd) break 19
• Response to above command
• Breakpoint 1 at 0xx80015180 file sine_poly.cn,
  line 19
• (gbd)
• Start the program running
• (gdb) run
• You can now use debugger to examine the state of
  some of the variables (mono or poly). If you
  print a parallel variable, you will have a lot of
  values printed.
• (gbd) print sine

58
Using the Debugger (cont)

• Can limit the number of parallel variables
  printed by entering following command earlier
• set print elements 4
• Use of the continue command here will print the
  entire list of parallel values one PE value per
  line.
• (gbd) continue
• Exiting the debugger
• (gbd) quit

59
Some Basic csgdb Commands

• next
• Steps to next program line (stepping over
  function calls
• step
• Differs from next by stepping into a function
  call rather than stepping over.
• help
• Shows command help within csgdb
• set listsize 8
• Sets number of lines displayed by list command.
  Default is 10.
• break ltfcn-namegt
• Sets a break around a function
• break info
• Lists all breaks that have been set
• tbreak
• Sets temporary break. Will be deleted after it is
  hit the first time.

60
Some csgdb Commands (cont)

• where
• Finds the current location of the program counter
  while debugging
• whatis ltvariablenamegt
• Gives the data type of the variable name.
• delete ltbreakpointnumbergt
• Deletes the specified break point.
• next
• Move debugger to the next line of execution.
• continue
• Run till the end of the program is reached.
• set print elements 4
• Limits the number of PE values displayed to 4
• up
• Move up the call stack and back towards main
• down
• Move down the call stack towards the end of code

61
Some csgdb Commands (cont)

• Finish
• debugger can return from a function by using the
  finish command
• ignore 6 20
• Will ignore next 20 crossings of breakpoint 6.
• Print x
• print the address of variable xltmono or polygt
• print/f 8p4
• If address is 8p4 then above will print the
  value stored at this address
• Continue
• Continue program being debugged, after signal or
  breakpoint.
• Note Additional information about many of these
  command is given in Ch. 7 of the Introductory
  Programming Manual. Also, additional commands to
  step through functions and print values which are
  not covered in these slides is given in Chapter 7

62
Slides from ClearSpeed Training Set 3 follow

• Included for possible reference purposes

63
(No Transcript)
64
(No Transcript)
65
(No Transcript)
66
(No Transcript)
67
(No Transcript)
68
(No Transcript)
69
(No Transcript)
70
(No Transcript)