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

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

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