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

SCM Repository

[diderot] Annotation of /branches/pure-cfg/src/lib/main.c
ViewVC logotype

Annotation of /branches/pure-cfg/src/lib/main.c

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : jhr 571 /*! \file main.c
2 :     *
3 :     * \author John Reppy
4 :     */
5 :    
6 :     /*
7 :     * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
8 :     * All rights reserved.
9 :     */
10 :    
11 :     #include <string.h>
12 : jhr 572 #include <stdio.h>
13 : jhr 622 #include <assert.h>
14 : jhr 571 #include <Diderot/diderot.h>
15 :    
16 : jhr 622 struct struct_world {
17 :     bool isArray; // is the initialization an array or collection?
18 :     uint32_t nDims; // depth of iteration nesting
19 :     int32_t *base; // nDims array of base indices
20 :     uint32_t *size; // nDims array of iteration sizes
21 :     uint32_t numStrands; // number of strands in the world
22 :     void **inState;
23 :     void **outState;
24 :     bool *isActive; // array of isActive flags
25 :     };
26 :    
27 : jhr 572 extern float getOutf (void *self);
28 :    
29 : jhr 571 int main (int argc, const char **argv)
30 :     {
31 :     //
32 : jhr 572 printf("initializing globals ...\n");
33 : jhr 571 Diderot_InitGlobals ();
34 :    
35 :     // FIXME: we need to figure out how initialization should be handled.
36 : jhr 572 printf("initializing strands ...\n");
37 : jhr 622 Diderot_World_t *wrld = Diderot_Initially ();
38 : jhr 571
39 :     // iterate until all strands are stable
40 : jhr 572 printf("run ...\n");
41 :     int nSteps = 0, nUpdates = 0;
42 : jhr 622 int nActive = wrld->numStrands;
43 : jhr 571 while (nActive > 0) {
44 : jhr 572 nSteps++;
45 : jhr 571 // update strands
46 : jhr 622 for (int i = 0; i < wrld->numStrands; i++) {
47 :     if (wrld->isActive[i]) {
48 : jhr 572 nUpdates++;
49 : jhr 622 StrandStatus_t sts = Diderot_Strands[0].update(wrld->inState[i], wrld->outState[i]);
50 : jhr 571 if (sts == DIDEROT_STABILIZE) {
51 : jhr 589 // copy out to in so that both copies are the stable state
52 : jhr 622 // FIXME: there is a race condition here, since other strands might query this strand
53 :     memcpy (wrld->outState[i], wrld->inState[i], Diderot_Strands[0].stateSzb);
54 :     wrld->isActive[i] = false;
55 : jhr 571 nActive--;
56 :     }
57 :     }
58 :     }
59 :     // swap in and out
60 : jhr 622 void **tmp = wrld->inState;
61 :     wrld->inState = wrld->outState;
62 :     wrld->outState = tmp;
63 : jhr 571 }
64 :    
65 : jhr 572 printf("done: %d updates, %d steps\n", nUpdates, nSteps);
66 : jhr 571 // here we have the final state of all of the strands in the "in" buffer
67 : jhr 572 FILE *outS = fopen("mip.txt", "w");
68 :     if (outS == NULL) {
69 :     fprintf (stderr, "Cannot open output file\n");
70 :     exit (8);
71 :     }
72 : jhr 571
73 : jhr 622 for (int i = 0; i < wrld->numStrands; i++) {
74 :     float outV = getOutf (wrld->inState[i]);
75 :     fprintf (outS, "%f\n", outV);
76 : jhr 572 }
77 :     fclose (outS);
78 :    
79 : jhr 571 return 0;
80 :    
81 :     }
82 :    
83 :    
84 :     // this should be the part of the scheduler
85 :     void *Diderot_AllocStrand (Strand_t *strand)
86 :     {
87 :     return malloc(strand->stateSzb);
88 :     }
89 : jhr 622
90 :     // block allocation of an initial collection of strands
91 :     Diderot_World_t *Diderot_AllocInitially (Strand_t *strand, Diderot_Initially_t *init)
92 :     {
93 :     Diderot_World_t *wrld = (Diderot_World_t *) malloc (sizeof(Diderot_World_t));
94 :     if (wrld == 0) {
95 :     fprintf (stderr, "unable to allocate world\n");
96 :     exit (1);
97 :     }
98 :    
99 :     wrld->isArray = init->isArray;
100 :     wrld->nDims = init->nDims;
101 :     wrld->base = (int32_t *) malloc (wrld->nDims * sizeof(int32_t));
102 :     wrld->size = (int32_t *) malloc (wrld->nDims * sizeof(int32_t));
103 :     size_t numStrands = 1;
104 :     for (int i = 0; i < wrld->nDims; i++) {
105 :     numStrands *= init->size[i];
106 :     wrld->base[i] = init->base[i];
107 :     wrld->size[i] = init->size[i];
108 :     }
109 :    
110 :     // allocate the strand state pointers
111 :     wrld->numStrands = numStrands;
112 :     wrld->inState = (void **) malloc (numStrands * sizeof(void *));
113 :     wrld->outState = (void **) malloc (numStrands * sizeof(void *));
114 :     wrld->isActive = (bool *) malloc (numStrands * sizeof(bool));
115 :     if ((wrld->inState == 0) || (wrld->outState == 0) || (wrld->isActive == 0)) {
116 :     fprintf (stderr, "unable to allocate strand states\n");
117 :     exit (1);
118 :     }
119 :    
120 :     // initialize strand state pointers etc.
121 :     for (size_t i = 0; i < numStrands; i++) {
122 :     wrld->inState[i] = Diderot_AllocStrand (strand);
123 :     wrld->outState[i] = Diderot_AllocStrand (strand);
124 :     wrld->isActive[i] = true;
125 :     }
126 :    
127 :     return wrld;
128 :    
129 :     }
130 :    
131 :     // get strand state pointers
132 :     void *Diderot_InState (Diderot_World_t *wrld, uint32_t i)
133 :     {
134 :     assert (i < wrld->numStrands);
135 :     return wrld->inState[i];
136 :     }
137 :    
138 :     void *Diderot_OutState (Diderot_World_t *wrld, uint32_t i)
139 :     {
140 :     assert (i < wrld->numStrands);
141 :     return wrld->outState[i];
142 :     }
143 :    
144 :     bool Diderot_IsActive (Diderot_World_t *wrld, uint32_t i)
145 :     {
146 :     assert (i < wrld->numStrands);
147 :     return wrld->isActive[i];
148 :     }

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