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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/tree-ir/tree-ir.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/tree-ir/tree-ir.sml

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

revision 3767, Mon Apr 18 18:42:10 2016 UTC revision 4380, Mon Aug 8 17:05:58 2016 UTC
# Line 15  Line 15 
15      structure Op = TreeOps      structure Op = TreeOps
16      structure Ty = TreeTypes      structure Ty = TreeTypes
17    
18        type target_info = {
19            layout : int -> TreeTypes.vec_layout,
20            isInline : LowOps.rator -> bool
21          }
22    
23      datatype program = Program of {      datatype program = Program of {
24          props : Properties.t list,          props : Properties.t list,
25            target : target_info,           (* target-specific info about representation invariants *)
26          consts : global_var list,       (* large constant variables *)          consts : global_var list,       (* large constant variables *)
27          inputs : input list,            (* global input variables *)          inputs : input list,            (* global input variables *)
28          constInit : block,              (* code that initializes constants and inputs *)          constInit : block,              (* code that initializes constants and inputs *)
29          globals : global_var list,      (* other global variables *)          globals : global_var list,      (* other global variables *)
30          globalInit : block,             (* CFG to initialize other globals (if any) *)          funcs : func_def list,          (* user-defined functions *)
31            globInit : block,               (* CFG to initialize other globals (if any) *)
32          strand : strand,                (* the strand definition *)          strand : strand,                (* the strand definition *)
33          create : create,                (* initial strand creation *)          create : create,                (* initial strand creation *)
34          update : block option           (* optional update code. *)          init : block option,            (* optional global initially code *)
35            update : block option           (* optional global update code. *)
36          }
37    
38        and func_def = Func of {
39            name : func,
40            params : var list,
41            body : block
42        }        }
43    
44      and strand = Strand of {      and strand = Strand of {
45          name : Atom.atom,          name : Atom.atom,
46          params : var list,          params : var list,
47            spatialDim : int option,
48          state : state_var list,          state : state_var list,
49          stateInit : block,          stateInit : method,
50          initM : block option,          initM : method option,
51          updateM : block,          updateM : method,
52          stabilizeM : block option          stabilizeM : method option
53        }        }
54    
55      and create = Create of {      and method = Method of {
56          dim : int option,               (* grid dimension; NONE for collections *)            needsW : bool,                (* does the method need the world (e.g., to print) *)
57          code : block                    (* the loop nest for creating the strands *)            hasG : bool,                  (* does the method contain references to globals? *)
58              body : block                  (* the method body *)
59        }        }
60    
61      and block = Block of {      and block = Block of {
62          locals : var list,          locals : var list ref,          (* the local variables that are used in this block *)
63          body : stm list          body : stm list
64        }        }
65    
66      and stm      and stm
67        = S_Comment of string list        = S_Comment of string list
68        | S_Unpack of var list * exp      (* unpack vector pieces into local variables *)        | S_Assign of bool * var * exp    (* assignment; the boolean is true for var decls *)
69        | S_Assign of var * exp        | S_MAssign of var list * exp
70        | S_GAssign of global_var * exp        | S_GAssign of global_var * exp
71        | S_IfThen of exp * block        | S_IfThen of exp * block
72        | S_IfThenElse of exp * block * block        | S_IfThenElse of exp * block * block
73          | S_For of var * exp * exp * block
74        | S_Foreach of var * exp * block        | S_Foreach of var * exp * block
75      (* special Diderot forms *)      (* special Diderot forms *)
76        | S_LoadNrrd of var * string        | S_MapReduce of (var * Reductions.t * block) list * var * StrandSets.t
77          | S_LoadNrrd of var * APITypes.t * string
78        | S_Input of global_var * string * string option * exp option (* get input *)        | S_Input of global_var * string * string option * exp option (* get input *)
79        | S_InputNrrd of global_var * string * string option * string option (* get image/seq input *)        | S_InputNrrd of global_var * string * string option * string option (* get image/seq input *)
80        | S_New of Atom.atom * exp list   (* new strand creation *)        | S_New of Atom.atom * exp list   (* new strand creation *)
81        | S_Save of state_var * exp  (* save strand state *)        | S_Save of state_var * exp  (* save strand state *)
82        | S_Exit of exp list        | S_Print of Ty.t list * exp list
83          | S_Return of exp
84      (* return functions for methods *)      (* return functions for methods *)
85        | S_Active        | S_Active
86        | S_Stabilize        | S_Stabilize
# Line 69  Line 88 
88    
89      and exp      and exp
90        = E_Global of global_var        = E_Global of global_var
91        | E_State of state_var        | E_State of exp option * state_var
92        | E_Var of var        | E_Var of var
93        | E_Lit of Literal.t        | E_Lit of Literal.t
94        | E_Op of Op.rator * exp list        | E_Op of Op.rator * exp list
95        | E_Cons of exp list * Ty.ty        | E_Apply of func * exp list              (* user-defined function application *)
96        | E_Seq of exp list * Ty.ty        | E_Vec of int * int * exp list           (* vector value; the ints are the width and the
97        | E_Pack of exp list              (* pack vector pieces into composite vector value *)                                                   * padded width
98                                                     *)
99          | E_Cons of exp list * Ty.t               (* in-memory tensor value *)
100          | E_Seq of exp list * Ty.t
101          | E_Pack of Ty.vec_layout * exp list      (* pack vector pieces into composite vector value *)
102          | E_VLoad of Ty.vec_layout * exp * int    (* load a piece of a composite vector value from
103                                                     * a tensor.  The integer specifies the index of
104                                                     * the piece.
105                                                     *)
106    
107      and global_var = GV of {      and global_var = GV of {
108          name : string,          (* name (should be unique) *)          name : string,          (* name (should be unique) *)
109          ty : Ty.ty,             (* type *)          ty : Ty.t,                      (* type *)
110          input : bool            (* is an input variable *)          xty : APITypes.t option,        (* external type (for inputs and outputs) *)
111            input : bool,                   (* is an input variable *)
112            output : bool,                  (* is the output value of the strand *)
113            varying : bool                  (* varies over the execution of the program *)
114        }        }
115    
116      and state_var = SV of {      and state_var = SV of {
117          name : string,          (* name (should be unique) *)          name : string,          (* name (should be unique) *)
118          ty : Ty.ty,             (* type *)          ty : Ty.t,                      (* type *)
119          varying : bool,         (* varies over the lifetime of the strand *)          xty : APITypes.t option,        (* external type (for outputs) *)
120          output : bool           (* is the output value of the strand *)          varying : bool                  (* varies over the lifetime of the strand *)
121        }        }
122    
123      and var = V of {      and var = V of {
124          name : string,                  (* name (should be unique) *)          name : string,                  (* name (should be unique) *)
125          id : Stamp.stamp,               (* unique ID *)          id : Stamp.stamp,               (* unique ID *)
126          ty : Ty.ty                      (* type *)          ty : Ty.t                       (* type *)
127        }        }
128    
129      withtype input = global_var Inputs.input      and func = FV of {
130            name : string,                  (* name (should be unique) *)
131      structure GlobalVar : sig          id : Stamp.stamp,               (* unique ID *)
132          val name : global_var -> string          ty : Ty.t,                      (* return type *)
133          val ty : global_var -> Ty.ty          paramTys : Ty.t list,           (* parameter types *)
134          val isInput : global_var -> bool          needsW : bool,                  (* does the function need the world (e.g., to print) *)
135          val toString : global_var -> string          hasG : bool                     (* does the function contain references to globals? *)
136        end = struct        }
         fun name (GV{name, ...}) = name  
         fun ty (GV{ty, ...}) = ty  
         fun isInput (GV{input, ...}) = input  
         fun toString (GV{name, ...}) = "globals." ^ name  
       end  
   
     structure StateVar : sig  
         val name : state_var -> string  
         val ty : state_var -> Ty.ty  
         val isOutput : state_var -> bool  
         val isVarying : state_var -> bool  
         val toString : state_var -> string  
       end = struct  
         fun name (SV{name, ...}) = name  
         fun ty (SV{ty, ...}) = ty  
         fun isOutput (SV{output, ...}) = output  
         fun isVarying (SV{varying, ...}) = varying  
         fun toString (SV{name, ...}) = "self." ^ name  
       end  
137    
138      structure Var : sig      withtype input = global_var Inputs.input
139             and create = block Create.t
140    
141          val new : string * Ty.ty -> var      fun emptyBlk (Block{body=[], ...}) = true
142          val name : var -> string        | emptyBlk _ = false
         val toString : var -> string  
         val ty : var -> Ty.ty  
   
         structure Set : ORD_SET where type Key.ord_key = var  
         structure Map : ORD_MAP where type Key.ord_key = var  
   
       end = struct  
         fun new (name, ty) = V{  
                 name = name,  
                 id = Stamp.new(),  
                 ty = ty  
               }  
         fun name (V{name, ...}) = name  
         fun toString (V{name, id, ...}) = concat[name, "$", Stamp.toString id]  
         fun ty (V{ty, ...}) = ty  
         local  
           structure VarOrd =  
             struct  
               type ord_key = var  
               fun compare (V{id=a, ...}, V{id=b, ...}) = Stamp.compare(a, b)  
             end  
         in  
         structure Set = RedBlackSetFn (VarOrd)  
         structure Map = RedBlackMapFn (VarOrd)  
         end (* local *)  
       end  
143    
144    end    end

Legend:
Removed from v.3767  
changed lines
  Added in v.4380

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