HLT/SampleLib/AliHLTDummyComponent.cxx

   1 // $Id$
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
   7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
   8  *          for The ALICE Off-line Project.                               *
   9  *                                                                        *
  10  * Permission to use, copy, modify and distribute this software and its   *
  11  * documentation strictly for non-commercial purposes is hereby granted   *
  12  * without fee, provided that the above copyright notice appears in all   *
  13  * copies and that both the copyright notice and this permission notice   *
  14  * appear in the supporting documentation. The authors make no claims     *
  15  * about the suitability of this software for any purpose. It is          *
  16  * provided "as is" without express or implied warranty.                  *
  17  **************************************************************************/
  18
  19 /** @file   AliHLTDummyComponent.cxx
  20     @author Timm Steinbeck, Matthias Richter
  21     @date
  22     @brief  A dummy processing component for the HLT. */
  23
  24 #if __GNUC__ >= 3
  25 using namespace std;
  26 #endif
  27
  28 #include "AliHLTSystem.h"
  29 #include "AliHLTDummyComponent.h"
  30 #include <stdlib.h>
  31 #include <errno.h>
  32
  33 // this is a global object used for automatic component registration, do not use this
  34 AliHLTDummyComponent gAliHLTDummyComponent;
  35
  36 ClassImp(AliHLTDummyComponent)
  37
  38 AliHLTDummyComponent::AliHLTDummyComponent()
  39   :
  40     fOutputPercentage(100) // By default we copy to the output exactly what we got as input
  41     {
  42     }
  43
  44 AliHLTDummyComponent::~AliHLTDummyComponent()
  45     {
  46     }
  47
  48 const char* AliHLTDummyComponent::GetComponentID()
  49     {
  50     return "Dummy"; // The ID of this component
  51     }
  52
  53 void AliHLTDummyComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  54     {
  55       /* in order to be backward compatible we have to keep the old code, at
  56        * least for a while. Remember to use the new const kAliHLTVoidDataType
  57        * if you are using a more recent AliRoot version (from Jan 07)
  58        list.push_back(kAliHLTAnyDataType); // We do not have any requirements for our input data type(s).
  59       */
  60
  61       AliHLTComponentDataType dt =
  62         { sizeof(AliHLTComponentDataType),
  63           {'*','*','*','*','*','*','*','\0'},
  64           {'*','*','*','\0'}};
  65        list.push_back(dt);
  66     }
  67
  68 AliHLTComponentDataType AliHLTDummyComponent::GetOutputDataType()
  69     {
  70       /* in order to be backward compatible we have to keep the old code, at
  71        * least for a while. Remember to use the new const kAliHLTVoidDataType
  72        * if you are using a more recent AliRoot version (from Jan 07)
  73       return kAliHLTVoidDataType;
  74       */
  75       AliHLTComponentDataType dt =
  76         { sizeof(AliHLTComponentDataType),
  77           {'\0','\0','\0','0','\0','\0','\0','\0'},
  78           {'\0','\0','\0','\0'}};
  79       return dt;
  80     }
  81
  82 void AliHLTDummyComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  83     {
  84     constBase = 0;
  85     inputMultiplier = ((double)fOutputPercentage)/100.0;
  86     }
  87
  88
  89
  90 // Spawn function, return new instance of this class
  91 AliHLTComponent* AliHLTDummyComponent::Spawn()
  92     {
  93     return new AliHLTDummyComponent;
  94     }
  95
  96 int AliHLTDummyComponent::DoInit( int argc, const char** argv )
  97     {
  98     // perform initialization. We check whether our relative output size is specified in the arguments.
  99     fOutputPercentage = 100;
 100     int i = 0;
 101     char* cpErr;
 102     while ( i < argc )
 103         {
 104         Logging( kHLTLogDebug, "HLT::Dummy::DoInit", "Arguments", "argv[%d] == %s", i, argv[i] );
 105         if ( !strcmp( argv[i], "output_percentage" ) )
 106             {
 107             if ( i+1>=argc )
 108                 {
 109                 Logging(kHLTLogError, "HLT::Dummy::DoInit", "Missing Argument", "Missing output_percentage parameter");
 110                 return ENOTSUP;
 111                 }
 112             Logging( kHLTLogDebug, "HLT::Dummy::DoInit", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
 113             fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
 114             if ( *cpErr )
 115                 {
 116                 Logging(kHLTLogError, "HLT::Dummy::DoInit", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
 117                 return EINVAL;
 118                 }
 119             Logging( kHLTLogInfo, "HLT::Dummy::DoInit", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
 120             i += 2;
 121             continue;
 122             }
 123         Logging(kHLTLogError, "HLT::Dummy::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
 124         return EINVAL;
 125         }
 126     return 0;
 127     }
 128
 129 int AliHLTDummyComponent::DoDeinit()
 130     {
 131     return 0;
 132     }
 133
 134 int AliHLTDummyComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
 135                                       AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr,
 136                                       AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
 137     {
 138     Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
 139     // Process an event
 140     unsigned long totalSize = 0;
 141     // Loop over all input blocks in the event
 142     for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
 143         {
 144         // Align the beginning of this  block to the required value.
 145         if ( totalSize % kAliHLTBlockAlignment )
 146             totalSize += kAliHLTBlockAlignment-(totalSize % kAliHLTBlockAlignment);
 147         if ( totalSize > size )
 148             break;
 149         // Determine the size we should use for the output for this block (the input block's size times the relative output size)
 150         unsigned long mySize = (blocks[n].fSize * fOutputPercentage) / 100;
 151         Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "mySize set (1)", "mySize == %lu B - blocks[%lu].fSize == %lu - fOutputPercentage == %lu",
 152                  mySize, n, blocks[n].fSize, fOutputPercentage );
 153         // Check how much space we have left and adapt this output block's size accordingly.
 154         if ( totalSize + mySize > size )
 155             mySize = size-totalSize;
 156         Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "mySize set (2)", "mySize == %lu B - totalSize == %lu - size == %lu",
 157                  mySize, totalSize, size );
 158         if ( mySize<=0 )
 159             continue; // No room left to write a further block.
 160         // Now copy the input block
 161         unsigned long copied = 0;
 162         // First copy all full multiples of the input block
 163         while ( copied+blocks[n].fSize <= mySize )
 164             {
 165             Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
 166                      blocks[n].fSize, copied, totalSize );
 167             memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, blocks[n].fSize );
 168             copied += blocks[n].fSize;
 169             }
 170         // And the copy the remaining fragment of the block
 171         Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Copying", "Copying %lu B - Copied: %lu B - totalSize: %lu B",
 172                  mySize-copied, copied, totalSize );
 173         memcpy( outputPtr+totalSize+copied, blocks[n].fPtr, mySize-copied );
 174         Logging( kHLTLogInfo, "HLT::Dummy::DoEvent", "Copied", "Copied: %lu B - totalSize: %lu B",
 175                  copied, totalSize );
 176         // Fill a block data structure for our output block.
 177         AliHLTComponentBlockData ob;
 178         // Let the structure be filled with the default values.
 179         // This takes care of setting the shared memory and data type values to default values,
 180         // so that they can be filled in by the calling code.
 181         FillBlockData( ob );
 182         // This block's start (offset) is after all other blocks written so far
 183         ob.fOffset = totalSize;
 184         // the size of this block's data.
 185         ob.fSize = mySize;
 186         // The specification of the data is copied from the input block.
 187         ob.fSpecification = blocks[n].fSpecification;
 188         // The data type is set automatically to the component's specified output data type.
 189         // Place this block into the list of output blocks
 190         outputBlocks.push_back( ob );
 191         // Increase the total amount of data written so far to our output memory
 192         totalSize += mySize;
 193         }
 194     // Finally we set the total size of output memory we consumed.
 195     size = totalSize;
 196     return 0;
 197     }