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

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

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