@note The class is used in Offline (AliRoot) context
*/
-#include <cerrno>
+// see below for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
#include <vector>
+#include "TObject.h"
#include "AliHLTLogging.h"
#include "AliHLTDataTypes.h"
-#include "AliHLTDefinitions.h"
-#include "TObject.h"
-//#include "TList.h"
-
-class AliHLTComponent;
-/* @name internal data structures
- */
-
-/**
- * @struct AliHLTDataSegment
- * @brief Descriptor of a data segment within the buffer.
- * @ingroup alihlt_system
- */
-struct AliHLTDataSegment {
- AliHLTDataSegment()
- :
- fDataType(),
- fSegmentOffset(0),
- fSegmentSize(0),
- fSpecification(0)
- {
- memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
- }
- AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size)
- :
- fDataType(),
- fSegmentOffset(offset),
- fSegmentSize(size),
- fSpecification(0)
- {
- memset(&fDataType, 0, sizeof(AliHLTComponentDataType));
- }
- /** the data type of this segment */
- AliHLTComponentDataType fDataType; // see above
- /** offset in byte within the data buffer */
- AliHLTUInt32_t fSegmentOffset; // see above
- /** size of the actual content */
- AliHLTUInt32_t fSegmentSize; // see above
- /** data specification */
- AliHLTUInt32_t fSpecification; // see above
-};
-
-/**
- * @struct AliHLTRawBuffer
- * @brief Descriptor of the raw data buffer which can host several segments.
- * @ingroup alihlt_system
- */
-struct AliHLTRawBuffer {
- /** size of the currently occupied partition of the buffer */
- AliHLTUInt32_t fSize; // see above
- /** total size of the buffer, including safety margin */
- AliHLTUInt32_t fTotalSize; // see above
- /** the buffer */
- void* fPtr; //! transient
-};
-
-/**
- * @class AliHLTConsumerDescriptor
- * @brief Helper class to describe a consumer component.
- *
- * There is unfortunately no unique determination of the data type from the
- * component itself possible, thats why both component and data type have to
- * be initialized and are stored in a compound. The class is intended to make
- * bookkeeping easier.
- *
- * @note This class is only used for the @ref alihlt_system.
- *
- * @ingroup alihlt_system
- */
-class AliHLTConsumerDescriptor : public TObject, public AliHLTLogging {
- public:
- /** standard constructur */
- AliHLTConsumerDescriptor();
- /** constructur
- * @param pConsumer pointer to the consumer component
- */
- AliHLTConsumerDescriptor(AliHLTComponent* pConsumer);
- /** not a valid copy constructor, defined according to effective C++ style */
- AliHLTConsumerDescriptor(const AliHLTConsumerDescriptor&);
- /** not a valid assignment op, but defined according to effective C++ style */
- AliHLTConsumerDescriptor& operator=(const AliHLTConsumerDescriptor&);
- /** destructor */
- ~AliHLTConsumerDescriptor();
-
- /**
- * Get the component of this descriptor.
- * @return pointer to the component
- */
- AliHLTComponent* GetComponent() {return fpConsumer;}
-
- /**
- * Set an active data segment.
- * the pointer will be handled in a container, no allocation, copy or
- * cleanup.
- * @param offset offset of the segment in the buffer
- * @param size size of the segment in the buffer
- * @return >=0 if succeeded
- */
- int SetActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
- /**
- * Check whether there is an active data segment of certain size with
- * certain offset.
- * @param offset offset of the data segment in the data buffer
- * @param size size of the data segment in the data buffer
- * @return > if existend, 0 if not
- */
- int CheckActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
-
- /** find an active data segment of certain size with certain offset
- * will see if this is necessary
- * @param offset offset of the data segment in the data buffer
- * @param size size of the data segment in the data buffer
- * @return offset of the data segment
- */
- //AliHLTUInt32_t FindActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+#include "AliHLTComponent.h"
- /** get the number of active segments for this consumer
- * @return number of active segments
- */
- int GetNofActiveSegments() {return fSegments.size();};
+class AliHLTConsumerDescriptor;
+class AliHLTTask;
- /**
- */
- int ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size);
+/** list of AliHLTConsumerDescriptor pointers */
+typedef vector<AliHLTConsumerDescriptor*> AliHLTConsumerDescriptorPList;
- private:
- /** consumer object */
- AliHLTComponent* fpConsumer; //! transient
-
- /** list of data segments */
- vector<AliHLTDataSegment> fSegments; // see above
-
- //ClassDef(AliHLTConsumerDescriptor, 0)
-};
+typedef AliHLTUInt8_t* AliHLTUInt8Pointer_t;
/**
* @class AliHLTDataBuffer
*
* @ingroup alihlt_system
*/
-class AliHLTDataBuffer : public TObject, public AliHLTLogging {
+class AliHLTDataBuffer : public TObject, public AliHLTLogging
+{
public:
//////////////////////////////////////////////////////////////////////////////
- // condtructors and destructors
+ // constructors and destructors
/* standard constructor
*/
AliHLTDataBuffer();
- /** not a valid copy constructor, defined according to effective C++ style */
- AliHLTDataBuffer(const AliHLTDataBuffer&);
- /** not a valid assignment op, but defined according to effective C++ style */
- AliHLTDataBuffer& operator=(const AliHLTDataBuffer&);
/** destructor */
virtual ~AliHLTDataBuffer();
* -EINVAL invalid parameter <br>
*/
int FindMatchingDataBlocks(const AliHLTComponent* pConsumer,
- vector<AliHLTComponentDataType>* tgtList=NULL);
+ AliHLTComponentDataTypeList* tgtList=NULL);
/**
* Subscribe to a segment of the data buffer.
* would have been prepared if there was enough space in the array<br>
* The method is used by the consumer component.
* @param pConsumer the component which subscribes to the buffer
- * @param arrayBlockDesc pointer to block descriptor to be filled
- * @param iArraySize size of the block descriptor array
+ * @param blockDescList block descriptor vector to be filled
* @return: number of matching data blocks, neg. error code if failed<br>
* -EACCESS the consumer state can't be changed (activated)
* -EBADF unresolved data segments <br>
* -EINVAL invalid parameter <br>
*/
int Subscribe(const AliHLTComponent* pConsumer,
- AliHLTComponentBlockData* arrayBlockDesc,
- int iArraySize);
+ AliHLTComponentBlockDataList& blockDescList);
/**
* Release an instance of the data buffer.
* The method is used by the consumer component.
* @param pBlockDesc descriptor of the data segment
* @param pConsumer the component which subscribes to the buffer
+ * @param pOwnerTask task owning this buffer
* @return: >0 if success, negative error code if failed <br>
* -EACCESS the consumer state can not be changed (de-activated)
* -ENOENT consumer has not subscribed to the buffer <br>
* -EINVAL invalid parameter <br>
*/
- int Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer);
+ int Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer,
+ const AliHLTTask* pOwnerTask);
+
+ /**
+ * Release a forwarded data block.
+ */
+ int ReleaseForwardedBlock(AliHLTComponentBlockData* pBlockDesc,
+ const AliHLTTask* pOwnerTask);
+
+ /**
+ * Register an input data block for forwarding.
+ * Consumer of this data buffer subscribe to forwarded data blocks in te same way.
+ * Forwarded data blocks are released when the last consumer has released the
+ * blocks.
+ * @param pSrcTask original source task of the data block
+ * @param pBlockDesc descriptor of the data segment
+ */
+ int Forward(AliHLTTask* pSrcTask, AliHLTComponentBlockData* pBlockDesc);
/**
* Get a target buffer of minimum size iMinSize.
//int GetTotalSize();
/**
- * Get the number of segments
+ * Get the number of segments including the forwarded data blocks.
* @return number of segments
*/
int GetNofSegments();
/**
- * Get the number of consumers
+ * Get the total number of consumers.
+ * This gives the number of consumers regardless of their state.
* @return number of consumers
*/
int GetNofConsumers();
/**
- * Get the number of active consumers
+ * Get the number of consumers which still need to be processed during
+ * the current event.
+ * @return number of consumers
+ */
+ int GetNofPendingConsumers();
+
+ /**
+ * Get the number of consumers currently under processing.
* @return number of active consumers
*/
int GetNofActiveConsumers();
* search only in fConsumer list if 0
* @return 1 if found, 0 if not
*/
- int FindConsumer(AliHLTComponent* pConsumer, int bAllLists=1);
+ int FindConsumer(const AliHLTComponent* pConsumer, int bAllLists=1);
/**
* Public method to reset the buffer.
*/
int Reset();
+ /**
+ * Set local logging level
+ * logging filter for individual object
+ */
+ void SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
+ {fgLogging.SetLocalLoggingLevel(level); AliHLTLogging::SetLocalLoggingLevel(level);}
+
+ /**
+ * Print summary of the global buffer management.
+ */
+ static int PrintStatistics();
+
+ /**
+ * Set the global event count.
+ * The event count is deployed to find buffers which have not been used
+ * for a while. In such a case to policy to find an appropriate buffer is
+ * adjusted.
+ */
+ static int SetGlobalEventCount(AliHLTUInt32_t eventCount) {fgEventCount=eventCount; return 0;}
+
+ /**
+ * @class AliHLTDataSegment
+ * @brief Descriptor of a data segment within the buffer.
+ */
+ class AliHLTDataSegment {
+ friend class AliHLTDataBuffer;
+ friend class AliHLTConsumerDescriptor;
+ public:
+ AliHLTDataSegment()
+ :
+ fDataType(kAliHLTVoidDataType),
+ fPtr(NULL),
+ fSegmentOffset(0),
+ fSegmentSize(0),
+ fSpecification(0)
+ {
+ }
+
+ AliHLTDataSegment(AliHLTUInt8_t* ptr, AliHLTUInt32_t offset, AliHLTUInt32_t size)
+ :
+ fDataType(kAliHLTVoidDataType),
+ fPtr(ptr),
+ fSegmentOffset(offset),
+ fSegmentSize(size),
+ fSpecification(0)
+ {
+ }
+
+ AliHLTDataSegment(void* ptr, AliHLTUInt32_t offset, AliHLTUInt32_t size)
+ :
+ fDataType(kAliHLTVoidDataType),
+ fPtr((AliHLTUInt8_t*)ptr),
+ fSegmentOffset(offset),
+ fSegmentSize(size),
+ fSpecification(0)
+ {
+ }
+
+ AliHLTDataSegment(void* ptr, AliHLTUInt32_t offset, AliHLTUInt32_t size, AliHLTComponentDataType dt, AliHLTUInt32_t spec)
+ :
+ fDataType(dt),
+ fPtr((AliHLTUInt8_t*)ptr),
+ fSegmentOffset(offset),
+ fSegmentSize(size),
+ fSpecification(spec)
+ {
+ }
+
+ AliHLTUInt8_t* GetPtr() const {return (AliHLTUInt8_t*)*this;}
+
+ AliHLTUInt32_t GetSize() const {return fSegmentSize;}
+
+ int operator==(const AliHLTDataSegment& seg) const
+ {
+ return (fPtr+fSegmentOffset==seg.fPtr+seg.fSegmentOffset) && (fSegmentSize==seg.fSegmentSize);
+ }
+ operator AliHLTUInt8_t*() const {return fPtr+fSegmentOffset;}
+
+ private:
+ /** the data type of this segment */
+ AliHLTComponentDataType fDataType; // see above
+ /** pointer to the buffer */
+ AliHLTUInt8Pointer_t fPtr; //!transient
+ /** offset in byte within the data buffer */
+ AliHLTUInt32_t fSegmentOffset; // see above
+ /** size of the actual content */
+ AliHLTUInt32_t fSegmentSize; // see above
+ /** data specification */
+ AliHLTUInt32_t fSpecification; // see above
+ };
+
+ class AliHLTRawBuffer;
+ typedef vector<AliHLTRawBuffer*> AliHLTRawBufferPList;
+
+ /**
+ * @class AliHLTRawPage
+ * Memory allocation is organized in pages of a fixed size. Within a
+ * page, AliHLTRawBuffer chunks are created.
+ */
+ class AliHLTRawPage : public AliHLTLogging {
+ public:
+ /** standard constructor */
+ AliHLTRawPage() : fSize(0), fPtr(NULL), fFreeBuffers(), fUsedBuffers() {}
+ /** constructor */
+ AliHLTRawPage(AliHLTUInt32_t pagesize);
+ /** destructor */
+ virtual ~AliHLTRawPage();
+
+ /** alloc a buffer of specified size from the global pages*/
+ static AliHLTRawBuffer* GlobalAlloc(AliHLTUInt32_t size, int verbosity=0);
+ /** find buffer in the global pages */
+ static AliHLTRawPage* FindPage(AliHLTRawBuffer* buffer);
+ /** cleanup the global pages */
+ static int GlobalClean();
+ /** adjust global page size */
+ static void SetGlobalPageSize(AliHLTUInt32_t size) {fgGlobalPageSize=size;}
+ /** find next page after prev, or first page */
+ static AliHLTRawPage* NextPage(AliHLTRawPage* prev=NULL);
+
+ /** alloc a buffer of specified size */
+ AliHLTRawBuffer* Alloc(AliHLTUInt32_t size);
+ /** free a buffer and merge consecutive free buffers */
+ int Free(AliHLTRawBuffer* pBuffer);
+ /** set the size of a raw buffer and release the remaining part */
+ int SetSize(AliHLTRawBuffer* pBuffer, AliHLTUInt32_t size);
+ /// check if the buffer is in this page
+ bool HasBuffer(AliHLTRawBuffer* pBuffer);
+
+ AliHLTUInt32_t Size() const {return fSize;}
+ AliHLTUInt32_t Capacity() const;
+ bool IsUsed() const {return fUsedBuffers.size()>0;}
+ bool IsFragmented() const {return (fFreeBuffers.size()+fUsedBuffers.size())>1;}
+
+ /**
+ * Print page information
+ */
+ void Print(const char* option);
+
+ private:
+ /** copy constructor prohibited */
+ AliHLTRawPage(const AliHLTRawPage&);
+ /** assignment operator prohibited */
+ AliHLTRawPage& operator=(const AliHLTRawPage&);
+
+ /// list of global pages
+ static vector<AliHLTDataBuffer::AliHLTRawPage*> fgGlobalPages; //! transient
+ /// pages size of global pages
+ static AliHLTUInt32_t fgGlobalPageSize; //! transient
+
+ /** page size */
+ AliHLTUInt32_t fSize; // see above
+ /** the memory segment */
+ AliHLTUInt8_t* fPtr; //! transient
+
+ /** list of free buffers */
+ AliHLTRawBufferPList fFreeBuffers; //! transient
+ /** list of used buffers */
+ AliHLTRawBufferPList fUsedBuffers; //! transient
+ };
+
+ /**
+ * @class AliHLTRawBuffer
+ * @brief Descriptor of the raw data buffer which can host several segments.
+ */
+ class AliHLTRawBuffer {
+ public:
+ /** standard constructor */
+ AliHLTRawBuffer() : fSize(0), fTotalSize(0), fExternalPtr(NULL), fPtr(NULL), fLastEventCount(0) {}
+ /** constructor */
+ AliHLTRawBuffer(AliHLTUInt32_t size);
+ /** constructor */
+ AliHLTRawBuffer(AliHLTUInt32_t size, AliHLTUInt8_t* buffer);
+ /** destructor */
+ virtual ~AliHLTRawBuffer();
+
+ /**
+ * Use a fraction of the buffer.
+ * @param size size in bytes to be used
+ * @return pointer to buffer
+ */
+ AliHLTUInt8_t* UseBuffer(AliHLTUInt32_t size);
+
+ /**
+ * split a buffer at specified size
+ * only possible for buffers with external memory
+ */
+ AliHLTRawBuffer* Split(AliHLTUInt32_t size);
+
+ /**
+ * Check whether buffer fits for a request.
+ * A buffer fits if it is at least of the requested size and at most
+ * the requested size plus a margin. The margin increases with the
+ * number of events the buffer has not been used.
+ * @param size size of the request in bytes
+ * @return 1 if buffer is big enough, 0 if not
+ */
+ int CheckSize(AliHLTUInt32_t size) const;
+
+ /**
+ * Get used size of the buffer
+ */
+ AliHLTUInt32_t GetUsedSize() const {return fSize;}
+
+ /**
+ * Get total size of the buffer
+ */
+ AliHLTUInt32_t GetTotalSize() const {return fTotalSize;}
+
+ /**
+ * Get pointer of data buffer
+ */
+ AliHLTUInt8_t* GetPointer() const {return fPtr;}
+
+ /**
+ * Write check pattern
+ */
+ int WritePattern(const char* pattern, int size);
+
+ /**
+ * Check pattern
+ */
+ int CheckPattern(const char* pattern, int size) const;
+
+ /**
+ * Reset buffer.
+ * Data buffer remains allocated, used size set to 0
+ */
+ int Reset();
+
+ /*
+ * Merge buffer with succeeding buffer.
+ * Only possible if the buffers are consecutive with out any gap.
+ */
+ int Merge(const AliHLTRawBuffer& succ);
+
+ /**
+ * Print buffer information
+ */
+ void Print(const char* option);
+
+ int operator==(void*) const;
+ int operator==(AliHLTUInt8_t* ptr) const {return fPtr==ptr;}
+ int operator<(void*) const;
+ int operator<=(void*) const;
+ int operator>(void*) const;
+ int operator-(void*) const;
+ int operator<(const AliHLTRawBuffer&) const;
+ int operator<=(const AliHLTRawBuffer&) const;
+ int operator>(const AliHLTRawBuffer&) const;
+
+ operator void*() const {return fPtr;}
+ operator AliHLTUInt8_t*() const {return fPtr;}
+
+ private:
+ /** copy constructor prohibited */
+ AliHLTRawBuffer(const AliHLTRawBuffer&);
+ /** assignment operator prohibited */
+ AliHLTRawBuffer& operator=(const AliHLTRawBuffer&);
+
+ /** size of the currently occupied partition of the buffer */
+ AliHLTUInt32_t fSize; // see above
+ /** total size of the buffer, including safety margin */
+ AliHLTUInt32_t fTotalSize; // see above
+ /** optional external buffer */
+ AliHLTUInt8_t* fExternalPtr; //! transient
+ /** the buffer, external or allocated */
+ AliHLTUInt8_t* fPtr; //! transient
+ /** last event count where the buffer has been used */
+ AliHLTUInt32_t fLastEventCount; //! transient
+ };
+
private:
+ /** copy constructor prohibited */
+ AliHLTDataBuffer(const AliHLTDataBuffer&);
+ /** assignment operator prohibited */
+ AliHLTDataBuffer& operator=(const AliHLTDataBuffer&);
+
/* lets see if this is needed
- AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
+ AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype);
*/
/**
* of the consumer, neg. error code if failed <br>
* -EINVAL invalid parameter <br>
*/
- int FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector<AliHLTDataSegment>& tgtList);
+ int FindMatchingDataSegments(const AliHLTComponent* pConsumer,
+ vector<AliHLTDataBuffer::AliHLTDataSegment>& tgtList);
+ protected:
+ // 2010-02-01 make function protected in order to be used from unit test
/**
* Reset the data buffer.
* Removes all consumers back to the @ref fConsumers list, deletes
* segments and releases the Raw Buffer.
*/
int ResetDataBuffer();
+ private:
//////////////////////////////////////////////////////////////////////////////
vector<AliHLTDataSegment> fSegments; // see above
// the list of all consumers which are going to subscribe to the buffer
- vector<AliHLTConsumerDescriptor*> fConsumers; // see above
+ AliHLTConsumerDescriptorPList fConsumers; // see above
// the list of all consumers which are currently subscribed to the buffer
- vector<AliHLTConsumerDescriptor*> fActiveConsumers; // see above
+ AliHLTConsumerDescriptorPList fActiveConsumers; // see above
// the list of all consumers which are already released for the current event
- vector<AliHLTConsumerDescriptor*> fReleasedConsumers; // see above
+ AliHLTConsumerDescriptorPList fReleasedConsumers; // see above
// the buffer instance
AliHLTRawBuffer* fpBuffer; //! transient
// flags indicating the state of the buffer
AliHLTUInt32_t fFlags; // see above
+ /** list of tasks with forwarded data blocks */
+ vector<AliHLTTask*> fForwardedSegmentSources; //! transient
+
+ /** list of forwarded block descriptors */
+ vector<AliHLTDataSegment> fForwardedSegments; //! transient
+
//////////////////////////////////////////////////////////////////////////////
// global buffer handling, internal use only
*/
static AliHLTRawBuffer* CreateRawBuffer(AliHLTUInt32_t size);
+ /**
+ * Set the data size of a raw buffer after it has been filled by
+ * the component.
+ */
+ int SetRawBufferDataSize(AliHLTRawBuffer* pBuffer, AliHLTUInt32_t size) const;
+
/**
* Mark a buffer as free.
* After the Data Buffer has finnished using the raw buffer, it is released
/** global instance to HLT logging class for static methods */
static AliHLTLogging fgLogging; // see above
+ /** size of the safety pattern */
+ static const Int_t fgkSafetyPatternSize; // see above
+
+ /** the safety pattern */
+ static const char fgkSafetyPattern[]; //!transient
+
+ static AliHLTUInt32_t fgEventCount; //!transient
+
//////////////////////////////////////////////////////////////////////////////
// internal helper functions
* @param list list where to search for the consumer
*/
AliHLTConsumerDescriptor* FindConsumer(const AliHLTComponent* pConsumer,
- vector<AliHLTConsumerDescriptor*> &list) const;
+ AliHLTConsumerDescriptorPList &list) const;
/**
* Change the state of a consumer.
* @param tgtList list where to move the consumer
*/
int ChangeConsumerState(AliHLTConsumerDescriptor* pDesc,
- vector<AliHLTConsumerDescriptor*> &srcList,
- vector<AliHLTConsumerDescriptor*> &tgtList);
+ AliHLTConsumerDescriptorPList &srcList,
+ AliHLTConsumerDescriptorPList &tgtList);
/**
* Cleanup a consumer list.
*/
int CleanupConsumerList();
- ClassDef(AliHLTDataBuffer, 0)
+ ClassDef(AliHLTDataBuffer, 1)
};
+
#endif // ALIHLTDATABUFFER_H