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 4460 - (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 :     return static_cast<S_strand *>(this->_blocks[blkId] + offset * sizeof(S_strand));
28 :     }
29 :     // return a pointer to the local state of strand ix
30 :     @STRANDTY@ *local_state (index_t ix) const
31 :     {
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 :     }
106 :    
107 :     // initialize the first nStrands locations as new active strands
108 :     void create_strands (uint32_t nStrands)
109 :     {
110 :     assert (this->_nActive == 0);
111 :     assert (this->_nItems >= nStrands);
112 :    
113 :     uint32_t ix = 0;
114 :     for (uint32_t i = 0; i < this->_blocks.size(); i++) {
115 :     @STRANDTY@ *p = static_cast<@STRANDTY@ *>(this->_blocks[i]);
116 :     for (uint32_t j = 0; j < BLKSZ; j++, ix++) {
117 :     this->_idx[ix] = ix;
118 :     this->_status[ix] = (ix < nStrands) ? diderot::kActive : diderot::kDead;
119 :     new (p++) @STRANDTY@;
120 :     }
121 :     }
122 :    
123 :     this->_nActive = nStrands;
124 :     }
125 :    
126 :     // kill the specified strand
127 :     void kill (index_t ix)
128 :     {
129 :     assert (this->_nStable <= ix);
130 :     assert (ix < this->_nStable + this->_nActive);
131 :     this->_nActive--;
132 :     uint32_t jx = this->_nStable + this->_nActive;
133 :     uint32_t id = this->_idx[ix];
134 :     this->_statux[jx] = diderot::kDead;
135 :     std::swap (this->_idx[ix], this->_idx[jx]);
136 :     // invoke the dead strand's destructors
137 :     static_cast<@STRANDTY@ *>(&this->_storage[id])->~@STRANDTY@();
138 :     }
139 :    
140 :     // create a new strand
141 :     index_t new_strand ()
142 :     {
143 :     index_t ix = this->_nStable + this->_nActive;
144 :     if (this->_nItems <= ix) {
145 :     if (this->_grow ()) {
146 :     std::cerr << "Fatal error: unable to allocate space for new strands"; << std::endl;
147 :     exit (1);
148 :     }
149 :     }
150 :     this->_status[ix] = diderot::kNew;
151 :     this->_nActive++;
152 :     return ix;
153 :     }
154 :    
155 :     // allocate more space for strand state
156 :     bool grow ()
157 :     {
158 :     size_t nItems = static_cast<size_t>(this->_nItems) + BLKSZ;
159 :     if (nItems >= UINT32_MAX) {
160 :     // cannot have more than UINT32_MAX elements
161 :     return true;
162 :     }
163 :    
164 :     // allocate a new block at the end of the _blocks array
165 :     char *blk = static_cast<char *>(std::malloc (BLKSZ * sizeof(@STRANDTY@)));
166 :     if (blk == nullptr) {
167 :     return true;
168 :     }
169 :     this->_blocks.push_back (blk);
170 :    
171 :     // grow the _status and _idx arrays
172 :     uint8_t *status = static_cast<uint8_t *>(std::malloc (nItems * sizeof(uint8_t)));
173 :     uint32_t *idx = static_cast<uint32_t *>(std::malloc (nItems * sizeof(uint32_t)));
174 :     if ((status == nullptr) || (idx == nullptr)) {
175 :     return true;
176 :     }
177 :     std::memcpy (status, this->_status, this->_nItems * sizeof(uint8_t));
178 :     std::memcpy (idx, this->_idx, this->_nItems * sizeof(uint32_t));
179 :    
180 :     // initialize the new storage
181 :     @STRANDTY@ *p = static_cast<@STRANDTY@ *>(blk);
182 :     for (uint32_t ix = this->_nItems; ix < nItems; ix++) {
183 :     status[ix] = diderot::kDead;
184 :     idx[ix] = ix;
185 :     new (p++) @STRANDTY@;
186 :     }
187 :    
188 :     // free the old storage
189 :     std::free (this->_status);
190 :     std::free (this->_idx);
191 :    
192 :     // update pointers
193 :     this->_status = status;
194 :     this->_idx = idx;
195 :     this->_nItems = nItems;
196 :    
197 :     }
198 :    
199 :     }; // struct strand_array

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