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

Last change on this file since 3912 was 3909, checked in by ansari, 15 years ago

1/ Mise en place d'informations auxiliaires au niveau de RAcqMemZoneMgr ,

FillTime (DATEOBS) pour chaque zone et identificateur des fibres

2/ remplissage de FillTime(DATEOBS) Et FiberId's de MemZoneMgr par

les classes PCIEMultiReader et EthernetReader

3/ Ajout de mots-cle (ds les datacards) pour numeros d'identification des

fibres et parametres de controles du DMA (@fiberids @waitenddma)
et corrections/ameliorations des modes acq (raw1c ordfft2c ...)

4/ Parametrage des WaitEndDMA ds PCIEWrapperInterface et implementation

au niveau de DMAMgrV6 (dmamgrv6.h .cc)

5/ Gestion d'echec DMA -> arret acquisition ds PCIEMultiReader,EthernetReader

modification TimeOut DMA entre le premier DMA et les suivants pour permettre
un arret propre rapide

6/ Adaptation de la classe BRVisibilityCalculator pour utilisation

FillTime (DATEOBS) et FiberIds de MemZoneMgr - amelioration de
l'identification des numeros de canaux pour les matrices de visibilites

7/ Petites ameliorations (ecriture mot-cles) pour MultiDataSaver et

amelioration classe BRMultiFitsReader pour lecture FillTime (DATEOBS)
et FiberIds depuis les fichiers FITS et remplissage de RAcqMemZoneMgr

Reza, 21/11/2010
File size: 9.7 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_SaveProc) ) return rid;
75
76 mex.lock();
77 uint_8 bestserial = serial_ + 5;
78 while ((rid < 0)&&(!stop_)) {
79 switch (act) {
80 case MemZA_Fill:
81 if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
82 if ((states[k].act == MemZA_None) &&
83 ((states[k].stat == MemZS_Free)||((states[k].stat&mask_finalized_)==mask_finalized_) )) {
84 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
85 }
86 }
87 if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
88 break;
89 case MemZA_Save:
90 for(uint_4 k=0; k<NbZones(); k++) {
91 if ((states[k].act == MemZA_None) &&
92 (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Saved) ) {
93 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
94 }
95 }
96 if (rid >= 0) states[rid].act = MemZA_Save;
97 break;
98 case MemZA_Proc:
99 for(uint_4 k=0; k<NbZones(); k++) {
100 if ((states[k].act == MemZA_None) &&
101 (states[k].stat & MemZS_Saved) && !(states[k].stat & MemZS_Proc) ) {
102 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
103 }
104 }
105 if (rid >= 0) states[rid].act = MemZA_Proc;
106 break;
107 case MemZA_ProcA:
108 for(uint_4 k=0; k<NbZones(); k++) {
109 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
110 !(states[k].stat & MemZS_ProcA) ) {
111 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
112 }
113 }
114 if (rid >= 0) states[rid].act = MemZA_ProcA;
115 break;
116 case MemZA_ProcB:
117 for(uint_4 k=0; k<NbZones(); k++) {
118 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
119 (states[k].stat & MemZS_ProcA) && !(states[k].stat & MemZS_ProcB) ) {
120 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
121 }
122 }
123 if (rid >= 0) states[rid].act = MemZA_ProcB;
124 break;
125 case MemZA_ProcC:
126 for(uint_4 k=0; k<NbZones(); k++) {
127 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
128 (states[k].stat & MemZS_ProcB) && !(states[k].stat & MemZS_ProcC) ) {
129 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
130 }
131 }
132 if (rid >= 0) states[rid].act = MemZA_ProcC;
133 break;
134 case MemZA_ProcD:
135 for(uint_4 k=0; k<NbZones(); k++) {
136 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
137 (states[k].stat & MemZS_ProcC) && !(states[k].stat & MemZS_ProcD) ) {
138 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
139 }
140 }
141 if (rid >= 0) states[rid].act = MemZA_ProcD;
142 break;
143 case MemZA_ProcE:
144 for(uint_4 k=0; k<NbZones(); k++) {
145 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
146 (states[k].stat & MemZS_ProcD) && !(states[k].stat & MemZS_ProcE) ) {
147 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
148 }
149 }
150 if (rid >= 0) states[rid].act = MemZA_ProcE;
151 break;
152 case MemZA_ProcF:
153 for(uint_4 k=0; k<NbZones(); k++) {
154 if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
155 (states[k].stat & MemZS_ProcE) && !(states[k].stat & MemZS_ProcF) ) {
156 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
157 }
158 }
159 if (rid >= 0) states[rid].act = MemZA_ProcF;
160 break;
161 case MemZA_SaveProc:
162 for(uint_4 k=0; k<NbZones(); k++) {
163 if ((states[k].act == MemZA_None) &&
164 (states[k].stat & mask_saveproc_ready_) && !(states[k].stat & MemZS_SavedProc) ) {
165 if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
166 }
167 }
168 if (rid >= 0) states[rid].act = MemZA_SaveProc;
169 break;
170 case MemZA_None: // MTQ pour supprimer un warning
171 break;
172 } // Fin de switch
173 if (rid < 0) mex.wait();
174 } // Fin de while
175 mex.unlock();
176 return rid;
177}
178
179/* --Methode-- */
180int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
181{
182 if ((id < 0) || (id >= (int)states.size())) return 1;
183 int rc = 0;
184 mex.lock();
185 switch (st) {
186 case MemZS_Free :
187 states[id].serial = 0;
188 states[id].stat = MemZS_Free;
189 states[id].act = MemZA_None;
190 break;
191 case MemZS_Filled :
192 if (states[id].act != MemZA_Fill) rc = 2;
193 else states[id].nbact[0]++;
194 serial_ ++;
195 states[id].serial = serial_;
196 states[id].stat |= MemZS_Filled;
197 states[id].act = MemZA_None;
198 break;
199 case MemZS_Saved :
200 if (states[id].act != MemZA_Save) rc = 4;
201 else states[id].nbact[1]++;
202 states[id].stat |= MemZS_Saved;
203 states[id].act = MemZA_None;
204 break;
205 case MemZS_Proc :
206 if (states[id].act != MemZA_Proc) rc = 8;
207 else states[id].nbact[2]++;
208 states[id].stat |= MemZS_Proc;
209 states[id].act = MemZA_None;
210 break;
211 case MemZS_ProcA :
212 if (states[id].act != MemZA_ProcA) rc = 16;
213 else states[id].nbact[3]++;
214 states[id].stat |= MemZS_ProcA;
215 states[id].act = MemZA_None;
216 break;
217 case MemZS_ProcB :
218 if (states[id].act != MemZA_ProcB) rc = 32;
219 else states[id].nbact[4]++;
220 states[id].stat |= MemZS_ProcB;
221 states[id].act = MemZA_None;
222 break;
223 case MemZS_ProcC :
224 if (states[id].act != MemZA_ProcC) rc = 64;
225 else states[id].nbact[5]++;
226 states[id].stat |= MemZS_ProcC;
227 states[id].act = MemZA_None;
228 break;
229 case MemZS_ProcD :
230 if (states[id].act != MemZA_ProcD) rc = 128;
231 else states[id].nbact[6]++;
232 states[id].stat |= MemZS_ProcD;
233 states[id].act = MemZA_None;
234 break;
235 case MemZS_ProcE :
236 if (states[id].act != MemZA_ProcE) rc = 256;
237 else states[id].nbact[7]++;
238 states[id].stat |= MemZS_ProcE;
239 states[id].act = MemZA_None;
240 break;
241 case MemZS_ProcF :
242 if (states[id].act != MemZA_ProcF) rc = 512;
243 else states[id].nbact[8]++;
244 states[id].stat |= MemZS_ProcF;
245 states[id].act = MemZA_None;
246 break;
247 case MemZS_SavedProc :
248 if (states[id].act != MemZA_SaveProc) rc = 1024;
249 else states[id].nbact[9]++;
250 states[id].stat |= MemZS_ProcF;
251 states[id].act = MemZA_None;
252 break;
253 default :
254 rc = 65536;
255 states[id].serial = 0;
256 states[id].stat = MemZS_Free;
257 states[id].act = MemZA_None;
258 break;
259 } // Fin de switch
260 mex.unlock();
261 mex.broadcast();
262 return rc;
263}
264
265ostream& RAcqMemZoneMgr::Print(ostream& os)
266{
267 os << "RAcqMemZoneMgr::Print() NbZones=" << NbZones() << " PaqSize()=" << PaqSize()
268 << " NbPaquets()=" << NbPaquets() << " ZoneSize()=" << ZoneSize() << endl;
269 if (ProcPaqSize() > 0)
270 cout << " ... With Processed Data Zones ProcPaqSize()=" << ProcPaqSize()
271 << " ProcZoneSize()=" << ProcZoneSize() << endl;
272 else cout << " ... NO Processed Data Zones" << endl;
273 for(uint_4 k=0; k<states.size(); k++) {
274 os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat
275 << " NbAct[0.."<< MXNACTMZM-1 << "]=" << states[k].nbact[0];
276 for(uint_4 j=1; j<MXNACTMZM; j++) cout << "," << states[k].nbact[j];
277 cout << endl;
278 }
279 return os;
280}
281
282void RAcqMemZoneMgr::Stop()
283{
284 // cout << "RAcqMemZoneMgr::Stop() ........ STOP BROADCAST" <<endl;
285 stop_ = true;
286 runstate_ = MemZR_Stopped;
287 mex.broadcast();
288}
Note: See TracBrowser for help on using the repository browser.