b279f02a530dcdfd3aadf458a6228d861ffabb61
[u/mrichter/AliRoot.git] / HLT / BASE / HOMER / AliHLTHOMERWriter.cxx
1 /************************************************************************
2 **
3 **
4 ** This file is property of and copyright by the Technical Computer
5 ** Science Group, Kirchhoff Institute for Physics, Ruprecht-Karls-
6 ** University, Heidelberg, Germany, 2001
7 ** This file has been written by Timm Morten Steinbeck, 
8 ** timm@kip.uni-heidelberg.de
9 **
10 **
11 ** See the file license.txt for details regarding usage, modification,
12 ** distribution and warranty.
13 ** Important: This file is provided without any warranty, including
14 ** fitness for any particular purpose.
15 **
16 **
17 ** Newer versions of this file's package will be made available from 
18 ** http://web.kip.uni-heidelberg.de/Hardwinf/L3/ 
19 ** or the corresponding page of the Heidelberg Alice Level 3 group.
20 **
21 *************************************************************************/
22
23 /*
24 ***************************************************************************
25 **
26 ** $Author$ - Initial Version by Timm Morten Steinbeck
27 **
28 ** $Id$ 
29 **
30 ***************************************************************************
31 */
32
33 /** @file   AliHLTHOMERWriter.cxx
34     @author Timm Steinbeck
35     @date   Sep 14 2007
36     @brief  HLT Online Monitoring Environment including ROOT - Writer   
37     @note   migrated from PubSub HLT-stable-20070905.141318 (rev 2375)    */
38
39 // see header file for class documentation
40 // or
41 // refer to README to build package
42 // or
43 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
44
45 #include "AliHLTHOMERWriter.h"
46 #include <sys/time.h>
47 #include <time.h>
48
49
50 HOMERWriter::HOMERWriter()
51   :
52   fDataOffset(0),
53   fBlocks()
54     {
55 // Writer implementation of the HOMER interface.
56 // The HLT Monitoring Environment including ROOT is
57 // a native interface to ship out data from the HLT chain.
58 // See pdf document shiped with the package
59 // for class documentation and tutorial.
60     Clear();
61     }
62
63 HOMERWriter::~HOMERWriter()
64     {
65 // see header file for class documentation
66     }
67
68 void HOMERWriter::Clear()
69     {
70 // see header file for class documentation
71     fDataOffset = 0;
72     fBlocks.clear();
73     }
74
75 void HOMERWriter::AddBlock( const void* descriptor, const void* data )
76     {
77 // see header file for class documentation
78     TBlockData bd;
79     memcpy( bd.fDescriptor, descriptor, HOMERBlockDescriptor::GetHOMERBlockDescriptorSize() );
80     bd.fData = data;
81     HOMERBlockDescriptor hbd( &bd.fDescriptor );
82     hbd.SetBlockOffset( fDataOffset );
83     fDataOffset += hbd.GetBlockSize();
84     fBlocks.push_back( bd );
85     }
86
87 homer_uint32 HOMERWriter::GetTotalMemorySize( bool includeData )
88     {
89 // see header file for class documentation
90     if ( includeData )
91         return fDataOffset + HOMERBlockDescriptor::GetHOMERBlockDescriptorSize()*(fBlocks.size()+1);
92     else
93         return HOMERBlockDescriptor::GetHOMERBlockDescriptorSize()*(fBlocks.size()+1);
94     }
95
96 void HOMERWriter::Copy( void* destination, homer_uint64 eventType, homer_uint64 eventNr, homer_uint64 statusFlags, homer_uint64 nodeID, bool includeData )
97     {
98 // see header file for class documentation
99     HOMERBlockDescriptor homerBlock;
100     homer_uint8* bd = reinterpret_cast<homer_uint8*>( destination );
101     struct timeval now;
102     gettimeofday( &now, NULL );
103     homerBlock.UseHeader( bd );
104     homerBlock.Initialize();
105     homerBlock.SetUInt64Alignment( HOMERWriter::DetermineUInt64Alignment() );
106     homerBlock.SetUInt32Alignment( HOMERWriter::DetermineUInt32Alignment() );
107     homerBlock.SetUInt16Alignment( HOMERWriter::DetermineUInt16Alignment() );
108     homerBlock.SetUInt8Alignment( HOMERWriter::DetermineUInt8Alignment() );
109     homerBlock.SetDoubleAlignment( HOMERWriter::DetermineDoubleAlignment() );
110     homerBlock.SetFloatAlignment( HOMERWriter::DetermineFloatAlignment() );
111     homerBlock.SetType( eventType );
112     homerBlock.SetSubType1( eventNr );
113     homerBlock.SetSubType2( fBlocks.size() );
114     homerBlock.SetBirth_s( now.tv_sec );
115     homerBlock.SetBirth_us( now.tv_usec );
116     homerBlock.SetProducerNode( nodeID );
117     homerBlock.SetBlockOffset( homerBlock.GetHeaderLength() );
118     homerBlock.SetBlockSize( HOMERBlockDescriptor::GetHOMERBlockDescriptorSize()*fBlocks.size() );
119     homerBlock.SetStatusFlags( statusFlags );
120     bd += homerBlock.GetHeaderLength();
121
122     //unsigned long dataOffset = HOMERBlockDescriptor::GetHOMERBlockDescriptorSize()*(fBlocks.size()+1);
123     unsigned long dataOffset = homerBlock.GetBlockOffset() + homerBlock.GetBlockSize();
124     std::vector<TBlockData>::iterator iter, end;
125     iter = fBlocks.begin();
126     end = fBlocks.end();
127     while ( iter != end )
128         {
129         homerBlock.UseHeader( iter->fDescriptor );
130         homerBlock.SetBlockOffset( homerBlock.GetBlockOffset()+dataOffset );
131         memcpy( bd, iter->fDescriptor, homerBlock.GetHeaderLength() );
132         bd += homerBlock.GetHeaderLength();
133         if ( includeData )
134             {
135             memcpy( ((homer_uint8*)destination)+homerBlock.GetBlockOffset(), iter->fData, homerBlock.GetBlockSize() );
136             }
137         iter++;
138         }
139     }
140
141 homer_uint8 HOMERWriter::DetermineUInt64Alignment()
142     {
143 // see header file for class documentation
144     HOMERWriterAlignment64TestStructure test;
145     if ( (unsigned long)(&test.f64Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
146         {
147         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
148         return ~(homer_uint8)0;
149         }
150     if ( (unsigned long)(&test.f64Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
151         {
152         // The 64 bit element does not immedately follow the 32 bit element, 
153         // therefore the alignment has to be greater than 4.
154         return (homer_uint8)8;
155         }
156     if ( (unsigned long)(&test.f64Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
157         {
158         // The 64 bit element does not immedately follow the 16 bit element, 
159         // therefore the alignment has to be greater than 2.
160         return (homer_uint8)4;
161         }
162     if ( (unsigned long)(&test.f64Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
163         {
164         // The 64 bit element does not immedately follow the 8 bit element, 
165         // therefore the alignment has to be greater than 1.
166         return (homer_uint8)2;
167         }
168     return 1;
169     }
170
171 homer_uint8 HOMERWriter::DetermineUInt32Alignment()
172     {
173 // see header file for class documentation
174     HOMERWriterAlignment32TestStructure test;
175     if ( (unsigned long)(&test.f32Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
176         {
177         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
178         return ~(homer_uint8)0;
179         }
180     if ( (unsigned long)(&test.f32Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
181         {
182         // The 32 bit element does not immedately follow the 32 bit element, 
183         // therefore the alignment has to be greater than 4.
184         return (homer_uint8)8;
185         }
186     if ( (unsigned long)(&test.f32Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
187         {
188         // The 32 bit element does not immedately follow the 16 bit element, 
189         // therefore the alignment has to be greater than 2.
190         return (homer_uint8)4;
191         }
192     if ( (unsigned long)(&test.f32Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
193         {
194         // The 32 bit element does not immedately follow the 8 bit element, 
195         // therefore the alignment has to be greater than 1.
196         return (homer_uint8)2;
197         }
198     return 1;
199     }
200
201 homer_uint8 HOMERWriter::DetermineUInt16Alignment()
202     {
203 // see header file for class documentation
204     HOMERWriterAlignment16TestStructure test;
205     if ( (unsigned long)(&test.f16Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
206         {
207         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
208         return ~(homer_uint8)0;
209         }
210     if ( (unsigned long)(&test.f16Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
211         {
212         // The 16 bit element does not immedately follow the 32 bit element, 
213         // therefore the alignment has to be greater than 4.
214         return (homer_uint8)8;
215         }
216     if ( (unsigned long)(&test.f16Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
217         {
218         // The 16 bit element does not immedately follow the 16 bit element, 
219         // therefore the alignment has to be greater than 2.
220         return (homer_uint8)4;
221         }
222     if ( (unsigned long)(&test.f16Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
223         {
224         // The 16 bit element does not immedately follow the 8 bit element, 
225         // therefore the alignment has to be greater than 1.
226         return (homer_uint8)2;
227         }
228     return 1;
229     }
230
231 homer_uint8 HOMERWriter::DetermineUInt8Alignment()
232     {
233 // see header file for class documentation
234     HOMERWriterAlignment8TestStructure test;
235     if ( (unsigned long)(&test.f8Test64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
236         {
237         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
238         return ~(homer_uint8)0;
239         }
240     if ( (unsigned long)(&test.f8Test32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
241         {
242         // The 8 bit element does not immedately follow the 32 bit element, 
243         // therefore the alignment has to be greater than 4.
244         return (homer_uint8)8;
245         }
246     if ( (unsigned long)(&test.f8Test16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
247         {
248         // The 8 bit element does not immedately follow the 16 bit element, 
249         // therefore the alignment has to be greater than 2.
250         return (homer_uint8)4;
251         }
252     if ( (unsigned long)(&test.f8Test8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
253         {
254         // The 8 bit element does not immedately follow the 8 bit element, 
255         // therefore the alignment has to be greater than 1.
256         return (homer_uint8)2;
257         }
258     return 1;
259     }
260
261 homer_uint8 HOMERWriter::DetermineDoubleAlignment()
262     {
263 // see header file for class documentation
264     HOMERWriterAlignmentDoubleTestStructure test;
265     if ( (unsigned long)(&test.fDoubleTest64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
266         {
267         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
268         return ~(homer_uint8)0;
269         }
270     if ( (unsigned long)(&test.fDoubleTest32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
271         {
272         // The double element does not immedately follow the 32 bit element, 
273         // therefore the alignment has to be greater than 4.
274         return (homer_uint8)8;
275         }
276     if ( (unsigned long)(&test.fDoubleTest16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
277         {
278         // The double element does not immedately follow the 16 bit element, 
279         // therefore the alignment has to be greater than 2.
280         return (homer_uint8)4;
281         }
282     if ( (unsigned long)(&test.fDoubleTest8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
283         {
284         // The double element does not immedately follow the 8 bit element, 
285         // therefore the alignment has to be greater than 1.
286         return (homer_uint8)2;
287         }
288     return 1;
289     }
290
291 homer_uint8 HOMERWriter::DetermineFloatAlignment()
292     {
293 // see header file for class documentation
294     HOMERWriterAlignmentFloatTestStructure test;
295     if ( (unsigned long)(&test.fFloatTest64) != ((unsigned long)(&test.f64Fill))+sizeof(test.f64Fill) )
296         {
297         // Alignment is beyond 64 bit, this is, to the best of my knowledge, currently unheard of.
298         return ~(homer_uint8)0;
299         }
300     if ( (unsigned long)(&test.fFloatTest32) != ((unsigned long)(&test.f32Fill))+sizeof(test.f32Fill) )
301         {
302         // The float element does not immedately follow the 32 bit element, 
303         // therefore the alignment has to be greater than 4.
304         return (homer_uint8)8;
305         }
306     if ( (unsigned long)(&test.fFloatTest16) != ((unsigned long)(&test.f16Fill))+sizeof(test.f16Fill) )
307         {
308         // The float element does not immedately follow the 16 bit element, 
309         // therefore the alignment has to be greater than 2.
310         return (homer_uint8)4;
311         }
312     if ( (unsigned long)(&test.fFloatTest8) != ((unsigned long)(&test.f8Fill))+sizeof(test.f8Fill) )
313         {
314         // The float element does not immedately follow the 8 bit element, 
315         // therefore the alignment has to be greater than 1.
316         return (homer_uint8)2;
317         }
318     return 1;
319     }
320
321
322
323 /*
324 ***************************************************************************
325 **
326 ** $Author$ - Initial Version by Timm Morten Steinbeck
327 **
328 ** $Id$ 
329 **
330 ***************************************************************************
331 */