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" |
30 | #include "AliHLTComponentHandler.h" |
f23a6e1a |
31 | #include "AliHLTSystem.h" |
32 | |
b22e91eb |
33 | /** ROOT macro for the implementation of ROOT specific class methods */ |
f23a6e1a |
34 | ClassImp(AliHLTComponent) |
35 | |
f23a6e1a |
36 | AliHLTComponent::AliHLTComponent() |
85869391 |
37 | : |
53feaef5 |
38 | fEnvironment(), |
39 | fCurrentEvent(0) |
f23a6e1a |
40 | { |
41 | memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment)); |
42 | if (fpComponentHandler) |
43 | fpComponentHandler->ScheduleRegister(this); |
44 | } |
45 | |
46 | AliHLTComponent::~AliHLTComponent() |
47 | { |
48 | } |
49 | |
b22e91eb |
50 | AliHLTComponentHandler* AliHLTComponent::fpComponentHandler=NULL; |
51 | |
85869391 |
52 | int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite) |
53 | { |
54 | int iResult=0; |
55 | if (fpComponentHandler==NULL || bOverwrite!=0) |
56 | fpComponentHandler=pCH; |
57 | else |
58 | iResult=-EPERM; |
59 | return iResult; |
60 | } |
61 | |
62 | int AliHLTComponent::UnsetGlobalComponentHandler() { |
63 | return SetGlobalComponentHandler(NULL,1); |
64 | } |
65 | |
f23a6e1a |
66 | int AliHLTComponent::Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv ) |
67 | { |
68 | int iResult=0; |
69 | if (environ) { |
70 | memcpy(&fEnvironment, environ, sizeof(AliHLTComponentEnvironment)); |
71 | fEnvironment.fParam=environ_param; |
72 | } |
73 | iResult=DoInit(argc, argv); |
74 | return iResult; |
75 | } |
76 | |
77 | int AliHLTComponent::Deinit() |
78 | { |
79 | int iResult=0; |
80 | iResult=DoDeinit(); |
81 | return iResult; |
82 | } |
fa2e9b7c |
83 | |
53feaef5 |
84 | int AliHLTComponent::DoInit( int argc, const char** argv ) |
85 | { |
86 | if (argc==0 && argv==NULL) { |
87 | // this is currently just to get rid of the warning "unused parameter" |
88 | } |
89 | return 0; |
90 | } |
91 | |
92 | int AliHLTComponent::DoDeinit() |
93 | { |
94 | return 0; |
95 | } |
96 | |
8ede8717 |
97 | void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[14] ) { |
fa2e9b7c |
98 | memset( output, 0, 14 ); |
99 | strncat( output, type.fOrigin, 4 ); |
100 | strcat( output, ":" ); |
101 | strncat( output, type.fID, 8 ); |
102 | } |
103 | |
85869391 |
104 | void* AliHLTComponent::AllocMemory( unsigned long size ) { |
105 | if (fEnvironment.fAllocMemoryFunc) |
106 | return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size ); |
107 | return NULL; |
108 | } |
109 | |
8ede8717 |
110 | int AliHLTComponent::MakeOutputDataBlockList( const vector<AliHLTComponentBlockData>& blocks, AliHLTUInt32_t* blockCount, |
111 | AliHLTComponentBlockData** outputBlocks ) { |
fa2e9b7c |
112 | if ( !blockCount || !outputBlocks ) |
2d7ff710 |
113 | return -EFAULT; |
fa2e9b7c |
114 | AliHLTUInt32_t count = blocks.size(); |
115 | if ( !count ) |
116 | { |
117 | *blockCount = 0; |
118 | *outputBlocks = NULL; |
119 | return 0; |
120 | } |
8ede8717 |
121 | *outputBlocks = reinterpret_cast<AliHLTComponentBlockData*>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) ); |
fa2e9b7c |
122 | if ( !*outputBlocks ) |
2d7ff710 |
123 | return -ENOMEM; |
fa2e9b7c |
124 | for ( unsigned long i = 0; i < count; i++ ) |
125 | (*outputBlocks)[i] = blocks[i]; |
126 | *blockCount = count; |
127 | return 0; |
128 | |
129 | } |
0c0c9d99 |
130 | |
8ede8717 |
131 | int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) { |
85869391 |
132 | if (fEnvironment.fGetEventDoneDataFunc) |
133 | return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd ); |
134 | return -ENOSYS; |
135 | } |
136 | |
8ede8717 |
137 | int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, vector<AliHLTComponentDataType>* tgtList) |
0c0c9d99 |
138 | { |
139 | int iResult=0; |
140 | if (pConsumer) { |
8ede8717 |
141 | vector<AliHLTComponentDataType> ctlist; |
0c0c9d99 |
142 | ((AliHLTComponent*)pConsumer)->GetInputDataTypes(ctlist); |
8ede8717 |
143 | vector<AliHLTComponentDataType>::iterator type=ctlist.begin(); |
0c0c9d99 |
144 | while (type!=ctlist.end() && iResult==0) { |
145 | if ((*type)==GetOutputDataType()) { |
146 | if (tgtList) tgtList->push_back(*type); |
147 | iResult++; |
148 | break; |
149 | } |
150 | type++; |
151 | } |
152 | } else { |
153 | iResult=-EINVAL; |
154 | } |
155 | return iResult; |
156 | } |
2d7ff710 |
157 | |
158 | void AliHLTComponent::FillBlockData( AliHLTComponentBlockData& blockData ) { |
159 | blockData.fStructSize = sizeof(blockData); |
160 | FillShmData( blockData.fShmKey ); |
161 | blockData.fOffset = ~(AliHLTUInt32_t)0; |
162 | blockData.fPtr = NULL; |
163 | blockData.fSize = 0; |
164 | FillDataType( blockData.fDataType ); |
165 | blockData.fSpecification = ~(AliHLTUInt32_t)0; |
166 | } |
167 | |
168 | void AliHLTComponent::FillShmData( AliHLTComponentShmData& shmData ) { |
169 | shmData.fStructSize = sizeof(shmData); |
170 | shmData.fShmType = gkAliHLTComponentInvalidShmType; |
171 | shmData.fShmID = gkAliHLTComponentInvalidShmID; |
172 | } |
173 | |
174 | void AliHLTComponent::FillDataType( AliHLTComponentDataType& dataType ) { |
175 | dataType.fStructSize = sizeof(dataType); |
176 | memset( dataType.fID, '*', kAliHLTComponentDataTypefIDsize ); |
177 | memset( dataType.fOrigin, '*', kAliHLTComponentDataTypefOriginSize ); |
178 | } |
179 | |
180 | void AliHLTComponent::CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt) { |
181 | memcpy(&tgtdt.fID[0], &srcdt.fID[0], kAliHLTComponentDataTypefIDsize); |
182 | memcpy(&tgtdt.fOrigin[0], &srcdt.fOrigin[0], kAliHLTComponentDataTypefOriginSize); |
183 | } |
184 | |
185 | void AliHLTComponent::SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin) { |
186 | tgtdt.fStructSize = sizeof(AliHLTComponentDataType); |
187 | memset(&tgtdt.fID[0], 0, kAliHLTComponentDataTypefIDsize); |
188 | memset(&tgtdt.fOrigin[0], 0, kAliHLTComponentDataTypefOriginSize); |
189 | |
190 | if (strlen(id)>kAliHLTComponentDataTypefIDsize) { |
191 | HLTWarning("data type id %s is too long, truncated to %d", id, kAliHLTComponentDataTypefIDsize); |
192 | } |
193 | strncpy(&tgtdt.fID[0], id, kAliHLTComponentDataTypefIDsize); |
194 | |
195 | if (strlen(origin)>kAliHLTComponentDataTypefOriginSize) { |
196 | HLTWarning("data type origin %s is too long, truncated to %d", origin, kAliHLTComponentDataTypefOriginSize); |
197 | } |
198 | strncpy(&tgtdt.fOrigin[0], origin, kAliHLTComponentDataTypefOriginSize); |
199 | } |