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

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

1/ Correction bug de lecture ds BRMultiFitsReader et EthernetReader lorsque lecture avec SameFrameCounter etait demande
2/ Amelioration des impressions ds ces deux classes et ajout possibilite de controle du flag "SameFC" avec les classes de parametres BRParList et BRAnaParam
3/ Nouveaux datacard @ethrforcesamefc et @prtlev pour acquisition

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