#include "AliHLTConsumerDescriptor.h"
#include "AliHLTComponent.h"
#include <cerrno>
+#include <cassert>
//#include <string>
//#include "AliHLTSystem.h"
+typedef vector<AliHLTDataBuffer::AliHLTDataSegment> AliHLTDataSegmentList;
+typedef vector<AliHLTDataBuffer::AliHLTRawBuffer*> AliHLTRawBufferPList;
+
/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTDataBuffer)
}
int AliHLTDataBuffer::fgNofInstances=0;
-vector<AliHLTDataBuffer::AliHLTRawBuffer*> AliHLTDataBuffer::fgFreeBuffers;
-vector<AliHLTDataBuffer::AliHLTRawBuffer*> AliHLTDataBuffer::fgActiveBuffers;
+AliHLTRawBufferPList AliHLTDataBuffer::fgFreeBuffers;
+AliHLTRawBufferPList AliHLTDataBuffer::fgActiveBuffers;
AliHLTUInt32_t AliHLTDataBuffer::fgMargin=1024;
AliHLTLogging AliHLTDataBuffer::fgLogging;
const Int_t AliHLTDataBuffer::fgkSafetyPatternSize=16;
return iResult;
}
-int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList)
+int AliHLTDataBuffer::FindMatchingDataBlocks(const AliHLTComponent* pConsumer, AliHLTComponentDataTypeList* tgtList)
{
// see header file for function documentation
int iResult=0;
if (pConsumer) {
- vector<AliHLTDataBuffer::AliHLTDataSegment> segments;
+ AliHLTDataSegmentList segments;
if ((iResult=FindMatchingDataSegments(pConsumer, segments))>=0) {
if (tgtList) {
- vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=segments.begin();
+ AliHLTDataSegmentList::iterator segment=segments.begin();
while (segment!=segments.end()) {
tgtList->push_back((*segment).fDataType);
segment++;
return iResult;
if (pConsumer) {
- vector<AliHLTComponentDataType> dtlist;
+ AliHLTComponentDataTypeList dtlist;
((AliHLTComponent*)pConsumer)->GetInputDataTypes(dtlist);
- vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
+ AliHLTDataSegmentList::iterator segment=fSegments.begin();
while (segment!=fSegments.end()) {
- vector<AliHLTComponentDataType>::iterator type=dtlist.begin();
+ AliHLTComponentDataTypeList::iterator type=dtlist.begin();
while (type!=dtlist.end()) {
if ((*segment).fDataType==(*type) ||
(*type)==kAliHLTAnyDataType) {
if (fpBuffer) {
AliHLTConsumerDescriptor* pDesc=FindConsumer(pConsumer, fConsumers);
if (pDesc) {
- vector<AliHLTDataBuffer::AliHLTDataSegment> tgtList;
+ AliHLTDataSegmentList tgtList;
// Matthias 26.07.2007 AliHLTSystem should behave the same way as PubSub
// so it does not matter if there are matching data types or not, unless
// we implement such a check in PubSub
if ((iResult=FindMatchingDataSegments(pConsumer, tgtList))>=0) {
int i =0;
- vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=tgtList.begin();
+ AliHLTDataSegmentList::iterator segment=tgtList.begin();
while (segment!=tgtList.end() && i<iArraySize) {
// fill the block data descriptor
arrayBlockDesc[i].fStructSize=sizeof(AliHLTComponentBlockData);
// pointer
if (arrayBlockData[i].fPtr==NULL ||
arrayBlockData[i].fPtr==*fpBuffer) {
- if (arrayBlockData[i].fOffset+arrayBlockData[i].fSize<=fpBuffer->fSize) {
+ if (arrayBlockData[i].fOffset+arrayBlockData[i].fSize<=fpBuffer->GetUsedSize()) {
segment.fSegmentOffset=arrayBlockData[i].fOffset;
segment.fSegmentSize=arrayBlockData[i].fSize;
segment.fDataType=arrayBlockData[i].fDataType;
HLTDebug("set segment %s with size %d at offset %d", AliHLTComponent::DataType2Text(segment.fDataType).data(), segment.fSegmentSize, segment.fSegmentOffset);
} else {
HLTError("block data specification %#d (%s) exceeds size of data buffer", i, AliHLTComponent::DataType2Text(arrayBlockData[i].fDataType).data());
- HLTError("block offset=%d, block size=%d, buffer size=%d", arrayBlockData[i].fOffset, arrayBlockData[i].fSize, fpBuffer->fSize);
+ HLTError("block offset=%d, block size=%d, buffer size=%d", arrayBlockData[i].fOffset, arrayBlockData[i].fSize, fpBuffer->GetUsedSize());
iResult=-E2BIG;
}
} else {
HLTError("invalid pointer (%p) in block data specification (buffer %p size %d)."
"please note: for output blocks only the fOffset value is valid and must "
- "be relative to the output buffer", arrayBlockData[i].fPtr, fpBuffer->fPtr, fpBuffer->fSize);
+ "be relative to the output buffer", arrayBlockData[i].fPtr, fpBuffer->GetPointer(), fpBuffer->GetUsedSize());
iResult=-ERANGE;
}
}
} else {
- HLTError("this data buffer (%p) does not match the internal data buffer %p of raw buffer %p", pTgt, fpBuffer->fPtr, fpBuffer);
+ HLTError("this data buffer (%p) does not match the internal data buffer %p of raw buffer %p", pTgt, fpBuffer->GetPointer(), fpBuffer);
iResult=-EINVAL;
}
} else {
// see header file for function documentation
AliHLTRawBuffer* pRawBuffer=NULL;
unsigned int reqSize=size+fgkSafetyPatternSize;
- vector<AliHLTRawBuffer*>::iterator buffer=fgFreeBuffers.begin();
+ AliHLTRawBufferPList::iterator buffer=fgFreeBuffers.begin();
while (buffer!=fgFreeBuffers.end() && pRawBuffer==NULL) {
- if ((*buffer)->fTotalSize>=reqSize && ((*buffer)->fTotalSize-reqSize)<fgMargin) {
+ if ((*buffer)->CheckSize(reqSize)) {
// assign this element
pRawBuffer=*buffer;
- pRawBuffer->fSize=size;
+ pRawBuffer->UseBuffer(size);
fgFreeBuffers.erase(buffer);
- 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->fTotalSize, pRawBuffer->fPtr);
+ 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());
fgActiveBuffers.push_back(pRawBuffer);
break;
}
}
if (pRawBuffer==NULL) {
// no buffer found, create a new one
- pRawBuffer=new AliHLTRawBuffer;
+ pRawBuffer=new AliHLTRawBuffer(reqSize);
if (pRawBuffer) {
- pRawBuffer->fPtr=static_cast<AliHLTUInt8_t*>(malloc(reqSize));
- if (pRawBuffer->fPtr) {
- pRawBuffer->fSize=size;
- pRawBuffer->fTotalSize=reqSize;
+ if (pRawBuffer->GetPointer()) {
+ pRawBuffer->UseBuffer(size);
fgActiveBuffers.push_back(pRawBuffer);
- fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "new raw buffer %p of size %d created (container %p)", pRawBuffer->fPtr, pRawBuffer->fTotalSize, pRawBuffer);
+ fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "new raw buffer %p of size %d created (container %p)", pRawBuffer->GetPointer(), pRawBuffer->GetTotalSize(), pRawBuffer);
} else {
delete pRawBuffer;
pRawBuffer=NULL;
}
}
if (pRawBuffer!=NULL && fgkSafetyPatternSize>0) {
- //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "writing safety pattern to %p offset %d", pRawBuffer->fPtr, pRawBuffer->fSize);
- memcpy(((char*)pRawBuffer->fPtr)+pRawBuffer->fSize, fgkSafetyPattern, fgkSafetyPatternSize);
+ //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "writing safety pattern to %p offset %d", (*buffer)->GetPointer(), (*buffer)->GetUsedSize());
+ int res=pRawBuffer->WritePattern(fgkSafetyPattern, fgkSafetyPatternSize);
+ assert(res>=0);
}
return pRawBuffer;
}
// see header file for function documentation
int iResult=0;
if (pBuffer) {
- vector<AliHLTRawBuffer*>::iterator buffer=fgActiveBuffers.begin();
+ AliHLTRawBufferPList::iterator buffer=fgActiveBuffers.begin();
while (buffer!=fgActiveBuffers.end() && (*buffer)!=pBuffer) {
buffer++;
}
if (buffer!=fgActiveBuffers.end()) {
if (fgkSafetyPatternSize>0) {
- //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "comparing safety pattern at %p offset %d", (*buffer)->fPtr, (*buffer)->fSize);
- if (memcmp(((char*)(*buffer)->fPtr)+(*buffer)->fSize, fgkSafetyPattern, fgkSafetyPatternSize)!=0) {
- fgLogging.Logging(kHLTLogFatal, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "component has written beyond end of data buffer %p size %d", (*buffer)->fPtr, (*buffer)->fSize);
+ //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "comparing safety pattern at %p offset %d", (*buffer)->GetPointer(), reinterpret_cast<AliHLTUInt32_t>(*buffer));
+ if ((*buffer)->CheckPattern(fgkSafetyPattern, fgkSafetyPatternSize)) {
+ fgLogging.Logging(kHLTLogFatal, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "component has written beyond end of data buffer %p size %d", (*buffer)->GetPointer(), (*buffer)->GetUsedSize());
}
}
- (*buffer)->fSize=0;
+ (*buffer)->Reset();
fgFreeBuffers.push_back(*buffer);
fgActiveBuffers.erase(buffer);
} else {
{
// see header file for function documentation
int iResult=0;
- vector<AliHLTRawBuffer*>::iterator buffer=fgFreeBuffers.begin();
- while (buffer!=fgFreeBuffers.end()) {
- free((*buffer)->fPtr);
+// int iTotalSize=0;
+// int iCount=fgFreeBuffers.size()+fgActiveBuffers.size();
+ AliHLTRawBufferPList::iterator buffer;;
+ while ((buffer=fgFreeBuffers.begin())!=fgFreeBuffers.end()) {
+// iTotalSize+=(*buffer)->GetTotalSize();
delete *buffer;
fgFreeBuffers.erase(buffer);
- buffer=fgFreeBuffers.begin();
}
- buffer=fgActiveBuffers.begin();
- while (buffer!=fgActiveBuffers.end()) {
- fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "request to delete active raw buffer container (raw buffer %p, size %d)", (*buffer)->fPtr, (*buffer)->fTotalSize);
- free((*buffer)->fPtr);
+ while ((buffer=fgActiveBuffers.begin())!=fgActiveBuffers.end()) {
+// iTotalSize+=(*buffer)->GetTotalSize();
+ fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "request to delete active raw buffer container (raw buffer %p, size %d)", (*buffer)->GetPointer(), (*buffer)->GetTotalSize());
delete *buffer;
fgActiveBuffers.erase(buffer);
- buffer=fgActiveBuffers.begin();
}
+// fgLogging.Logging(kHLTLogInfo, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "Total memory allocation: %d byte in %d buffers", iTotalSize, iCount);
return iResult;
}
-AliHLTConsumerDescriptor* AliHLTDataBuffer::FindConsumer(const AliHLTComponent* pConsumer, vector<AliHLTConsumerDescriptor*> &list) const
+AliHLTConsumerDescriptor* AliHLTDataBuffer::FindConsumer(const AliHLTComponent* pConsumer, AliHLTConsumerDescriptorPList &list) const
{
// see header file for function documentation
AliHLTConsumerDescriptor* pDesc=NULL;
- vector<AliHLTConsumerDescriptor*>::iterator desc=list.begin();
+ AliHLTConsumerDescriptorPList::iterator desc=list.begin();
while (desc!=list.end() && pDesc==NULL) {
if ((pConsumer==NULL || (*desc)->GetComponent()==pConsumer)) {
pDesc=*desc;
fpBuffer=NULL;
// cleanup consumer states
- vector<AliHLTConsumerDescriptor*>::iterator desc;
+ AliHLTConsumerDescriptorPList::iterator desc;
// if (GetNofPendingConsumers()>0) {
// desc=fConsumers.begin();
// while (desc!=fConsumers.end()) {
}
// cleanup segments
- vector<AliHLTDataBuffer::AliHLTDataSegment>::iterator segment=fSegments.begin();
+ AliHLTDataSegmentList::iterator segment=fSegments.begin();
while (segment!=fSegments.end()) {
fSegments.erase(segment);
segment=fSegments.begin();
}
// this is the version which works on lists of components instead of consumer descriptors
-// int AliHLTDataBuffer::ChangeConsumerState(AliHLTComponent* pConsumer, vector<AliHLTComponent*> &srcList, vector<AliHLTComponent*> &tgtList)
+// int AliHLTDataBuffer::ChangeConsumerState(AliHLTComponent* pConsumer, AliHLTComponentPList &srcList, AliHLTComponentPList &tgtList)
// {
// int iResult=0;
// if (pDesc) {
-// vector<AliHLTComponent*>::iterator desc=srcList.begin();
+// AliHLTComponentPList::iterator desc=srcList.begin();
// while (desc!=srcList.end()) {
// if ((*desc)==pConsumer) {
// srcList.erase(desc);
// return iResult;
// }
-int AliHLTDataBuffer::ChangeConsumerState(AliHLTConsumerDescriptor* pDesc, vector<AliHLTConsumerDescriptor*> &srcList, vector<AliHLTConsumerDescriptor*> &tgtList)
+int AliHLTDataBuffer::ChangeConsumerState(AliHLTConsumerDescriptor* pDesc, AliHLTConsumerDescriptorPList &srcList, AliHLTConsumerDescriptorPList &tgtList)
{
// see header file for function documentation
int iResult=-ENOENT;
if (pDesc) {
- vector<AliHLTConsumerDescriptor*>::iterator desc=srcList.begin();
+ AliHLTConsumerDescriptorPList::iterator desc=srcList.begin();
while (desc!=srcList.end()) {
if ((*desc)==pDesc) {
srcList.erase(desc);
// see header file for function documentation
int iResult=0;
ResetDataBuffer();
- vector<AliHLTConsumerDescriptor*>::iterator desc=fConsumers.begin();
+ AliHLTConsumerDescriptorPList::iterator desc=fConsumers.begin();
while (desc!=fConsumers.end()) {
delete *desc;
fConsumers.erase(desc);
int AliHLTDataBuffer::FindConsumer(AliHLTComponent* pConsumer, int bAllLists)
{
// see header file for function documentation
- vector<AliHLTConsumerDescriptor*>::iterator desc=fConsumers.begin();
+ AliHLTConsumerDescriptorPList::iterator desc=fConsumers.begin();
while (desc!=fConsumers.end()) {
if ((*desc)->GetComponent()==pConsumer)
return 1;
return 0;
}
-int AliHLTDataBuffer::AliHLTRawBuffer::operator==(void* ptr)
+AliHLTDataBuffer::AliHLTRawBuffer::AliHLTRawBuffer(AliHLTUInt32_t size)
+ :
+ fSize(0),
+ fTotalSize(size),
+ fPtr(static_cast<AliHLTUInt8_t*>(malloc(size)))
+{
+ // see header file for class documentation
+ // or
+ // refer to README to build package
+ // or
+ // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+ if (fPtr==NULL) {
+ fSize=0;
+ fTotalSize=0;
+ }
+}
+
+AliHLTDataBuffer::AliHLTRawBuffer::~AliHLTRawBuffer()
+{
+ if (fPtr) {
+ free(fPtr);
+ }
+ fPtr=NULL;
+ fSize=0;
+ fTotalSize=0;
+}
+
+int AliHLTDataBuffer::AliHLTRawBuffer::operator==(void* ptr) const
{
+ // see header file for function documentation
return fPtr == static_cast<AliHLTUInt8_t*>(ptr);
}
-int AliHLTDataBuffer::AliHLTRawBuffer::operator<=(void* ptr)
+int AliHLTDataBuffer::AliHLTRawBuffer::operator<=(void* ptr) const
{
+ // see header file for function documentation
int iResult=fPtr <= static_cast<AliHLTUInt8_t*>(ptr);
//printf("%p: %p <= %p (%d)\n", this, fPtr, ptr, iResult);
return iResult;
}
-int AliHLTDataBuffer::AliHLTRawBuffer::operator>(void* ptr)
+int AliHLTDataBuffer::AliHLTRawBuffer::operator>(void* ptr) const
{
+ // see header file for function documentation
int iResult=fPtr+fSize > static_cast<AliHLTUInt8_t*>(ptr);
//printf("%p: %p + %d > %p (%d)\n", this, fPtr, fSize, ptr, iResult);
return iResult;
}
-int AliHLTDataBuffer::AliHLTRawBuffer::operator-(void* ptr)
+int AliHLTDataBuffer::AliHLTRawBuffer::operator-(void* ptr) const
{
+ // see header file for function documentation
return static_cast<int>(static_cast<AliHLTUInt8_t*>(ptr)-fPtr);
}
+
+AliHLTUInt8_t* AliHLTDataBuffer::AliHLTRawBuffer::UseBuffer(AliHLTUInt32_t size)
+{
+ // see header file for function documentation
+ if (size>0 && fTotalSize>=size) {
+ fSize=size;
+ return fPtr;
+ }
+ return NULL;
+}
+
+int AliHLTDataBuffer::AliHLTRawBuffer::CheckSize(AliHLTUInt32_t size) const
+{
+ // see header file for function documentation
+ return fTotalSize>=size && ((fTotalSize-size)<fgMargin);
+}
+
+int AliHLTDataBuffer::AliHLTRawBuffer::Reset()
+{
+ // see header file for function documentation
+ fSize=0;
+ return 0;
+}
+
+int AliHLTDataBuffer::AliHLTRawBuffer::WritePattern(const char* pattern, int size)
+{
+ // see header file for function documentation
+ int iResult=0;
+ if (pattern!=NULL && size>0) {
+ if (fSize+size<=fTotalSize) {
+ memcpy(((char*)fPtr)+fSize, pattern, size);
+ iResult=size;
+ } else {
+ iResult=-ENOSPC;
+ }
+ }
+ return iResult;
+}
+
+int AliHLTDataBuffer::AliHLTRawBuffer::CheckPattern(const char* pattern, int size) const
+{
+ // see header file for function documentation
+ int iResult=0;
+ if (pattern!=NULL && size>0) {
+ if (fSize+size<=fTotalSize) {
+ iResult=memcmp(((char*)fPtr)+fSize, pattern, size)!=0;
+ } else {
+ iResult=-ENOSPC;
+ }
+ }
+ return iResult;
+}