GPU621/Chapel

From CDOT Wiki
Revision as of 22:17, 29 November 2022 by Lhuangtang (talk | contribs) (→‎Procedure)
Jump to: navigation, search

Introduction

The Chapel is an open-source programming language designed for productive parallel computing at scale. The Chapel compiler is written in C and C++14. The backend is LLVM, written in C++. The goal of Chapel is to improve the programmability of parallel computers in general.

Installation

Basic

Variables

Variables are declared with the var keyword. Variable declarations must have a type, initializer, or both. 

     var myVariable1: int;
     writeln("myVariable1 = ", myVariable1);

const and param can be used to declare runtime constants and compile-time constants respectively. A const must be initialized in place, but can have its value generated at runtime. A param must be known at compile time. 

     const myConst: real = sqrt(myVariable2);
     param myParam = 3.14;
     writeln("myConst = ", myConst, ", myParam = ", myParam);

At module scope, all three variable kinds can be qualified by the config keyword. This allows the initial value to be overridden on the command line. A config var or config const may be overridden when the program is executed; a config param may be overridden when the program is compiled. Similarly, type aliases maybe be qualified by the config keyword. The comment following each declaration shows how the value can be modified. 

     config var cfgVar = "hello";         // ./variables --cfgVar="world"
     config const cfgConst: bool = false; // ./variables --cfgConst=true
     config param cfgParam = 4;           // chpl variables.chpl -s cfgParam=1
     config type cfgType = complex;       // chpl variables.chpl -s cfgType=imag
     writeln("cfgVar = ", cfgVar,
             ", cfgConst = ", cfgConst,
             ", cfgParam = ", cfgParam,
             ", cfgType = ", cfgType:string);

Procedure

The primer covers procedures including overloading, argument intents and dynamic dispatch.

Overloading

The prime allows the user to do the overload function and overload operators.

Argument Intents

Normal (default) intent means that a formal argument cannot be modified in the body of a procedure.

  • To allow changing the formal (but not the actual), use the in intent
  • The inout intent will write back the final value of a formal parameter when the procedure exits.
  • Similar to the inout intent, the ref intent causes the value of the actual to change depending on the function. However, while the inout copies the argument in upon entering the function and copies the new value out upon exiting, using a ref intent causes any updates to the formal to immediately affect the call site.
  • The out intent causes the actual argument to be ignored when the procedure starts. The actual is assigned the value of the corresponding formal when the routine exits.

Class

Like C++, the prime allows the user to create a new type that can contain variables and constants, called fields, as well as functions and iterators called methods. A new class type is declared using the class keyword. 

   class C {
     var a, b: int;
     proc printFields() {
       writeln("a = ", a, " b = ", b);
     }
   }

Record

A record type can be declared using the record keyword. A record is a type that can contain variables and constants, called fields, as well as functions and iterators called methods. Records have many similarities to classes, but there are several important differences:

  • Records do not support inheritance and virtual dispatch
  • Record variables refer to distinct memory
  • copy-initialization and assignment can be implemented for records
   record Color {
     var red: uint(8);
     var green: uint(8);
     var blue: uint(8);
   }

Special MEthods

Reference

Retrieved from "https://wiki.cdot.senecapolytechnic.ca/w/index.php?title=GPU621/Chapel&oldid=159243"