- bugfix AliHLTDataBuffer: size of buffer descriptor set correctly
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTDataBuffer.cxx
1 // $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   AliHLTDataBuffer.cxx
20     @author Matthias Richter
21     @date   
22     @brief  Handling of Data Buffers for HLT components.
23 */
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #if __GNUC__>= 3
32 using namespace std;
33 #endif
34
35 #include "AliHLTDataBuffer.h"
36 #include "AliHLTConsumerDescriptor.h"
37 #include "AliHLTComponent.h"
38 #include <cerrno>
39 #include <cassert>
40 //#include <string>
41 //#include "AliHLTSystem.h"
42
43 typedef vector<AliHLTDataBuffer::AliHLTDataSegment> AliHLTDataSegmentList;
44 typedef vector<AliHLTDataBuffer::AliHLTRawBuffer*>  AliHLTRawBufferPList;
45
46 /** ROOT macro for the implementation of ROOT specific class methods */
47 ClassImp(AliHLTDataBuffer)
48
49 AliHLTDataBuffer::AliHLTDataBuffer()
50   :
51   fSegments(),
52   fConsumers(),
53   fActiveConsumers(),
54   fReleasedConsumers(),
55   fpBuffer(NULL),
56   fFlags(0)
57 {
58   // see header file for class documentation
59   // or
60   // refer to README to build package
61   // or
62   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
63   fSegments.empty();
64   fConsumers.empty();
65   fActiveConsumers.empty();
66   fReleasedConsumers.empty();
67   fgNofInstances++;
68 }
69
70 int AliHLTDataBuffer::fgNofInstances=0;
71 AliHLTRawBufferPList AliHLTDataBuffer::fgFreeBuffers;
72 AliHLTRawBufferPList AliHLTDataBuffer::fgActiveBuffers;
73 AliHLTUInt32_t AliHLTDataBuffer::fgMargin=1024;
74 AliHLTLogging AliHLTDataBuffer::fgLogging;
75 const Int_t AliHLTDataBuffer::fgkSafetyPatternSize=16;
76 const char AliHLTDataBuffer::fgkSafetyPattern[]={0x28, 0x63, 0x29, 0x4d, 0x52, 0x49, 0x43, 0x48, 0x54, 0x45, 0x52, 0x20, 0x32, 0x30, 0x30, 0x37};
77
78 AliHLTDataBuffer::~AliHLTDataBuffer()
79 {
80   // see header file for function documentation
81   if (--fgNofInstances<=0) {
82     DeleteRawBuffers();
83   }
84   CleanupConsumerList();
85 }
86
87 int AliHLTDataBuffer::SetConsumer(AliHLTComponent* pConsumer)
88 {
89   // see header file for function documentation
90   int iResult=0;
91   if (pConsumer) {
92     if (FindConsumer(pConsumer)) {
93       HLTWarning("consumer %s (%p) already set to data buffer %p", pConsumer->GetComponentID(), pConsumer, this);
94     }
95     AliHLTConsumerDescriptor* pDesc=new AliHLTConsumerDescriptor(pConsumer);
96     if (pDesc) {
97       fConsumers.push_back(pDesc);
98       HLTDebug("set consumer %s (%p) to data buffer %p", pConsumer->GetComponentID(), pConsumer, this);
99     } else {
100       HLTError("memory allocation failed");
101       iResult=-ENOMEM;
102     }
103   } else {
104     HLTError("invalid parameter: consumer component (nil)");
105     iResult=-EINVAL;
106   }
107   return iResult;
108 }
109
110 int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, AliHLTComponentDataTypeList* tgtList)
111 {
112   // see header file for function documentation
113   int iResult=0;
114   if (pConsumer) {
115     AliHLTDataSegmentList segments;
116     if ((iResult=FindMatchingDataSegments(pConsumer, segments))>=0) {
117       if (tgtList) {
118         AliHLTDataSegmentList::iterator segment=segments.begin();
119         while (segment!=segments.end()) {
120           tgtList->push_back((*segment).fDataType);
121           segment++;
122         }
123       }
124       iResult=segments.size();
125     }
126   } else {
127     iResult=-EINVAL;
128   }
129   return iResult;
130 }
131
132 int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector<AliHLTDataBuffer::AliHLTDataSegment>& tgtList)
133 {
134   // see header file for function documentation
135   int iResult=0;
136
137   // Matthias 26.09.2007 relax the restriction to matching data blocks
138   // all blocks are passed to the consumer, which is the policy also in
139   // PubSub
140   tgtList.assign(fSegments.begin(), fSegments.end());
141   iResult=tgtList.size();
142   return iResult;
143   
144   if (pConsumer) {
145     AliHLTComponentDataTypeList dtlist;
146     ((AliHLTComponent*)pConsumer)->GetInputDataTypes(dtlist);
147     AliHLTDataSegmentList::iterator segment=fSegments.begin();
148     while (segment!=fSegments.end()) {
149       AliHLTComponentDataTypeList::iterator type=dtlist.begin();
150       while (type!=dtlist.end()) {
151         if ((*segment).fDataType==(*type) ||
152             (*type)==kAliHLTAnyDataType) {
153           tgtList.push_back(*segment);
154           iResult++;
155           break;
156         }
157         type++;
158       }
159       segment++;
160     }
161   } else {
162     iResult=-EINVAL;
163   }
164   return iResult;
165 }
166
167 int AliHLTDataBuffer::Subscribe(const AliHLTComponent* pConsumer, AliHLTComponentBlockData* arrayBlockDesc, int iArraySize)
168 {
169   // see header file for function documentation
170   int iResult=0;
171   if (pConsumer && arrayBlockDesc) {
172     if (fpBuffer) {
173       AliHLTConsumerDescriptor* pDesc=FindConsumer(pConsumer, fConsumers);
174       if (pDesc) {
175         AliHLTDataSegmentList tgtList;
176         // Matthias 26.07.2007 AliHLTSystem should behave the same way as PubSub
177         // so it does not matter if there are matching data types or not, unless
178         // we implement such a check in PubSub
179         if ((iResult=FindMatchingDataSegments(pConsumer, tgtList))>=0) {
180           int i =0;
181           AliHLTDataSegmentList::iterator segment=tgtList.begin();
182           while (segment!=tgtList.end() && i<iArraySize) {
183             // fill the block data descriptor
184             arrayBlockDesc[i].fStructSize=sizeof(AliHLTComponentBlockData);
185             // the shared memory key is not used in AliRoot
186             arrayBlockDesc[i].fShmKey.fStructSize=sizeof(AliHLTComponentShmData);
187             arrayBlockDesc[i].fShmKey.fShmType=gkAliHLTComponentInvalidShmType;
188             arrayBlockDesc[i].fShmKey.fShmID=gkAliHLTComponentInvalidShmID;
189             // This models the behavior of PubSub.
190             // For incoming data blocks, fOffset must be ignored by the
191             // processing component. It is set for bookkeeping in the framework.
192             // fPtr always points to the beginning of the data.
193             arrayBlockDesc[i].fOffset=(*segment).fSegmentOffset;
194             AliHLTUInt8_t* pTgt=*fpBuffer;
195             pTgt+=(*segment).fSegmentOffset;
196             arrayBlockDesc[i].fPtr=reinterpret_cast<void*>(pTgt);
197             arrayBlockDesc[i].fSize=(*segment).fSegmentSize;
198             arrayBlockDesc[i].fDataType=(*segment).fDataType;
199             arrayBlockDesc[i].fSpecification=(*segment).fSpecification;
200             pDesc->SetActiveDataSegment(arrayBlockDesc[i].fOffset, arrayBlockDesc[i].fSize);
201             HLTDebug("component %p (%s) subscribed to segment #%d offset %d size %d data type %s %#x", 
202                      pConsumer, ((AliHLTComponent*)pConsumer)->GetComponentID(), i, arrayBlockDesc[i].fOffset,
203                      arrayBlockDesc[i].fSize, (AliHLTComponent::DataType2Text(arrayBlockDesc[i].fDataType)).c_str(), 
204                      arrayBlockDesc[i].fSpecification);
205             i++;
206             segment++;
207           }
208           // check whether there was enough space for the segments
209           if (i!=(int)tgtList.size()) {
210             HLTError("too little space in block descriptor array: required %d, available %d", tgtList.size(), iArraySize);
211             iResult=-ENOSPC;
212           } else {
213           // move this consumer to the active list
214           if (ChangeConsumerState(pDesc, fConsumers, fActiveConsumers)>=0) {
215             HLTDebug("component %p (%s) subscribed to data buffer %p", pConsumer, ((AliHLTComponent*)pConsumer)->GetComponentID(), this);
216           } else {
217             // TODO: cleanup the consumer descriptor correctly
218             memset(arrayBlockDesc, 0, iArraySize*sizeof(AliHLTComponentBlockData));
219             HLTError("can not activate consumer %p for data buffer %p", pConsumer, this);
220             iResult=-EACCES;
221           }
222           }
223         } else {
224           HLTError("unresolved data segment(s) for component %p (%s)", pConsumer, ((AliHLTComponent*)pConsumer)->GetComponentID());
225           iResult=-EBADF;
226         }
227       } else {
228         HLTError("component %p is not a data consumer of data buffer %s", pConsumer, this);
229         iResult=-ENOENT;
230       }
231     } else {
232       // Matthias 26.07.2007 until now, data had to be present for successful subscription
233       // in order to be consistent with the PubSub framework, this restiction has been
234       // removed
235       //HLTError("data buffer %p is empty", this);
236       //iResult=-ENODATA;
237     }
238   } else {
239     HLTError("invalid parameter");
240     iResult=-EINVAL;
241   }
242   return iResult;
243 }
244
245 int AliHLTDataBuffer::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer)
246 {
247   // see header file for function documentation
248   int iResult=0;
249   if (pBlockDesc && pConsumer) {
250     AliHLTConsumerDescriptor* pDesc=FindConsumer(pConsumer, fActiveConsumers);
251     if (pDesc) {
252       if ((iResult=pDesc->CheckActiveDataSegment(pBlockDesc->fOffset, pBlockDesc->fSize))!=1) {
253         HLTWarning("data segment missmatch, component %p has not subscribed to a segment with offset %#x and size %d", pConsumer, pBlockDesc->fOffset, pBlockDesc->fSize);
254         // TODO: appropriate error handling, but so far optional
255         iResult=0;
256       } else {
257         pDesc->ReleaseActiveDataSegment(pBlockDesc->fOffset, pBlockDesc->fSize);
258         pBlockDesc->fOffset=0;
259         pBlockDesc->fPtr=NULL;
260         pBlockDesc->fSize=0;
261       }
262       if (pDesc->GetNofActiveSegments()==0) {
263         if ((iResult=ChangeConsumerState(pDesc, fActiveConsumers, fReleasedConsumers))>=0) {
264           if (GetNofActiveConsumers()==0 && GetNofPendingConsumers()==0) {
265             // this is the last consumer, reset the consumer list and release the raw buffer
266             ResetDataBuffer();
267           }
268         } else {
269           HLTError("can not deactivate consumer %p for data buffer %p", pConsumer, this);
270           iResult=-EACCES;
271         }
272       }
273     } else {
274       HLTWarning("component %p has currently not subscribed to the data buffer %p", pConsumer, this);
275       iResult=-ENOENT;
276     }
277   } else {
278     HLTError("inavalid parameter: pBlockDesc=%p pConsumer=%p", pBlockDesc, pConsumer);
279     iResult=-EINVAL;
280   }
281   return iResult;
282 }
283
284 AliHLTUInt8_t* AliHLTDataBuffer::GetTargetBuffer(int iMinSize)
285 {
286   // see header file for function documentation
287   AliHLTUInt8_t* pTargetBuffer=NULL;
288   if (fpBuffer!=NULL) {
289     HLTWarning("data buffer not properly reset, possible memory leak\n");
290   }
291   fpBuffer=CreateRawBuffer(iMinSize);
292   if (fpBuffer) {
293     pTargetBuffer=*fpBuffer;
294   } else {
295     HLTError("can not create raw buffer");
296   }
297   return pTargetBuffer;
298 }
299
300 int AliHLTDataBuffer::SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponentBlockData* arrayBlockData, int iSize)
301 {
302   // see header file for function documentation
303   int iResult=0;
304   if (pTgt && arrayBlockData && iSize>=0) {
305     if (fpBuffer) {
306       if (*fpBuffer==pTgt) {
307         AliHLTDataBuffer::AliHLTDataSegment segment;
308         for (int i=0; i<iSize; i++) {
309           // This function has to model the behavior of PubSub
310           // For output blocks only the fOffset value is used, this must be the offset
311           // relative to the output pointer. fPtr must be either NULL or the output
312           // pointer
313           if (arrayBlockData[i].fPtr==NULL ||
314               arrayBlockData[i].fPtr==*fpBuffer) {
315             if (arrayBlockData[i].fOffset+arrayBlockData[i].fSize<=fpBuffer->GetUsedSize()) {
316               segment.fSegmentOffset=arrayBlockData[i].fOffset;
317               segment.fSegmentSize=arrayBlockData[i].fSize;
318               segment.fDataType=arrayBlockData[i].fDataType;
319               segment.fSpecification=arrayBlockData[i].fSpecification;
320               fSegments.push_back(segment);
321               HLTDebug("set segment %s with size %d at offset %d", AliHLTComponent::DataType2Text(segment.fDataType).data(), segment.fSegmentSize, segment.fSegmentOffset);
322             } else {
323               HLTError("block data specification %#d (%s) exceeds size of data buffer", i, AliHLTComponent::DataType2Text(arrayBlockData[i].fDataType).data());
324               HLTError("block offset=%d, block size=%d, buffer size=%d", arrayBlockData[i].fOffset, arrayBlockData[i].fSize, fpBuffer->GetUsedSize());
325               iResult=-E2BIG;
326             }
327           } else {
328             HLTError("invalid pointer (%p) in block data specification (buffer %p size %d)."
329                      "please note: for output blocks only the fOffset value is valid and must "
330                      "be relative to the output buffer", arrayBlockData[i].fPtr, fpBuffer->GetPointer(), fpBuffer->GetUsedSize());
331             iResult=-ERANGE;
332           }
333         }
334       } else {
335         HLTError("this data buffer (%p) does not match the internal data buffer %p of raw buffer %p", pTgt, fpBuffer->GetPointer(), fpBuffer);
336         iResult=-EINVAL;
337       }
338     } else {
339       HLTFatal("internal data structur missmatch");
340       iResult=-EFAULT;
341     }
342   } else {
343     HLTError("invalid parameter: pTgtBuffer=%p arrayBlockData=%p", pTgt, arrayBlockData);
344     iResult=-EINVAL;
345   }
346   return iResult;
347 }
348
349 int AliHLTDataBuffer::IsEmpty()
350 {
351   // see header file for function documentation
352   int iResult=fpBuffer==NULL || GetNofSegments()==0;
353   return iResult;
354 }
355
356 int AliHLTDataBuffer::GetNofSegments()
357 {
358   // see header file for function documentation
359   int iResult=fSegments.size();
360   return iResult;
361 }
362
363 int AliHLTDataBuffer::GetNofConsumers()
364 {
365   // see header file for function documentation
366   int iResult=fConsumers.size() + GetNofActiveConsumers() + fReleasedConsumers.size();
367   return iResult;
368 }
369
370 int AliHLTDataBuffer::GetNofPendingConsumers()
371 {
372   // see header file for function documentation
373   int iResult=fConsumers.size();
374   return iResult;
375 }
376
377 int AliHLTDataBuffer::GetNofActiveConsumers()
378 {
379   // see header file for function documentation
380   int iResult=fActiveConsumers.size();
381   return iResult;
382 }
383
384 AliHLTDataBuffer::AliHLTRawBuffer* AliHLTDataBuffer::CreateRawBuffer(AliHLTUInt32_t size)
385 {
386   // see header file for function documentation
387   AliHLTRawBuffer* pRawBuffer=NULL;
388   unsigned int reqSize=size+fgkSafetyPatternSize;
389   AliHLTRawBufferPList::iterator buffer=fgFreeBuffers.begin();
390   while (buffer!=fgFreeBuffers.end() && pRawBuffer==NULL) {
391     if ((*buffer)->CheckSize(reqSize)) {
392       // assign this element
393       pRawBuffer=*buffer;
394       pRawBuffer->UseBuffer(size);
395       fgFreeBuffers.erase(buffer);
396       fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "raw buffer container %p provided for request of %d bytes (total %d available in buffer %p)", pRawBuffer, size, pRawBuffer->GetTotalSize(), pRawBuffer->GetPointer());
397       fgActiveBuffers.push_back(pRawBuffer);
398       break;
399     }
400     buffer++;
401   }
402   if (pRawBuffer==NULL) {
403     // no buffer found, create a new one
404     pRawBuffer=new AliHLTRawBuffer(reqSize);
405     if (pRawBuffer) {
406       if (pRawBuffer->GetPointer()) {
407         pRawBuffer->UseBuffer(size);
408         fgActiveBuffers.push_back(pRawBuffer);
409         fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "new raw buffer %p of size %d created (container %p)", pRawBuffer->GetPointer(), pRawBuffer->GetTotalSize(), pRawBuffer);
410       } else {
411         delete pRawBuffer;
412         pRawBuffer=NULL;
413         fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "memory allocation failed");
414       } 
415     } else {
416       fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "memory allocation failed");
417     }
418   }
419   if (pRawBuffer!=NULL && fgkSafetyPatternSize>0) {
420     //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "writing safety pattern to %p offset %d", (*buffer)->GetPointer(), (*buffer)->GetUsedSize());
421     int res=pRawBuffer->WritePattern(fgkSafetyPattern, fgkSafetyPatternSize);
422     assert(res>=0);
423   }
424   return pRawBuffer;
425 }
426
427 int AliHLTDataBuffer::ReleaseRawBuffer(AliHLTRawBuffer* pBuffer)
428 {
429   // see header file for function documentation
430   int iResult=0;
431   if (pBuffer) {
432     AliHLTRawBufferPList::iterator buffer=fgActiveBuffers.begin();
433     while (buffer!=fgActiveBuffers.end() && (*buffer)!=pBuffer) {
434       buffer++;
435     }
436     if (buffer!=fgActiveBuffers.end()) {
437       if (fgkSafetyPatternSize>0) {
438         //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "comparing safety pattern at %p offset %d", (*buffer)->GetPointer(), reinterpret_cast<AliHLTUInt32_t>(*buffer));
439         if ((*buffer)->CheckPattern(fgkSafetyPattern, fgkSafetyPatternSize)) {
440           fgLogging.Logging(kHLTLogFatal, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "component has written beyond end of data buffer %p size %d", (*buffer)->GetPointer(), (*buffer)->GetUsedSize());
441         }
442       }
443       (*buffer)->Reset();
444       fgFreeBuffers.push_back(*buffer);
445       fgActiveBuffers.erase(buffer);
446     } else {
447       fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "can not find raw buffer container %p in the list of active containers", pBuffer);
448       iResult=-ENOENT;
449     }
450   } else {
451     fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "invalid parameter");
452     iResult=-EINVAL;
453   }
454   return iResult;
455 }
456
457
458 int AliHLTDataBuffer::DeleteRawBuffers() 
459 {
460   // see header file for function documentation
461   int iResult=0;
462 //   int iTotalSize=0;
463 //   int iCount=fgFreeBuffers.size()+fgActiveBuffers.size();
464   AliHLTRawBufferPList::iterator buffer;;
465   while ((buffer=fgFreeBuffers.begin())!=fgFreeBuffers.end()) {
466 //     iTotalSize+=(*buffer)->GetTotalSize();
467     delete *buffer;
468     fgFreeBuffers.erase(buffer);
469   }
470   while ((buffer=fgActiveBuffers.begin())!=fgActiveBuffers.end()) {
471 //     iTotalSize+=(*buffer)->GetTotalSize();
472     fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "request to delete active raw buffer container (raw buffer %p, size %d)", (*buffer)->GetPointer(), (*buffer)->GetTotalSize());
473     delete *buffer;
474     fgActiveBuffers.erase(buffer);
475   }
476 //   fgLogging.Logging(kHLTLogInfo, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "Total memory allocation: %d byte in %d buffers", iTotalSize, iCount);
477   return iResult;
478 }
479
480 AliHLTConsumerDescriptor* AliHLTDataBuffer::FindConsumer(const AliHLTComponent* pConsumer, AliHLTConsumerDescriptorPList &list) const
481 {
482   // see header file for function documentation
483   AliHLTConsumerDescriptor* pDesc=NULL;
484   AliHLTConsumerDescriptorPList::iterator desc=list.begin();
485   while (desc!=list.end() && pDesc==NULL) {
486     if ((pConsumer==NULL || (*desc)->GetComponent()==pConsumer)) {
487       pDesc=*desc;
488     }
489     desc++;
490   }
491   return pDesc;
492 }
493
494 int AliHLTDataBuffer::ResetDataBuffer() 
495 {
496   // see header file for function documentation
497   int iResult=0;
498   AliHLTRawBuffer* pBuffer=fpBuffer;
499   fpBuffer=NULL;
500
501   // cleanup consumer states
502   AliHLTConsumerDescriptorPList::iterator desc;
503 //   if (GetNofPendingConsumers()>0) {
504 //     desc=fConsumers.begin();
505 //     while (desc!=fConsumers.end()) {
506 //       AliHLTComponent* pComp=(*desc)->GetComponent();
507 //       HLTError("internal error: consumer %p (%s %p) did not get data from data buffer %p", *desc, pComp?pComp->GetComponentID():"", pComp, this);
508 //       desc++;
509 //     }
510 //   }
511   desc=fReleasedConsumers.begin();
512   while (desc!=fReleasedConsumers.end()) {
513     AliHLTConsumerDescriptor* pDesc=*desc;
514     fReleasedConsumers.erase(desc);
515     desc=fReleasedConsumers.begin();
516     fConsumers.push_back(pDesc);
517   }
518   desc=fActiveConsumers.begin();
519   while (desc!=fActiveConsumers.end()) {
520     AliHLTConsumerDescriptor* pDesc=*desc;
521     HLTWarning("consumer %p was not released", pDesc);
522     fActiveConsumers.erase(desc);
523     desc=fActiveConsumers.begin();
524     fConsumers.push_back(pDesc);
525   }
526
527   // cleanup segments
528   AliHLTDataSegmentList::iterator segment=fSegments.begin();
529   while (segment!=fSegments.end()) {
530     fSegments.erase(segment);
531     segment=fSegments.begin();
532   }
533
534   // cleanup raw buffer
535   if (pBuffer) {
536     ReleaseRawBuffer(pBuffer);
537   }
538   return iResult;
539 }
540
541 int AliHLTDataBuffer::Reset()
542 {
543   // see header file for function documentation
544   return ResetDataBuffer();
545 }
546
547 // this is the version which works on lists of components instead of consumer descriptors
548 // int AliHLTDataBuffer::ChangeConsumerState(AliHLTComponent* pConsumer, AliHLTComponentPList &srcList, AliHLTComponentPList &tgtList)
549 // {
550 //   int iResult=0;
551 //   if (pDesc) {
552 //     AliHLTComponentPList::iterator desc=srcList.begin();
553 //     while (desc!=srcList.end()) {
554 //       if ((*desc)==pConsumer) {
555 //      srcList.erase(desc);
556 //      tgtList.push_back(pConsumer);
557 //      break;
558 //       }
559 //      desc++;
560 //     }
561 //     if (desc==srcList.end()) {
562 //       HLTError("can not find consumer component %p in list", pConsumer);
563 //       iResult=-ENOENT;
564 //     }
565 //   } else {
566 //     HLTError("invalid parameter");
567 //     iResult=-EINVAL;
568 //   }
569 //   return iResult;
570 // }
571
572 int AliHLTDataBuffer::ChangeConsumerState(AliHLTConsumerDescriptor* pDesc, AliHLTConsumerDescriptorPList &srcList, AliHLTConsumerDescriptorPList &tgtList)
573 {
574   // see header file for function documentation
575   int iResult=-ENOENT;
576   if (pDesc) {
577     AliHLTConsumerDescriptorPList::iterator desc=srcList.begin();
578     while (desc!=srcList.end()) {
579       if ((*desc)==pDesc) {
580         srcList.erase(desc);
581         tgtList.push_back(pDesc);
582         iResult=0;
583         break;
584       }
585       desc++;
586     }
587     if (iResult<0) {
588       HLTError("can not find consumer descriptor %p in list", pDesc);
589     }
590   } else {
591     HLTError("invalid parameter");
592     iResult=-EINVAL;
593   }
594   return iResult;
595 }
596
597 int AliHLTDataBuffer::CleanupConsumerList() 
598 {
599   // see header file for function documentation
600   int iResult=0;
601   ResetDataBuffer();
602   AliHLTConsumerDescriptorPList::iterator desc=fConsumers.begin();
603   while (desc!=fConsumers.end()) {
604     delete *desc;
605     fConsumers.erase(desc);
606     desc=fConsumers.begin();
607   }
608   return iResult;
609 }
610
611 int AliHLTDataBuffer::FindConsumer(AliHLTComponent* pConsumer, int bAllLists)
612 {
613   // see header file for function documentation
614   AliHLTConsumerDescriptorPList::iterator desc=fConsumers.begin();
615   while (desc!=fConsumers.end()) {
616     if ((*desc)->GetComponent()==pConsumer)
617       return 1;
618     desc++;
619   }
620   if (bAllLists==0) return 0;
621
622   desc=fActiveConsumers.begin();
623   while (desc!=fActiveConsumers.end()) {
624     if ((*desc)->GetComponent()==pConsumer)
625       return 1;
626     desc++;
627   }
628   desc=fReleasedConsumers.begin();
629   while (desc!=fReleasedConsumers.end()) {
630     if ((*desc)->GetComponent()==pConsumer)
631       return 1;
632     desc++;
633   }
634   return 0;
635 }
636
637 AliHLTDataBuffer::AliHLTRawBuffer::AliHLTRawBuffer(AliHLTUInt32_t size)
638   :
639   fSize(0),
640   fTotalSize(size),
641   fPtr(static_cast<AliHLTUInt8_t*>(malloc(size)))
642 {
643   // see header file for class documentation
644   // or
645   // refer to README to build package
646   // or
647   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
648   if (fPtr==NULL) {
649     fSize=0;
650     fTotalSize=0;
651   }
652 }
653
654 AliHLTDataBuffer::AliHLTRawBuffer::~AliHLTRawBuffer()
655 {
656   if (fPtr) {
657     free(fPtr);
658   }
659   fPtr=NULL;
660   fSize=0;
661   fTotalSize=0;
662 }
663
664 int AliHLTDataBuffer::AliHLTRawBuffer::operator==(void* ptr) const
665 {
666   // see header file for function documentation
667   return fPtr == static_cast<AliHLTUInt8_t*>(ptr);
668 }
669
670 int AliHLTDataBuffer::AliHLTRawBuffer::operator<=(void* ptr) const
671 {
672   // see header file for function documentation
673   int iResult=fPtr <= static_cast<AliHLTUInt8_t*>(ptr);
674   //printf("%p: %p <= %p (%d)\n", this, fPtr, ptr, iResult);
675   return iResult;
676 }
677
678 int AliHLTDataBuffer::AliHLTRawBuffer::operator>(void* ptr) const
679 {
680   // see header file for function documentation
681   int iResult=fPtr+fSize > static_cast<AliHLTUInt8_t*>(ptr);
682   //printf("%p: %p + %d > %p (%d)\n", this, fPtr, fSize, ptr, iResult);
683   return iResult;
684 }
685
686 int AliHLTDataBuffer::AliHLTRawBuffer::operator-(void* ptr) const
687 {
688   // see header file for function documentation
689   return static_cast<int>(static_cast<AliHLTUInt8_t*>(ptr)-fPtr);
690 }
691
692 AliHLTUInt8_t* AliHLTDataBuffer::AliHLTRawBuffer::UseBuffer(AliHLTUInt32_t size)
693 {
694   // see header file for function documentation
695   if (size>0 && fTotalSize>=size) {
696     fSize=size;
697     return fPtr;
698   }
699   return NULL;
700 }
701
702 int AliHLTDataBuffer::AliHLTRawBuffer::CheckSize(AliHLTUInt32_t size) const
703 {
704   // see header file for function documentation
705   return fTotalSize>=size && ((fTotalSize-size)<fgMargin);
706 }
707
708 int AliHLTDataBuffer::AliHLTRawBuffer::Reset()
709 {
710   // see header file for function documentation
711   fSize=0;
712   return 0;
713 }
714
715 int AliHLTDataBuffer::AliHLTRawBuffer::WritePattern(const char* pattern, int size)
716 {
717   // see header file for function documentation
718   int iResult=0;
719   if (pattern!=NULL && size>0) {
720     if (fSize+size<=fTotalSize) {
721       memcpy(((char*)fPtr)+fSize, pattern, size);
722       iResult=size;
723     } else {
724       iResult=-ENOSPC;
725     }
726   }
727   return iResult;
728 }
729
730 int AliHLTDataBuffer::AliHLTRawBuffer::CheckPattern(const char* pattern, int size) const
731 {
732   // see header file for function documentation
733   int iResult=0;
734   if (pattern!=NULL && size>0) {
735     if (fSize+size<=fTotalSize) {
736       iResult=memcmp(((char*)fPtr)+fSize, pattern, size)!=0;
737     } else {
738       iResult=-ENOSPC;
739     }
740   }
741   return iResult;
742 }