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

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/target-cpu/fragments/seq-sarr-dual-indirect.in
ViewVC logotype

Annotation of /branches/vis15/src/compiler/target-cpu/fragments/seq-sarr-dual-indirect.in

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4489 - (view) (download)

1 : jhr 4460 // strand_array for BSP/DUAL STATE/INDIRECT ACCESS
2 :     //
3 :     struct strand_array {
4 :     typedef uint32_t index_t;
5 :     typedef char *block_t; // points to array of @STRANDTY@ structs
6 :    
7 :     uint8_t *_status; // the array of status information for the strands
8 :     uint32_t *_idx; // array of strand indices for indirect state rep.
9 :     std::vector<block_t> _blocks; // vector of pointers to strand-storage blocks
10 :     uint32_t _inIdx; // index of shared input state (either 0 or 1)
11 :     uint32_t _nItems; // number of items in the _blocks and _status arrays
12 :     uint32_t _nStable; // stable strands (in locations 0.._nStable-1)
13 :     uint32_t _nActive; // active strands (in locations _nStable.._nStable+_nActive-1)
14 :    
15 :     static const uint32_t LOG_BLKSZ= 12 // 2^12 items per block
16 :     static const uint32_t BLKSZ = (1 << LOG_BLKSZ);
17 :     static const uint32_t BLKMASK = (BLKSZ-1); // mask for block index
18 :    
19 :     strand_array () : _status(nullptr), _idx(nullptr), _nItems(0) { }
20 :    
21 :     // return a pointer to the given strand
22 :     @STRANDTY@ *strand (index_t ix) const
23 :     {
24 :     uint32_t jx = this->_idx[ix];
25 :     uint32_t blkId = jx >> LOG_BLKSZ;
26 :     uint32_t offset = ix & BLKMASK;
27 : jhr 4489 return reinterpret_cast<@STRANDTY@ *>(this->_blocks[blkId] + offset * sizeof(S_strand));
28 : jhr 4460 }
29 :     // return a pointer to the local state of strand ix
30 : jhr 4489 @STRAND@_local *local_state (index_t ix) const
31 : jhr 4460 {
32 :     return &(this->strand()->_local);
33 :     }
34 :     // return a pointer to the in-state of strand ix
35 :     const @STRAND@_shared *in_state (index_t ix) const
36 :     {
37 :     return &(this->strand()->_shared[this->_inIdx]);
38 :     }
39 :     // return a pointer to the out-state of strand ix
40 :     @STRAND@_shared *out_state (index_t ix) const
41 :     {
42 :     return &(this->strand()->_shared[this->_inIdx ^ 1]);
43 :     }
44 :    
45 :     // swap in and out states
46 :     void swap ()
47 :     {
48 :     tihs->_inIdx ^= 1;
49 :     }
50 :    
51 :     // deallocate space reserved for strands
52 :     void dealloc ()
53 :     {
54 :     if (this->_status != nullptr) {
55 :     std::free (this->_status);
56 :     this->_status = nullptr;
57 :     }
58 :     if (this->_idx != nullptr) {
59 :     std::free (this->_idx);
60 :     this->_idx = nullptr;
61 :     }
62 :     for (uint32_t i = 0; i < this->_blocks.size(); i++) {
63 :     if (this->_blocks[i] != nullptr) {
64 :     std::free (this->_blocks[i]);
65 :     this->_blocks[i] = nullptr;
66 :     }
67 :     else {
68 :     break;
69 :     }
70 :     }
71 :     }
72 :    
73 :     // allocate space for at least nItems
74 :     bool alloc (uint32_t nItems)
75 :     {
76 :     nItems = (nItems + BLKSZ - 1) & ~BLKMASK;
77 :     uint32_t nBlks = nItems >> LOG_BLKSZ;
78 :     // allocate block vector
79 :     this->_blocks.resize(nBlks, nullptr);
80 :     // allocate blocks
81 :     for (int i = 0; i < nBlks; i++) {
82 :     this->_blocks[i] = static_cast<char *>(std::malloc (BLKSZ * sizeof(@STRANDTY@)));
83 :     if (this->_blocks[i] == nullptr) {
84 :     // unable to allocate memory
85 :     this->dealloc();
86 :     return true;
87 :     }
88 :     }
89 :     // allocate _status array
90 :     this->_status = static_cast<uint8_t *>(std::malloc (nItems * sizeof(uint8_t)));
91 :     if (this->_status == nullptr) {
92 :     std::free (this->_storage);
93 :     return true;
94 :     }
95 :     // allocate _idx array
96 :     this->_idx = static_cast<uint32_t *>(std::malloc (nItems * sizeof(uint32_t)));
97 :     if (this->_idx == nullptr) {
98 :     std::free (this->_storage);
99 :     std::free (this->_status);
100 :     return true;
101 :     }
102 :     this->_nItems = nItems;
103 :     this->_nActive = 0;
104 :     this->_nStable = 0;
105 : jhr 4489 return false;
106 : jhr 4460 }
107 :    
108 :     // initialize the first nStrands locations as new active strands
109 :     void create_strands (uint32_t nStrands)
110 :     {
111 :     assert (this->_nActive == 0);
112 :     assert (this->_nItems >= nStrands);
113 :    
114 :     uint32_t ix = 0;
115 :     for (uint32_t i = 0; i < this->_blocks.size(); i++) {
116 : jhr 4489 @STRANDTY@ *p = reinterpret_cast<@STRANDTY@ *>(this->_blocks[i]);
117 : jhr 4460 for (uint32_t j = 0; j < BLKSZ; j++, ix++) {
118 :     this->_idx[ix] = ix;
119 :     this->_status[ix] = (ix < nStrands) ? diderot::kActive : diderot::kDead;
120 :     new (p++) @STRANDTY@;
121 :     }
122 :     }
123 :    
124 :     this->_nActive = nStrands;
125 :     }
126 :    
127 :     // kill the specified strand
128 :     void kill (index_t ix)
129 :     {
130 :     assert (this->_nStable <= ix);
131 :     assert (ix < this->_nStable + this->_nActive);
132 :     this->_nActive--;
133 :     uint32_t jx = this->_nStable + this->_nActive;
134 :     uint32_t id = this->_idx[ix];
135 :     this->_statux[jx] = diderot::kDead;
136 :     std::swap (this->_idx[ix], this->_idx[jx]);
137 :     // invoke the dead strand's destructors
138 : jhr 4489 reinterpret_cast<@STRANDTY@ *>(&this->_storage[id])->~@STRANDTY@();
139 : jhr 4460 }
140 :    
141 :     // create a new strand
142 :     index_t new_strand ()
143 :     {
144 :     index_t ix = this->_nStable + this->_nActive;
145 :     if (this->_nItems <= ix) {
146 :     if (this->_grow ()) {
147 :     std::cerr << "Fatal error: unable to allocate space for new strands"; << std::endl;
148 :     exit (1);
149 :     }
150 :     }
151 :     this->_status[ix] = diderot::kNew;
152 :     this->_nActive++;
153 :     return ix;
154 :     }
155 :    
156 :     // allocate more space for strand state
157 :     bool grow ()
158 :     {
159 :     size_t nItems = static_cast<size_t>(this->_nItems) + BLKSZ;
160 :     if (nItems >= UINT32_MAX) {
161 :     // cannot have more than UINT32_MAX elements
162 :     return true;
163 :     }
164 :    
165 :     // allocate a new block at the end of the _blocks array
166 :     char *blk = static_cast<char *>(std::malloc (BLKSZ * sizeof(@STRANDTY@)));
167 :     if (blk == nullptr) {
168 :     return true;
169 :     }
170 :     this->_blocks.push_back (blk);
171 :    
172 :     // grow the _status and _idx arrays
173 :     uint8_t *status = static_cast<uint8_t *>(std::malloc (nItems * sizeof(uint8_t)));
174 :     uint32_t *idx = static_cast<uint32_t *>(std::malloc (nItems * sizeof(uint32_t)));
175 :     if ((status == nullptr) || (idx == nullptr)) {
176 :     return true;
177 :     }
178 :     std::memcpy (status, this->_status, this->_nItems * sizeof(uint8_t));
179 :     std::memcpy (idx, this->_idx, this->_nItems * sizeof(uint32_t));
180 :    
181 :     // initialize the new storage
182 : jhr 4489 @STRANDTY@ *p = reinterpret_cast<@STRANDTY@ *>(blk);
183 : jhr 4460 for (uint32_t ix = this->_nItems; ix < nItems; ix++) {
184 :     status[ix] = diderot::kDead;
185 :     idx[ix] = ix;
186 :     new (p++) @STRANDTY@;
187 :     }
188 :    
189 :     // free the old storage
190 :     std::free (this->_status);
191 :     std::free (this->_idx);
192 :    
193 :     // update pointers
194 :     this->_status = status;
195 :     this->_idx = idx;
196 :     this->_nItems = nItems;
197 :    
198 :     }
199 :    
200 :     }; // struct strand_array

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