Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/pure-cfg/src/compiler/codegen/target-sig.sml
ViewVC logotype

Diff of /branches/pure-cfg/src/compiler/codegen/target-sig.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 838, Mon Apr 18 02:53:09 2011 UTC revision 839, Mon Apr 18 16:50:47 2011 UTC
# Line 14  Line 14 
14      type var      type var
15      type exp      type exp
16      type stm      type stm
17      type ty  
18      (* environment for mapping from TreeIL variables to target variables.  It is also used to
19       * track the translation context (e.g., global initialization vs. strand initialization, etc.
20       *)
21        type env
22    
23    (* the supprted widths of vectors of reals on the target.  This value takes into    (* the supprted widths of vectors of reals on the target.  This value takes into
24     * account the actual size of reals (i.e., 32 or 64 bits).     * account the actual size of reals (i.e., 32 or 64 bits).
# Line 25  Line 29 
29      val inlineCons : int -> bool        (* can n'th-order tensor construction appear inline *)      val inlineCons : int -> bool        (* can n'th-order tensor construction appear inline *)
30      val inlineMatrixExp : bool          (* can matrix-valued expressions appear inline? *)      val inlineMatrixExp : bool          (* can matrix-valued expressions appear inline? *)
31    
32    (* target types *)    (* TreeIL to target translations *)
33      val boolTy : ty      structure Tr : sig
34      val intTy : ty          val block : env * TreeIL.block -> stm
35      val realTy : ty          val exp : env * TreeIL.exp -> exp
36      val vecTy : int -> ty        end
     val ivecTy : int -> ty  
     val tensorTy : int list -> ty       (* for tensors of order > 0 *)  
     val stringTy : ty  
     val imageTy : ImageInfo.info -> ty  
     val imageDataTy : ImageInfo.info -> ty  
   
     val newProgram : unit -> program  
37    
38    (* output the code to a file.  The string is the basename of the file, the extension    (* variables *)
39     * is provided by the target.      structure Var : sig
40     *)          val global : program * TreeIL.var -> var        (* global variables *)
41      val generate : string * program -> unit          val param : TreeIL.var -> var
42            val state : strand * TreeIL.var -> var          (* strand state variables *)
43          end
44    
45    (* register the global initialization part of a program *)    (* environments *)
46      val globalInit : program * stm -> unit      structure Env : sig
47          (* create a new environment *)
48            val new : program -> env
49          (* define the current translation context *)
50            val scopeGlobal : env -> env                    (* global initialization *)
51            val scopeInitially : env -> env                 (* initial strand creation *)
52            val scopeStrand : env * strand -> env           (* strand initialization *)
53            val scopeMethod : env * TreeIL.var list -> env  (* method body *)
54          (* bind a TreeIL varaiable to a target variable *)
55            val bind : env * TreeIL.var * var -> env
56          end
57    
58      (* programs *)
59        structure Program : sig
60            val new : unit -> program
61            val init : program * stm -> unit        (* global initialization *)
62    (* register the initially code for a program *)    (* register the initially code for a program *)
63      val initially : {      val initially : {
64              prog : program,              prog : program,
# Line 56  Line 69 
69              strand : Atom.atom,              strand : Atom.atom,
70              args : exp list              args : exp list
71            } -> unit            } -> unit
72          (* output the code to a file.  The string is the basename of the file, the extension
73      structure Var : sig         * is provided by the target.
74          val global : program * ty * string -> var         *)
75          val param : ty * string -> var          val generate : string * program -> unit
         val state : strand * ty * string -> var  
         val var : ty * string -> var  
         val tmp : ty -> var  
       end  
   
   (* expression construction *)  
     structure Expr : sig  
       (* return true if the given expression from is allowed as a subexpression *)  
         val allowedInline : exp -> bool  
       (* variable references *)  
         val global : var -> exp  
         val getState : var -> exp  
         val param : var -> exp  
         val var : var -> exp  
       (* literals *)  
         val intLit : IntegerLit.integer -> exp  
         val floatLit : FloatLit.float -> exp  
         val stringLit : string -> exp  
         val boolLit : bool -> exp  
       (* select a fixed element from a vector *)  
         val select : int * exp -> exp  
       (* vector and matrix subscripting *)  
         val subscript1 : exp * exp -> exp  
         val subscript2 : exp * exp * exp -> exp  
       (* vector (and scalar) arithmetic *)  
         val add : exp * exp -> exp  
         val mul : exp * exp -> exp  
         val sub : exp * exp -> exp  
         val divide : exp * exp -> exp  
         val neg : exp -> exp  
         val abs : exp -> exp  
         val dot : exp * exp -> exp              (* dot product *)  
         val mulVecMat  : exp * exp -> exp       (* vector-matrix multiplication *)  
         val mulMatVec  : exp * exp -> exp       (* matrix-vector multiplication *)  
         val mulMatMat  : exp * exp -> exp       (* matrix-matrix multiplication *)  
         val cross : exp * exp -> exp            (* cross product *)  
         val length : exp -> exp                 (* vector length *)  
         val normalize : exp -> exp              (* normalize vector *)  
       (* matrix operations *)  
         val trace : exp -> exp  
       (* comparisons *)  
         val lt : exp * exp -> exp  
         val lte : exp * exp -> exp  
         val equ : exp * exp -> exp  
         val neq : exp * exp -> exp  
         val gte : exp * exp -> exp  
         val gt : exp * exp -> exp  
       (* logical connectives *)  
         val not : exp -> exp  
         val && : exp * exp -> exp  
         val || : exp * exp -> exp  
       (* misc functions *)  
         val min : exp * exp -> exp  
         val max : exp * exp -> exp  
         val lerp : exp * exp * exp -> exp  
       (* rounding *)  
         val trunc : exp -> exp                  (* truncate real to integral real *)  
         val round : exp -> exp                  (* round real to integral real *)  
         val floor : exp -> exp                  (* real to integral real floor *)  
         val ceil : exp -> exp                   (* real to integral real ceiling *)  
       (* conversions *)  
         val toInt : exp -> exp                  (* real to integer *)  
         val toReal : exp -> exp                 (* integer to real *)  
       (* runtime system hooks *)  
         val imageAddr : exp -> exp              (* based address of image data *)  
         val getImgData : exp -> exp             (* fetch a data value from the *)  
                                                 (* specified address and convert to *)  
                                                 (* a real *)  
         val posToImgSpace : exp * exp -> exp    (* map world-space pos to image-space *)  
         val inside : exp * exp * int -> exp     (* inside image domain test, *)  
                                                 (* where params are: dim, pos, *)  
                                                 (* img , and border width *)  
       (* other basis functions *)  
         val apply : ILBasis.name * exp list -> exp  
       end  
   
   (* statement construction *)  
     structure Stmt : sig  
         val comment : string list -> stm  
         val assignState : var * exp -> stm  
         val decl : var * exp option -> stm      (* local variable declaration *)  
         val assign : var * exp -> stm  
         val block : stm list -> stm  
         val ifthen : exp * stm -> stm  
         val ifthenelse : exp * stm * stm -> stm  
         val for : var * exp * exp * stm -> stm  
       (* special Diderot forms *)  
         val cons : var * exp list -> stm list  
         val getImgData : var * exp -> stm list  (* load a vector of data from the *)  
                                                 (* specified address and convert to *)  
                                                 (* a vector *)  
         val loadImage : var * int * exp -> stm list  
         val input : var * string * exp option -> stm list  
         val exit : unit -> stm  
       (* update method exits *)  
         val active : unit -> stm  
         val stabilize : unit -> stm  
         val die : unit -> stm  
76        end        end
77    
78    (* strands *)    (* strands *)

Legend:
Removed from v.838  
changed lines
  Added in v.839

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0