- bugfix: correct equipment ids for HLT ddl links
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 13:44:23 +0000 (13:44 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 13:44:23 +0000 (13:44 +0000)
- scanning of HLTOUT data blocks corrected according to new specification
  and corrected offset in case of HLT decision data block
- improved robustness for corrupted data blocks
- corrected handling of HOMER data type ids (swapped byte order)
- optimized data treatment in AliRawReaderHLT
- additional criterion for HLTOUT data block selection by handler type

HLT/BASE/AliHLTModuleAgent.h
HLT/BASE/AliHLTOUT.cxx
HLT/BASE/AliHLTOUT.h
HLT/BASE/AliHLTOUTHomerBuffer.cxx
HLT/rec/AliHLTOUTRawReader.cxx
HLT/rec/AliHLTOUTRawReader.h
HLT/rec/AliRawReaderHLT.cxx
HLT/rec/AliRawReaderHLT.h
HLT/sim/AliHLTOUTComponent.cxx

index 3de30066b12764ac34dba5dc6ed5ea005e901f9d..0dedf769de26f4aab9f037f886be4d65d6bf1b1b 100644 (file)
@@ -269,6 +269,10 @@ class AliHLTModuleAgent : public TObject, public AliHLTLogging {
 
     ~AliHLTOUTHandlerDesc() {}
 
+    bool operator==(const AliHLTOUTHandlerType handlerType) const {
+      return fHType==handlerType;
+    }
+
   private:
     /** type of the handler */
     AliHLTOUTHandlerType    fHType;                          //!transient
index 61e143fd729551b36dac870547dd52142b3928d2..b248571fad11c673eb9e3f4ccf3131b235e042d8 100644 (file)
@@ -38,11 +38,13 @@ AliHLTOUT::AliHLTOUT()
   :
   fSearchDataType(kAliHLTVoidDataType),
   fSearchSpecification(kAliHLTVoidDataSpec),
+  fSearchHandlerType(AliHLTModuleAgent::kUnknownOutput),
   fFlags(0),
   fBlockDescList(),
   fCurrent(fBlockDescList.begin()),
   fpBuffer(NULL),
-  fDataHandlers()
+  fDataHandlers(),
+  fbVerbose(true)
 {
   // see header file for class documentation
   // or
@@ -76,14 +78,14 @@ int AliHLTOUT::GetNofDataBlocks()
 }
 
 int AliHLTOUT::SelectFirstDataBlock(AliHLTComponentDataType dt, AliHLTUInt32_t spec,
-                                   AliHLTModuleAgent::AliHLTOUTHandlerType /*handlerType*/)
+                                   AliHLTModuleAgent::AliHLTOUTHandlerType handlerType)
 {
   // see header file for class documentation
   if (CheckStatusFlag(kLocked)) return -EPERM;
   fCurrent=fBlockDescList.begin();
   fSearchDataType=dt;
   fSearchSpecification=spec;
-  //fSearchHandlerType=handlerType;
+  fSearchHandlerType=handlerType;
   return FindAndSelectDataBlock();
 }
 
@@ -103,8 +105,8 @@ int AliHLTOUT::FindAndSelectDataBlock()
   int iResult=-ENOENT;
   while (fCurrent!=fBlockDescList.end() && iResult==-ENOENT) {
     if ((*fCurrent)==fSearchDataType &&
-       fSearchSpecification==kAliHLTVoidDataSpec || (*fCurrent)==fSearchSpecification &&
-       1/*fSearchHandlerType==AliHLTModuleAgent::kUnknownOutput*/) {
+       (fSearchSpecification==kAliHLTVoidDataSpec || (*fCurrent)==fSearchSpecification) &&
+       (fSearchHandlerType==AliHLTModuleAgent::kUnknownOutput || FindHandlerDesc(fCurrent->GetIndex())==fSearchHandlerType)) {
       iResult=fCurrent->GetIndex();
       // TODO: check the byte order on the current system and the byte order of the
       // data block, print warning when missmatch and user did not check
@@ -218,7 +220,9 @@ int AliHLTOUT::InitHandlers()
   // see header file for class documentation
   int iResult=0;
   AliHLTOUTIndexList remnants;
+  int iCount=0;
   for (int havedata=SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec); havedata>=0; havedata=SelectNextDataBlock()) {
+    iCount++;
     remnants.push_back(GetDataBlockIndex());
     AliHLTComponentDataType dt=kAliHLTVoidDataType;
     AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
@@ -233,8 +237,16 @@ int AliHLTOUT::InitHandlers()
       }
     }
   }
+
+  // warning if some of the data blocks are not selected by the kAliHLTAnyDataType
+  // criterion
+  if (GetNofDataBlocks()>iCount) {
+    HLTWarning("incomplete data type in %d out of %d data block(s)", GetNofDataBlocks()-iCount, iCount);
+  }
+
+  // warning if handler not found
   if (remnants.size()>0) {
-    HLTWarning("no handlers found for %d data blocks out of %d", remnants.size(), GetNofDataBlocks());
+    HLTWarning("no handlers found for %d data blocks out of %d", remnants.size(), iCount);
     AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
     for (AliHLTOUTIndexList::iterator element=remnants.begin(); element!=remnants.end(); element++) {
       for (int trials=0; trials<2; trials++) {
@@ -273,7 +285,7 @@ int AliHLTOUT::InsertHandler(const AliHLTOUTHandlerListEntry &entry)
   return iResult;
 }
 
-AliHLTOUT::AliHLTOUTHandlerListEntry AliHLTOUT::FindHandlerDesc(AliHLTUInt32_t blockIndex)
+const AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::FindHandlerDesc(AliHLTUInt32_t blockIndex)
 {
   // see header file for class documentation
   AliHLTOUTHandlerListEntryVector::iterator element=fDataHandlers.begin();
@@ -283,7 +295,7 @@ AliHLTOUT::AliHLTOUTHandlerListEntry AliHLTOUT::FindHandlerDesc(AliHLTUInt32_t b
     }
     element++;
   }
-  return AliHLTOUT::AliHLTOUTHandlerListEntry::fgkVoidHandlerListEntry;
+  return const_cast<AliHLTOUT::AliHLTOUTHandlerListEntry&>(AliHLTOUT::AliHLTOUTHandlerListEntry::fgkVoidHandlerListEntry);
 }
 
 AliHLTOUT::AliHLTOUTHandlerListEntry::AliHLTOUTHandlerListEntry()
@@ -334,7 +346,8 @@ AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::AliHLTOUTHandlerListEntry::oper
 {
   // see header file for class documentation
   fpHandler=src.fpHandler;
-  *fpHandlerDesc=*src.fpHandlerDesc;
+  if (src.fpHandlerDesc)
+    *fpHandlerDesc=*src.fpHandlerDesc;
   fpAgent=src.fpAgent;
   fBlocks.assign(src.fBlocks.begin(), src.fBlocks.end());
   return *this;
@@ -355,6 +368,13 @@ bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTOUTHandlerList
   return true;
 }
 
+bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const
+{
+  // see header file for class documentation
+  if (!fpHandlerDesc) return false;
+  return *fpHandlerDesc==handlerType;
+}
+
 void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(AliHLTOUT::AliHLTOUTHandlerListEntry &desc)
 {
   // see header file for class documentation
@@ -381,3 +401,25 @@ bool AliHLTOUT::AliHLTOUTHandlerListEntry::HasIndex(AliHLTUInt32_t index)
 }
 
 const AliHLTOUT::AliHLTOUTHandlerListEntry AliHLTOUT::AliHLTOUTHandlerListEntry::fgkVoidHandlerListEntry;
+
+AliHLTUInt64_t AliHLTOUT::Swap(AliHLTUInt64_t src)
+{
+  // see header file for class documentation
+  return ((src & 0xFFULL) << 56) | 
+    ((src & 0xFF00ULL) << 40) | 
+    ((src & 0xFF0000ULL) << 24) | 
+    ((src & 0xFF000000ULL) << 8) | 
+    ((src & 0xFF00000000ULL) >> 8) | 
+    ((src & 0xFF0000000000ULL) >> 24) | 
+    ((src & 0xFF000000000000ULL) >>  40) | 
+    ((src & 0xFF00000000000000ULL) >> 56);
+}
+
+AliHLTUInt32_t AliHLTOUT::Swap(AliHLTUInt32_t src)
+{
+  // see header file for class documentation
+  return ((src & 0xFFULL) << 24) | 
+    ((src & 0xFF00ULL) << 8) | 
+    ((src & 0xFF0000ULL) >> 8) | 
+    ((src & 0xFF000000ULL) >> 24);
+}
index f5cb32a2ec325171738544ad8596e53dc8bbafd9..755e406b397793193fb3a0d55b201076447c18c0 100644 (file)
@@ -148,6 +148,20 @@ class AliHLTOUT : public AliHLTLogging {
     AliHLTUInt64_t fEventID; //! see above
   };
 
+  enum {
+    /// versions 1 of the HLT header
+    kVersion1 = 1,
+    /// versions 2 of the HLT header
+    kVersion2 = 2
+  };
+
+  enum {
+    /// size of HLT decision in data format version 1: 29x4
+    kSizeDecisionVersion1 = 116,
+    /// size of HLT decision in data format version 2: 30x4
+    kSizeDecisionVersion2 = 120
+  };
+
   // definitions from ALICE internal notes ALICE-INT-2002-010 and
   // ALICE-INT-2006-XXX
   enum {
@@ -212,6 +226,16 @@ class AliHLTOUT : public AliHLTLogging {
    */
   int CheckAlignment(AliHLTOUT::AliHLTOUTDataType type);
 
+  /**
+   * Helper function to byte swap a 64 bit value.
+   */
+  static AliHLTUInt64_t Swap(AliHLTUInt64_t src);
+
+  /**
+   * Helper function to byte swap a 32 bit value.
+   */
+  static AliHLTUInt32_t Swap(AliHLTUInt32_t src);
+
  protected:
   /**
    * Add a block descriptor.
@@ -222,6 +246,16 @@ class AliHLTOUT : public AliHLTLogging {
    */
   int AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc);
 
+  /**
+   * Print output or suppress.
+   */
+  bool BeVerbose() {return fbVerbose;}
+
+  /**
+   * Switch output.
+   */
+  void SwitchVerbosity(bool verbose) {fbVerbose=verbose;}
+
  private:
   /** copy constructor prohibited */
   AliHLTOUT(const AliHLTOUT&);
@@ -264,6 +298,11 @@ class AliHLTOUT : public AliHLTLogging {
     static const AliHLTOUTHandlerListEntry fgkVoidHandlerListEntry; //! initializer
 
     operator AliHLTOUTHandler*() const {return fpHandler;}
+
+    // please note that fpHandlerDesc is really a pointer and is created
+    // in the constructor. Thats why it is dereferenced here. The pointer
+    // type is on purpose, even though it is a bit confusing with the 
+    // argument by reference in the AliHLTOUTHandlerListEntry constructor.
     operator AliHLTModuleAgent::AliHLTOUTHandlerDesc&() const {return *fpHandlerDesc;}
     operator AliHLTModuleAgent*() const {return fpAgent;}
 
@@ -273,6 +312,8 @@ class AliHLTOUT : public AliHLTLogging {
      */
     bool operator==(const AliHLTOUTHandlerListEntry& entry) const;
 
+    bool operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const;
+
     AliHLTUInt32_t operator[](int i) const;
 
     /**
@@ -389,7 +430,7 @@ class AliHLTOUT : public AliHLTLogging {
   /**
    * Find handler description for a certain block index.
    */
-  AliHLTOUTHandlerListEntry FindHandlerDesc(AliHLTUInt32_t blockIndex);
+  const AliHLTOUTHandlerListEntry& FindHandlerDesc(AliHLTUInt32_t blockIndex);
 
   /** data type for the current block search, set from @ref SelectFirstDataBlock */
   AliHLTComponentDataType fSearchDataType; //!transient
@@ -397,6 +438,9 @@ class AliHLTOUT : public AliHLTLogging {
   /** data specification for the current block search */
   AliHLTUInt32_t fSearchSpecification; //!transient
 
+  /** handler type for the current block search */
+  AliHLTModuleAgent::AliHLTOUTHandlerType fSearchHandlerType; // !transient
+
   /** instance flags: locked, collecting, ... */
   unsigned int fFlags; //!transient
 
@@ -415,6 +459,9 @@ class AliHLTOUT : public AliHLTLogging {
   /** list of AliHLTOUTHandlers */
   AliHLTOUTHandlerListEntryVector fDataHandlers; // !transient
 
-  ClassDef(AliHLTOUT, 1)
+  /** verbose or silent output */
+  bool fbVerbose; //!transient
+
+  ClassDef(AliHLTOUT, 2)
 };
 #endif
index d57a0eee8f664f72d71c783e1a014ea969005567..d6b10409ab9f0573bd57d7281fef7a3fcfb41956 100644 (file)
@@ -119,7 +119,7 @@ int AliHLTOUTHomerBuffer::ScanReader(AliHLTMonitoringReader* pReader, AliHLTUInt
 {
   // see header file for class documentation
   int iResult=0;
-  if (pReader && pReader->ReadNextEvent()==0) {
+  if (pReader && (iResult=pReader->ReadNextEvent())==0) {
     AliHLTUInt32_t nofBlocks=pReader->GetBlockCnt();
     AliHLTUInt32_t tmp1=0x1;
     AliHLTUInt32_t tmp2=offset;
@@ -142,13 +142,21 @@ int AliHLTOUTHomerBuffer::ScanReader(AliHLTMonitoringReader* pReader, AliHLTUInt
       homer_uint32 origin=pReader->GetBlockDataOrigin( i );
       homer_uint32 spec=pReader->GetBlockDataSpec( i );
       AliHLTComponentDataType dt;
-      AliHLTComponent::SetDataType(dt, id, origin);
+      AliHLTComponent::SetDataType(dt, Swap(id), Swap(origin));
       AliHLTOUTBlockDescriptor desc(dt, spec, offset|i);
       HLTDebug("adding block %d: %s %#x", i, AliHLTComponent::DataType2Text(dt).c_str(), spec);
       iResult=AddBlockDescriptor(desc);
     }
   } else {
-    iResult=-ENODEV;
+    if (iResult==EBADMSG) {
+      HLTWarning("Format error in data block");
+      iResult*=-1;
+    } else if (iResult==ENOKEY) {
+      HLTWarning("Format error in data block: can not find HOMER block descriptor id");
+      iResult*=-1;
+    } else {
+      iResult=-ENODEV;
+    }
   }
   return iResult;
 }
index 55ba12c29be2d2c19e5a1bac8859b5ec243de067..b28540f30d17418540191b5eb5e25c775efea1e8 100644 (file)
@@ -62,18 +62,26 @@ AliHLTOUTRawReader::~AliHLTOUTRawReader()
 int AliHLTOUTRawReader::GenerateIndex()
 {
   // see header file for class documentation
-  // step through all HLT ddls, create HOMER reader and
+  // step through all HLT ddls, create HOMER readers and
   // scan data block
   int iResult=0;
   if (fpRawreader && fpManager) {
     fpRawreader->Reset();
-    fpRawreader->Select("HLT");
+    // there was a bug in AliDAQ returning the wrong equipment id
+    // for the HLT links. It has been fixed in the trunk on Feb 5th 2008
+    // and from v4-10-Release (Rev-02). For the moment we select directly
+    // to support older AliRoot versions
+    //fpRawreader->Select("HLT");
+    fpRawreader->SelectEquipment(0,7680, 7689);
     UChar_t* pSrc=NULL;
     while (fpRawreader->ReadNextData(pSrc) && pSrc!=NULL && iResult>=0) {
-      AliHLTUInt32_t id=(fpRawreader->GetEquipmentId())<<fgkIdShift;
-      int size=fpRawreader->GetDataSize();
-      int offset=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
-      AliHLTHOMERReader* pReader=fpManager->OpenReaderBuffer(pSrc+offset, size-offset);
+      AliHLTUInt32_t id=(fpRawreader->GetEquipmentId());
+      unsigned int size=fpRawreader->GetDataSize();
+
+      AliHLTHOMERReader* pReader=OpenReader(pSrc, size);
+
+      // we use the equipment id to identify the different homer blocks 
+      id<<=fgkIdShift;
       if (pReader) {
        iResult=ScanReader(pReader, id);
        fpManager->DeleteReader(pReader);
@@ -109,8 +117,7 @@ int AliHLTOUTRawReader::GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t*
       UChar_t* pSrc=NULL;
       if (fpRawreader->ReadNextData(pSrc) && pSrc!=NULL) {
        int srcSize=fpRawreader->GetDataSize();
-       int offset=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
-       fpCurrent=fpManager->OpenReaderBuffer(pSrc+offset, srcSize-offset);
+       fpCurrent=OpenReader(pSrc, srcSize);
        if (fpCurrent && fpCurrent->ReadNextEvent()!=0) {
          iResult=-ENODATA;
        }
@@ -133,3 +140,56 @@ int AliHLTOUTRawReader::GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t*
   }
   return iResult;
 }
+
+AliHLTHOMERReader* AliHLTOUTRawReader::OpenReader(UChar_t* pSrc, unsigned int size)
+{
+  // see header file for class documentation
+  unsigned int offset=sizeof(AliHLTOUTEventHeader);
+  const AliRawDataHeader* pCDH=fpRawreader->GetDataHeader();
+  AliHLTUInt32_t id=(fpRawreader->GetEquipmentId());
+  AliHLTUInt32_t statusFlags=pCDH->GetStatus();
+  AliHLTOUTEventHeader* pHLTHeader=reinterpret_cast<AliHLTOUTEventHeader*>(pSrc);
+
+  // consistency check for the block size
+  if (pHLTHeader->fLength!=size) {
+    HLTWarning("can not treat HLT data block %d: size missmatch, header %d, but buffer is %d", id, pHLTHeader->fLength, size);
+    return NULL;
+  }
+
+  // determine the offset of the homer block
+  // the HLT header is mandatory, HLT decision and HLT
+  // payload are optional. HLT decision is always before HLT
+  // payload if existent.
+  if (statusFlags&(0x1<<kCDHFlagsHLTDecision)) {
+    // the block contains HLT decision data, this is just
+    // skipped here
+    AliHLTUInt32_t* pDecisionLen=reinterpret_cast<AliHLTUInt32_t*>(pSrc+offset);
+    if ((*pDecisionLen)*sizeof(AliHLTUInt32_t)+offset<size) {
+      // the first 32bit word specifies the number of 32bit words in the
+      // decision block -> +1 for this length word
+      offset+=((*pDecisionLen)+1)*sizeof(AliHLTUInt32_t);
+    } else {
+      HLTWarning("size missmatch: HLT decision block bigger than total block length, skipping ...");
+      return NULL;
+    }
+  }
+
+  // check if there is payload
+  if (!(statusFlags&(0x1<<kCDHFlagsHLTPayload))) return NULL;
+
+  // continue if there is no data left in the buffer
+  if (offset>=size) {
+    HLTWarning("no HLT payload available, but bit is set, skipping ...");
+    return NULL;
+  }
+
+  // check for the HOME descriptor type id
+  AliHLTUInt64_t* pHomerDesc=reinterpret_cast<AliHLTUInt64_t*>(pSrc+offset);
+  if (*(pHomerDesc+kID_64b_Offset) != HOMER_BLOCK_DESCRIPTOR_TYPEID && 
+      Swap(*(pHomerDesc+kID_64b_Offset)) != HOMER_BLOCK_DESCRIPTOR_TYPEID) {
+    HLTWarning("format error: can not find HOMER block descriptor typid, skipping this data block");
+    return NULL;
+  }
+
+  return fpManager->OpenReaderBuffer(pSrc+offset, size-offset);
+}
index c483aa6f8562c07e64240c40fa5626acbd708601..bc0b6302e65ebebe9eec7440f2078d7719e82513 100644 (file)
@@ -58,6 +58,17 @@ class AliHLTOUTRawReader : public AliHLTOUTHomerBuffer {
   int GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t* &pBuffer, 
                    AliHLTUInt32_t& size);
 
+  /**
+   * Open HOMER reader for the data buffer.
+   * The function expects the data buffer including all headers (CDH
+   * and HLTOUT header). The offset for the HLT payload is determined from
+   * the headers and the optional HLT decision data.
+   * @param pSrc    data buffer
+   * @param size    size of the buffer in byte
+   * @return instance of HOMER reader
+   */
+  AliHLTHOMERReader* OpenReader(UChar_t* pSrc, unsigned int size);
+
   /** the rawreader */
   AliRawReader* fpRawreader; //!transient
 
index 47ff0b4da3cd34afa2c40bab358f53507d1c453a..bd11a1ebcfe0e0e7f0789f5f78c6c88b91e68bc2 100644 (file)
@@ -57,6 +57,7 @@ AliRawReaderHLT::AliRawReaderHLT(AliRawReader* pRawreader, const char* options)
   fbHaveHLTData(false),
   fDetectors(),
   fpHLTOUT(NULL),
+  fbReadFirst(true),
   fpDataHandler(NULL)
 {
   // see header file for class documentation
@@ -230,7 +231,7 @@ Bool_t   AliRawReaderHLT::ReadNextData(UChar_t*& data)
 
   // read new header if data already read
   if (fPosition<fDataSize || (result=ReadHeader())) {
-    if (fpHLTOUT!=NULL) {
+    if (fbHaveHLTData && fpHLTOUT!=NULL) {
       // all internal data variables set
       result=kTRUE;
       data=const_cast<AliHLTUInt8_t*>(fpData+sizeof(AliRawDataHeader));
@@ -321,19 +322,25 @@ Bool_t   AliRawReaderHLT::ReadNext(UChar_t* data, Int_t size)
 Bool_t   AliRawReaderHLT::Reset()
 {
   // see header file for class documentation
-  ReleaseHLTData();
+  ReleaseHLTData(false/* keep HLTOUT instance */);
   Bool_t result=fpParentReader->Reset();
   fEquipmentId=-1;
 
   // check if redirection is enabled for at least one detector in the selected range
   fbHaveHLTData=EvaluateSelection();
 
+  // start reading HLTOUT data blocks from the beginning
+  fbReadFirst=true;
+
   return result;
 }
 
 Bool_t   AliRawReaderHLT::NextEvent()
 {
   // see header file for class documentation
+
+  ReleaseHLTData();
+
   Bool_t result=fpParentReader->NextEvent();
   if (result) {
     fEventNumber++;
@@ -428,7 +435,8 @@ Bool_t   AliRawReaderHLT::ReadNextHLTData()
 {
   // see header file for class documentation
   bool result=kTRUE;
-  if (!fpHLTOUT) {
+  if (fbReadFirst || !fpHLTOUT) {
+    if (!fpHLTOUT) {
     fpHLTOUT=new AliHLTOUTRawReader(fpParentReader);
     if (result=(fpHLTOUT!=NULL)) {
       AliHLTSystem* pSystem=GetInstance();
@@ -436,10 +444,14 @@ Bool_t   AliRawReaderHLT::ReadNextHLTData()
        pSystem->ScanOptions(fSystemOptions.Data());
       }
       if (result=(fpHLTOUT->Init()>=0)) {
-       result=fpHLTOUT->SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec,
-                                             AliHLTModuleAgent::kRawReader)>=0;
       }
     }
+    }
+    if (result) {
+      result=fpHLTOUT->SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec,
+                                           AliHLTModuleAgent::kRawReader)>=0;
+    }
+    fbReadFirst=false;
   } else {
     // first release the data buffer
     ReleaseHLTData(false /* keep HLTOUT instance */);
@@ -459,6 +471,7 @@ Bool_t   AliRawReaderHLT::ReadNextHLTData()
        fDataSize=pHandler->GetProcessedData(fpData);
        if (!fpData) {
          result=fpHLTOUT->GetDataBuffer(fpData, size)>=0;
+         fpDataHandler=NULL;
          AliDebug(AliLog::kDebug, Form("forward data block from HLTOUT stream to equipment %d", fEquipmentId));
          fDataSize=(int)size;
        } else {
@@ -476,7 +489,7 @@ Bool_t   AliRawReaderHLT::ReadNextHLTData()
                      fpHLTOUT->GetDataBlockIndex(), AliHLTComponent::DataType2Text(dt).c_str(), spec));
     }
   } else {
-    ReleaseHLTData();
+    ReleaseHLTData(false /* keep HLTOUT instance */);
   }
   return kFALSE;
 }
index 243c619a9027b57a13dab94a00574c092e713181..c9e0b664ec5ad43b6e0cbf5dab8e73563ba699a2 100644 (file)
@@ -163,10 +163,13 @@ class AliRawReaderHLT : public AliRawReader, public AliHLTReconstructorBase {
   /** instance of the HLTOUT handler */
   AliHLTOUT* fpHLTOUT; // !transient
 
+  /** start reading HLTOUT from beginning */
+  bool fbReadFirst; //!transient
+
   /** instance of the data handler providing the current data buffer */
   AliHLTOUTHandler* fpDataHandler; // !transient
 
-  ClassDef(AliRawReaderHLT, 3)
+  ClassDef(AliRawReaderHLT, 4)
 };
 
 #define ALIHLTREC_LIBRARY                   "libHLTrec.so"
index 965b8852023a0b64b667c0084671ab0e197bd712..45b73e192c9ca072c994159e3971fba7795572d1 100644 (file)
@@ -51,7 +51,7 @@ AliHLTOUTComponent::AliHLTOUTComponent()
   AliHLTOfflineDataSink(),
   fWriters(),
   fNofDDLs(10),
-  fIdFirstDDL(4864), // 0x13<<8
+  fIdFirstDDL(7680), // 0x1e<<8
   fWriteDigits(kTRUE),
   fWriteRaw(kTRUE),
   fBuffer(),
@@ -66,8 +66,11 @@ AliHLTOUTComponent::AliHLTOUTComponent()
   // I guess DDL definitions should never change any more
   assert(fNofDDLs==AliDAQ::NumberOfDdls("HLT"));
   fNofDDLs=AliDAQ::NumberOfDdls("HLT");
+  
+  /* AliDAQ::DdlIDOffset returns wrong offset for HLT links
   assert(fIdFirstDDL==AliDAQ::DdlIDOffset("HLT"));
   fIdFirstDDL=AliDAQ::DdlIDOffset("HLT");
+  */
 }
 
 AliHLTOUTComponent::~AliHLTOUTComponent()
@@ -184,9 +187,18 @@ int AliHLTOUTComponent::DumpEvent( const AliHLTComponentEventData& evtData,
     for (int n=0; n<(int)evtData.fBlockCnt; n++ ) {
       memset( homerHeader, 0, sizeof(homer_uint64)*kCount_64b_Words );
       homerDescriptor.Initialize();
-      homerDescriptor.SetType(*(reinterpret_cast<const homer_uint64*>(blocks[n].fDataType.fID)));
-      homerDescriptor.SetSubType1(*(reinterpret_cast<const homer_uint32*>(blocks[n].fDataType.fOrigin)));
-      homerDescriptor.SetSubType2(static_cast<homer_uint64>(blocks[n].fSpecification));
+      // for some traditional reason the TCPDumpSubscriber swaps the bytes
+      // of the data type id and data type origin. Actually I do not understand
+      // the corresponding code line
+      // homerBlock.SetType( blocks[n].fDataType.fID );
+      // this compiles in the PubSub framework and in addition does a byte swap
+      homer_uint64 id=0;
+      homer_uint64 origin=0;
+      memcpy(&id, blocks[n].fDataType.fID, sizeof(homer_uint64));
+      memcpy(((AliHLTUInt8_t*)&origin)+sizeof(homer_uint32), blocks[n].fDataType.fOrigin, sizeof(homer_uint32));
+      homerDescriptor.SetType(AliHLTOUT::Swap(id));
+      homerDescriptor.SetSubType1(AliHLTOUT::Swap(origin));
+      homerDescriptor.SetSubType2(blocks[n].fSpecification);
       homerDescriptor.SetBlockSize(blocks[n].fSize);
       int writerNo=ShuffleWriters(fWriters, blocks[n].fSize);
       assert(writerNo>=0 && writerNo<(int)fWriters.size());
@@ -296,7 +308,7 @@ int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pW
     AliHLTOUT::AliHLTOUTEventHeader* pHLTH=reinterpret_cast<AliHLTOUT::AliHLTOUTEventHeader*>(&fBuffer[sizeof(AliRawDataHeader)]);
     memset(pCDH, 0, sizeof(AliRawDataHeader));
     memset(pHLTH, 0, sizeof(AliHLTOUT::AliHLTOUTEventHeader));
-    pHLTH->fVersion=1;
+
     if (pWriter) {
       // copy payload
       pWriter->Copy(&fBuffer[sizeof(AliRawDataHeader)+sizeof(AliHLTOUT::AliHLTOUTEventHeader)], 0, 0, 0, 0);
@@ -306,8 +318,11 @@ int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pW
     }
     pHLTH->fLength+=sizeof(AliHLTOUT::AliHLTOUTEventHeader);
     pHLTH->fEventID=eventNo;
+    // version does not really matter since we do not add decision data
+    pHLTH->fVersion=AliHLTOUT::kVersion1;
 
     pCDH->fSize=sizeof(AliRawDataHeader)+pHLTH->fLength;
+    pCDH->fStatusMiniEventID|=0x1<<(AliHLTOUT::kCDHStatusFlagsOffset + AliHLTOUT::kCDHFlagsHLTPayload);
     
     pBuffer=&fBuffer[0];
     iResult=(int)bufferSize;