source: Sophya/trunk/AddOn/TAcq/racqueth.cc@ 3758

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

Debug divers classes/progeramme envoi-reception paquets sur Ethernet, Reza 30/04/2010
File size: 18.6 KB
RevLine 
[3757]1//----------------------------------------------------------------
2// ---- classes de threads pour lecture (transfert DMA)
3// et ecriture disque pour acquisition BAORadio -----
4// LAL - R. Ansari - Juin/Juillet 2008
5//----------------------------------------------------------------
6
7#include "racqueth.h"
8
9#include <stdlib.h>
10#include <unistd.h>
11#include <fstream>
12#include <signal.h>
13#include "pexceptions.h"
14#include "ctimer.h"
15#include "timestamp.h"
16
17#include "pciewrap.h"
18#include "brpaqu.h"
19
20#include "resusage.h" // Pour mesure temps elapsed/CPU ...
21#include <sys/time.h> // pour gettimeofday
22
23////////////////////////////////////////////////////////////////////////////////////////////////////////
24//----------------------------------------------------------------------------------------------------------
25// Classe thread de lecture PCI-Express et recopie sur interface reseau (Ethernet)
26//----------------------------------------------------------------------------------------------------------
27
28
29/* --Methode-- */
30PCIEToEthernet::PCIEToEthernet(vector<PCIEWrapperInterface*> vec_pciw, vector<string>& destname, BRParList const& par, int portid)
31 : par_(par), vec_pciw_ (vec_pciw), destname_(destname), tcpportid_(portid)
32{
33 nmaxpaq_ = par_.MaxNbPaquets();
34 swapall_ = par_.GetDataConvFg(); // select data swap/format conversion for BRPaquet
35 stop_ = false;
36 packSize_ = par_.RecvPaquetSize();
37 packSizeInMgr_=par_.MMgrPaquetSize();
38 sizeFr_=par_.DMASizeBytes();
39 if (vec_pciw.size() > MAXNBFIB)
40 throw ParmError("PCIEToEthernet:ERROR/ vec_pciw.size() > MAXNBFIB ");
41 nbDma_= vec_pciw.size();
42
43 char msg[BRTCPMSGLEN];
[3758]44 cout << "PCIEToEthernet/Info: Establishing TCP/IP connections ... " << endl;
[3757]45 for(size_t i=0; i<vec_pciw_.size(); i++) {
46 vector<ClientSocket> vskt;
[3758]47 for(size_t j=0; j<destname_.size(); j++) {
[3757]48 ClientSocket sok(destname_[j], tcpportid_);
49 for(int ii=0; ii<BRTCPMSGLEN; ii++) msg[ii]='\0';
50 sprintf(msg,"BAORadio-PCIEToEthernet %d %d",0,i);
51 sok.Send(msg,BRTCPMSGLEN);
52 sok.Receive(msg,BRTCPMSGLEN);
53 if (strncmp(msg,"BAORadio-EthernetReader-OK",26)!=0)
54 throw SocketException("PCIEToEthernet:ERROR/ Connection to EthernetReader not established ");
55 cout << " PCIEToEthernet: Ethernet connection established for DMA/fiber" << i << " with " << destname_[j] << endl;
56 vskt.push_back(sok);
57 }
58 vvec_skt_.push_back(vskt);
59 }
[3758]60 totrdsnd_ = 0;
[3757]61}
62
63/* --Methode-- */
64PCIEToEthernet::~PCIEToEthernet()
65{
66 for(size_t i=0; i<vec_pciw_.size(); i++) {
67 vector<ClientSocket>& vskt = vvec_skt_[i];
68 for(size_t j=0; j<destname_.size(); j++) vskt[j].Close();
69 }
70}
71
72/* --Methode-- */
73void PCIEToEthernet::run()
74{
75
76 struct timeval tv1,tv2;
77 gettimeofday(&tv1, NULL);
78
79 cout << " PCIEToEthernet::run() - Starting , NMaxMemZones=" << par_.MaxNbBlocs()
80 << " MMgrNbPaquet=" << par_.MMgrNbPaquet() << " MMgr.PaqSiz=" << par_.MMgrPaquetSize()
81 << " DMA-Paqsize " << packSize_ << " " << BRPaquet::FmtConvToString(swapall_) << endl;
82 setRC(1);
83
84 // sigaddset(&act.sa_mask,SIGINT); // pour proteger le transfert DMA
85 //sigaction(SIGINT,&act,NULL);
[3758]86 uint_4 paqszmm = par_.MMgrPaquetSize();
[3757]87 uint_4 paqsz = packSize_;
88 uint_4 dmasz = vec_pciw_[0]->TransferSize();
89 //DEL vec_pciw_[0]->StartTransfers();
90
91 BRPaqChecker pcheck[MAXNBFIB]; // Verification/comptage des paquets
92 Byte* Datas[MAXNBFIB];
93 Byte* tampon[MAXNBFIB] ;
94 Byte* nexpaq[MAXNBFIB] ; // Pour recevevoir les paquets apres reduction de taille
95
96 Byte* predtampon=NULL; // tampon de recopie pour la reduction des tailles de paquets
97 Byte* nextpaq=NULL;
98 uint_4 off_acheval=0;
99
100 int nerrdma = 0;
101 int maxerrdma = 10;
102 bool fgarret = false;
103
104 // Initialisation des tampons pour recopie des paquets a cheval pour chaque DMA
105 for (int i=0;i< (int)nbDma_ ;i++) {
[3758]106 // cout << " DEBUG*AB paqsz=" << paqsz << " paqszmm=" << paqszmm << endl;
107 tampon[i]=nexpaq[i]=NULL;
[3757]108 tampon[i] = new Byte[paqsz];
109 nexpaq[i] = new Byte[paqszmm];
110 }
111
112 bool fgdirectsend = (par_.pci2eth_fgdirect && (swapall_==BR_Copy) ) ? true : false; // true -> direct transfer of data to ethernet
113 if (fgdirectsend)
114 cout << " PCIEToEthernet::run() Direct transfer mode DMA to Ethernet ... " << endl;
115 bool fgredpaq=par_.fgreducpsize;
116 if (fgredpaq) {
117 cout << " PCIEToEthernet::run() - PaquetSizeReduction - RedSize=" << par_.redpqsize
118 << " Offset=" << par_.reducoffset << " " << ((par_.reducneedcopy)?"NeedCopy":"NOCopy")
119 << " " << BRPaquet::ReducActionToString(par_.pqreducmode) << endl;
120 predtampon = new Byte[paqsz];
121 }
122
123
124 uint_8 trnbytes[MAXNBFIB];
125 uint_4 npaqfait[MAXNBFIB];
126 for (int i=0;i< (int)nbDma_ ;i++) {
127 npaqfait[i]=0; trnbytes[i]=0;
128 }
129 // Attente du message GO des taches lecteurs
130 cout << " PCIEToEthernet::run() Waiting for GO message from EthernetReader's ..." << endl;
131 char msg[BRTCPMSGLEN];
132 for(size_t i=0; i<vec_pciw_.size(); i++) {
133 vector<ClientSocket>& vskt=vvec_skt_[i];
134 for(size_t j=0; j<vskt.size(); j++) {
135 for(int ii=0; ii<BRTCPMSGLEN; ii++) msg[ii]='\0';
[3758]136 vskt[j].Receive(msg,BRTCPMSGLEN);
137 if (strncmp(msg,"BAORadio-EthernetReader-Ready-GO",32)!=0) {
138 msg[BRTCPMSGLEN-1]='\0';
139 cout << "PCIEToEthernet:ERROR BAD Go for fiber=" << i << " dest=" << j << " msg: " << msg << endl;
[3757]140 throw SocketException("PCIEToEthernet:ERROR/ BAD Go message from EthernetReader ");
[3758]141 }
142 cout << " PCIEToEthernet::run() Received GO message for Fiber/DMA " << i << " from " << destname_[j] << endl;
[3757]143 }
144 }
145
146 cout << " PCIEToEthernet::run() Starting DMA to Ethernet transfers - NbFibers=NbDMA=" << vec_pciw_.size()
147 << " x NbEthDestinations=" << destname_.size() << endl;
148
149 // Byte* nextdma = locdata+((kmz%memgr.NbZones())*(paqsz*memgr.NbPaquets()));
150 uint_4 npaqfaitg = 0;
151 while (npaqfaitg < nmaxpaq_) { // Boucle global G
152 if (fgarret) break;
153 if (stop_) break;
154
155 // Lancement des DMA
156 for (int dma=0; dma < (int)nbDma_ ;dma++) vec_pciw_[dma]->StartTransfers();
157
158 // On pointe vers le debut de la zone a remplir aver le prochain DMA
159 //-- Zone memoire locale Byte* nextdma = buff+i*paqsz;
160
161 bool fgbaddma=false;
162 // On boucle sur les nbDma_ en attente de leurs terminaison
163 for (int dma=0; dma <(int) nbDma_ ;dma++) {
164 Datas[dma]=vec_pciw_[dma]->GetData();
165 if (Datas[dma] == NULL) { // No data Read in DMA
166 nerrdma ++; fgbaddma=true;
167 cout << "PCIEToEthernetChecker/Erreur Waiting for datas ..." << endl;
168 vec_pciw_[dma]->PrintStatus(cout);
169 if (nerrdma>=maxerrdma) { fgarret = true; break; }
170 }
171 }
172 if (fgbaddma) continue;
[3758]173
[3757]174 if (fgdirectsend) { // Pas de copie / reduction de taille de paquet, on rebalance tel quel ...
175 for (int fib=0; fib<(int) nbDma_ ;fib++) {
[3758]176 //DBG cout << " DEBUG*B fib=" << fib << " Datas[fib]=" << hex << Datas[fib] << dec << endl;
177 SendToTargets(fib, Datas[fib], dmasz);
[3757]178 trnbytes[fib] += (uint_8)dmasz;
179 npaqfait[fib] += (trnbytes[fib]/(uint_8)paqszmm);
180 if (fib==nbDma_-1) npaqfaitg += (trnbytes[fib]/(uint_8)paqszmm);
181 trnbytes[fib] = trnbytes[fib]%(uint_8)paqszmm;
182 }
183 continue; // On bypasse le reste
184 }
[3758]185
[3757]186 // Si on arrive ici, c'est qu'il faut copier / reduire les paquets ....
187 uint_4 curoff=0;
188 //1- On traite le paquet a cheval, rempli partiellement avec le DMA d'avant si necessaire pour les n fibres
189 if (off_acheval > 0) { // IF Numero B
190 if ((paqsz-off_acheval)< dmasz) { // IF Numero A
191 for(uint_4 fib=0; fib<nbDma_; fib++)
192 memcpy((void *)((tampon[fib])+off_acheval), (void *)Datas[fib], paqsz-off_acheval);
193 curoff = paqsz-off_acheval; off_acheval = 0;
194 for(uint_4 fib=0; fib<nbDma_; fib++) {
195 // CHECK S'il faut faire une reduction de taille de paquet
196 if (fgredpaq) { // reduction taille de paquet
197 if (par_.reducneedcopy) {
198 BRPaquet paqc1(tampon[fib], predtampon, paqsz, swapall_);
199 BRPaquet paqc2(nexpaq[fib], par_.redpqsize);
200 paqc2.CopyFrom(paqc1, par_.pqreducmode, par_.reducoffset);
201 }
202 else {
203 BRPaquet paqc1(tampon[fib], paqsz);
204 BRPaquet paqc2(nexpaq[fib], par_.redpqsize);
205 paqc2.CopyFrom(paqc1, par_.pqreducmode, par_.reducoffset);
206 }
207 }
208 else {
209 BRPaquet paqc(tampon[fib], nexpaq[fib], paqsz, swapall_);
210 }
211 BRPaquet paq(nexpaq[fib], packSizeInMgr_);
[3758]212 SendToTargets(fib, nexpaq[fib], packSizeInMgr_);
[3757]213 npaqfait[fib]++;
214 if (fib==nbDma_-1) npaqfaitg++; // Ne pas oublier le compteur de paquets faits
215 pcheck[fib].Check(paq); // Verification du paquet / FrameCounter
216 }
217 }
218 else { // se rapporte au IF numero A
219 for(uint_4 fib=0; fib<nbDma_; fib++)
220 memcpy((void *)(tampon[fib]+off_acheval), (void *)Datas[fib], dmasz);
221 curoff =dmasz;
222 off_acheval = (dmasz+off_acheval);
223 }
224 } // Fin IF Numero B
225
226 //2- On traite les paquets complets qui se trouvent dans la zone du DMA
227 while ((curoff+paqsz)<=dmasz) { // while numero C
228 // if ((dma==nbDma_-1)&&(npaqfait >= nmax_* memgr.NbPaquets())) break;
229 // CHECK S'il faut faire une reduction de taille de paquet
230 for(uint_4 fib=0; fib<nbDma_; fib++) {
231 if (fgredpaq) { // reduction taille de paquet
232 if (par_.reducneedcopy) {
233 BRPaquet paqc1(Datas[fib]+curoff, predtampon, paqsz, swapall_);
234 BRPaquet paqc2(nexpaq[fib], par_.redpqsize);
235 paqc2.CopyFrom(paqc1, par_.pqreducmode, par_.reducoffset);
236 }
237 else {
238 BRPaquet paqc1(Datas[fib]+curoff, paqsz);
239 BRPaquet paqc2(nexpaq[fib], par_.redpqsize);
240 paqc2.CopyFrom(paqc1, par_.pqreducmode, par_.reducoffset);
241 }
242 }
243 else {
244 BRPaquet paqc(Datas[fib]+curoff, nexpaq[fib], paqsz, swapall_);
245 }
246 BRPaquet paq(nexpaq[fib], packSizeInMgr_);
[3758]247 SendToTargets(fib, nexpaq[fib], packSizeInMgr_);
[3757]248 npaqfait[fib]++;
249 if (fib==nbDma_-1) npaqfaitg++; // Ne pas oublier le compteur de paquets faits
250 pcheck[fib].Check(paq); // Verification du paquet / FrameCounter
251 }
252 curoff += paqsz; // On avance l'index dans le buffer du DMA
253 } // -- FIN traitement des paquets complets ds un DMA - FIN du while numero C
254 //3- On copie si besoin la fin du DMA dans la zone tampon
255 if (curoff < dmasz) { // IF numero D
256 off_acheval = dmasz-curoff;
257 for(uint_4 fib=0; fib<nbDma_; fib++)
258 memcpy(tampon[fib], (void*)(Datas[fib]+curoff), off_acheval);
259 // ne sert a rien curoff += off_acheval;
260 } // FIN du if numero D
261 } // FIN Boucle global G
262
263 setRC(0);
264 gettimeofday(&tv2, NULL);
265 double tmelaps2 = (tv2.tv_sec-tv1.tv_sec)*1000.+(tv2.tv_usec-tv1.tv_usec)/1000.;
266 if (tmelaps2<0.1) tmelaps2=0.1;
267 cout << " ---------- PCIEToEthernet::run()-End summary NPaqFait=" << npaqfaitg
[3758]268 << " TotSend (kb)=" << totrdsnd_/1024 << "------ " << endl;
[3757]269 for (int dma=0; dma < (int)nbDma_ ;dma++) {
270 cout << " --Fib=" << dma << " NPaqFait=" << npaqfait[dma] << " TotDMATransfer="
271 << vec_pciw_[dma]->TotTransferBytes()/1024
272 << " ElapsTime=" << tmelaps2 << " ms ->"
273 << (double)vec_pciw_[dma]->TotTransferBytes()/tmelaps2 << " kb/s" << endl;
274
275 vector<ClientSocket>& vskt = vvec_skt_[dma];
276 cout << " TotEthTransfer=";
277 for(size_t j=0; j<vskt.size(); j++)
278 cout << vskt[j].NBytesSent()/1024 << " , ";
279 cout << " kb" << endl;
280
281 if (!fgdirectsend) pcheck[dma].Print(cout);
282 }
283 cout << " --------------------------------------------------------------------" << endl;
284
285 for (int i=0;i< (int)nbDma_ ;i++) {
286 delete[] tampon[i];
287 delete[] nexpaq[i];
288 }
289 if ((fgredpaq)&&predtampon) delete[] predtampon;
290
291 //DBG cout << " fin thread ========================" <<endl;
292 return;
293}
294
295
296/* --Methode-- */
297void PCIEToEthernet::Stop()
298{
299 // cout << " PCIEReaderChecker::stop() ........ STOP" <<endl;
300 stop_ = true;
301
302}
303
[3758]304static long cnt_prt=0;
305/* --Methode-- */
306size_t PCIEToEthernet::SendToTargets(int fib, Byte* data, size_t len)
307{
308 //DBG cout << " SendToTargets/DBG" << cnt_prt << " len=" << len << " data=" << hex << (unsigned long)data << dec << endl; cnt_prt++;
309 vector<ClientSocket>& vskt = vvec_skt_[fib];
310 size_t rc=0;
311 for(size_t j=0; j<vskt.size(); j++) {
312 rc += vskt[j].Send((const char *)data, len);
313 totrdsnd_ += len;
314 }
315 return rc;
316}
[3757]317//------------------------------------------------------------------
318// Classe thread de lecture sur interface reseau (Ethernet)
319//------------------------------------------------------------------
320
321/* --Methode-- */
322EthernetReader::EthernetReader(RAcqMemZoneMgr& mem, BRParList const& par, int portid, bool rdsamefc)
323 : memgr_(mem), par_(par), stop_(false), rdsamefc_(rdsamefc), tcpportid_(portid)
324{
325 SetPrintLevel();
326 totnbytesrd_ = 0;
327 totnpaqrd_ = 0;
328 totsamefc_ = 0;
329 if (memgr_.NbFibres() > MAXANAFIB)
330 throw BAORadioException("EthernetReader::EthernetReader/ NbFibres>MAXANAFIB ");
331 if (par_.ethr_nlink != memgr_.NbFibres())
332 throw BAORadioException("EthernetReader::EthernetReader/ NbFibres != ethr_nlink");
333
334 packsize_=memgr_.PaqSize();
335 mid_=-2;
336 mmbuf_=NULL;
337 max_targ_npaq = memgr_.NbPaquets();
338 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) mmbufib_[fib]=NULL;
339
340 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
341 vpaq_.push_back(BRPaquet(NULL,memgr_.PaqSize()));
342 vpchk_.push_back(BRPaqChecker(true,0));
343 curfc_.push_back(0);
344 totnpqrd_.push_back(0);
345 totnpqok_.push_back(0);
346 }
347 ServerSocket srv(tcpportid_, par_.ethr_nlink);
348 char msg[BRTCPMSGLEN];
349 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
350 Socket sok=srv.WaitClientConnection();
351 for(int ii=0; ii<BRTCPMSGLEN; ii++) msg[ii]='\0';
352 sok.Receive(msg,BRTCPMSGLEN);
353 if (strncmp(msg,"BAORadio-PCIEToEthernet",23)!=0)
354 throw SocketException("EthernetReader:ERROR/ Bad message from PCIEToEthernet client !");
355 for(int ii=0; ii<BRTCPMSGLEN; ii++) msg[ii]='\0';
356 strcpy(msg,"BAORadio-EthernetReader-OK");
357 sok.Send(msg,BRTCPMSGLEN);
358 vsok_.push_back(sok);
359 cout << " EthernetReader/Info connection/link" << fib << " established." << endl;
360 }
361}
362
363
364/* --Methode-- */
365void EthernetReader::run()
366{
367 setRC(1);
368 try {
369 TimeStamp ts;
370 Timer tm("EthernetReader", false);
371 cout << " EthernetReader::run() - Starting " << ts << " NbFibres()=" << memgr_.NbFibres()
372 << " PaqSize() = " << memgr_.PaqSize() << endl;
373 cout << " ...ReadMode: " << ((rdsamefc_)?"Paquets With SameFrameCounter":"All OK paquets") << endl;
374
375 cout << " Sending GO message to all PCIEToEthernet clients ... " << endl;
376 char msg[BRTCPMSGLEN];
377 for(int ii=0; ii<BRTCPMSGLEN; ii++) msg[ii]='\0';
378 strcpy(msg,"BAORadio-EthernetReader-Ready-GO");
379 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
[3758]380 cout << " EthernetReader/Debug - Sending GO message to sender " << fib << endl;
[3757]381 vsok_[fib].Send(msg,BRTCPMSGLEN);
382 }
383 Byte* nextpaq=NULL;
384 bool fgok=true;
385 while (fgok&&(totnpaqrd_<par_.MaxNbPaquets())) {
386 if (stop_) break;
387 if ( MoveToNextTarget() ) {
388 cout << "EthernetReader::run()/Error-A- MoveToNextTarget() returned true ->STOP 9" << endl;
389 setRC(7); fgok=false; break;
390 }
391 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
392 nextpaq=GetPaquetTarget(fib);
393 if (nextpaq == NULL) { // Cela ne devrait pas arriver
394 cout << "EthernetReader::run()/Error-A2- GetPaquetTarget(fib) returned NULL ->STOP 9" << endl;
395 setRC(9); fgok=false; break;
396 }
397 vpaq_[fib].Set(nextpaq);
398 }
399 if (ReadNextAllFibers()) { fgok=false; break; }
400 totnpaqrd_++;
401 }
402
403 MoveToNextTarget(); // Pour faire traiter le dernier paquet si plein
404 MZoneManage(true); // Nettoyage final
405 usleep(50000); // Attente de traitement du dernier paquet
406 memgr_.Stop(); // Arret
407
408 cout << " ------------------ EthernetReader::run() END ----------------- " << endl;
409 ts.SetNow();
410 tm.SplitQ();
411 cout << " END reading TotNPaq/Link=" << totnpaqrd_ << " :" << ts ;
412 if (rdsamefc_) cout << " NSameFC=" << totsamefc_ << endl;
413 else cout << endl;
414 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
415 int perc=0;
416 if (totnpqrd_[fib]>0) perc=100*totsamefc_/totnpqrd_[fib];
417 cout << " Fiber" << fib << " TotNPaqRd=" << totnpqrd_[fib] << " TotNPaqOK=" << totnpqok_[fib]
418 << " FracSameFC=" << perc << " %" << endl;
419 if (prtlev_ > 0) vpchk_[fib].Print(cout);
420 }
421 cout << " TotalEthernetRead= " << totnbytesrd_/(1024*1024) << " MBytes Ethernet-Read rate= "
422 << (double)(totnbytesrd_)/1024./tm.PartialElapsedTimems() << " MB/s" << endl;
423 cout << " EthernetReader::run()/Timing: \n";
424 tm.Print();
425 cout << " ---------------------------------------------------------- " << endl;
426
427 } // Fin du bloc try
428 catch (std::exception& exc) {
429 cout << " EthernetReader::run()/catched execption msg= " << exc.what() << endl;
430 setRC(3);
431 return;
432 }
433 catch(...) {
434 cout << " EthernetReader::run()/catched unknown ... exception " << endl;
435 setRC(4);
436 return;
437 }
438 setRC(0);
439 return;
440}
441
442/* --Methode-- */
443bool EthernetReader::ReadNextAllFibers()
444{
445 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++) {
446 if (ReadNext(fib)) return true; // probleme
447 }
448 if (!rdsamefc_ || (memgr_.NbFibres()<2)) {
449 totsamefc_++; return false; // c'est OK
450 }
451 uint_8 cfc=curfc_[0];
452 bool fgsamefc=true;
453 for(size_t fib=1; fib<memgr_.NbFibres(); fib++) {
454 if (curfc_[fib]!=cfc) {
455 fgsamefc=false;
456 if (curfc_[fib] > cfc) cfc=curfc_[fib];
457 }
458 }
459 if (fgsamefc) {
460 totsamefc_++; return false; // c'est OK , same framecounter
461 }
462 else { // else !fgsame
463 for(uint_4 fib=0; fib<memgr_.NbFibres(); fib++) {
464 while (curfc_[fib]<cfc) {
465 if (ReadNext(fib)) return true; // probleme
466 }
467 }
468 } // fin de else !fgsame
469 totsamefc_++;
470 return false; // c'est OK
471}
472
473/* --Methode-- */
474bool EthernetReader::ReadNext(int fib)
475{
476 bool fggood=false;
477 while(!fggood) {
478 vsok_[fib].Receive((char *)vpaq_[fib].Begin(), packsize_);
479 totnbytesrd_+=packsize_;
480 totnpqrd_[fib]++;
481 fggood = vpchk_[fib].Check(vpaq_[fib],curfc_[fib]);
482 }
483 totnpqok_[fib]++;
484 return false;
485}
486
487/* --Methode-- */
488bool EthernetReader::MZoneManage(bool fgclean) // Retourne true si probleme
489{
490 /* Pour debug
491 cout << " EthernetReader::MZoneManage() mid_=" << mid_ << " arg_npaq_= " << targ_npaq_
492 << " max_targ_npaq=" << max_targ_npaq << endl;
493 */
494 if (mid_ >= 0) {
495 if (fgclean) memgr_.FreeMemZone(mid_, MemZS_Free);
496 else memgr_.FreeMemZone(mid_, MemZS_Filled);
497 }
498 mmbuf_ = NULL; targ_npaq_ = 0; mid_ = -2;
499 for (int fib=0;fib<(int)memgr_.NbFibres() ;fib++) mmbufib_[fib]=NULL;
500 if (fgclean) return false;
501 mid_ = memgr_.FindMemZoneId(MemZA_Fill);
502 mmbuf_ = memgr_.GetMemZone(mid_);
503 if (mmbuf_==NULL) return true;
504 for(size_t fib=0; fib<(size_t)memgr_.NbFibres(); fib++)
505 mmbufib_[fib]=memgr_.GetMemZone(mid_,fib);
506 return false;
507}
Note: See TracBrowser for help on using the repository browser.