X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FBASE%2FAliHLTDataBuffer.h;h=8fce7598c6122e2f35a077674af07eda1da19cda;hb=62bb3cd4f3cd3538739ebe2456896b0b4132a446;hp=9445746927bb81431ef4c1764997887a20c2f41d;hpb=b22e91ebe4a536f9297f8739a42200567f807e2c;p=u%2Fmrichter%2FAliRoot.git diff --git a/HLT/BASE/AliHLTDataBuffer.h b/HLT/BASE/AliHLTDataBuffer.h index 9445746927b..8fce7598c61 100644 --- a/HLT/BASE/AliHLTDataBuffer.h +++ b/HLT/BASE/AliHLTDataBuffer.h @@ -12,160 +12,54 @@ @note The class is used in Offline (AliRoot) context */ -#include +// see below for class documentation +// or +// refer to README to build package +// or +// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt + +#include +#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=0; - fSegmentOffset=0; - fSegmentSize=0; - fSpecification=0; - } - AliHLTDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size) - { - //fDataType=0; - fSegmentOffset=offset; - fSegmentSize=size; - fSpecification=0; - } - /** the data type of this segment */ - AliHLTComponent_DataType fDataType; - /** offset in byte within the data buffer */ - AliHLTUInt32_t fSegmentOffset; - /** size of the actual content */ - AliHLTUInt32_t fSegmentSize; - /** data specification */ - AliHLTUInt32_t fSpecification; -}; - -/** - * @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; - /** total size of the buffer, including safety margin */ - AliHLTUInt32_t fTotalSize; - /** the buffer */ - void* fPtr; -}; - -/** - * @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 AliHLTLogging, public TObject { - private: - AliHLTComponent* fpConsumer; - vector fSegments; - - public: - /** standard constructur */ - AliHLTConsumerDescriptor(); - /** constructur - * @param pConsumer pointer to the consumer component - */ - AliHLTConsumerDescriptor(AliHLTComponent* pConsumer); - ~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, not 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); - - /** get the number of active segments for this consumer - * @return number of active segments - */ - int GetNofActiveSegments() {return fSegments.size();}; +#include "AliHLTComponent.h" - /** - */ - int ReleaseActiveDataSegment(AliHLTUInt32_t offset, AliHLTUInt32_t size); +class AliHLTConsumerDescriptor; - //ClassDef(AliHLTConsumerDescriptor, 0) -}; +/** list of AliHLTConsumerDescriptor pointers */ +typedef vector AliHLTConsumerDescriptorPList; /** * @class AliHLTDataBuffer * @brief Handling of data buffers for the HLT. * - * The class provides handling of data buffers for HLT components. Each component gets its - * own Data Buffer instance. The buffer is grouped into different data segments according - * to the output of the component.
- * The Data Buffer keeps control over the data requests of the 'child' componets. Each - * component can subscribe to a certain segment of the data buffer. It's state is that - * changed from 'reserved' to 'active'. After the data processing the component has to - * release the segment and it's state is set to 'processed'. - * If all components have requested and released their data, the Raw Buffer is released - * and pushed back in the list of available buffers. + * The class provides handling of data buffers for HLT tasks. Each task gets + * its own Data Buffer instance. The buffer is grouped into different data + * segments according to the output of the component.
+ * The Data Buffer keeps control over the data requests of the 'child' + * components. Each component can subscribe to a certain segment of the data + * buffer. It's state is then changed from 'reserved' to 'active'. After the + * data processing, the component has to release the segment and it's state is + * set to 'processed'. If all components have requested and released their data, + * the Raw Buffer is released and pushed back in the list of available buffers. * * @note This class is only used for the @ref alihlt_system. * * @ingroup alihlt_system */ -class AliHLTDataBuffer : public AliHLTLogging, public TObject { +class AliHLTDataBuffer : public TObject, public AliHLTLogging +{ public: - //////////////////////////////////////////////////////////////////////////////////////////////////////////////// - // condtructors and destructors + ////////////////////////////////////////////////////////////////////////////// + // constructors and destructors /* standard constructor */ AliHLTDataBuffer(); - + /** destructor */ virtual ~AliHLTDataBuffer(); - //////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////// // initialization /** @@ -174,39 +68,44 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { */ int SetConsumer(AliHLTComponent* pConsumer); - //////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////// // component to component communication /** - * Determine the number of matching data blocks for the component and a consumer - * component.
- * The first approach will support only one output data type for processing components. + * Determine the number of matching data blocks for the component and a + * consumer component.
+ * The first approach will support only one output data type for processing + * components. * @param pConsumer the component which subscribes to the buffer * @param tgtList (optional) the list to receive the data types * @return: number of data blocks which match the input data types * of the consumer, neg. error code if failed
* -EINVAL invalid parameter
*/ - int FindMatchingDataBlocks(const AliHLTComponent* pConsumer, vector* tgtList=NULL); + int FindMatchingDataBlocks(const AliHLTComponent* pConsumer, + AliHLTComponentDataTypeList* tgtList=NULL); /** * Subscribe to a segment of the data buffer. - * The function prepares the block descriptor for subsequent use with the AliHLTComponent::ProcessEvent - * method, the method can prepare several block descriptors up to the array size specified by - * iArraySize. The return value is independent from the array size the number of block descriptors - * which would have been prepared if there was enough space in the array
+ * The function prepares the block descriptor for subsequent use with the + * AliHLTComponent::ProcessEvent method, the method can prepare several block + * descriptors up to the array size specified by iArraySize. The return value + * is independent from the array size the number of block descriptors which + * would have been prepared if there was enough space in the array
* 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 - * @return: number of matching data blocks if success, negative error code if failed
- * -EACCESS the state of the consumer can not be changed (activated) + * @return: number of matching data blocks, neg. error code if failed
+ * -EACCESS the consumer state can't be changed (activated) * -EBADF unresolved data segments
* -ENOENT consumer component not found
* -ENODATA data buffer does not have raw data
* -EINVAL invalid parameter
*/ - int Subscribe(const AliHLTComponent* pConsumer, AliHLTComponent_BlockData* arrayBlockDesc, int iArraySize); + int Subscribe(const AliHLTComponent* pConsumer, + AliHLTComponentBlockData* arrayBlockDesc, + int iArraySize); /** * Release an instance of the data buffer. @@ -217,11 +116,11 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { * @param pBlockDesc descriptor of the data segment * @param pConsumer the component which subscribes to the buffer * @return: >0 if success, negative error code if failed
- * -EACCESS the state of the consumer can not be changed (de-activated) - * -ENOENT consumer component has not subscribed to the buffer
+ * -EACCESS the consumer state can not be changed (de-activated) + * -ENOENT consumer has not subscribed to the buffer
* -EINVAL invalid parameter
*/ - int Release(AliHLTComponent_BlockData* pBlockDesc, const AliHLTComponent* pConsumer); + int Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTComponent* pConsumer); /** * Get a target buffer of minimum size iMinSize. @@ -237,14 +136,14 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { * This is usually done after the component has written the data to the buffer, * which was requested by the @ref GetTargetBuffer method. The component might * produce different types of data, for each type a segment has to be defined - * which describes the data inside the bauffer.
- * The @ref AliHLTComponent_BlockData segment descriptor comes directly from the - * @ref AliHLTComponent::ProcessEvent method. + * which describes the data inside the buffer.
+ * The @ref AliHLTComponentBlockData segment descriptor comes directly from + * the @ref AliHLTComponent::ProcessEvent method. * @param pTgt the target buffer which the segments refer to * @param arraySegments the output block descriptors of the component * @param iSize size of the array */ - int SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponent_BlockData* arraySegments, int iSize); + int SetSegments(AliHLTUInt8_t* pTgt, AliHLTComponentBlockData* arraySegments, int iSize); /** * Check if the data buffer is empty. @@ -265,20 +164,168 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { 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(); + /** + * Check if a consumer is already in the list + * @param pConsumer pointer to consumer component + * @param bAllLists search in all lists if 1 + * search only in fConsumer list if 0 + * @return 1 if found, 0 if not + */ + int FindConsumer(AliHLTComponent* pConsumer, int bAllLists=1); + + /** + * Public method to reset the buffer. + * Eventually with some additional checks. In normal operation, + * an external reset should not be necessary. + */ + int Reset(); + + /** + * @class AliHLTDataSegment + * @brief Descriptor of a data segment within the buffer. + */ + class AliHLTDataSegment { + friend class AliHLTDataBuffer; + friend class AliHLTConsumerDescriptor; + public: + 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)); + } + + private: + /** 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 + }; + + /** + * @class AliHLTRawBuffer + * @brief Descriptor of the raw data buffer which can host several segments. + */ + class AliHLTRawBuffer { + public: + /** standard constructor */ + AliHLTRawBuffer() : fSize(0), fTotalSize(0), fPtr(NULL) {} + /** constructor */ + AliHLTRawBuffer(AliHLTUInt32_t size); + /** 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); + + /** + * Check whether buffer fits for a request. + * @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(); + + 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; + + 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 + /** the buffer */ + AliHLTUInt8_t* fPtr; //! transient + }; + private: + /** copy constructor prohibited */ + AliHLTDataBuffer(const AliHLTDataBuffer&); + /** assignment operator prohibited */ + AliHLTDataBuffer& operator=(const AliHLTDataBuffer&); + /* lets see if this is needed - AliHLTDataSegment* FindDataSegment(AliHLTComponent_DataType datatype); + AliHLTDataSegment* FindDataSegment(AliHLTComponentDataType datatype); */ /** @@ -289,42 +336,43 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { * of the consumer, neg. error code if failed
* -EINVAL invalid parameter
*/ - int FindMatchingDataSegments(const AliHLTComponent* pConsumer, vector& tgtList); + int FindMatchingDataSegments(const AliHLTComponent* pConsumer, + vector& tgtList); /** * Reset the data buffer. - * Removes all consumers back to the @ref fConsumers list - * and releases the Raw Buffer. + * Removes all consumers back to the @ref fConsumers list, deletes + * segments and releases the Raw Buffer. */ int ResetDataBuffer(); + ////////////////////////////////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////////////////////////////////////////// // the data description // the data segments within this buffer - vector fSegments; + vector fSegments; // see above // the list of all consumers which are going to subscribe to the buffer - vector fConsumers; + AliHLTConsumerDescriptorPList fConsumers; // see above // the list of all consumers which are currently subscribed to the buffer - vector fActiveConsumers; + AliHLTConsumerDescriptorPList fActiveConsumers; // see above // the list of all consumers which are already released for the current event - vector fReleasedConsumers; + AliHLTConsumerDescriptorPList fReleasedConsumers; // see above // the buffer instance - AliHLTRawBuffer* fpBuffer; + AliHLTRawBuffer* fpBuffer; //! transient // flags indicating the state of the buffer - AliHLTUInt32_t fFlags; + AliHLTUInt32_t fFlags; // see above - //////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ////////////////////////////////////////////////////////////////////////////// // global buffer handling, internal use only /** * Create a raw buffer of a certain size. * The function tries to find a buffer of the given size (or a bit bigger by a - * certain margin @ref fMargin) from the list of free buffers. + * certain margin @ref fgMargin) from the list of free buffers. * If no buffer is available, a new one is created and added to the buffer handling. * @param size min. size of the requested buffer * @return pointer to raw buffer @@ -333,8 +381,8 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { /** * Mark a buffer as free. - * After the Data Buffer has finnished using the raw buffer, it is released and - * added to the list of available buffers. + * After the Data Buffer has finnished using the raw buffer, it is released + * and added to the list of available buffers. * @param pBuffer the raw buffer to release * @return >=0 if succeeded, neg. error code if failed */ @@ -342,47 +390,59 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { /** * Deletes all the raw buffers. - * When the last Data Buffer object is destructed, all raw data buffers are relesed. + * When the last Data Buffer object is destructed, all raw data buffers are + * relesed. */ static int DeleteRawBuffers(); /** * Number of instances of AliHLTDataBuffer. - * The statice variable is incremented and decremented in the constructor/destructor. - * All internal data structures are cleaned up when the last instance is exiting. + * The statice variable is incremented and decremented in the constructor/ + * destructor. All internal data structures are cleaned up when the last + * instance is exiting. */ - static int fNofInstances; + static int fgNofInstances; // see above /** global list of free raw buffers */ - static vector fFreeBuffers; + static vector fgFreeBuffers; // see above /** global list of currently active raw buffers */ - static vector fActiveBuffers; + static vector fgActiveBuffers; // see above /** determines the raw buffer size margin at buffer requests */ - static AliHLTUInt32_t fMargin; + static AliHLTUInt32_t fgMargin; // see above /** global instance to HLT logging class for static methods */ - static AliHLTLogging fgLogging; + 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 + + ////////////////////////////////////////////////////////////////////////////// // internal helper functions /** * Find the consumer descriptor for a certain component and data type in * a list of consumers.
- * Note: There are three lists which contain the consumers in the different states. + * Note: There are three lists which contain the consumers in the + * different states. * @param pConsumer pointer to consumer component * @param list list where to search for the consumer */ - AliHLTConsumerDescriptor* FindConsumer(const AliHLTComponent* pConsumer, vector &list); + AliHLTConsumerDescriptor* FindConsumer(const AliHLTComponent* pConsumer, + AliHLTConsumerDescriptorPList &list) const; /** * Change the state of a consumer. - * The state of a consumer is determined by the list it is strored in, the method moves a consumer from - * the source to the target list. + * The state of a consumer is determined by the list it is strored in, the + * method moves a consumer from the source to the target list. * @param pDesc pointer to consumer descriptor * @param srcList list where the consumer is currently to be found * @param tgtList list where to move the consumer */ - int ChangeConsumerState(AliHLTConsumerDescriptor* pDesc, vector &srcList, vector &tgtList); + int ChangeConsumerState(AliHLTConsumerDescriptor* pDesc, + AliHLTConsumerDescriptorPList &srcList, + AliHLTConsumerDescriptorPList &tgtList); /** * Cleanup a consumer list. @@ -392,4 +452,5 @@ class AliHLTDataBuffer : public AliHLTLogging, public TObject { ClassDef(AliHLTDataBuffer, 0) }; + #endif // ALIHLTDATABUFFER_H