//* provided "as is" without express or implied warranty. *
//**************************************************************************
-/** @file AliHLTDataBuffer.cxx
- @author Matthias Richter
- @date
- @brief Handling of Data Buffers for HLT components.
-*/
+// @file AliHLTDataBuffer.cxx
+// @author Matthias Richter
+// @date
+// @brief Handling of Data Buffers for HLT components.
+// @note Only used in the AliRoot framework
+
+// 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 __GNUC__>= 3
using namespace std;
//#include <string>
//#include "AliHLTSystem.h"
+#define USE_ALIHLTRAWPAGE
+
typedef vector<AliHLTDataBuffer::AliHLTDataSegment> AliHLTDataSegmentList;
/** ROOT macro for the implementation of ROOT specific class methods */
AliHLTDataBuffer::~AliHLTDataBuffer()
{
// see header file for function documentation
+ CleanupConsumerList();
+
if (--fgNofInstances<=0) {
DeleteRawBuffers();
}
- CleanupConsumerList();
}
int AliHLTDataBuffer::SetConsumer(AliHLTComponent* pConsumer)
return iResult;
}
-int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector<AliHLTDataBuffer::AliHLTDataSegment>& tgtList)
+int AliHLTDataBuffer::FindMatchingDataSegments(const AliHLTComponent* pConsumer, AliHLTDataSegmentList& tgtList)
{
// see header file for function documentation
int iResult=0;
}
}
// to be enabled if unit test is ready
- //iResult=SetRawBufferDataSize(fpBuffer, maxSize);
+#ifdef USE_ALIHLTRAWPAGE
+ iResult=SetRawBufferDataSize(fpBuffer, maxSize);
+#endif //USE_ALIHLTRAWPAGE
} else {
HLTError("this data buffer (%p) does not match the internal data buffer %p of raw buffer %p", pTgt, fpBuffer->GetPointer(), fpBuffer);
iResult=-EINVAL;
// see header file for function documentation
AliHLTRawBuffer* pRawBuffer=NULL;
unsigned int reqSize=size+fgkSafetyPatternSize;
+#ifndef USE_ALIHLTRAWPAGE
AliHLTRawBufferPList::iterator buffer=fgFreeBuffers.begin();
while (buffer!=fgFreeBuffers.end() && pRawBuffer==NULL) {
if ((*buffer)->CheckSize(reqSize)) {
fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "memory allocation failed");
}
}
+#else
+ pRawBuffer=AliHLTDataBuffer::AliHLTRawPage::GlobalAlloc(reqSize);
+ if (pRawBuffer) {
+ pRawBuffer->UseBuffer(size);
+ }
+#endif
if (pRawBuffer!=NULL && fgkSafetyPatternSize>0) {
//fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::CreateRawBuffer", "data buffer handling", "writing safety pattern to %p offset %d", (*buffer)->GetPointer(), (*buffer)->GetUsedSize());
pRawBuffer->WritePattern(fgkSafetyPattern, fgkSafetyPatternSize);
}
}
// shrink the buffer and write new pattern at the end
+#ifdef USE_ALIHLTRAWPAGE
+ AliHLTDataBuffer::AliHLTRawPage* rawpage=AliHLTDataBuffer::AliHLTRawPage::FindPage(pBuffer);
+ if (rawpage) {
+ pBuffer->UseBuffer(size);
+ if (rawpage->SetSize(pBuffer, size+fgkSafetyPatternSize)==0) {
+ // nothing to do
+ } else {
+ fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::SetRawBufferDataSize", "data buffer handling", "failed to set size for raw buffer %p", pBuffer);
+ iResult=-EFAULT;
+ }
+ } else {
+ fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::SetRawBufferDataSize", "data buffer handling", "can not find raw page for buffer %p", pBuffer);
+ iResult=-ENOENT;
+ }
+#else //!USE_ALIHLTRAWPAGE
pBuffer->UseBuffer(size);
+#endif //USE_ALIHLTRAWPAGE
if (fgkSafetyPatternSize>0) {
pBuffer->WritePattern(fgkSafetyPattern, fgkSafetyPatternSize);
}
// see header file for function documentation
int iResult=0;
if (pBuffer) {
+#ifdef USE_ALIHLTRAWPAGE
+ AliHLTDataBuffer::AliHLTRawPage* rawpage=AliHLTDataBuffer::AliHLTRawPage::FindPage(pBuffer);
+ if (rawpage)
+#else //!USE_ALIHLTRAWPAGE
AliHLTRawBufferPList::iterator buffer=fgActiveBuffers.begin();
while (buffer!=fgActiveBuffers.end() && (*buffer)!=pBuffer) {
buffer++;
}
- if (buffer!=fgActiveBuffers.end()) {
+ if (buffer!=fgActiveBuffers.end())
+#endif //USE_ALIHLTRAWPAGE
+ {
if (fgkSafetyPatternSize>0) {
- //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());
+ //fgLogging.Logging(kHLTLogDebug, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "comparing safety pattern at %p offset %d", pBuffer->GetPointer(), reinterpret_cast<AliHLTUInt32_t>(pBuffer));
+ if ((pBuffer)->CheckPattern(fgkSafetyPattern, fgkSafetyPatternSize)) {
+ fgLogging.Logging(kHLTLogFatal, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "component has written beyond end of data buffer %p size %d", pBuffer->GetPointer(), pBuffer->GetUsedSize());
}
}
- (*buffer)->Reset();
- fgFreeBuffers.push_back(*buffer);
+ pBuffer->Reset();
+#ifdef USE_ALIHLTRAWPAGE
+ if (rawpage->Free(pBuffer)==0) {
+ } else {
+ fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "failed to release raw buffer %p", pBuffer);
+ }
+#else //!USE_ALIHLTRAWPAGE
+ fgFreeBuffers.push_back(pBuffer);
fgActiveBuffers.erase(buffer);
+#endif //USE_ALIHLTRAWPAGE
} else {
+#ifdef USE_ALIHLTRAWPAGE
+ fgLogging.Logging(kHLTLogError, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "can not find raw page for buffer %p", pBuffer);
+#else //!USE_ALIHLTRAWPAGE
fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "can not find raw buffer container %p in the list of active containers", pBuffer);
+#endif //USE_ALIHLTRAWPAGE
iResult=-ENOENT;
}
} else {
#ifdef ALIHLTSYSTEM_PROFILING
iTotalSize+=(*buffer)->GetTotalSize();
#endif //ALIHLTSYSTEM_PROFILING
- fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "request to delete active raw buffer container (raw buffer %p, size %d)", (*buffer)->GetPointer(), (*buffer)->GetTotalSize());
+ fgLogging.Logging(kHLTLogWarning, "AliHLTDataBuffer::DeleteRawBuffer", "data buffer handling", "request to delete active raw buffer container (raw buffer %p, size %d)", (*buffer)->GetPointer(), (*buffer)->GetTotalSize());
delete *buffer;
fgActiveBuffers.erase(buffer);
}
#ifdef ALIHLTSYSTEM_PROFILING
- fgLogging.Logging(kHLTLogImportant, "AliHLTDataBuffer::ReleaseRawBuffer", "data buffer handling", "Total memory allocation: %d byte in %d buffers", iTotalSize, iCount);
+ fgLogging.Logging(kHLTLogImportant, "AliHLTDataBuffer::DeleteRawBuffer", "data buffer handling", "Total memory allocation: %d byte in %d buffers", iTotalSize, iCount);
#endif //ALIHLTSYSTEM_PROFILING
return iResult;
}
{
// see header file for function documentation
int iResult=0;
+#ifdef USE_ALIHLTRAWPAGE
+ int nofPages=0;
+ AliHLTUInt32_t totalSize=0;
+ for (AliHLTDataBuffer::AliHLTRawPage* rawpage=AliHLTDataBuffer::AliHLTRawPage::NextPage(NULL);
+ rawpage!=NULL;
+ rawpage=AliHLTDataBuffer::AliHLTRawPage::NextPage(rawpage)) {
+ nofPages++;
+ totalSize+=rawpage->Size();
+ }
+ //if (rawpage) rawpage->Print("global");
+ fgLogging.Logging(kHLTLogInfo, "AliHLTDataBuffer::PrintStatistics", "data buffer handling", "total number of memory pages: %d total size %d", nofPages, totalSize);
+
+#else //! USE_ALIHLTRAWPAGE
int iFree=0;
int iActive=0;
AliHLTRawBufferPList::iterator buffer;;
iActive+=(*buffer)->GetTotalSize();
}
fgLogging.Logging(kHLTLogInfo, "AliHLTDataBuffer::PrintStatistics", "data buffer handling", "Total memory allocation: %d byte; %d free buffers (%d byte) - %d active buffers (%d byte) ", iFree+iActive, fgFreeBuffers.size(), iFree, fgActiveBuffers.size(), iActive);
+#endif // USE_ALIHLTRAWPAGE
return iResult;
}
AliHLTDataBuffer::AliHLTRawBuffer::~AliHLTRawBuffer()
{
+ // see header file for class documentation
if (fExternalPtr==NULL && fPtr) {
free(fPtr);
}
// split a buffer at specified size
// only possible for buffers with external memory
if (fTotalSize>size &&
- (fSize==0 || fSize<size) &&
+ (fSize==0 || fSize<=size) &&
fExternalPtr!=NULL) {
AliHLTRawBuffer* part2=new AliHLTRawBuffer(fTotalSize-size, fPtr+size);
if (part2) {
fTotalSize=size;
}
return part2;
+ } else {
+ cout << "can not split fTotalSize=" << fTotalSize << " fSize=" << fSize << " at size=" << size << endl;
}
return NULL;
}
iter!=fUsedBuffers.end() && iResult>=0;
iter++) {
if ((*iter)==pBuffer) {
- if (false/*pBuffer->GetTotalSize()==0*/) {
- HLTInfo("release zero lenght buffer %p %d (used %d)", pBuffer, pBuffer->GetTotalSize(), pBuffer->GetUsedSize());
- pBuffer->Print("");
- Print("");
- }
fUsedBuffers.erase(iter);
AliHLTRawBufferPList::iterator prev=fFreeBuffers.begin();
for (; prev!=fFreeBuffers.end() && iResult>=0; prev++) {
- if (false/*pBuffer->GetTotalSize()==0*/) {
- HLTInfo("iterator buffer %p %d (used %d)", (*prev), (*prev)->GetTotalSize(), (*prev)->GetUsedSize());
- (*prev)->Print("");
- }
if ((*pBuffer)<(*(*prev)) ||
((*prev)->GetTotalSize()==0 && pBuffer->GetPointer()<=(*prev)->GetPointer() && (*prev)->GetPointer()<=pBuffer->GetPointer()+pBuffer->GetTotalSize())) {
// check consecutive buffers
// check consecutive buffers
if ((*pBuffer) == ((*prev)->GetPointer()+(*prev)->GetTotalSize())||
(pBuffer->GetTotalSize()==0 && (*prev)->GetPointer()<=pBuffer->GetPointer() && pBuffer->GetPointer()<=(*prev)->GetPointer()+(*prev)->GetTotalSize())) {
- if (false/*pBuffer->GetTotalSize()==0*/) {
- HLTInfo("merge with buffer %p %d (used %d)", (*prev), (*prev)->GetTotalSize(), (*prev)->GetUsedSize());
- }
// the buffer to be released is consecutive to a free buffer -> merge them
if ((iResult=pBuffer->Merge(*(*prev)))>=0) {
AliHLTRawBufferPList::iterator succ=prev+1;
}
}
if (prev==fFreeBuffers.end()) {
- if (false/*pBuffer->GetTotalSize()==0*/) {
- HLTInfo("insert as free buffer");
- Print("");
- }
fFreeBuffers.push_back(pBuffer);
}
return 1;
}
-int AliHLTDataBuffer::AliHLTRawPage::SetSize(AliHLTDataBuffer::AliHLTRawBuffer* pBuffer, AliHLTUInt32_t size)
+int AliHLTDataBuffer::AliHLTRawPage::SetSize(const AliHLTDataBuffer::AliHLTRawBuffer* pBuffer, AliHLTUInt32_t size)
{
/// set the size of a raw buffer and release the remaining part
int iResult=0;
HLTError("%d exceeds total size of buffer %p (%d used %d)\n", size, *iter, (*iter)->GetTotalSize(), (*iter)->GetUsedSize());
return -ENOSPC;
}
- //HLTInfo("setting size %d of buffer %p (%d used %d)", size, *iter, (*iter)->GetTotalSize(), (*iter)->GetUsedSize());
AliHLTDataBuffer::AliHLTRawBuffer* freespace=(*iter)->Split(size);
- //(*iter)->Print("");
if (freespace) {
- //freespace->Print("");
fUsedBuffers.push_back(freespace);
Free(freespace);
} else {
return 1;
}
-bool AliHLTDataBuffer::AliHLTRawPage::HasBuffer(AliHLTDataBuffer::AliHLTRawBuffer* pBuffer)
+bool AliHLTDataBuffer::AliHLTRawPage::HasBuffer(const AliHLTDataBuffer::AliHLTRawBuffer* pBuffer)
{
/// check if the buffer is in this page
for (AliHLTRawBufferPList::iterator iter=fUsedBuffers.begin();
}
}
if (!rawbuffer) {
- AliHLTDataBuffer::AliHLTRawPage* rawpage=new AliHLTDataBuffer::AliHLTRawPage(fgGlobalPageSize);
+ AliHLTUInt32_t rawPageSize=fgGlobalPageSize;
+ if (rawPageSize<size) {
+ if (rawPageSize*10<size ||
+ rawPageSize*10>1024*1024*1024) {
+ log.Logging(kHLTLogError, "AliHLTDataBuffer::AliHLTRawPage::GlobalAlloc", "data buffer handling", "refusing to allocate buffer of size", size);
+ return NULL;
+ }
+ rawPageSize=size;
+ }
+ AliHLTDataBuffer::AliHLTRawPage* rawpage=new AliHLTDataBuffer::AliHLTRawPage(rawPageSize);
if (!rawpage) {
log.Logging(kHLTLogError, "AliHLTDataBuffer::AliHLTRawPage::GlobalAlloc", "data buffer handling", "can not create raw page");
return NULL;
return 0;
}
-AliHLTDataBuffer::AliHLTRawPage* AliHLTDataBuffer::AliHLTRawPage::NextPage(AliHLTDataBuffer::AliHLTRawPage* prev)
+AliHLTDataBuffer::AliHLTRawPage* AliHLTDataBuffer::AliHLTRawPage::NextPage(const AliHLTDataBuffer::AliHLTRawPage* prev)
{
// get next global page
vector<AliHLTDataBuffer::AliHLTRawPage*>::iterator page=fgGlobalPages.begin();