- HOMER library manager completed
authorrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Oct 2007 19:54:25 +0000 (19:54 +0000)
committerrichterm <richterm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Oct 2007 19:54:25 +0000 (19:54 +0000)
- pure virtual interface for HOMER reader and writer added
- HLTOUT component completed (untested)
- fixes in documentation

13 files changed:
HLT/BASE/AliHLTHOMERLibManager.cxx
HLT/BASE/AliHLTHOMERLibManager.h
HLT/BASE/AliHLTOUTHomerBuffer.cxx
HLT/BASE/AliHLTOUTHomerBuffer.h
HLT/BASE/HOMER/AliHLTHOMERReader.cxx
HLT/BASE/HOMER/AliHLTHOMERReader.h
HLT/BASE/HOMER/AliHLTHOMERWriter.cxx
HLT/BASE/HOMER/AliHLTHOMERWriter.h
HLT/comp/AliHLTCompAgent.cxx
HLT/comp/AliHLTCompAgent.h
HLT/rec/AliHLTOUTRawReader.cxx
HLT/sim/AliHLTOUTComponent.cxx
HLT/sim/AliHLTOUTComponent.h

index 3b34994cb80a057a176aedce6f1aa78bc45574a7..3ec3698f836cff9cde911b94d611bd374c821f0f 100644 (file)
@@ -41,6 +41,8 @@ ClassImp(AliHLTHOMERLibManager)
 AliHLTHOMERLibManager::AliHLTHOMERLibManager()
   :
   fLibraryStatus(0),
+  fFctCreateReaderFromTCPPort(NULL),
+  fFctCreateReaderFromTCPPorts(NULL),
   fFctCreateReaderFromBuffer(NULL),
   fFctDeleteReader(NULL),
   fFctCreateWriter(NULL),
@@ -58,6 +60,40 @@ AliHLTHOMERLibManager::~AliHLTHOMERLibManager()
   // see header file for class documentation
 }
 
+AliHLTHOMERReader* AliHLTHOMERLibManager::OpenReader(const char* hostname, unsigned short port )
+{
+  // see header file for class documentation
+  if (fLibraryStatus<0) return NULL;
+
+  if (fLibraryStatus==0) {
+    fLibraryStatus=LoadHOMERLibrary();
+  }
+  
+  AliHLTHOMERReader* pReader=NULL;
+  if (fFctCreateReaderFromTCPPort!=NULL && (pReader=(((AliHLTHOMERReaderCreateFromTCPPort_t)fFctCreateReaderFromTCPPort)(hostname, port)))==NULL) {
+    HLTError("can not create instance of HOMER reader (function %p)", fFctCreateReaderFromTCPPort);
+  }
+  
+  return pReader;
+}
+
+AliHLTHOMERReader* AliHLTHOMERLibManager::OpenReader(unsigned int tcpCnt, const char** hostnames, unsigned short* ports)
+{
+  // see header file for class documentation
+  if (fLibraryStatus<0) return NULL;
+
+  if (fLibraryStatus==0) {
+    fLibraryStatus=LoadHOMERLibrary();
+  }
+  
+  AliHLTHOMERReader* pReader=NULL;
+  if (fFctCreateReaderFromTCPPorts!=NULL && (pReader=(((AliHLTHOMERReaderCreateFromTCPPorts_t)fFctCreateReaderFromTCPPorts)(tcpCnt, hostnames, ports)))==NULL) {
+    HLTError("can not create instance of HOMER reader (function %p)", fFctCreateReaderFromTCPPorts);
+  }
+  
+  return pReader;
+}
+
 AliHLTHOMERReader* AliHLTHOMERLibManager::OpenReader(const AliHLTUInt8_t* pBuffer, int size)
 {
   // see header file for class documentation
@@ -133,8 +169,7 @@ int AliHLTHOMERLibManager::LoadHOMERLibrary()
   do {
     TString libs = gSystem->GetLibraries();
     if (libs.Contains(*library) ||
-       (gSystem->Load(*library)) > 0) {
-      HLTDebug("%s (is) loaded", *library);
+       (gSystem->Load(*library)) >= 0) {
       iResult=1;
       break;
     }
@@ -155,18 +190,26 @@ int AliHLTHOMERLibManager::LoadHOMERLibrary()
       HLTInfo("no build info available for %s", *library);
     }
 
+    fFctCreateReaderFromTCPPort=gSystem->DynFindSymbol(*library, ALIHLTHOMERREADER_CREATE_FROM_TCPPORT);
+    fFctCreateReaderFromTCPPorts=gSystem->DynFindSymbol(*library, ALIHLTHOMERREADER_CREATE_FROM_TCPPORTS);
     fFctCreateReaderFromBuffer=gSystem->DynFindSymbol(*library, ALIHLTHOMERREADER_CREATE_FROM_BUFFER);
     fFctDeleteReader=gSystem->DynFindSymbol(*library, ALIHLTHOMERREADER_DELETE);
     fFctCreateWriter=gSystem->DynFindSymbol(*library, ALIHLTHOMERWRITER_CREATE);
     fFctDeleteWriter=gSystem->DynFindSymbol(*library, ALIHLTHOMERWRITER_DELETE);
-    if (fFctCreateReaderFromBuffer==NULL || fFctDeleteReader==NULL ||
-       fFctCreateWriter==NULL || fFctDeleteWriter==NULL) {
+    if (fFctCreateReaderFromTCPPort==NULL ||
+       fFctCreateReaderFromTCPPorts==NULL ||
+       fFctCreateReaderFromBuffer==NULL || 
+       fFctDeleteReader==NULL ||
+       fFctCreateWriter==NULL ||
+       fFctDeleteWriter==NULL) {
       iResult=-ENOSYS;
     } else {
-      HLTDebug("%s: create fct %p, delete fct %p", *library, fFctCreateReaderFromBuffer, fFctDeleteReader);
+      //HLTDebug("%s: entries found", *library);
     }
   }
   if (iResult<0 || *library==NULL) {
+    fFctCreateReaderFromTCPPort=NULL;
+    fFctCreateReaderFromTCPPorts=NULL;
     fFctCreateReaderFromBuffer=NULL;
     fFctDeleteReader=NULL;
     fFctCreateWriter=NULL;
index e896776b745164d0c081dbb9ec4b57ddd8e43c79..e26c98120435a1d02ab8771a783f67619c410746 100644 (file)
@@ -26,7 +26,35 @@ class AliHLTHOMERWriter;
 
 /**
  * @class AliHLTHOMERLibManager
- * Handler of HLTOUT data for buffer input.
+ * Dynamic manager of HOMER library.
+ * The class allows to generate objects of HOMER readers and writers
+ * dynamically and loads also the HOMER lib. In order to write HOMER library
+ * independent code it is important to use the AliHLTMonitoringWriter/
+ * AliHLTMonitoringReader classes when ever class methods are used. Those
+ * classes just define a virtual interface. <br>
+ *
+ * Instead of creating a reader or writer by \em new and deleting it with
+ * \em delete, one has to use the Open and Delete methods of this class.
+ *
+ * <pre>
+ * AliHLTHOMERLibManager manager;
+ *
+ * // open a HOMER reader listening at port 23000 of the localhost
+ * AliHLTMonitoringReader* pReader=manager.OpenReader(localhost, 23000);
+ *
+ * // read next event, timeout 5s
+ * while (pReader && pReader->ReadNextEvent(5000000)) {
+ *   unsigned long count=pReader->GetBlockCnt();
+ *   ...
+ * }
+ *
+ * // delete reader
+ * manager.DeleteReader(pReader);
+ * </pre>
+ *
+ * The manager does not not provide methods to create a HOMER reader on
+ * basis of shared memory. This is most likely a depricated functionality,
+ * although kept for the sake of completeness.
  */
 class AliHLTHOMERLibManager : public AliHLTLogging {
  public:
@@ -35,6 +63,32 @@ class AliHLTHOMERLibManager : public AliHLTLogging {
   /** destructor */
   virtual ~AliHLTHOMERLibManager();
 
+  /**
+   * Open a homer reader working on a TCP port.
+   */
+  AliHLTHOMERReader* OpenReader(const char* hostname, unsigned short port );
+  
+  /**
+   * Open a homer reader working on multiple TCP ports.
+   */
+  AliHLTHOMERReader* OpenReader(unsigned int tcpCnt, const char** hostnames, unsigned short* ports);
+       
+  /**
+   * Open a HOMER reader for reading from a System V shared memory segment.
+  AliHLTHOMERReader* OpenReader(key_t shmKey, int shmSize );
+   */
+       
+  /**
+   * Open a HOMER reader for reading from multiple System V shared memory segments
+  AliHLTHOMERReader* OpenReader(unsigned int shmCnt, key_t* shmKey, int* shmSize );
+   */
+       
+  /**
+   * Open a HOMER reader for reading from multiple TCP ports and multiple System V shared memory segments
+  AliHLTHOMERReader* OpenReader(unsigned int tcpCnt, const char** hostnames, unsigned short* ports, 
+                                   unsigned int shmCnt, key_t* shmKey, int* shmSize );
+   */
+
   /**
    * Open a HOMER reader.
    * Load HOMER library dynamically and create object working on the provided
@@ -77,6 +131,12 @@ class AliHLTHOMERLibManager : public AliHLTLogging {
   /** status of the loading of the HOMER library */
   int fLibraryStatus; //!transient
 
+  /** entry in the HOMER library */
+  void* fFctCreateReaderFromTCPPort; //!transient
+
+  /** entry in the HOMER library */
+  void* fFctCreateReaderFromTCPPorts; //!transient
+
   /** entry in the HOMER library */
   void* fFctCreateReaderFromBuffer; //!transient
 
index b93514b0423b9dc02a023b538dffc5b228e7d746..73a722a0e6e053a5957829ee6b37cc85c4a6edb6 100644 (file)
@@ -115,7 +115,7 @@ int AliHLTOUTHomerBuffer::CheckBlockAlignment(AliHLTUInt32_t index, AliHLTOUT::A
   return -ENODATA;
 }
 
-int AliHLTOUTHomerBuffer::ScanReader(AliHLTHOMERReader* pReader, AliHLTUInt32_t offset)
+int AliHLTOUTHomerBuffer::ScanReader(AliHLTMonitoringReader* pReader, AliHLTUInt32_t offset)
 {
   // see header file for class documentation
   int iResult=0;
@@ -138,14 +138,14 @@ int AliHLTOUTHomerBuffer::ScanReader(AliHLTHOMERReader* pReader, AliHLTUInt32_t
     // loop over data blocks
     HLTDebug("generating index for %d data blocks of reader with offset %#x", nofBlocks, offset);
     for (AliHLTUInt32_t i=0; i<nofBlocks && iResult>=0; i++) {
-//       homer_uint64 id=pReader->GetBlockDataType( i );
-//       homer_uint32 origin=pReader->GetBlockDataOrigin( i );
-//       homer_uint32 spec=pReader->GetBlockDataSpec( i );
-//       AliHLTComponentDataType dt;
-//       memcpy(&dt.fID, &id, kAliHLTComponentDataTypefIDsize);
-//       memcpy(&dt.fOrigin, &origin, kAliHLTComponentDataTypefOriginSize);
-//       AliHLTOUTBlockDescriptor desc(dt, spec, offset|i);
-//       iResult=AddBlockDescriptor(desc);
+      homer_uint64 id=pReader->GetBlockDataType( i );
+      homer_uint32 origin=pReader->GetBlockDataOrigin( i );
+      homer_uint32 spec=pReader->GetBlockDataSpec( i );
+      AliHLTComponentDataType dt;
+      memcpy(&dt.fID, &id, kAliHLTComponentDataTypefIDsize);
+      memcpy(&dt.fOrigin, &origin, kAliHLTComponentDataTypefOriginSize);
+      AliHLTOUTBlockDescriptor desc(dt, spec, offset|i);
+      iResult=AddBlockDescriptor(desc);
     }
   } else {
     iResult=-ENODEV;
index b8c3edbf7dff91744e8a028fdc5fa46c40663694..075325d3346c1a1d9be71baf012f83699c51eb30 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliHLTOUT.h"
 
 class AliHLTHOMERReader;
+class AliHLTMonitoringReader;
 class AliHLTHOMERLibManager;
 
 /**
@@ -38,7 +39,7 @@ class AliHLTOUTHomerBuffer : public AliHLTOUT {
   /**
    * Step trough data blocks of a HOMER reader and generate index.
    */
-  int ScanReader(AliHLTHOMERReader* pReader, AliHLTUInt32_t majorIndex=0);
+  int ScanReader(AliHLTMonitoringReader* pReader, AliHLTUInt32_t majorIndex=0);
 
   /** dynamic loader manager for HOMER library */
   AliHLTHOMERLibManager* fpManager; //!transient
index adb76ac79d2edfefcffad349a306cdd89e9132ac..2c9d9c410ffeee4d61373396700e7caf2a220e53 100644 (file)
@@ -1282,15 +1282,27 @@ homer_uint32 AliHLTHOMERReader::Swap( homer_uint8 destFormat, homer_uint8 source
        ((source & 0xFF000000UL) >> 24);
     }
 
-AliHLTHOMERReader* AliHLTHOMERReaderCreate(const void* pBuffer, int size)
+AliHLTHOMERReader* AliHLTHOMERReaderCreateFromTCPPort(const char* hostname, unsigned short port )
     {
-// see header file for function documentation
+      // see header file for function documentation
+      return new AliHLTHOMERReader(hostname, port);
+    }
+
+AliHLTHOMERReader* AliHLTHOMERReaderCreateFromTCPPorts(unsigned int tcpCnt, const char** hostnames, unsigned short* ports)
+    {
+      // see header file for function documentation
+      return new AliHLTHOMERReader(tcpCnt, hostnames, ports);
+    }
+
+AliHLTHOMERReader* AliHLTHOMERReaderCreateFromBuffer(const void* pBuffer, int size)
+    {
+      // see header file for function documentation
       return new AliHLTHOMERReader(pBuffer, size);
     }
 
 void AliHLTHOMERReaderDelete(AliHLTHOMERReader* pInstance)
     {
-// see header file for function documentation
+      // see header file for function documentation
       if (pInstance) delete pInstance;
     }
 
index bb4755139d7e8f437e760b6a3ea85a02e0bec7e2..4f185148e7cda812045ce51e44fa173cd4d2f7a6 100644 (file)
 
 
 
+/**
+ * @class AliHLTMonitoringReader
+ * The class provides a virtual interface for the HOMER reader.
+ * Used for dynamic generation of HOMER readers and dynamic loading of
+ * the libAliHLTHOMER library.
+ * @see AliHLTHOMERLibManager
+ */
 class AliHLTMonitoringReader
     {
     public:
@@ -78,6 +85,27 @@ class AliHLTMonitoringReader
 
        virtual homer_uint64 GetBlockStatusFlags( unsigned long ndx ) const = 0;
 
+       /* Return the type of the data in the current event's data
+          block with the given block index (starting at 0). */
+       virtual homer_uint64 GetBlockDataType( unsigned long ndx ) const = 0;
+       /* Return the origin of the data in the current event's data
+          block with the given block index (starting at 0). */
+       virtual homer_uint32 GetBlockDataOrigin( unsigned long ndx ) const = 0;
+       /* Return a specification of the data in the current event's data
+          block with the given block index (starting at 0). */
+       virtual homer_uint32 GetBlockDataSpec( unsigned long ndx ) const = 0;
+
+       /* Find the next data block in the current event with the given
+          data type, origin, and specification. Returns the block's 
+          index. */
+       virtual unsigned long FindBlockNdx( homer_uint64 type, homer_uint32 origin, 
+                                   homer_uint32 spec, unsigned long startNdx=0 ) const = 0;
+
+       /* Find the next data block in the current event with the given
+          data type, origin, and specification. Returns the block's 
+          index. */
+       virtual unsigned long FindBlockNdx( char type[8], char origin[4], 
+                                   homer_uint32 spec, unsigned long startNdx=0 ) const = 0;
 #ifdef USE_ROOT
         ClassDef(AliHLTMonitoringReader,1);
 #endif
@@ -313,19 +341,34 @@ typedef AliHLTMonitoringReader MonitoringReader;
 typedef AliHLTHOMERReader HOMERReader;
 
 // external interface of the HOMER reader
-#define ALIHLTHOMERREADER_CREATE_FROM_BUFFER "AliHLTHOMERReaderCreateFromBuffer"
-#define ALIHLTHOMERREADER_DELETE "AliHLTHOMERReaderDelete"
+#define ALIHLTHOMERREADER_CREATE_FROM_TCPPORT  "AliHLTHOMERReaderCreateFromTCPPort"
+#define ALIHLTHOMERREADER_CREATE_FROM_TCPPORTS "AliHLTHOMERReaderCreateFromTCPPorts"
+#define ALIHLTHOMERREADER_CREATE_FROM_BUFFER   "AliHLTHOMERReaderCreateFromBuffer"
+#define ALIHLTHOMERREADER_DELETE               "AliHLTHOMERReaderDelete"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+  typedef AliHLTHOMERReader* (*AliHLTHOMERReaderCreateFromTCPPort_t)(const char* hostname, unsigned short port );
+  typedef AliHLTHOMERReader* (*AliHLTHOMERReaderCreateFromTCPPorts_t)(unsigned int tcpCnt, const char** hostnames, unsigned short* ports);
   typedef AliHLTHOMERReader* (*AliHLTHOMERReaderCreateFromBuffer_t)(const void* pBuffer, int size);
   typedef void (*AliHLTHOMERReaderDelete_t)(AliHLTHOMERReader* pInstance);
+
+  /**
+   * Create instance of HOMER reader working on a TCP port.
+   */
+  AliHLTHOMERReader* AliHLTHOMERReaderCreateFromTCPPort(const char* hostname, unsigned short port );
+  
+  /**
+   * Create instance of HOMER reader working on multiple TCP ports.
+   */
+  AliHLTHOMERReader* AliHLTHOMERReaderCreateFromTCPPorts(unsigned int tcpCnt, const char** hostnames, unsigned short* ports);
+
   /**
-   * Create instance of HOMER reader.
+   * Create instance of HOMER reader working on buffer.
    */
-  AliHLTHOMERReader* AliHLTHOMERReaderCreateFromBuffer();
+  AliHLTHOMERReader* AliHLTHOMERReaderCreateFromBuffer(const void* pBuffer, int size);
 
   /**
    * Delete instance of HOMER reader.
index c94005a94397c32d4b06c9efbc581eacdac64f9d..8a8e50e77d4126668a1e793e6bbe5792e184c847 100644 (file)
@@ -52,29 +52,29 @@ AliHLTHOMERWriter::AliHLTHOMERWriter()
   fDataOffset(0),
   fBlocks()
     {
-// Writer implementation of the HOMER interface.
-// The HLT Monitoring Environment including ROOT is
-// a native interface to ship out data from the HLT chain.
-// See pdf document shiped with the package
-// for class documentation and tutorial.
+    // Writer implementation of the HOMER interface.
+    // The HLT Monitoring Environment including ROOT is
+    // a native interface to ship out data from the HLT chain.
+    // See pdf document shiped with the package
+    // for class documentation and tutorial.
     Clear();
     }
 
 AliHLTHOMERWriter::~AliHLTHOMERWriter()
     {
-// see header file for class documentation
+    // see header file for class documentation
     }
 
 void AliHLTHOMERWriter::Clear()
     {
-// see header file for class documentation
+    // see header file for class documentation
     fDataOffset = 0;
     fBlocks.clear();
     }
 
 void AliHLTHOMERWriter::AddBlock( const void* descriptor, const void* data )
     {
-// see header file for class documentation
+    // see header file for class documentation
     TBlockData bd;
     memcpy( bd.fDescriptor, descriptor, HOMERBlockDescriptor::GetHOMERBlockDescriptorSize() );
     bd.fData = data;
@@ -86,7 +86,7 @@ void AliHLTHOMERWriter::AddBlock( const void* descriptor, const void* data )
 
 homer_uint32 AliHLTHOMERWriter::GetTotalMemorySize( bool includeData )
     {
-// see header file for class documentation
+    // see header file for class documentation
     if ( includeData )
        return fDataOffset + HOMERBlockDescriptor::GetHOMERBlockDescriptorSize()*(fBlocks.size()+1);
     else
@@ -95,7 +95,7 @@ homer_uint32 AliHLTHOMERWriter::GetTotalMemorySize( bool includeData )
 
 void AliHLTHOMERWriter::Copy( void* destination, homer_uint64 eventType, homer_uint64 eventNr, homer_uint64 statusFlags, homer_uint64 nodeID, bool includeData )
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERBlockDescriptor homerBlock;
     homer_uint8* bd = reinterpret_cast<homer_uint8*>( destination );
     struct timeval now;
@@ -140,7 +140,7 @@ void AliHLTHOMERWriter::Copy( void* destination, homer_uint64 eventType, homer_u
 
 homer_uint8 AliHLTHOMERWriter::DetermineUInt64Alignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignment64TestStructure test;
     if ( (unsigned long)(&test.f64Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -149,19 +149,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt64Alignment()
        }
     if ( (unsigned long)(&test.f64Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The 64 bit element does not immedately follow the 32 bit element, 
+       // The 64 bit element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.f64Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The 64 bit element does not immedately follow the 16 bit element, 
+       // The 64 bit element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.f64Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The 64 bit element does not immedately follow the 8 bit element, 
+       // The 64 bit element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -170,7 +170,7 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt64Alignment()
 
 homer_uint8 AliHLTHOMERWriter::DetermineUInt32Alignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignment32TestStructure test;
     if ( (unsigned long)(&test.f32Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -179,19 +179,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt32Alignment()
        }
     if ( (unsigned long)(&test.f32Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The 32 bit element does not immedately follow the 32 bit element, 
+       // The 32 bit element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.f32Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The 32 bit element does not immedately follow the 16 bit element, 
+       // The 32 bit element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.f32Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The 32 bit element does not immedately follow the 8 bit element, 
+       // The 32 bit element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -200,7 +200,7 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt32Alignment()
 
 homer_uint8 AliHLTHOMERWriter::DetermineUInt16Alignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignment16TestStructure test;
     if ( (unsigned long)(&test.f16Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -209,19 +209,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt16Alignment()
        }
     if ( (unsigned long)(&test.f16Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The 16 bit element does not immedately follow the 32 bit element, 
+       // The 16 bit element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.f16Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The 16 bit element does not immedately follow the 16 bit element, 
+       // The 16 bit element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.f16Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The 16 bit element does not immedately follow the 8 bit element, 
+       // The 16 bit element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -230,7 +230,7 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt16Alignment()
 
 homer_uint8 AliHLTHOMERWriter::DetermineUInt8Alignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignment8TestStructure test;
     if ( (unsigned long)(&test.f8Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -239,19 +239,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt8Alignment()
        }
     if ( (unsigned long)(&test.f8Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The 8 bit element does not immedately follow the 32 bit element, 
+       // The 8 bit element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.f8Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The 8 bit element does not immedately follow the 16 bit element, 
+       // The 8 bit element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.f8Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The 8 bit element does not immedately follow the 8 bit element, 
+       // The 8 bit element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -260,7 +260,7 @@ homer_uint8 AliHLTHOMERWriter::DetermineUInt8Alignment()
 
 homer_uint8 AliHLTHOMERWriter::DetermineDoubleAlignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignmentDoubleTestStructure test;
     if ( (unsigned long)(&test.fDoubleTest64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -269,19 +269,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineDoubleAlignment()
        }
     if ( (unsigned long)(&test.fDoubleTest32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The double element does not immedately follow the 32 bit element, 
+       // The double element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.fDoubleTest16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The double element does not immedately follow the 16 bit element, 
+       // The double element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.fDoubleTest8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The double element does not immedately follow the 8 bit element, 
+       // The double element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -290,7 +290,7 @@ homer_uint8 AliHLTHOMERWriter::DetermineDoubleAlignment()
 
 homer_uint8 AliHLTHOMERWriter::DetermineFloatAlignment()
     {
-// see header file for class documentation
+    // see header file for class documentation
     HOMERWriterAlignmentFloatTestStructure test;
     if ( (unsigned long)(&test.fFloatTest64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
        {
@@ -299,19 +299,19 @@ homer_uint8 AliHLTHOMERWriter::DetermineFloatAlignment()
        }
     if ( (unsigned long)(&test.fFloatTest32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
        {
-       // The float element does not immedately follow the 32 bit element, 
+       // The float element does not immediately follow the 32 bit element, 
        // therefore the alignment has to be greater than 4.
        return (homer_uint8)8;
        }
     if ( (unsigned long)(&test.fFloatTest16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
        {
-       // The float element does not immedately follow the 16 bit element, 
+       // The float element does not immediately follow the 16 bit element, 
        // therefore the alignment has to be greater than 2.
        return (homer_uint8)4;
        }
     if ( (unsigned long)(&test.fFloatTest8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
        {
-       // The float element does not immedately follow the 8 bit element, 
+       // The float element does not immediately follow the 8 bit element, 
        // therefore the alignment has to be greater than 1.
        return (homer_uint8)2;
        }
@@ -320,14 +320,14 @@ homer_uint8 AliHLTHOMERWriter::DetermineFloatAlignment()
 
 AliHLTHOMERWriter* AliHLTHOMERWriterCreate()
     {
-// see header file for function documentation
-      return new AliHLTHOMERWriter();
+    // see header file for function documentation
+    return new AliHLTHOMERWriter();
     }
 
 void AliHLTHOMERWriterDelete(AliHLTHOMERWriter* pInstance)
     {
-// see header file for function documentation
-      if (pInstance) delete pInstance;
+    // see header file for function documentation
+    if (pInstance) delete pInstance;
     }
 
 
index 2fb72e8e29cae8203be5b3fa2270f251dc339043..dcd9420ac3218edd7c5facf9418802dd2cee2a72 100644 (file)
 #include "AliHLTHOMERData.h"
 #include <vector>
 
+/**
+ * @class AliHLTMonitoringWriter
+ * A pure virtual interface definition for HLT monitoring writers.
+ */
+class AliHLTMonitoringWriter
+    {
+    public:
+        AliHLTMonitoringWriter() {}
+        virtual ~AliHLTMonitoringWriter() {}
+
+       virtual void Clear() = 0;
+
+       virtual void AddBlock( const void* descriptor, const void* data ) = 0;
 
+       virtual homer_uint32 GetTotalMemorySize( bool includeData = true ) = 0;
+       virtual void Copy( void* destination, homer_uint64 eventType, homer_uint64 eventNr, homer_uint64 statusFlags, homer_uint64 nodeID, bool includeData = true ) = 0;
+     };
 
-class AliHLTHOMERWriter
+/**
+ * @class AliHLTHOMERWriter
+ * The HOMER writer assembles several data blocks of different properties
+ * into one big buffer and adds meta information to describe the data's
+ * alignment and byte order.
+ */
+class AliHLTHOMERWriter : public AliHLTMonitoringWriter
     {
     public:
 
        AliHLTHOMERWriter();
        virtual ~AliHLTHOMERWriter();
 
+        /**
+        * Resets the writer and clears the block list.
+         */
        void Clear();
 
        void AddBlock( const void* descriptor, const void* data );
@@ -66,17 +91,33 @@ class AliHLTHOMERWriter
                AddBlock( descriptor->GetHeader(), data );
                }
 
+        /**
+         * Get the total buffer size required to write all data into one buffer
+         */
        homer_uint32 GetTotalMemorySize( bool includeData = true );
+
+        /**
+         * Copy the data into a buffer.
+         * The buffer is supposed to be big enough, the capacity should be queried
+         * by calling @ref GetTotalMemorySize.
+         */
        void Copy( void* destination, homer_uint64 eventType, homer_uint64 eventNr, homer_uint64 statusFlags, homer_uint64 nodeID, bool includeData = true );
 
+        /** determine alignment of 64 bit variables */
        static homer_uint8 DetermineUInt64Alignment();
+        /** determine alignment of 32 bit variables */
        static homer_uint8 DetermineUInt32Alignment();
+        /** determine alignment of 16 bit variables */
        static homer_uint8 DetermineUInt16Alignment();
+        /** determine alignment of 8 bit variables */
        static homer_uint8 DetermineUInt8Alignment();
+        /** determine alignment of double type variables */
        static homer_uint8 DetermineDoubleAlignment();
+        /** determine alignment of float type bit variables */
        static homer_uint8 DetermineFloatAlignment();
 
 
+        /** test structure for the alignment determination of 64 bit variables */
         struct HOMERWriterAlignment64TestStructure
         {
                homer_uint64 f64Fill;   // !
@@ -88,6 +129,7 @@ class AliHLTHOMERWriter
                homer_uint8  f8Fill;    // !
                homer_uint64 f64Test8;  // !
         };
+        /** test structure for the alignment determination of 32 bit variables */
         struct HOMERWriterAlignment32TestStructure
         {
                homer_uint64 f64Fill;   // !
@@ -99,6 +141,7 @@ class AliHLTHOMERWriter
                homer_uint8  f8Fill;    // !
                homer_uint32 f32Test8;  // !
         };
+        /** test structure for the alignment determination of 16 bit variables */
         struct HOMERWriterAlignment16TestStructure
         {
                homer_uint64 f64Fill;   // !
@@ -110,6 +153,7 @@ class AliHLTHOMERWriter
                homer_uint8  f8Fill;    // !
                homer_uint16 f16Test8;  // !
         };
+        /** test structure for the alignment determination of 8 bit variables */
         struct HOMERWriterAlignment8TestStructure
         {
                homer_uint64 f64Fill; // !
@@ -121,6 +165,7 @@ class AliHLTHOMERWriter
                homer_uint8  f8Fill;  // !
                homer_uint8 f8Test8;  // !
         };
+        /** test structure for the alignment determination of double type variables */
         struct HOMERWriterAlignmentDoubleTestStructure
         {
                homer_uint64 f64Fill; // !
@@ -132,6 +177,7 @@ class AliHLTHOMERWriter
                homer_uint8  f8Fill;  // !
                double fDoubleTest8;  // !
         };
+        /** test structure for the alignment determination of float type variables */
         struct HOMERWriterAlignmentFloatTestStructure
         {
                homer_uint64 f64Fill; // !
@@ -145,8 +191,11 @@ class AliHLTHOMERWriter
         };
     protected:
 
-
-
+        /**
+         * Block descriptor structure.
+         * The descriptor contains a header for meta information and position
+         * and a pointer to the data.
+         */
        struct TBlockData
            {
              homer_uint64 fDescriptor[kCount_64b_Words]; //!transient
@@ -155,6 +204,7 @@ class AliHLTHOMERWriter
 
         unsigned long fDataOffset; //!transient
 
+        /** list of data blocks */
         std::vector<TBlockData> fBlocks; //!transient
 #ifdef USE_ROOT
       ClassDef(AliHLTHOMERWriter,0);
index 2fc7a916beec3c172fbf889ada5a924c7fe39bc5..81b44dfed49812837fced22ab49869f05dbd4bd0 100644 (file)
@@ -19,7 +19,7 @@
 /** @file   AliHLTCompAgent.cxx
     @author Matthias Richter
     @date   
-    @brief  Agent of the libHLTsim library
+    @brief  Agent of the libAliHLTComp library
 */
 
 // see header file for class documentation
index 31ee33639f315484a43061876fcc916887691c25..3d751a786720f099285d18a139e45435687bcc10 100644 (file)
@@ -68,7 +68,7 @@ class AliHLTCompAgent : public AliHLTModuleAgent {
   const char* GetRequiredComponentLibraries() const;
 
   /**
-   * Register components for the AliHLTSim library.
+   * Register components for the AliHLTComp library.
    * @param pHandler  [in] instance of the component handler          
    */
   int RegisterComponents(AliHLTComponentHandler* pHandler) const;
index 7dbfb468dd488acdf4c7bcebacd84c7e13e18e48..2f4fc6130fe2bd08616f07dd06887ece6190934f 100644 (file)
@@ -113,8 +113,9 @@ int AliHLTOUTRawReader::GetDataBuffer(AliHLTUInt32_t index, const AliHLTUInt8_t*
 
     // get data
     if (fpCurrent) {
-      if ((pBuffer=static_cast<const AliHLTUInt8_t*>(fpCurrent->GetBlockData(blockNo)))!=NULL) {
-       size=fpCurrent->GetBlockDataLength(blockNo);
+      AliHLTMonitoringReader* pReader=fpCurrent;
+      if ((pBuffer=static_cast<const AliHLTUInt8_t*>(pReader->GetBlockData(blockNo)))!=NULL) {
+       size=pReader->GetBlockDataLength(blockNo);
       } else {
        iResult=-ENOENT;
       }
index a377f82da52dbdc2d4cfd0464bdcfb6d51942904..db2494c860c911361290c497eaac6c3993edb064 100644 (file)
@@ -32,10 +32,11 @@ using namespace std;
 #endif
 
 #include <cassert>
+#include <iostream>
 #include "AliHLTOUTComponent.h"
 #include "AliHLTOUT.h"
 #include "AliHLTHOMERWriter.h"
-#include "AliDAQ.h" // euqipment Ids
+#include "AliDAQ.h" // equipment Ids
 #include "AliRawDataHeader.h" // Common Data Header 
 #include <TDatime.h> // seed for TRandom
 #include <TRandom.h> // random int generation for DDL no
@@ -51,7 +52,8 @@ AliHLTOUTComponent::AliHLTOUTComponent()
   fIdFirstDDL(4864), // 0x13<<8
   fWriteDigits(kTRUE),
   fWriteRaw(kTRUE),
-  fBuffer()
+  fBuffer(),
+  fpLibManager(NULL)
 {
   // see header file for class documentation
   // or
@@ -69,6 +71,8 @@ AliHLTOUTComponent::AliHLTOUTComponent()
 AliHLTOUTComponent::~AliHLTOUTComponent()
 {
   // see header file for class documentation
+  if (fpLibManager) delete fpLibManager;
+  fpLibManager=NULL;
 }
 
 const char* AliHLTOUTComponent::GetComponentID()
@@ -112,15 +116,20 @@ int AliHLTOUTComponent::DoInit( int argc, const char** argv )
   if (iResult>=0) {
   }
 
-  int writerNo=0;
-  for (writerNo=0; writerNo<fNofDDLs; writerNo++) {
-    AliHLTHOMERWriter* pWriter=new AliHLTHOMERWriter;
-    if (pWriter) {
-      fWriters.push_back(pWriter);
-    } else {
-      iResult=-ENOMEM;
-      break;
+  fpLibManager=new AliHLTHOMERLibManager;
+  if (fpLibManager) {
+    int writerNo=0;
+    for (writerNo=0; writerNo<fNofDDLs; writerNo++) {
+      AliHLTMonitoringWriter* pWriter=fpLibManager->OpenWriter();
+      if (pWriter) {
+       fWriters.push_back(pWriter);
+      } else {
+       iResult=-ENOMEM;
+       break;
+      }
     }
+  } else {
+    iResult=-ENOMEM;
   }
 
   return iResult;
@@ -131,11 +140,13 @@ int AliHLTOUTComponent::DoDeinit()
   // see header file for class documentation
   int iResult=0;
 
-  vector<AliHLTHOMERWriter*>::iterator element=fWriters.begin();
-  while (element!= fWriters.end()) {
-    assert(*element);
-    if (*element!=NULL) delete *element;
-    element=fWriters.erase(element);
+  if (fpLibManager) {
+    AliHLTMonitoringWriterPVector::iterator element=fWriters.begin();
+    while (element!= fWriters.end()) {
+      assert(*element);
+      if (*element!=NULL) fpLibManager->DeleteWriter(dynamic_cast<AliHLTHOMERWriter*>(*element));
+      element=fWriters.erase(element);
+    }
   }
   
   return iResult;
@@ -175,7 +186,7 @@ int AliHLTOUTComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEven
   
   // search for the writer with the biggest data volume in order to allocate the
   // output buffer of sufficient size
-  AliHLTHOMERWriterPVector::iterator writer=fWriters.begin();
+  AliHLTMonitoringWriterPVector::iterator writer=fWriters.begin();
   vector<int> sorted;
   for (int i=0; i<fWriters.size(); i++) {
     assert(fWriters[i]);
@@ -203,7 +214,7 @@ int AliHLTOUTComponent::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEven
   return iResult;
 }
 
-int AliHLTOUTComponent::ShuffleWriters(AliHLTHOMERWriterPVector &list, AliHLTUInt32_t size)
+int AliHLTOUTComponent::ShuffleWriters(AliHLTMonitoringWriterPVector &list, AliHLTUInt32_t size)
 {
   // see header file for class documentation
   int iResult=-ENOENT;
@@ -237,7 +248,7 @@ int AliHLTOUTComponent::ShuffleWriters(AliHLTHOMERWriterPVector &list, AliHLTUIn
   return iResult;
 }
 
-int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTHOMERWriter* pWriter, const AliHLTUInt8_t* &pBuffer)
+int AliHLTOUTComponent::FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pWriter, const AliHLTUInt8_t* &pBuffer)
 {
   // see header file for class documentation
   int iResult=0;
@@ -295,8 +306,8 @@ int AliHLTOUTComponent::WriteRawFile(int eventNo, AliRunLoader* runLoader, int h
   // see header file for class documentation
   int iResult=0;
   const char* fileName=AliDAQ::DdlFileName("HLT", hltddl);
-  TString filePath;
   assert(fileName!=NULL);
+  TString filePath(fileName);
   if (fileName) {
     ios::openmode filemode=(ios::openmode)0;
     ofstream rawfile(filePath.Data(), filemode);
index d7b957040eb7265e85e94611bdb06b30c22596a9..74a4f12a2c77e3425d9f1dbfda0aff2807724a3d 100644 (file)
 
 #include <vector>
 #include "AliHLTOfflineDataSink.h"
-#include <TString.h>
+#include "AliHLTHOMERLibManager.h"
 
-class AliHLTHOMERWriter;
-typedef vector<AliHLTHOMERWriter*> AliHLTHOMERWriterPVector;
+class AliHLTMonitoringWriter;
+typedef vector<AliHLTMonitoringWriter*> AliHLTMonitoringWriterPVector;
 
 /**
  * @class AliHLTOUTComponent
@@ -80,7 +80,7 @@ class AliHLTOUTComponent : public AliHLTOfflineDataSink  {
   /** assignment operator prohibited */
   AliHLTOUTComponent& operator=(const AliHLTOUTComponent&);
 
-  int ShuffleWriters(AliHLTHOMERWriterPVector &list, AliHLTUInt32_t size);
+  int ShuffleWriters(AliHLTMonitoringWriterPVector &list, AliHLTUInt32_t size);
 
   /**
    * Fill the output buffer and allocate if neccessary.
@@ -92,7 +92,7 @@ class AliHLTOUTComponent : public AliHLTOfflineDataSink  {
    * @param pBuffer    [OUT] target to receive the pointer to buffer
    * @return size of the buffer
    */
-  int FillOutputBuffer(int eventNo, AliHLTHOMERWriter* pWriter, const AliHLTUInt8_t* &pBuffer);
+  int FillOutputBuffer(int eventNo, AliHLTMonitoringWriter* pWriter, const AliHLTUInt8_t* &pBuffer);
 
   /**
    * Write the digits for one DDL
@@ -117,7 +117,7 @@ class AliHLTOUTComponent : public AliHLTOfflineDataSink  {
   int WriteRawFile(int eventNo, AliRunLoader* runLoader, int hltddl, const AliHLTUInt8_t* pBuffer, int size);
 
   /** list of HOMER writers */
-  AliHLTHOMERWriterPVector fWriters; //!transient
+  AliHLTMonitoringWriterPVector fWriters; //!transient
 
   /** number of DDLs used*/
   int fNofDDLs; //!transient
@@ -134,6 +134,9 @@ class AliHLTOUTComponent : public AliHLTOfflineDataSink  {
   /** output buffer, allocated once in order to avoid frequent alloc/dealloc */
   vector<AliHLTUInt8_t> fBuffer; //!transient
 
+  /** instance of the HOMER library manager */
+  AliHLTHOMERLibManager* fpLibManager; // !transient
+
   ClassDef(AliHLTOUTComponent, 0)
 };
 #endif