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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3750 - (view) (download)

1 : jhr 3691 (* tree-ir.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *
8 :     * This representation restores the block structure and nested expression syntax
9 :     * of the source language.
10 :     *)
11 :    
12 :     structure TreeIR =
13 :     struct
14 :    
15 :     structure Op = LowOps
16 : jhr 3750 structure Ty = TreeTypes
17 : jhr 3691
18 :     datatype program = Program of {
19 :     props : Properties.t list,
20 :     consts : global_var list, (* large constant variables *)
21 :     inputs : input list, (* global input variables *)
22 :     constInit : block, (* code that initializes constants and inputs *)
23 :     globals : global_var list, (* other global variables *)
24 :     globalInit : block, (* CFG to initialize other globals (if any) *)
25 :     strand : strand, (* the strand definition *)
26 :     create : create, (* initial strand creation *)
27 :     update : block option (* optional update code. *)
28 :     }
29 :    
30 :     and strand = Strand of {
31 :     name : Atom.atom,
32 :     params : var list,
33 :     state : state_var list,
34 :     stateInit : block,
35 :     initM : block option,
36 :     updateM : block,
37 :     stabilizeM : block option
38 :     }
39 :    
40 :     and create = Create of {
41 :     dim : int option, (* grid dimension; NONE for collections *)
42 :     code : block (* the loop nest for creating the strands *)
43 :     }
44 :    
45 :     and block = Block of {
46 :     locals : var list,
47 :     body : stm list
48 :     }
49 :    
50 :     and stm
51 :     = S_Comment of string list
52 :     | S_Assign of var list * exp
53 :     | S_GAssign of global_var * exp
54 :     | S_IfThen of exp * block
55 :     | S_IfThenElse of exp * block * block
56 :     | S_Foreach of var * exp * block
57 :     (* special Diderot forms *)
58 :     | S_LoadNrrd of var * Ty.ty * string
59 :     | S_Input of global_var * string * string option * exp option (* get input *)
60 :     | S_InputNrrd of global_var * string * string option * string option (* get image/seq input *)
61 :     | S_New of Atom.atom * exp list (* new strand creation *)
62 :     | S_Save of state_var list * exp (* save strand state *)
63 :     | S_Exit of exp list
64 :     (* return functions for methods *)
65 :     | S_Active
66 :     | S_Stabilize
67 :     | S_Die
68 :    
69 :     and exp
70 :     = E_Global of global_var
71 :     | E_State of state_var
72 :     | E_Var of var
73 :     | E_Lit of Literal.t
74 :     | E_Op of Op.rator * exp list
75 :     | E_Cons of Ty.ty * exp list
76 :     | E_Seq of Ty.ty * exp list
77 :    
78 :     and global_var = GV of {
79 :     name : string, (* name (should be unique) *)
80 :     ty : Ty.ty, (* type *)
81 :     input : bool (* is an input variable *)
82 :     }
83 :    
84 :     and state_var = SV of {
85 :     name : string, (* name (should be unique) *)
86 :     ty : Ty.ty, (* type *)
87 :     varying : bool, (* varies over the lifetime of the strand *)
88 :     output : bool (* is the output value of the strand *)
89 :     }
90 :    
91 :     and var = V of {
92 :     name : string, (* name (should be unique) *)
93 :     id : Stamp.stamp, (* unique ID *)
94 :     ty : Ty.ty (* type *)
95 :     }
96 :    
97 :     withtype input = global_var Inputs.input
98 :    
99 :     structure GlobalVar : sig
100 :     val name : global_var -> string
101 :     val ty : global_var -> Ty.ty
102 :     val isInput : global_var -> bool
103 :     val toString : global_var -> string
104 :     end = struct
105 :     fun name (GV{name, ...}) = name
106 :     fun ty (GV{ty, ...}) = ty
107 :     fun isInput (GV{input, ...}) = input
108 :     fun toString (GV{name, ...}) = "globals." ^ name
109 :     end
110 :    
111 :     structure StateVar : sig
112 :     val name : state_var -> string
113 :     val ty : state_var -> Ty.ty
114 :     val isOutput : state_var -> bool
115 :     val isVarying : state_var -> bool
116 :     val toString : state_var -> string
117 :     end = struct
118 :     fun name (SV{name, ...}) = name
119 :     fun ty (SV{ty, ...}) = ty
120 :     fun isOutput (SV{output, ...}) = output
121 :     fun isVarying (SV{varying, ...}) = varying
122 :     fun toString (SV{name, ...}) = "self." ^ name
123 :     end
124 :    
125 :     structure Var : sig
126 :    
127 :     val new : string * Ty.ty -> var
128 :     val name : var -> string
129 :     val toString : var -> string
130 :     val ty : var -> Ty.ty
131 :    
132 :     structure Map : ORD_MAP where type Key.ord_key = var
133 :    
134 :     end = struct
135 :     fun new (name, ty) = V{
136 :     name = name,
137 :     id = Stamp.new(),
138 :     ty = ty
139 :     }
140 :     fun name (V{name, ...}) = name
141 :     fun toString (V{name, id, ...}) = concat[name, "$", Stamp.toString id]
142 :     fun ty (V{ty, ...}) = ty
143 :     local
144 :     structure VarOrd =
145 :     struct
146 :     type ord_key = var
147 :     fun compare (V{id=a, ...}, V{id=b, ...}) = Stamp.compare(a, b)
148 :     end
149 :     in
150 :     structure Map = RedBlackMapFn (VarOrd)
151 :     end (* local *)
152 :     end
153 :    
154 :     end

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