source: Sophya/trunk/AddOn/TAcq/racqumem.cc@ 3957

Last change on this file since 3957 was 3955, checked in by ansari, 15 years ago

Ajout des actions de traitemnt ProcG,ProcH,ProcI,ProcJ ds le gestionnaire memoire RAcqMemZoneMgr et adaptation de BRBaseProcessor, Reza 02/03/2011
File size: 12.8 KB
Line 
1#include "racqumem.h"
2
3using namespace SOPHYA;
4
5//----------------------------------------------------------------
6// ---- classes de gestion memoire pour acquisition BAORadio -----
7// LAL - R. Ansari - Juin/Juillet 2008
8//----------------------------------------------------------------
9
10/* --Methode-- */
11RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nz, uint_4 np, uint_4 psz)
12 : mex(true), nzones(nz), nfibres(1), npaq(np), paqsz(psz), procpaqsz(0), stop_(false), runstate_(MemZR_Running)
13{
14 Init();
15}
16
17/* --Methode-- */
18RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nzon, uint_4 nfib, uint_4 npaq, uint_4 paqsz, uint_4 procsz)
19 : mex(true), nzones(nzon), nfibres(nfib), npaq(npaq), paqsz(paqsz), procpaqsz(procsz),
20 stop_(false), runstate_(MemZR_Running)
21{
22 Init();
23}
24
25/* --Methode-- */
26void RAcqMemZoneMgr::Init()
27{
28 St_MemZ st;
29
30 st.serial = 0;
31 st.act = (uint_4)MemZA_None;
32 st.stat = (uint_4)MemZS_Free;
33 for(int k=0; k<MXNACTMZM; k++) st.nbact[k] = 0;
34 uint_8 mzsz = nfibres*npaq*paqsz;
35 uint_8 procmzsz = nfibres*npaq*procpaqsz;
36
37 for(unsigned int k=0; k<NbZones(); k++) {
38 memzones.push_back(new Byte[mzsz] );
39 states.push_back(st);
40 auxdatap.push_back(new RAcqMZAuxData );
41 fiber_id.push_back(0);
42 if (procmzsz > 0) procmemzones.push_back(new Byte[procmzsz] );
43 }
44 dummy_=0;
45 serial_ = 0;
46 SetFinalizedMask();
47 SetProcSavedReadyMask();
48}
49
50/* --Methode-- */
51RAcqMemZoneMgr::~RAcqMemZoneMgr()
52{
53 for(uint_4 k=0; k<NbZones(); k++) {
54 delete[] memzones[k];
55 delete auxdatap[k];
56 if (procpaqsz > 0) delete[] procmemzones[k];
57 }
58}
59
60/* --Methode-- */
61int RAcqMemZoneMgr::FindMemZoneId(MemZaction act)
62// Recherche et renvoie une zone memoire compatible pour effectuer l'operation act
63// Pour act = MemZA_Fill : Zone vide ou satisfaisant la condition mask_finalized_
64// On recherche a chaque fois la zone ayant le plus petit numero de serie
65// cad le numero d'ordre de remplissage
66// Pour ProcA/B/C on attend que la zone avec le plus petit numero soit disponible
67
68{
69 int rid = -1;
70 if (stop_) return rid;
71 if ((act != MemZA_Fill) && (act != MemZA_Save) && (act != MemZA_Proc) &&
72 (act != MemZA_ProcA) && (act != MemZA_ProcB) && (act != MemZA_ProcC) &&
73 (act != MemZA_ProcD) && (act != MemZA_ProcE) && (act != MemZA_ProcF) &&
74 (act != MemZA_ProcG) && (act != MemZA_ProcH) && (act != MemZA_ProcI) &&
75 (act != MemZA_ProcJ) &&
76 (act != MemZA_SaveProc) ) return rid;
77
78 mex.lock();
79 uint_8 bestserial = serial_ + 5;
80 while ((rid < 0)&&(!stop_)) {
81 switch (act) {
82 case MemZA_Fill:
83 if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
84 if ((states[k].act == MemZA_None) &&
85 ((states[k].stat == MemZS_Free)||((states[k].stat&mask_finalized_)==mask_finalized_) )) {
86 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
87 }
88 }
89 if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
90 break;
91 case MemZA_Save:
92 for(uint_4 k=0; k<NbZones(); k++) {
93 if ((states[k].act == MemZA_None) &&
94 (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Saved) ) {
95 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
96 }
97 }
98 if (rid >= 0) states[rid].act = MemZA_Save;
99 break;
100 case MemZA_Proc:
101 for(uint_4 k=0; k<NbZones(); k++) {
102 if ((states[k].act == MemZA_None) &&
103 (states[k].stat & MemZS_Saved) && !(states[k].stat & MemZS_Proc) ) {
104 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
105 }
106 }
107 if (rid >= 0) states[rid].act = MemZA_Proc;
108 break;
109 case MemZA_ProcA:
110 for(uint_4 k=0; k<NbZones(); k++) {
111 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
112 !(states[k].stat & MemZS_ProcA) ) {
113 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
114 }
115 }
116 if (rid >= 0) states[rid].act = MemZA_ProcA;
117 break;
118 case MemZA_ProcB:
119 for(uint_4 k=0; k<NbZones(); k++) {
120 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
121 (states[k].stat & MemZS_ProcA) && !(states[k].stat & MemZS_ProcB) ) {
122 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
123 }
124 }
125 if (rid >= 0) states[rid].act = MemZA_ProcB;
126 break;
127 case MemZA_ProcC:
128 for(uint_4 k=0; k<NbZones(); k++) {
129 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
130 (states[k].stat & MemZS_ProcB) && !(states[k].stat & MemZS_ProcC) ) {
131 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
132 }
133 }
134 if (rid >= 0) states[rid].act = MemZA_ProcC;
135 break;
136 case MemZA_ProcD:
137 for(uint_4 k=0; k<NbZones(); k++) {
138 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
139 (states[k].stat & MemZS_ProcC) && !(states[k].stat & MemZS_ProcD) ) {
140 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
141 }
142 }
143 if (rid >= 0) states[rid].act = MemZA_ProcD;
144 break;
145 case MemZA_ProcE:
146 for(uint_4 k=0; k<NbZones(); k++) {
147 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
148 (states[k].stat & MemZS_ProcD) && !(states[k].stat & MemZS_ProcE) ) {
149 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
150 }
151 }
152 if (rid >= 0) states[rid].act = MemZA_ProcE;
153 break;
154 case MemZA_ProcF:
155 for(uint_4 k=0; k<NbZones(); k++) {
156 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
157 (states[k].stat & MemZS_ProcE) && !(states[k].stat & MemZS_ProcF) ) {
158 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
159 }
160 }
161 if (rid >= 0) states[rid].act = MemZA_ProcF;
162 break;
163 case MemZA_ProcG:
164 for(uint_4 k=0; k<NbZones(); k++) {
165 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
166 (states[k].stat & MemZS_ProcF) && !(states[k].stat & MemZS_ProcG) ) {
167 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
168 }
169 }
170 if (rid >= 0) states[rid].act = MemZA_ProcG;
171 break;
172 case MemZA_ProcH:
173 for(uint_4 k=0; k<NbZones(); k++) {
174 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
175 (states[k].stat & MemZS_ProcG) && !(states[k].stat & MemZS_ProcH) ) {
176 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
177 }
178 }
179 if (rid >= 0) states[rid].act = MemZA_ProcH;
180 break;
181 case MemZA_ProcI:
182 for(uint_4 k=0; k<NbZones(); k++) {
183 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
184 (states[k].stat & MemZS_ProcH) && !(states[k].stat & MemZS_ProcI) ) {
185 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
186 }
187 }
188 if (rid >= 0) states[rid].act = MemZA_ProcI;
189 break;
190 case MemZA_ProcJ:
191 for(uint_4 k=0; k<NbZones(); k++) {
192 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
193 (states[k].stat & MemZS_ProcI) && !(states[k].stat & MemZS_ProcJ) ) {
194 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
195 }
196 }
197 if (rid >= 0) states[rid].act = MemZA_ProcJ;
198 break;
199 case MemZA_SaveProc:
200 for(uint_4 k=0; k<NbZones(); k++) {
201 if ((states[k].act == MemZA_None) &&
202 (states[k].stat & mask_saveproc_ready_) && !(states[k].stat & MemZS_SavedProc) ) {
203 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
204 }
205 }
206 if (rid >= 0) states[rid].act = MemZA_SaveProc;
207 break;
208 case MemZA_None: // MTQ pour supprimer un warning
209 break;
210 } // Fin de switch
211 if (rid < 0) mex.wait();
212 } // Fin de while
213 mex.unlock();
214 return rid;
215}
216
217/* --Methode-- */
218int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
219{
220 if ((id < 0) || (id >= (int)states.size())) return 1;
221 int rc = 0;
222 mex.lock();
223 switch (st) {
224 case MemZS_Free :
225 states[id].serial = 0;
226 states[id].stat = MemZS_Free;
227 states[id].act = MemZA_None;
228 break;
229 case MemZS_Filled :
230 if (states[id].act != MemZA_Fill) rc = 2;
231 else states[id].nbact[0]++;
232 serial_ ++;
233 states[id].serial = serial_;
234 states[id].stat |= MemZS_Filled;
235 states[id].act = MemZA_None;
236 break;
237 case MemZS_Saved :
238 if (states[id].act != MemZA_Save) rc = 4;
239 else states[id].nbact[1]++;
240 states[id].stat |= MemZS_Saved;
241 states[id].act = MemZA_None;
242 break;
243 case MemZS_Proc :
244 if (states[id].act != MemZA_Proc) rc = 8;
245 else states[id].nbact[2]++;
246 states[id].stat |= MemZS_Proc;
247 states[id].act = MemZA_None;
248 break;
249 case MemZS_ProcA :
250 if (states[id].act != MemZA_ProcA) rc = 16;
251 else states[id].nbact[3]++;
252 states[id].stat |= MemZS_ProcA;
253 states[id].act = MemZA_None;
254 break;
255 case MemZS_ProcB :
256 if (states[id].act != MemZA_ProcB) rc = 32;
257 else states[id].nbact[4]++;
258 states[id].stat |= MemZS_ProcB;
259 states[id].act = MemZA_None;
260 break;
261 case MemZS_ProcC :
262 if (states[id].act != MemZA_ProcC) rc = 64;
263 else states[id].nbact[5]++;
264 states[id].stat |= MemZS_ProcC;
265 states[id].act = MemZA_None;
266 break;
267 case MemZS_ProcD :
268 if (states[id].act != MemZA_ProcD) rc = 128;
269 else states[id].nbact[6]++;
270 states[id].stat |= MemZS_ProcD;
271 states[id].act = MemZA_None;
272 break;
273 case MemZS_ProcE :
274 if (states[id].act != MemZA_ProcE) rc = 256;
275 else states[id].nbact[7]++;
276 states[id].stat |= MemZS_ProcE;
277 states[id].act = MemZA_None;
278 break;
279 case MemZS_ProcF :
280 if (states[id].act != MemZA_ProcF) rc = 512;
281 else states[id].nbact[8]++;
282 states[id].stat |= MemZS_ProcF;
283 states[id].act = MemZA_None;
284 break;
285 case MemZS_ProcG :
286 if (states[id].act != MemZA_ProcG) rc = 1024;
287 else states[id].nbact[9]++;
288 states[id].stat |= MemZS_ProcG;
289 states[id].act = MemZA_None;
290 break;
291 case MemZS_ProcH :
292 if (states[id].act != MemZA_ProcH) rc = 2048;
293 else states[id].nbact[10]++;
294 states[id].stat |= MemZS_ProcH;
295 states[id].act = MemZA_None;
296 break;
297 case MemZS_ProcI :
298 if (states[id].act != MemZA_ProcI) rc = 4096;
299 else states[id].nbact[11]++;
300 states[id].stat |= MemZS_ProcI;
301 states[id].act = MemZA_None;
302 break;
303 case MemZS_ProcJ :
304 if (states[id].act != MemZA_ProcJ) rc = 4096;
305 else states[id].nbact[12]++;
306 states[id].stat |= MemZS_ProcJ;
307 states[id].act = MemZA_None;
308 break;
309 case MemZS_SavedProc :
310 if (states[id].act != MemZA_SaveProc) rc = 16384;
311 else states[id].nbact[13]++;
312 states[id].stat |= MemZS_ProcF;
313 states[id].act = MemZA_None;
314 break;
315 default :
316 rc = 65536;
317 states[id].serial = 0;
318 states[id].stat = MemZS_Free;
319 states[id].act = MemZA_None;
320 break;
321 } // Fin de switch
322 mex.unlock();
323 mex.broadcast();
324 return rc;
325}
326
327/* --Methode-- */
328ostream& RAcqMemZoneMgr::Print(ostream& os)
329{
330 os << "RAcqMemZoneMgr::Print() NbZones=" << NbZones() << " PaqSize()=" << PaqSize()
331 << " NbPaquets()=" << NbPaquets() << " ZoneSize()=" << ZoneSize() << endl;
332 if (ProcPaqSize() > 0)
333 cout << " ... With Processed Data Zones ProcPaqSize()=" << ProcPaqSize()
334 << " ProcZoneSize()=" << ProcZoneSize() << endl;
335 else cout << " ... NO Processed Data Zones" << endl;
336 for(uint_4 k=0; k<states.size(); k++) {
337 os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat
338 << " NbAct[0.."<< MXNACTMZM-1 << "]=" << states[k].nbact[0];
339 for(uint_4 j=1; j<MXNACTMZM; j++) cout << "," << states[k].nbact[j];
340 cout << endl;
341 }
342 return os;
343}
344
345/* --Methode-- */
346void RAcqMemZoneMgr::Stop()
347{
348 // cout << "RAcqMemZoneMgr::Stop() ........ STOP BROADCAST" <<endl;
349 stop_ = true;
350 runstate_ = MemZR_Stopped;
351 mex.broadcast();
352}
353
354/* --Methode-- */
355MemZaction RAcqMemZoneMgr::Convert_Status2Action(MemZStatus st)
356// methode statique
357{
358 MemZaction ra=MemZA_None;
359 switch (st) {
360 case MemZS_Filled:
361 ra=MemZA_Fill;
362 break;
363 case MemZS_Saved:
364 ra=MemZA_Save;
365 break;
366 case MemZS_Proc:
367 ra=MemZA_Proc;
368 break;
369 case MemZS_ProcA:
370 ra=MemZA_ProcA;
371 break;
372 case MemZS_ProcB:
373 ra=MemZA_ProcB;
374 break;
375 case MemZS_ProcC:
376 ra=MemZA_ProcC;
377 break;
378 case MemZS_ProcD:
379 ra=MemZA_ProcD;
380 break;
381 case MemZS_ProcE:
382 ra=MemZA_ProcE;
383 break;
384 case MemZS_ProcF:
385 ra=MemZA_ProcF;
386 break;
387 default:
388 ra=MemZA_None;
389 break;
390 }
391 return ra;
392}
Note: See TracBrowser for help on using the repository browser.