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

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

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