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

SCM Repository

[diderot] Annotation of /branches/pure-cfg/src/include/Diderot/diderot.h
ViewVC logotype

Annotation of /branches/pure-cfg/src/include/Diderot/diderot.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 671 - (view) (download) (as text)

1 : jhr 438 /*! \file diderot.h
2 :     *
3 :     * \author John Reppy
4 : jhr 441 *
5 :     * This is the interface to the Diderot runtime for the C target. For now,
6 :     * we are targetting single-precision computations.
7 : jhr 438 */
8 :    
9 :     /*
10 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
11 :     * All rights reserved.
12 :     */
13 :    
14 :     #ifndef _DIDEROT_H_
15 :     #define _DIDEROT_H_
16 :    
17 : jhr 601 /* gcc has a bug that breaks code that uses 8-byte vectors (e.g., vec2f_t), but clang
18 :     * handles the code correctly.
19 :     */
20 :     #if defined(__clang__)
21 :     # define VEC2_OK
22 :     #endif
23 :    
24 : jhr 579 #ifdef NDEBUG
25 : jhr 440 #define STATIC_INLINE static inline
26 : jhr 579 #else
27 :     #define STATIC_INLINE static
28 :     #endif
29 : jhr 440
30 : jhr 438 #include <stdint.h>
31 :     #include <stdbool.h>
32 : jhr 558 #include <stdlib.h>
33 :     #include <math.h>
34 : jhr 654 #include <stdio.h> // for printing output
35 : jhr 438
36 :     /* library-call status */
37 :     typedef enum { DIDEROT_OK = 0, DIDEROT_FAIL = -1 } Status_t;
38 :    
39 : jhr 564 /* update method return type */
40 :     typedef enum { DIDEROT_DIE, DIDEROT_ACTIVE, DIDEROT_STABILIZE } StrandStatus_t;
41 :    
42 : jhr 438 /* SSE vector types */
43 : jhr 441 typedef float __m128 __attribute__ ((__vector_size__ (16), __may_alias__));
44 : jhr 601 #ifdef VEC2_OK
45 : jhr 561 typedef float vec2f_t __attribute__ ((vector_size (8)));
46 : jhr 601 #else
47 :     typedef float vec2f_t __attribute__ ((vector_size (16))); // pad so that gcc aligns correctly
48 :     #endif
49 : jhr 561 typedef float vec4f_t __attribute__ ((vector_size (16)));
50 :     typedef float vec8f_t __attribute__ ((vector_size (32)));
51 : jhr 438
52 : jhr 601 #ifdef VEC2_OK
53 : jhr 561 typedef int32_t vec2i_t __attribute__ ((vector_size (8)));
54 : jhr 601 #else
55 :     typedef int32_t vec2i_t __attribute__ ((vector_size (16))); // pad so that gcc aligns correctly
56 :     #endif
57 : jhr 561 typedef int32_t vec4i_t __attribute__ ((vector_size (16)));
58 :     typedef int32_t vec8i_t __attribute__ ((vector_size (32)));
59 : jhr 560
60 : jhr 561 typedef float vec2d_t __attribute__ ((vector_size (16)));
61 :     typedef float vec4d_t __attribute__ ((vector_size (32)));
62 :     typedef float vec8d_t __attribute__ ((vector_size (64)));
63 : jhr 438
64 : jhr 561 typedef int64_t vec2l_t __attribute__ ((vector_size (16)));
65 :     typedef int64_t vec4l_t __attribute__ ((vector_size (32)));
66 :     typedef int64_t vec8l_t __attribute__ ((vector_size (64)));
67 : jhr 560
68 : jhr 561 typedef union { float r[2]; vec2f_t v; } union2f_t;
69 :     typedef union { float r[4]; vec4f_t v; } union4f_t;
70 :     typedef union { float r[8]; vec8f_t v; } union8f_t;
71 : jhr 438
72 : jhr 561 typedef union { int32_t i[2]; vec2i_t v; } union2i_t;
73 :     typedef union { int32_t i[4]; vec4i_t v; } union4i_t;
74 :     typedef union { int32_t i[8]; vec8i_t v; } union8i_t;
75 : jhr 560
76 : jhr 561 typedef union { double r[2]; vec2d_t v; } union2d_t;
77 :     typedef union { double r[4]; vec4d_t v; } union4d_t;
78 :     typedef union { double r[8]; vec8d_t v; } union8d_t;
79 : jhr 545
80 : jhr 561 typedef union { int64_t r[2]; vec2l_t v; } union2l_t;
81 :     typedef union { int64_t r[4]; vec4l_t v; } union4l_t;
82 :     typedef union { int64_t r[8]; vec8l_t v; } union8l_t;
83 : jhr 558
84 : jhr 545 /* vector lengths must be power of 2, but vec3 is useful, so we pad to 4 */
85 : jhr 561 typedef vec4f_t vec3f_t;
86 :     typedef union4f_t union3f_t;
87 :     typedef vec4d_t vec3d_t;
88 :     typedef union4d_t union3d_t;
89 :     typedef vec4i_t vec3i_t;
90 :     typedef union4i_t union3i_t;
91 :     typedef vec4l_t vec3l_t;
92 :     typedef union4l_t union3l_t;
93 : jhr 545
94 : jhr 438 /* typedefs for Diderot types */
95 : jhr 560 #if defined(DIDEROT_SINGLE_PRECISION)
96 : jhr 438 typedef int32_t Diderot_int_t;
97 :     typedef float Diderot_real_t;
98 : jhr 561 typedef union4f_t Diderot_vec3_t; // padded to fit in SSE register
99 :     typedef union4f_t Diderot_vec4_t;
100 : jhr 560 #else
101 :     typedef int64_t Diderot_int_t;
102 :     typedef double Diderot_real_t;
103 : jhr 561 typedef union4d_t Diderot_vec3_t; // padded to fit in SSE register
104 :     typedef union4d_t Diderot_vec4_t;
105 : jhr 560 #endif
106 : jhr 438 typedef const char *Diderot_string_t;
107 :    
108 : jhr 557 typedef Diderot_real_t Diderot_Mat2x2_t[4];
109 :     typedef Diderot_real_t Diderot_Mat3x3_t[9];
110 : jhr 565 typedef union4f_t Diderot_Mat4x4_t[4]; // represented as row vectors
111 : jhr 579 //typedef struct {
112 :     // float m[16] __attribute__((aligned(16))); // individual elements
113 :     //} Diderot_Mat4x4_t;
114 : jhr 557
115 : jhr 438 typedef struct { // wrapper for 1D image data
116 :     uint32_t dim; // dimension (== 1)
117 :     uint32_t size[1];
118 :     void *data;
119 : jhr 444 Diderot_Mat2x2_t m; // image to world-space transform
120 :     Diderot_Mat2x2_t mInv; // world to image-space transform (m inverse)
121 : jhr 438 } Diderot_image1D_t;
122 :    
123 :     typedef struct { // wrapper for 2D image data
124 :     uint32_t dim; // dimension (== 2)
125 :     uint32_t size[2]; // sizes (fast to slow)
126 :     void *data;
127 : jhr 444 Diderot_Mat3x3_t m; // image to world-space transform
128 :     Diderot_Mat3x3_t mInv; // world to image-space transform (m inverse)
129 :     Diderot_Mat3x3_t mInvT; // image to world-space transform for gradients
130 :     // (m inverse transpose)
131 : jhr 438 } Diderot_image2D_t;
132 :    
133 :     typedef struct { // wrapper for 3D image data
134 :     uint32_t dim; // dimension (== 3)
135 :     uint32_t size[3]; // sizes (fast to slow)
136 :     void *data;
137 : jhr 444 Diderot_Mat4x4_t m; // image to world-space transform
138 :     Diderot_Mat4x4_t mInv; // world to image-space transform (m inverse)
139 :     Diderot_Mat4x4_t mInvT; // image to world-space transform for gradients
140 :     // (m inverse transpose)
141 : jhr 438 } Diderot_image3D_t;
142 :    
143 : jhr 571 typedef StrandStatus_t (*update_method_t)(void *, void *);
144 : jhr 654 typedef void (*print_method_t)(FILE *, void *);
145 : jhr 571
146 : jhr 624 /* hooks generated by the compiler for the runtime */
147 : jhr 571 typedef struct {
148 :     char *name; // name of strand
149 :     size_t stateSzb; // sze of strand state
150 :     update_method_t update; // update method
151 : jhr 654 print_method_t print; // function for printing output state
152 : jhr 571 } Strand_t;
153 :    
154 :     extern int Diderot_NumStrands; // the number of strands in the program
155 : jhr 624 extern Strand_t *Diderot_Strands[]; // array of NumStrands strand descriptors
156 : jhr 571
157 : jhr 622 typedef struct struct_world Diderot_World_t;
158 :    
159 : jhr 571 extern void Diderot_InitGlobals ();
160 : jhr 622 extern Diderot_World_t *Diderot_Initially ();
161 : jhr 571
162 : jhr 622
163 : jhr 438 /* Diderot library functions */
164 :    
165 : jhr 622 // block allocation of an initial collection of strands
166 : jhr 624 extern Diderot_World_t *Diderot_AllocInitially (
167 :     Strand_t *strand, // the type of strands being allocated
168 :     bool isArray, // is the initialization an array or collection?
169 :     uint32_t nDims, // depth of iteration nesting
170 :     int32_t *base, // nDims array of base indices
171 :     uint32_t *size); // nDims array of iteration sizes
172 : jhr 622
173 :     // get strand state pointers
174 :     extern void *Diderot_InState (Diderot_World_t *wrld, uint32_t i);
175 :     extern void *Diderot_OutState (Diderot_World_t *wrld, uint32_t i);
176 :     extern bool Diderot_IsActive (Diderot_World_t *wrld, uint32_t i);
177 :    
178 : jhr 571 // strand allocation (no initializtion)
179 : jhr 622 extern void *Diderot_AllocStrand (Strand_t *strand);
180 : jhr 571
181 : jhr 438 /* load image data from Nrrd files */
182 : jhr 561 extern Status_t Diderot_LoadImage1D (Diderot_string_t name, Diderot_image1D_t **img);
183 :     extern Status_t Diderot_LoadImage2D (Diderot_string_t name, Diderot_image2D_t **img);
184 :     extern Status_t Diderot_LoadImage3D (Diderot_string_t name, Diderot_image3D_t **img);
185 : jhr 438
186 : jhr 439 /* functions to get input-parameter values */
187 : jhr 438 extern Status_t Diderot_InputString (const char *, const char **, bool);
188 : jhr 561 extern Status_t Diderot_Inputf (const char *, float *, bool);
189 :     extern Status_t Diderot_InputVec3f (const char *, vec3f_t *, bool);
190 : jhr 438
191 : jhr 561 /********** scalar math functions **********/
192 :    
193 :     STATIC_INLINE float maxf (float a, float b)
194 :     {
195 :     return (a < b)? b : a;
196 :     }
197 :    
198 : jhr 588 /********** 2-element vector functions **********/
199 :    
200 :     STATIC_INLINE vec2f_t vec2f (float a, float b)
201 :     {
202 : jhr 601 #ifdef VEC2_OK
203 : jhr 588 return __extension__ (vec2f_t){ a, b };
204 : jhr 601 #else
205 :     return __extension__ (vec2f_t){ a, b, 0.0, 0.0 };
206 :     #endif
207 : jhr 588 }
208 :    
209 :     STATIC_INLINE float dot2f (vec2f_t u, vec2f_t v)
210 :     {
211 : jhr 671 union2f_t uv = __extension__ (union2f_t)(u*v);
212 : jhr 588 return uv.r[0] + uv.r[1];
213 :     }
214 :    
215 : jhr 560 /********** 3-element vector functions **********/
216 :    
217 : jhr 588 STATIC_INLINE vec3i_t vec3ftoi (vec3f_t v)
218 :     {
219 :     union4f_t u;
220 :     u.v = v;
221 :     return __extension__ (vec3i_t){ (int32_t)u.r[0], (int32_t)u.r[1], (int32_t)u.r[2], 0 };
222 :     }
223 :    
224 :     STATIC_INLINE vec3f_t vec3itof (vec3i_t v)
225 :     {
226 :     union4i_t u;
227 :     u.v = v;
228 :     return __extension__ (vec3f_t){ (float)u.i[0], (float)u.i[1], (float)u.i[2], 0 };
229 :     }
230 :    
231 : jhr 561 STATIC_INLINE vec3f_t vec3f (float a, float b, float c)
232 : jhr 440 {
233 : jhr 561 return __extension__ (vec4f_t){ a, b, c, 0.0f };
234 : jhr 440 }
235 :    
236 : jhr 561 STATIC_INLINE vec3f_t scale3f (float s, vec3f_t v)
237 : jhr 440 {
238 : jhr 561 return vec3f(s, s, s) * v;
239 : jhr 440 }
240 :    
241 : jhr 561 STATIC_INLINE vec3f_t floor3f (vec3f_t v)
242 : jhr 440 {
243 : jhr 561 union4f_t u;
244 :     u.v = v;
245 :     return vec3f(floorf(u.r[0]), floorf(u.r[1]), floorf(u.r[2]));
246 :     }
247 :    
248 : jhr 565 STATIC_INLINE float dot3f (vec3f_t u, vec3f_t v)
249 :     {
250 : jhr 671 union3f_t uv = __extension__ (union3f_t)(u*v);
251 : jhr 565 return uv.r[0] + uv.r[1] + uv.r[2];
252 :     }
253 :    
254 : jhr 561 STATIC_INLINE float length3f (vec3f_t v)
255 :     {
256 : jhr 565 return sqrtf(dot3f(v, v));
257 : jhr 561 }
258 :    
259 :     STATIC_INLINE vec3i_t truncToInt3f (vec3f_t v)
260 :     {
261 :     union4f_t t;
262 : jhr 560 t.v = v;
263 : jhr 561 return __extension__ (vec4i_t){
264 : jhr 560 (int32_t)truncf(t.r[0]),
265 :     (int32_t)truncf(t.r[1]),
266 :     (int32_t)truncf(t.r[2]),
267 :     0 };
268 : jhr 440 }
269 :    
270 : jhr 560
271 :     /********** 4-element vector functions **********/
272 :    
273 : jhr 561 STATIC_INLINE vec4f_t vec4f (float a, float b, float c, float d)
274 : jhr 560 {
275 : jhr 561 return __extension__ (vec4f_t){ a, b, c, d };
276 : jhr 560 }
277 :    
278 : jhr 561 STATIC_INLINE float dot4f (vec4f_t u, vec4f_t v)
279 :     {
280 : jhr 671 union4f_t uv = __extension__ (union4f_t)(u*v);
281 : jhr 565 return uv.r[0] + uv.r[1] + uv.r[2] + uv.r[3];
282 : jhr 561 }
283 : jhr 560
284 : jhr 561
285 : jhr 560 /********** other Diderot support functions **********/
286 :    
287 : jhr 441 // check if pos is inside the img, assuming that we have a border of width s.
288 :     //
289 : jhr 561 STATIC_INLINE bool Diderot_Inside3f (vec3f_t posArg, Diderot_image3D_t *img, int s)
290 : jhr 441 {
291 :     // NOTE: there might be a vectorized way to do this compare!
292 : jhr 449 // cvtps2pi -- converts vector of floats to vector of int32_t values
293 :    
294 : jhr 561 union4f_t pos;
295 :     pos.v = posArg;
296 : glk 611 return ((s-1 < pos.r[0]) && (pos.r[0] < (img->size[0] - s))
297 :     && (s-1 < pos.r[1]) && (pos.r[1] < (img->size[1] - s))
298 :     && (s-1 < pos.r[2]) && (pos.r[2] < (img->size[2] - s)));
299 : jhr 441 }
300 :    
301 : jhr 565 STATIC_INLINE vec3f_t Diderot_ToImageSpace3f (Diderot_image3D_t *img, vec3f_t posArg)
302 :     {
303 : jhr 671 vec4f_t p = __extension__ vec4f(
304 : jhr 565 ((union3f_t)posArg).r[0],
305 : jhr 579 ((union3f_t)posArg).r[1],
306 :     ((union3f_t)posArg).r[2],
307 : jhr 565 1.0f);
308 : jhr 561
309 : jhr 579 // return vec3f(
310 :     // dot4f(vec4f(m->m[0], m->m[1], m->m[2], m->m[3]), p),
311 :     // dot4f(vec4f(m->m[4], m->m[5], m->m[6], m->m[7]), p),
312 :     // dot4f(vec4f(m->m[8], m->m[9], m->m[10], m->m[11]), p));
313 : jhr 565 return vec3f(
314 :     dot4f(img->mInv[0].v, p),
315 :     dot4f(img->mInv[1].v, p),
316 :     dot4f(img->mInv[2].v, p));
317 :     }
318 :    
319 : jhr 438 #endif /* !_DIDEROT_H_ */

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