6 //* This file is property of and copyright by the ALICE HLT Project *
7 //* ALICE Experiment at CERN, All rights reserved. *
8 //* See cxx source for full Copyright notice *
11 @author Matthias Richter
13 @brief The control class for HLTOUT data.
17 #include "AliHLTLogging.h"
18 #include "AliHLTModuleAgent.h"
20 class AliHLTOUTHandler;
21 class AliHLTOUTHandlerDesc; // AliHLTModuleAgent.h
23 #define AliHLTOUTInvalidIndex (~(AliHLTUInt32_t)0)
25 typedef vector<AliHLTUInt32_t> AliHLTOUTIndexList;
29 * The control class for HLTOUT data.
30 * The output of the HLT, either from the HLTOUT nodes or simulated output,
31 * is transferred and stored in the HOMER format. The AliHLTOUT class
32 * implements scanning of the HOMER data for all HLTOUT DDL links and
33 * abstracts access to the complete HLTOUT data.
36 class AliHLTOUT : public AliHLTLogging {
38 /** standard constructor */
40 /** standard destructor */
44 * Init for processing.
45 * The HLTOUT is scanned for all available data blocks and the
46 * AliHLTOUTHandler objects for the data blocks are created according
47 * to the module agents (see AliHLTModuleAgent).
52 * Get number of data blocks in the HLTOUT data
54 int GetNofDataBlocks();
57 * Select the first data block of a certain data type and specification.
58 * The selection criteria can be of kAliHLTAnyDataType and/or
59 * kAliHLTVoidDataSpec in order to be ignored and just match any data block.
61 * The search criteria can be combined with a handler type (e.g. kRawReader)
62 * @param dt [in] data type to match <br>
63 * @param spec [in] data specification to match <br>
64 * @param handlerType [in] type of the handler
65 * @return identifier >0 if success, 0 if no block found <br>
66 * neg. error code if failed <br>
67 * -EPERM if access denied (object locked)
69 int SelectFirstDataBlock(AliHLTComponentDataType dt=kAliHLTAnyDataType,
70 AliHLTUInt32_t spec=kAliHLTVoidDataSpec,
71 AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=AliHLTModuleAgent::kUnknownOutput);
74 * Select the next data block of data type and specification of the previous
75 * call to @ref SelectFirstDataBlock.
76 * @return identifier >0 if success, 0 if no block found <br>
77 * neg. error code if failed <br>
78 * -EPERM if access denied (object locked)
80 int SelectNextDataBlock();
83 * Get properties of the selected data block.
84 * @param dt [out] data type of the selected block
85 * @param spec [out] data specification of the selected block
87 int GetDataBlockDescription(AliHLTComponentDataType& dt, AliHLTUInt32_t& spec);
90 * Get the index of the current data block.
91 * @return index, AliHLTOUTInvalidIndex if no block selected
93 AliHLTUInt32_t GetDataBlockIndex();
96 * Get buffer of the selected data block.
97 * @param pBuffer [out] buffer of the selected data block
98 * @param size [out] size of the selected data block
100 int GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size);
103 * Release buffer after use.
104 * @param pBuffer [in] buffer of the selected data block
106 int ReleaseDataBuffer(const AliHLTUInt8_t* pBuffer);
109 * Get handler for the selected data block.
111 AliHLTOUTHandler* GetHandler();
114 * Locking guard for the AliHLTOUT object.
115 * If the object is locked, the selection of data blocks can not be changed.
117 class AliHLTOUTLockGuard {
120 AliHLTOUTLockGuard(AliHLTOUT* pInstance) : fpInstance(pInstance)
121 {if (fpInstance) fpInstance->SetStatusFlag(kLocked);}
123 ~AliHLTOUTLockGuard()
124 {if (fpInstance) fpInstance->ClearStatusFlag(kLocked);}
127 /** standard constructor prohibited */
128 AliHLTOUTLockGuard();
129 /** copy constructor prohibited */
130 AliHLTOUTLockGuard(const AliHLTOUTLockGuard&);
131 /** assignment operator prohibited */
132 AliHLTOUTLockGuard& operator=(const AliHLTOUTLockGuard&);
134 /** the AliHLTOUT instance the guard is locking */
135 AliHLTOUT* fpInstance; //!transient
139 * The HLT OUT Event Header.
140 * Defined between HLT and DAQ.
142 struct AliHLTOUTEventHeader {
143 /**Total length of the data in bytes, including HLT event header, excluding CDH. */
144 AliHLTUInt32_t fLength; //! see above
145 /** version of the header */
146 AliHLTUInt32_t fVersion; //! see above
148 AliHLTUInt64_t fEventID; //! see above
151 // definitions from ALICE internal notes ALICE-INT-2002-010 and
152 // ALICE-INT-2006-XXX
154 /** the 32bit word in the CDH containing the status flags */
155 kCDHStatusWord=4, //! see above
156 /** start of the flags in word fgkCDHStatusWord */
157 kCDHStatusFlagsOffset=12, //! see above
158 /** bit indicating HLT decision in the HLTOUT*/
159 kCDHFlagsHLTDecision=6, //! see above
160 /** bit indicating HLT payload in the HLTOUT*/
161 kCDHFlagsHLTPayload=7 //! see above
167 class AliHLTOUTBlockDescriptor {
169 AliHLTOUTBlockDescriptor(AliHLTComponentDataType dt, AliHLTUInt32_t spec, AliHLTUInt32_t index)
170 : fDataType(dt), fSpecification(spec), fIndex(index) {};
171 ~AliHLTOUTBlockDescriptor() {}
173 operator AliHLTComponentDataType() const {return fDataType;}
174 operator AliHLTUInt32_t() const {return fSpecification;}
175 int operator==(AliHLTComponentDataType dt) const {return dt==fDataType;}
176 int operator==(AliHLTUInt32_t spec) const {return spec==fSpecification;}
178 AliHLTUInt32_t GetIndex() const {return fIndex;}
180 /** data type of the block */
181 AliHLTComponentDataType fDataType; //!transient
182 /** data specification of the block */
183 AliHLTUInt32_t fSpecification; //!transient
184 /** index in the data stream */
185 AliHLTUInt32_t fIndex; //!transient
188 enum AliHLTOUTByteOrder {
189 /** no data block selected */
190 kInvalidByteOrder=-1,
196 enum AliHLTOUTDataType {
206 * Check byte order of selected block
208 AliHLTOUTByteOrder CheckByteOrder();
211 * Check alignment of selected block
213 int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);
217 * Add a block descriptor.
218 * This is done by the child classes generating the index. The AliHLTOUT
219 * object must be locked for index generation.
220 * @param desc the block descriptor
221 * @return 0 if success, -EPERM if access denied
223 int AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc);
226 /** copy constructor prohibited */
227 AliHLTOUT(const AliHLTOUT&);
228 /** assignment operator prohibited */
229 AliHLTOUT& operator=(const AliHLTOUT&);
232 * Internal status flags
235 /** the HLTOUT object is locked with the current data block */
237 /** childs can add block descriptors */
239 /** user of the data block has checked the byte order */
240 kByteOrderChecked = 0x4,
241 /** warning on byte order missmatch has been printed */
242 kByteOrderWarning = 0x8,
243 /** user of the data block has checked the alignment */
244 kAlignmentChecked = 0x10,
245 /** warning on alignment missmatch has been printed */
246 kAlignmentWarning = 0x20
249 class AliHLTOUTHandlerListEntry {
251 AliHLTOUTHandlerListEntry(AliHLTOUTHandler* pHandler,
252 AliHLTModuleAgent::AliHLTOUTHandlerDesc& handlerDesc,
253 AliHLTModuleAgent* pAgent,
254 AliHLTUInt32_t index);
256 /** copy constructor for vector handling */
257 AliHLTOUTHandlerListEntry(const AliHLTOUTHandlerListEntry& src);
259 /** assignment operator for vector handling */
260 AliHLTOUTHandlerListEntry& operator=(const AliHLTOUTHandlerListEntry& src);
262 ~AliHLTOUTHandlerListEntry();
264 static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer
266 operator AliHLTOUTHandler*() const {return fpHandler;}
267 operator AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const {return *fpHandlerDesc;}
268 operator AliHLTModuleAgent*() const {return fpAgent;}
271 * Two list entries are considered to be equal if the handlers
274 bool operator==(const AliHLTOUTHandlerListEntry& entry) const;
276 AliHLTUInt32_t operator[](int i) const;
279 * Add a block index to this descriptor.
280 * One descriptor can serve multiple blocks if the agent returns the
281 * same handler for all of the blocks. Instead of creating a new entry
282 * the block index ist just added
284 void AddIndex(AliHLTUInt32_t index);
287 * Add all indexes of the descriptor.
289 void AddIndex(AliHLTOUTHandlerListEntry &desc);
292 * Check if an index is served by this descriptor.
293 * @return true if the index is in the table
295 bool HasIndex(AliHLTUInt32_t index);
298 /** standard constructor prohibited */
299 AliHLTOUTHandlerListEntry();
301 /** pointer to the handler */
302 AliHLTOUTHandler* fpHandler; //! transient
304 /** pointer to handler description */
305 AliHLTModuleAgent::AliHLTOUTHandlerDesc* fpHandlerDesc; //! transient
307 /** pointer to module agent */
308 AliHLTModuleAgent* fpAgent; //! transient
310 /** list of block indexes */
311 AliHLTOUTIndexList fBlocks; //!transient
315 * Generate the index of the HLTOUT data.
316 * Must be implemented by the child classes.
318 virtual int GenerateIndex()=0;
321 * Find AliHLTOUTHandler objects for the data blocks.
322 * The available AliHLTModuleAgents are probed whether they provide
323 * handlers for data processing.
328 * Get the data buffer
329 * @param index [in] index of the block
330 * @param pBuffer [out] buffer of the selected data block
331 * @param size [out] size of the selected data block
333 virtual int GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t* &pBuffer,
334 AliHLTUInt32_t& size)=0;
337 * Check byte order of data block
339 virtual AliHLTOUTByteOrder CheckBlockByteOrder(AliHLTUInt32_t index)=0;
342 * Check alignment of data block
344 virtual int CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::AliHLTOUTDataType type)=0;
347 * Select the data block of data type and specification of the previous
348 * call to @ref SelectFirstDataBlock. Core function of @ref SelectFirstDataBlock
349 * and @ref SelectNextDataBlock, starts to find a block at the current list
351 * @return identifier >=0 if success, neg. error code if failed <br>
352 * -ENOENT if no block found <br>
353 * -EPERM if access denied (object locked)
355 int FindAndSelectDataBlock();
359 * @param flag flag to set
360 * @return current status flags
362 unsigned int SetStatusFlag(unsigned int flag) {return fFlags|=flag;}
366 * @param flag flag to clear
367 * @return current status flags
369 unsigned int ClearStatusFlag(unsigned int flag) {return fFlags&=~flag;}
373 * @param flag flag to check
374 * @return 1 if flag is set
376 int CheckStatusFlag(unsigned int flag) const {return (fFlags&flag)==flag;}
379 * Insert a handler item.
380 * The current list entries are checked if the handler is already in
381 * the list. It is added if not in the list, otherwise the block index
382 * is added to the existing entry.
383 * @param entry handler list entry
384 * @return 0 if added, EEXIST (non negative!) if merged with existing entry <br>
385 * neg. error code if failed
387 int InsertHandler(const AliHLTOUTHandlerListEntry &entry);
390 * Find handler description for a certain block index.
392 AliHLTOUTHandlerListEntry FindHandlerDesc(AliHLTUInt32_t blockIndex);
394 /** data type for the current block search, set from @ref SelectFirstDataBlock */
395 AliHLTComponentDataType fSearchDataType; //!transient
397 /** data specification for the current block search */
398 AliHLTUInt32_t fSearchSpecification; //!transient
400 /** instance flags: locked, collecting, ... */
401 unsigned int fFlags; //!transient
403 typedef vector<AliHLTOUTHandlerListEntry> AliHLTOUTHandlerListEntryVector;
404 typedef vector<AliHLTOUTBlockDescriptor> AliHLTOUTBlockDescriptorVector;
406 /** list of block descriptors */
407 AliHLTOUTBlockDescriptorVector fBlockDescList; //!transient
409 /** current position in the list */
410 AliHLTOUTBlockDescriptorVector::iterator fCurrent; //!transient
412 /** data buffer under processing */
413 const AliHLTUInt8_t* fpBuffer; //!transient
415 /** list of AliHLTOUTHandlers */
416 AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient
418 ClassDef(AliHLTOUT, 1)