[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTComponent.cxx

// $Id$

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
 *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
 *          for The ALICE Off-line Project.                               *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTComponent.cxx
    @author Matthias Richter, Timm Steinbeck
    @date   
    @brief  Base class implementation for HLT components. */

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTStdIncludes.h"
#include "AliHLTComponent.h"
#include "AliHLTComponentHandler.h"
#include "AliHLTSystem.h"

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTComponent)

AliHLTComponent::AliHLTComponent()
  :
  fEnvironment(),
  fCurrentEvent(0),
  fEventCount(-1)
{ 
  memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
  if (fpComponentHandler)
    fpComponentHandler->ScheduleRegister(this);
}

AliHLTComponent::~AliHLTComponent()
{
}

AliHLTComponentHandler* AliHLTComponent::fpComponentHandler=NULL;

int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite) 
{
  int iResult=0;
  if (fpComponentHandler==NULL || bOverwrite!=0)
    fpComponentHandler=pCH;
  else
    iResult=-EPERM;
  return iResult;
}

int AliHLTComponent::UnsetGlobalComponentHandler() {
  return SetGlobalComponentHandler(NULL,1);
}

int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv )
{
  int iResult=0;
  if (environ) {
    memcpy(&fEnvironment, environ, sizeof(AliHLTComponentEnvironment));
    fEnvironment.fParam=environ_param;
  }
  iResult=DoInit(argc, argv);
  if (iResult>=0) fEventCount=0;
  return iResult;
}

int AliHLTComponent::Deinit()
{
  int iResult=0;
  iResult=DoDeinit();
  return iResult;
}

int AliHLTComponent::DoInit( int argc, const char** argv )
{
  if (argc==0 && argv==NULL) {
    // this is currently just to get rid of the warning "unused parameter"
  }
  return 0;
}

int AliHLTComponent::DoDeinit()
{
  return 0;
}

void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2] ) {
  memset( output, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
  strncat( output, type.fOrigin, kAliHLTComponentDataTypefOriginSize );
  strcat( output, ":" );
  strncat( output, type.fID, kAliHLTComponentDataTypefIDsize );
}

string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type )
{
  string out("");
  
  if (type==kAliHLTVoidDataType) {
    out="VOID:VOID";
  } else {
    // some gymnastics in order to avoid a '0' which is part of either or both
    // ID and origin terminating the whole string. Unfortunately, string doesn't
    // stop appending at the '0' if the number of elements to append was 
    // explicitely specified
    string tmp("");
    tmp.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
    out.append(tmp.c_str());
    out.append(":");
    tmp="";
    tmp.append(type.fID, kAliHLTComponentDataTypefIDsize);
    out.append(tmp.c_str());
  }
  return out;
}


void* AliHLTComponent::AllocMemory( unsigned long size ) {
  if (fEnvironment.fAllocMemoryFunc)
    return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
  HLTFatal("no memory allocation handler registered");
  return NULL;
}

int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount,
					      AliHLTComponentBlockData** outputBlocks ) {
    if ( blockCount==NULL || outputBlocks==NULL )
	return -EFAULT;
    AliHLTUInt32_t count = blocks.size();
    if ( !count )
	{
	*blockCount = 0;
	*outputBlocks = NULL;
	return 0;
	}
    *outputBlocks = reinterpret_cast<AliHLTComponentBlockData*>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) );
    if ( !*outputBlocks )
	return -ENOMEM;
    for ( unsigned long i = 0; i < count; i++ ) {
	(*outputBlocks)[i] = blocks[i];
	if (blocks[i].fDataType==kAliHLTAnyDataType) {
	  memset((*outputBlocks)[i].fDataType.fID, '*', kAliHLTComponentDataTypefIDsize);
	  memset((*outputBlocks)[i].fDataType.fOrigin, '*', kAliHLTComponentDataTypefOriginSize);
	}
    }
    *blockCount = count;
    return 0;

}

int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) {
  if (fEnvironment.fGetEventDoneDataFunc)
    return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
  return -ENOSYS;
}

int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList) 
{
  int iResult=0;
  if (pConsumer) {
    vector<AliHLTComponentDataType> ctlist;
    ((AliHLTComponent*)pConsumer)->GetInputDataTypes(ctlist);
    vector<AliHLTComponentDataType>::iterator type=ctlist.begin();
    while (type!=ctlist.end() && iResult==0) {
      if ((*type)==GetOutputDataType() ||
	  (*type)==kAliHLTAnyDataType) {
	if (tgtList) tgtList->push_back(*type);
	iResult++;
	// this loop has to be changed in case of multiple output types
	break;
      }
      type++;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

void AliHLTComponent::FillBlockData( AliHLTComponentBlockData& blockData ) {
  blockData.fStructSize = sizeof(blockData);
  FillShmData( blockData.fShmKey );
  blockData.fOffset = ~(AliHLTUInt32_t)0;
  blockData.fPtr = NULL;
  blockData.fSize = 0;
  FillDataType( blockData.fDataType );
  blockData.fSpecification = ~(AliHLTUInt32_t)0;
}

void AliHLTComponent::FillShmData( AliHLTComponentShmData& shmData ) {
  shmData.fStructSize = sizeof(shmData);
  shmData.fShmType = gkAliHLTComponentInvalidShmType;
  shmData.fShmID = gkAliHLTComponentInvalidShmID;
}

void AliHLTComponent::FillDataType( AliHLTComponentDataType& dataType ) {
  dataType=kAliHLTAnyDataType;
}

void AliHLTComponent::CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt) {
  memcpy(&tgtdt.fID[0], &srcdt.fID[0], kAliHLTComponentDataTypefIDsize);
  memcpy(&tgtdt.fOrigin[0], &srcdt.fOrigin[0], kAliHLTComponentDataTypefOriginSize);
}

void AliHLTComponent::SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin) {
  tgtdt.fStructSize = sizeof(AliHLTComponentDataType);
  memset(&tgtdt.fID[0], 0, kAliHLTComponentDataTypefIDsize);
  memset(&tgtdt.fOrigin[0], 0, kAliHLTComponentDataTypefOriginSize);

  if ((int)strlen(id)>kAliHLTComponentDataTypefIDsize) {
    HLTWarning("data type id %s is too long, truncated to %d", id, kAliHLTComponentDataTypefIDsize);
  }
  strncpy(&tgtdt.fID[0], id, kAliHLTComponentDataTypefIDsize);

  if ((int)strlen(origin)>kAliHLTComponentDataTypefOriginSize) {
    HLTWarning("data type origin %s is too long, truncated to %d", origin, kAliHLTComponentDataTypefOriginSize);
  }
  strncpy(&tgtdt.fOrigin[0], origin, kAliHLTComponentDataTypefOriginSize);
}

void AliHLTComponent::FillEventData(AliHLTComponentEventData& evtData)
{
  memset(&evtData, 0, sizeof(AliHLTComponentEventData));
  evtData.fStructSize=sizeof(AliHLTComponentEventData);
}

void AliHLTComponent::PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt) {
  TString msg;
  msg.Form("AliHLTComponentDataType(%d): ID=\"", dt.fStructSize);
  for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) {
   if (dt.fID[i]!=0) msg+=dt.fID[i];
   else msg+="\\0";
  }
  msg+="\" Origin=\"";
  for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) {
   if (dt.fOrigin[i]!=0) msg+=dt.fOrigin[i];
   else msg+="\\0";
  }
  msg+="\"";
  AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, msg.Data());
}

int AliHLTComponent::GetEventCount()
{
  return fEventCount;
}

int AliHLTComponent::IncrementEventCounter()
{
  if (fEventCount>=0) fEventCount++;
  return fEventCount;
}

int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
				   const AliHLTComponentBlockData* blocks, 
				   AliHLTComponentTriggerData& trigData,
				   AliHLTUInt8_t* outputPtr, 
				   AliHLTUInt32_t& size,
				   AliHLTUInt32_t& outputBlockCnt, 
				   AliHLTComponentBlockData*& outputBlocks,
				   AliHLTComponentEventDoneData*& edd )
{
  int iResult=0;
  fCurrentEvent=evtData.fEventID;
  iResult=DoProcessing(evtData, blocks, trigData, outputPtr, size, outputBlockCnt, outputBlocks, edd);
  IncrementEventCounter();
  return iResult;
}
Commit	Line	Data
f23a6e1a	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> *
f23a6e1a	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
bfccbf68	19	/** @file AliHLTComponent.cxx
	20	@author Matthias Richter, Timm Steinbeck
	21	@date
	22	@brief Base class implementation for HLT components. */
f23a6e1a	23
0c0c9d99	24	#if __GNUC__>= 3
f23a6e1a	25	using namespace std;
	26	#endif
	27
85869391	28	#include "AliHLTStdIncludes.h"
f23a6e1a	29	#include "AliHLTComponent.h"
f23a6e1a	30	#include "AliHLTComponentHandler.h"
f23a6e1a	31	#include "AliHLTSystem.h"
f23a6e1a	32
b22e91eb	33	/** ROOT macro for the implementation of ROOT specific class methods */
f23a6e1a	34	ClassImp(AliHLTComponent)
f23a6e1a	35
f23a6e1a	36	AliHLTComponent::AliHLTComponent()
85869391	37	:
53feaef5	38	fEnvironment(),
3cde846d	39	fCurrentEvent(0),
3cde846d	40	fEventCount(-1)
f23a6e1a	41	{
	42	memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
	43	if (fpComponentHandler)
	44	fpComponentHandler->ScheduleRegister(this);
	45	}
	46
	47	AliHLTComponent::~AliHLTComponent()
	48	{
	49	}
	50
b22e91eb	51	AliHLTComponentHandler* AliHLTComponent::fpComponentHandler=NULL;
b22e91eb	52
85869391	53	int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite)
	54	{
	55	int iResult=0;
	56	if (fpComponentHandler==NULL \|\| bOverwrite!=0)
	57	fpComponentHandler=pCH;
	58	else
	59	iResult=-EPERM;
	60	return iResult;
	61	}
	62
	63	int AliHLTComponent::UnsetGlobalComponentHandler() {
	64	return SetGlobalComponentHandler(NULL,1);
	65	}
	66
f23a6e1a	67	int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv )
	68	{
	69	int iResult=0;
	70	if (environ) {
	71	memcpy(&fEnvironment, environ, sizeof(AliHLTComponentEnvironment));
	72	fEnvironment.fParam=environ_param;
	73	}
	74	iResult=DoInit(argc, argv);
3cde846d	75	if (iResult>=0) fEventCount=0;
f23a6e1a	76	return iResult;
	77	}
	78
	79	int AliHLTComponent::Deinit()
	80	{
	81	int iResult=0;
	82	iResult=DoDeinit();
	83	return iResult;
	84	}
fa2e9b7c	85
53feaef5	86	int AliHLTComponent::DoInit( int argc, const char** argv )
	87	{
	88	if (argc==0 && argv==NULL) {
	89	// this is currently just to get rid of the warning "unused parameter"
	90	}
	91	return 0;
	92	}
	93
	94	int AliHLTComponent::DoDeinit()
	95	{
	96	return 0;
	97	}
	98
9ce4bf4a	99	void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2] ) {
	100	memset( output, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
	101	strncat( output, type.fOrigin, kAliHLTComponentDataTypefOriginSize );
	102	strcat( output, ":" );
	103	strncat( output, type.fID, kAliHLTComponentDataTypefIDsize );
fa2e9b7c	104	}
fa2e9b7c	105
9ce4bf4a	106	string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type )
	107	{
	108	string out("");
3cde846d	109
9ce4bf4a	110	if (type==kAliHLTVoidDataType) {
	111	out="VOID:VOID";
	112	} else {
3cde846d	113	// some gymnastics in order to avoid a '0' which is part of either or both
	114	// ID and origin terminating the whole string. Unfortunately, string doesn't
	115	// stop appending at the '0' if the number of elements to append was
	116	// explicitely specified
	117	string tmp("");
	118	tmp.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
	119	out.append(tmp.c_str());
9ce4bf4a	120	out.append(":");
3cde846d	121	tmp="";
	122	tmp.append(type.fID, kAliHLTComponentDataTypefIDsize);
	123	out.append(tmp.c_str());
9ce4bf4a	124	}
	125	return out;
	126	}
	127
	128
85869391	129	void* AliHLTComponent::AllocMemory( unsigned long size ) {
	130	if (fEnvironment.fAllocMemoryFunc)
	131	return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
9ce4bf4a	132	HLTFatal("no memory allocation handler registered");
85869391	133	return NULL;
	134	}
	135
8ede8717	136	int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount,
8ede8717	137	AliHLTComponentBlockData** outputBlocks ) {
9ce4bf4a	138	if ( blockCount==NULL \|\| outputBlocks==NULL )
2d7ff710	139	return -EFAULT;
fa2e9b7c	140	AliHLTUInt32_t count = blocks.size();
	141	if ( !count )
	142	{
	143	*blockCount = 0;
	144	*outputBlocks = NULL;
	145	return 0;
	146	}
8ede8717	147	outputBlocks = reinterpret_cast<AliHLTComponentBlockData>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) );
fa2e9b7c	148	if ( !*outputBlocks )
2d7ff710	149	return -ENOMEM;
ca8524df	150	for ( unsigned long i = 0; i < count; i++ ) {
fa2e9b7c	151	(*outputBlocks)[i] = blocks[i];
ca8524df	152	if (blocks[i].fDataType==kAliHLTAnyDataType) {
	153	memset((outputBlocks)[i].fDataType.fID, '', kAliHLTComponentDataTypefIDsize);
	154	memset((outputBlocks)[i].fDataType.fOrigin, '', kAliHLTComponentDataTypefOriginSize);
	155	}
	156	}
fa2e9b7c	157	*blockCount = count;
	158	return 0;
	159
	160	}
0c0c9d99	161
8ede8717	162	int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) {
85869391	163	if (fEnvironment.fGetEventDoneDataFunc)
	164	return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
	165	return -ENOSYS;
	166	}
	167
8ede8717	168	int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList)
0c0c9d99	169	{
	170	int iResult=0;
	171	if (pConsumer) {
8ede8717	172	vector<AliHLTComponentDataType> ctlist;
0c0c9d99	173	((AliHLTComponent*)pConsumer)->GetInputDataTypes(ctlist);
8ede8717	174	vector<AliHLTComponentDataType>::iterator type=ctlist.begin();
0c0c9d99	175	while (type!=ctlist.end() && iResult==0) {
9ce4bf4a	176	if ((*type)==GetOutputDataType() \|\|
9ce4bf4a	177	(*type)==kAliHLTAnyDataType) {
0c0c9d99	178	if (tgtList) tgtList->push_back(*type);
0c0c9d99	179	iResult++;
9ce4bf4a	180	// this loop has to be changed in case of multiple output types
0c0c9d99	181	break;
	182	}
	183	type++;
	184	}
	185	} else {
	186	iResult=-EINVAL;
	187	}
	188	return iResult;
	189	}
2d7ff710	190
	191	void AliHLTComponent::FillBlockData( AliHLTComponentBlockData& blockData ) {
	192	blockData.fStructSize = sizeof(blockData);
	193	FillShmData( blockData.fShmKey );
	194	blockData.fOffset = ~(AliHLTUInt32_t)0;
	195	blockData.fPtr = NULL;
	196	blockData.fSize = 0;
	197	FillDataType( blockData.fDataType );
	198	blockData.fSpecification = ~(AliHLTUInt32_t)0;
	199	}
	200
	201	void AliHLTComponent::FillShmData( AliHLTComponentShmData& shmData ) {
	202	shmData.fStructSize = sizeof(shmData);
	203	shmData.fShmType = gkAliHLTComponentInvalidShmType;
	204	shmData.fShmID = gkAliHLTComponentInvalidShmID;
	205	}
	206
	207	void AliHLTComponent::FillDataType( AliHLTComponentDataType& dataType ) {
ca8524df	208	dataType=kAliHLTAnyDataType;
2d7ff710	209	}
	210
	211	void AliHLTComponent::CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt) {
	212	memcpy(&tgtdt.fID[0], &srcdt.fID[0], kAliHLTComponentDataTypefIDsize);
	213	memcpy(&tgtdt.fOrigin[0], &srcdt.fOrigin[0], kAliHLTComponentDataTypefOriginSize);
	214	}
	215
	216	void AliHLTComponent::SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin) {
	217	tgtdt.fStructSize = sizeof(AliHLTComponentDataType);
	218	memset(&tgtdt.fID[0], 0, kAliHLTComponentDataTypefIDsize);
	219	memset(&tgtdt.fOrigin[0], 0, kAliHLTComponentDataTypefOriginSize);
	220
9ce4bf4a	221	if ((int)strlen(id)>kAliHLTComponentDataTypefIDsize) {
2d7ff710	222	HLTWarning("data type id %s is too long, truncated to %d", id, kAliHLTComponentDataTypefIDsize);
	223	}
	224	strncpy(&tgtdt.fID[0], id, kAliHLTComponentDataTypefIDsize);
	225
9ce4bf4a	226	if ((int)strlen(origin)>kAliHLTComponentDataTypefOriginSize) {
2d7ff710	227	HLTWarning("data type origin %s is too long, truncated to %d", origin, kAliHLTComponentDataTypefOriginSize);
	228	}
	229	strncpy(&tgtdt.fOrigin[0], origin, kAliHLTComponentDataTypefOriginSize);
	230	}
9ce4bf4a	231
	232	void AliHLTComponent::FillEventData(AliHLTComponentEventData& evtData)
	233	{
	234	memset(&evtData, 0, sizeof(AliHLTComponentEventData));
	235	evtData.fStructSize=sizeof(AliHLTComponentEventData);
	236	}
	237
	238	void AliHLTComponent::PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt) {
	239	TString msg;
	240	msg.Form("AliHLTComponentDataType(%d): ID=\"", dt.fStructSize);
	241	for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) {
	242	if (dt.fID[i]!=0) msg+=dt.fID[i];
	243	else msg+="\\0";
	244	}
	245	msg+="\" Origin=\"";
	246	for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) {
	247	if (dt.fOrigin[i]!=0) msg+=dt.fOrigin[i];
	248	else msg+="\\0";
	249	}
	250	msg+="\"";
3cde846d	251	AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, msg.Data());
9ce4bf4a	252	}
9ce4bf4a	253
3cde846d	254	int AliHLTComponent::GetEventCount()
	255	{
	256	return fEventCount;
	257	}
	258
	259	int AliHLTComponent::IncrementEventCounter()
	260	{
	261	if (fEventCount>=0) fEventCount++;
	262	return fEventCount;
	263	}
	264
	265	int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
	266	const AliHLTComponentBlockData* blocks,
	267	AliHLTComponentTriggerData& trigData,
	268	AliHLTUInt8_t* outputPtr,
	269	AliHLTUInt32_t& size,
	270	AliHLTUInt32_t& outputBlockCnt,
	271	AliHLTComponentBlockData*& outputBlocks,
	272	AliHLTComponentEventDoneData*& edd )
	273	{
	274	int iResult=0;
	275	fCurrentEvent=evtData.fEventID;
	276	iResult=DoProcessing(evtData, blocks, trigData, outputPtr, size, outputBlockCnt, outputBlocks, edd);
	277	IncrementEventCounter();
	278	return iResult;
	279	}