3 #ifndef ALIHLTDATATYPES_H
4 #define ALIHLTDATATYPES_H
5 /* This file is property of and copyright by the ALICE HLT Project *
6 * ALICE Experiment at CERN, All rights reserved. *
7 * See cxx source for full Copyright notice */
9 /** @file AliHLTDataTypes.h
10 @author Matthias Richter, Timm Steinbeck, Jochen Thaeder
12 @brief Data type declaration for the HLT module.
15 //////////////////////////////////////////////////////////////////////////
17 // version no of HLT data types
19 //////////////////////////////////////////////////////////////////////////
21 /* Version Description
22 * 1 first version until June 07; implicite, not tagged
23 * 2 introduced June 07, enhanced/cleaned/arranged structure
24 * 3 2007-11-15 RAW DDL data type added; some inconsistencies fixed
25 * ('void' and 'any' origins); added signed HLT basic data types
27 #define ALIHLT_DATA_TYPES_VERSION 3
29 //////////////////////////////////////////////////////////////////////////
31 // HLT data origin defines
33 //////////////////////////////////////////////////////////////////////////
35 /** field size of datat type origin */
36 const int kAliHLTComponentDataTypefOriginSize=4;
39 /** invalid data origin */
40 # define kAliHLTDataOriginVoid "\0\0\0"
41 /** old invalid data origin, kept for backward compatibility */
42 # define kAliHLTVoidDataOrigin "\0\0\0"
44 /** wildcard data type origin */
45 # define kAliHLTDataOriginAny "***"
46 /** old wildcard data type origin, kept for backward compatibility */
47 # define kAliHLTAnyDataOrigin "***"
50 # define kAliHLTDataOriginOut {'H','L','T',' '}
52 /** HLT/PubSub private internal */
53 # define kAliHLTDataOriginPrivate {'P','R','I','V'}
56 # define kAliHLTDataOriginTPC {'T','P','C',' '}
59 # define kAliHLTDataOriginPHOS {'P','H','O','S'}
62 # define kAliHLTDataOriginMUON {'M','U','O','N'}
65 # define kAliHLTDataOriginTRD {'T','R','D',' '}
68 # define kAliHLTDataOriginITS {'I','T','S',' '}
70 //////////////////////////////////////////////////////////////////////////
72 // HLT common data type defines
74 //////////////////////////////////////////////////////////////////////////
76 /** field size of data type id */
77 const int kAliHLTComponentDataTypefIDsize=8;
80 /** invalid data type id */
81 # define kAliHLTVoidDataTypeID "\0\0\0\0\0\0\0"
83 /** special id for any data type id */
84 # define kAliHLTAnyDataTypeID "*******"
87 # define kAliHLTDDLRawDataTypeID {'D','D','L','_','R','A','W',' '}
89 /** calibration data for file exchange subscriber */
90 # define kAliHLTFXSCalibDataTypeID {'F','X','S','_','C','A','L',' '}
92 /** start of run (SOR) event
95 # define kAliHLTSORDataTypeID {'S','T','A','R','T','O','F','R'}
97 /** end of run (EOR) event
100 # define kAliHLTEORDataTypeID {'E','N','D','O','F','R','U','N'}
103 * @ref AliHLTEventDDL
105 # define kAliHLTDDLDataTypeID {'D','D','L','L','I','S','T',' '}
108 * - empty payload, specification gives eventType
110 # define kAliHLTEventDataTypeID {'E','V','E','N','T','T','Y','P'}
115 //////////////////////////////////////////////////////////////////////////
117 // Basic HLT data types
119 //////////////////////////////////////////////////////////////////////////
121 typedef unsigned char AliHLTUInt8_t;
123 typedef signed char AliHLTInt8_t;
125 typedef unsigned short AliHLTUInt16_t;
127 typedef signed short AliHLTInt16_t;
129 typedef unsigned int AliHLTUInt32_t;
131 typedef signed int AliHLTInt32_t;
133 typedef unsigned long long AliHLTUInt64_t;
135 typedef signed long long AliHLTInt64_t;
137 typedef float AliHLTFloat32_t;
139 typedef double AliHLTFloat64_t;
141 typedef AliHLTUInt64_t AliHLTEventID_t;
143 //////////////////////////////////////////////////////////////////////////
145 // HLT logging levels
147 //////////////////////////////////////////////////////////////////////////
149 enum AliHLTComponentLogSeverity {
151 kHLTLogBenchmark = 0x1,
154 kHLTLogWarning = 0x8,
158 kHLTLogDefault = 0x3d
161 //////////////////////////////////////////////////////////////////////////
163 // HLT data structures for data exchange and external interface
165 //////////////////////////////////////////////////////////////////////////
168 * @struct AliHLTComponentEventData
171 struct AliHLTComponentEventData
173 AliHLTUInt32_t fStructSize;
174 AliHLTEventID_t fEventID;
175 AliHLTUInt32_t fEventCreation_s;
176 AliHLTUInt32_t fEventCreation_us;
177 AliHLTUInt32_t fBlockCnt;
181 * @struct AliHLTComponentShmData
182 * Shared memory descriptor.
183 * Irrelevant for analysis components.
185 struct AliHLTComponentShmData
187 AliHLTUInt32_t fStructSize;
188 AliHLTUInt32_t fShmType;
189 AliHLTUInt64_t fShmID;
193 * @struct AliHLTComponentDataType
194 * Data type descriptor for data blocks transferred through the processing
197 struct AliHLTComponentDataType
199 AliHLTUInt32_t fStructSize;
200 char fID[kAliHLTComponentDataTypefIDsize]; //!
201 char fOrigin[kAliHLTComponentDataTypefOriginSize]; //!
205 * @struct AliHLTComponentBlockData
206 * This is the decription of data blocks exchanged between components.
207 * \b IMPORTANT: The validity of fPtr and fOffset is different for input and
209 * - input blocks: The \em fPtr member always points to the beginning of the data
210 * of size \em fSize. fOffset is ignored and should be in most
212 * - output blocks: The \em fPtr member is ignored by the framework. \em fOffset
213 * must specify the start of the data relative to the output
214 * buffer. The data block has size \em fSize.
216 struct AliHLTComponentBlockData
218 /* size and version of the struct */
219 AliHLTUInt32_t fStructSize;
220 /* shared memory key, ignored by processing components */
221 AliHLTComponentShmData fShmKey;
222 /* offset of output data relative to the output buffer */
223 AliHLTUInt32_t fOffset;
224 /* start of the data for input data blocks, fOffset to be ignored*/
226 /* size of the data block */
227 AliHLTUInt32_t fSize;
228 /* data type of the data block */
229 AliHLTComponentDataType fDataType;
230 /* data specification of the data block */
231 AliHLTUInt32_t fSpecification;
235 * @struct AliHLTComponentTriggerData
236 * Trigger data, not yet defined
238 struct AliHLTComponentTriggerData
240 AliHLTUInt32_t fStructSize;
241 AliHLTUInt32_t fDataSize;
246 * @struct AliHLTComponentEventDoneData
249 struct AliHLTComponentEventDoneData
251 AliHLTUInt32_t fStructSize;
252 AliHLTUInt32_t fDataSize;
257 * @struct AliHLTRunDesc
259 * The struct is send with the SOR and EOR events.
263 AliHLTUInt32_t fStructSize;
264 AliHLTUInt32_t fRunNo;
265 AliHLTUInt32_t fRunType;
268 /** size of the DDL list */
269 static const int gkAliHLTDDLListSize = 29;
272 * @struct AliHLTEventDDL
274 * The struct is send with the DDLLIST event.
276 struct AliHLTEventDDL
278 AliHLTUInt32_t fCount;
279 AliHLTUInt32_t fList[gkAliHLTDDLListSize];
282 //////////////////////////////////////////////////////////////////////////
284 // HLT Event Type Specification
286 //////////////////////////////////////////////////////////////////////////
288 /** Unknown eventType specification */
289 static const AliHLTUInt32_t gkAliEventTypeUnknown = ~(AliHLTUInt32_t)0;
290 /** SOR eventType specification */
291 static const AliHLTUInt32_t gkAliEventTypeStartOfRun=1;
292 /** Data eventType specification */
293 static const AliHLTUInt32_t gkAliEventTypeData=2;
294 /** EOR eventType specification */
295 static const AliHLTUInt32_t gkAliEventTypeEndOfRun=4;
296 /** Corrupt eventType specification */
297 static const AliHLTUInt32_t gkAliEventTypeCorruptID=8;
298 /** Calibration eventType specification */
299 static const AliHLTUInt32_t gkAliEventTypeCalibration=16;
300 /** DataReplay eventType specification */
301 static const AliHLTUInt32_t gkAliEventTypeDataReplay=32;
302 /** Tick eventType specification */
303 static const AliHLTUInt32_t gkAliEventTypeTick=64;
304 /** Max eventType specification */
305 static const AliHLTUInt32_t gkAliEventTypeMax=64;
307 //////////////////////////////////////////////////////////////////////////
309 // HLT defines and defaults
311 //////////////////////////////////////////////////////////////////////////
313 /** invalid event id */
314 const AliHLTEventID_t kAliHLTVoidEventID=~(AliHLTEventID_t)0;
316 /** invalid data specification */
317 const AliHLTUInt32_t kAliHLTVoidDataSpec = ~(AliHLTUInt32_t)0;
319 /** invalid shared memory type */
320 const AliHLTUInt32_t gkAliHLTComponentInvalidShmType = 0;
322 /** invalid shared memory id */
323 const AliHLTUInt64_t gkAliHLTComponentInvalidShmID = ~(AliHLTUInt64_t)0;
325 /** invalid data type */
326 const AliHLTComponentDataType kAliHLTVoidDataType = {
327 sizeof(AliHLTComponentDataType),
328 kAliHLTVoidDataTypeID,
329 kAliHLTDataOriginVoid
332 // there is currently a problem with rootcint if the predefined ids
333 // (commented below) are used. rootcint does not find the id if they
334 // are char arrays defined with {} and individual chars. If strings
335 // are used it works fine
337 const AliHLTComponentDataType kAliHLTAnyDataType = {
338 sizeof(AliHLTComponentDataType),
339 kAliHLTAnyDataTypeID,
343 /** multiple output data types */
344 extern const AliHLTComponentDataType kAliHLTMultipleDataType;
346 /** data to file exchange subscriber */
347 extern const AliHLTComponentDataType kAliHLTDataTypeFXSCalib;
349 /** DDL list data type */
350 extern const AliHLTComponentDataType kAliHLTDataTypeDDL;
353 extern const AliHLTComponentDataType kAliHLTDataTypeSOR;
356 extern const AliHLTComponentDataType kAliHLTDataTypeEOR;
358 /** Event type specification */
359 extern const AliHLTComponentDataType kAliHLTDataTypeEvent;
361 /** RAW DDL data specification, data publisher will set type id and origin correctly */
362 extern const AliHLTComponentDataType kAliHLTDataTypeDDLRaw;
364 //////////////////////////////////////////////////////////////////////////
366 // FXS subscriber meta information
368 //////////////////////////////////////////////////////////////////////////
370 static const int gkAliHLTFXSHeaderfOriginSize = 4;
371 static const int gkAliHLTFXSHeaderfFileIDSize = 128;
372 static const int gkAliHLTFXSHeaderfDDLNumberSize = 64;
374 /** Header in front of the data payload, in order to sent data to the FXS. */
375 struct AliHLTFXSHeader
377 AliHLTUInt32_t fHeaderVersion;
378 AliHLTUInt32_t fRunNumber;
379 char fOrigin[gkAliHLTFXSHeaderfOriginSize];
380 char fFileID[gkAliHLTFXSHeaderfFileIDSize];
381 char fDDLNumber[gkAliHLTFXSHeaderfDDLNumberSize];
384 //////////////////////////////////////////////////////////////////////////
386 // Component running environment
388 //////////////////////////////////////////////////////////////////////////
390 /** logging function */
391 typedef int (*AliHLTfctLogging)( void* param,
392 AliHLTComponentLogSeverity severity,
395 const char* message);
398 * @struct AliHLTComponentEnvironment
399 * Running environment for analysis components.
400 * The struct describes function callbacks for
402 struct AliHLTComponentEnvironment
404 AliHLTUInt32_t fStructSize;
406 void* (*fAllocMemoryFunc)( void* param, unsigned long size );
408 // future addition already foreseen/envisioned
409 // IMPORTANT: don not just remove the defines as this breaks the binary
411 int (*fAllocShmMemoryFunc)( void* param, unsigned long size, AliHLTComponentBlockData* blockLocation );
413 int (*fGetEventDoneDataFunc)( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd );
414 AliHLTfctLogging fLoggingFunc;
418 //////////////////////////////////////////////////////////////////////////
420 // Data type helper functions
422 //////////////////////////////////////////////////////////////////////////
424 inline bool operator==( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
426 for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ )
427 if ( dt1.fID[i] != dt2.fID[i] )
429 for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
430 if ( dt1.fOrigin[i] != dt2.fOrigin[i] )
435 inline bool operator!=( const AliHLTComponentDataType& dt1, const AliHLTComponentDataType& dt2 )
437 for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ )
438 if ( dt1.fID[i] != dt2.fID[i] )
440 for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ )
441 if ( dt1.fOrigin[i] != dt2.fOrigin[i] )