GammaWare  Head Version for release 0.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
BenchIO.C
Go to the documentation of this file.
1 
2 #ifndef __CINT__
3 
4 #include <stdio.h>
5 #include <unistd.h>
6 #include <stdlib.h>
7 
8 #include <TStopwatch.h>
9 #include <TFile.h>
10 #include <TTree.h>
11 #include <Riostream.h>
12 
13 #include <sys/types.h>
14 #include <sys/stat.h>
15 #include <fcntl.h>
16 
17 #endif
18 
19 #include <Buffer.h>
20 
21 using namespace Gws; // Gammaware System needed
22 
23 //const Int_t size = 16*KBYTE; // size of each array
24 const Int_t size = 32*KBYTE; // size of each array
25 
26 void Endian()
27 {
28  if ( Memory::IsBytes(Memory::kLittle) ) { cout << " endian type for this machine is little " << endl; }
29  else { cout << " endian type for this machine is big " << endl; }
30 }
31 
32 void Swap()
33 {
34  // buffers with the same endian type that your machine
35  Buffer bufferS(sizeof(Short_t)*size), bufferI(sizeof(Int_t)*size), bufferF(sizeof(Float_t)*size),bufferD(sizeof(Double_t)*size);
36 
37  // buffers with a different endian type that your machine
38  EndianBuffer bufferS_swap(sizeof(Short_t)*size), bufferI_swap(sizeof(Int_t)*size), bufferF_swap(sizeof(Float_t)*size), bufferD_swap(sizeof(Double_t)*size);
39 
40  TStopwatch watch;
41  for (Int_t ii = 0; ii < size; ii++) {
42  Short_t s = 1; Float_t f = 1; Int_t i = 1; Double_t d = 1;
43 
44  // write them without swapping
45  bufferS << s;
46  bufferI << i;
47  bufferF << f;
48  bufferD << d;
49  }
50  watch.Stop(); // watch.Print("u");
51  printf(" --> Writing rate without swapping %f MB/s (%f/%f) \n",
52  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
53  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
54 
55  watch.Start(kTRUE);
56  for (Int_t ii = 0; ii < size; ii++) {
57  Short_t s = 1; Float_t f = 1; Int_t i = 1; Double_t d = 1;
58 
59  // write them with swapping
60  bufferS_swap << s;
61  bufferI_swap << i;
62  bufferF_swap << f;
63  bufferD_swap << d;
64  }
65  watch.Stop();// watch.Print("u");
66 
67  printf(" --> Writing rate with swapping %f MB/s (%f/%f) \n",
68  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
69  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
70 
71  bufferS.SetOffset(0);bufferI.SetOffset(0);bufferF.SetOffset(); bufferD.SetOffset(0);
72  watch.Start(kTRUE);
73  for (Int_t ii = 0; ii < size; ii++) {
74  Short_t s; Float_t f; Int_t i; Double_t d;
75 
76  // read them without swapping
77  bufferS >> s;
78  bufferI >> i;
79  bufferF >> f;
80  bufferD >> d;
81  }
82  watch.Stop(); // watch.Print("u");
83  printf(" --> Reading rate without swapping %f MB/s (%f/%f) \n",
84  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
85  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
86 
87  bufferS_swap.SetOffset(0);bufferI_swap.SetOffset(0);bufferF_swap.SetOffset(); bufferD_swap.SetOffset(0);
88  watch.Start(kTRUE);
89  for (Int_t ii = 0; ii < size; ii++) {
90  Short_t s; Float_t f; Int_t i; Double_t d;
91 
92  // read them with swapping
93  bufferS_swap >> s;
94  bufferI_swap >> i;
95  bufferF_swap >> f;
96  bufferD_swap >> d;
97  }
98  watch.Stop(); // watch.Print("u");
99  printf(" --> Reading rate with swapping %f MB/s (%f/%f) \n",
100  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
101  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
102 }
103 
104 
105 void WriteIO_SYS()
106 {
107  Int_t id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
108 
109  // to know the endian type of your machine
110  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_sys"; swap = "big_sys"; inv_endian = Memory::kBig; }
111  else { noswap = "big_sys"; swap = "little_sys"; inv_endian = Memory::kLittle; }
112 
113  cout << noswap << " endian type for this machine " << endl;
114 
115  // buffers with the same endian type that your machine
116  Buffer bufferS(sizeof(Short_t)*size),
117  bufferI(sizeof(Int_t)*size),
118  bufferF(sizeof(Float_t)*size),
119  bufferD(sizeof(Double_t)*size);
120 
121  // fill the buffers and write them on disk
122  watch.Start(kTRUE);
123  id = open(noswap.Data(),O_WRONLY | O_CREAT,S_IRWXU);
124  if ( id == -1 ) {
125  printf("Cannot open file %s\n",noswap.Data()); return ;
126  }
127 
128  // write blocks and compute the needed time
129  for (Int_t ii = 0; ii < size; ii++) {
130  Short_t s; Float_t f; Int_t i; Double_t d;
131 
132  s = ii-size/2;
133  if ( ii-size/2 < kMinShort ) s = kMinShort;
134  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
135  i = ii-size/2;
136  f = ii-size/2;
137  d = ii-size/2;
138 
139  // write them without swapping
140  bufferS << s; if ( bufferS.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << s << " " << ii << endl;
141  bufferI << i; if ( bufferI.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << i << " " << ii << endl;
142  bufferF << f; if ( bufferF.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << f << " " << ii << endl;
143  bufferD << d; if ( bufferD.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << d << " " << ii << endl;
144  }
145  write(id,bufferS.GetBuffer(),bufferS.Size());
146  write(id,bufferI.GetBuffer(),bufferI.Size());
147  write(id,bufferF.GetBuffer(),bufferF.Size());
148  write(id,bufferD.GetBuffer(),bufferD.Size());
149 
150  close(id);
151 
152  watch.Stop();
153  printf(" --> Writing rate without swapping %f MB/s (%f/%f) \n",
154  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
155  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
156 
157  // fill the buffers and write them on disk
158  id = open(swap.Data(),O_WRONLY | O_CREAT, S_IRWXU);
159  if ( id == -1 ) {
160  printf("Cannot open file %s\n",swap.Data()); return ;
161  }
162 
163  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
164  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
165  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
166  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
167  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
168 
169  // write blocks and compute the needed time
170  watch.Start(kTRUE);
171  for (Int_t ii = 0; ii < size; ii++) {
172  Short_t s; Float_t f; Int_t i; Double_t d;
173  s = ii-size/2;
174  if ( ii-size/2 < kMinShort ) s = kMinShort;
175  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
176  i = ii-size/2;
177  f = ii-size/2;
178  d = ii-size/2;
179 
180  (*bufferS_swap) << s; if ( bufferS_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << s << " " << ii << endl;
181  (*bufferI_swap) << i; if ( bufferI_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << i << " " << ii << endl;
182  (*bufferF_swap) << f; if ( bufferF_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << f << " " << ii << endl;
183  (*bufferD_swap) << d; if ( bufferD_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << d << " " << ii << endl;
184  // write them with swapping
185  }
186  write(id,bufferS_swap->GetBuffer(),bufferS_swap->Size());
187  write(id,bufferI_swap->GetBuffer(),bufferI_swap->Size());
188  write(id,bufferF_swap->GetBuffer(),bufferF_swap->Size());
189  write(id,bufferD_swap->GetBuffer(),bufferD_swap->Size());
190 
191  close(id);
192 
193  watch.Stop();
194  printf(" --> Writing rate with swapping %f MB/s (%f/%f) \n",
195  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
196  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
197 
198 }
199 
200 void ReadIO_SYS()
201 {
202  Int_t id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
203 
204  // to know the endian type of your machine
205  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_sys"; swap = "big_sys"; inv_endian = Memory::kBig; }
206  else { noswap = "big_sys"; swap = "little_sys"; inv_endian = Memory::kLittle; }
207 
208  cout << noswap << " endian type for this machine " << endl;
209 
210  // 32 KBYTES buffers with the same endian type that your machine
211  Buffer bufferS(sizeof(Short_t)*size),
212  bufferI(sizeof(Int_t)*size),
213  bufferF(sizeof(Float_t)*size),
214  bufferD(sizeof(Double_t)*size);
215 
216  // read the buffers from disk
217  id = open(noswap.Data(),O_RDONLY);
218  if ( id == -1 ) {
219  printf("Cannot open file %s\n",noswap.Data()); return ;
220  }
221 
222  // read blocks and compute the needed time
223  watch.Start(kTRUE);
224 
225  read(id,bufferS.GetBuffer(),bufferS.Size());
226  read(id,bufferI.GetBuffer(),bufferI.Size());
227  read(id,bufferF.GetBuffer(),bufferF.Size());
228  read(id,bufferD.GetBuffer(),bufferD.Size());
229 
230 
231  for (Int_t ii = 0; ii < size; ii++) {
232  Short_t s; Float_t f; Int_t i; Double_t d;
233  bufferS >> s;
234  bufferI >> i;
235  bufferF >> f;
236  bufferD >> d; // read them without swapping
237 
238  Short_t stmp = ii-size/2;
239  if ( ii-size/2 < kMinShort ) stmp = kMinShort;
240  if ( ii-size/2 > kMaxShort ) stmp = kMaxShort;
241 
242  if ( s != stmp ) cout << " ERROR [short]" << ii-size/2 << " expected " << s << " read ! " << endl;
243  if ( i != ii-size/2 ) cout << " ERROR [int]" << ii-size/2 << " expected " << i << " read ! " << endl;
244  if ( f != ii-size/2 ) cout << " ERROR [float]" << ii-size/2 << " expected " << f << " read ! " << endl;
245  if ( d != ii-size/2 ) cout << " ERROR [double]" << ii-size/2 << " expected " << d << " read ! " << endl;
246  }
247  close(id);
248 
249  watch.Stop();
250  printf(" --> Reading rate without swapping %f MB/s (%f/%f) \n",
251  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
252  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
253 
254  // fill the buffers and write them on disk
255  id = open(swap.Data(),O_RDONLY);
256  if ( id == -1 ) {
257  printf("Cannot open file %s\n",swap.Data()); return ;
258  }
259 
260  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
261  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
262  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
263  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
264  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
265 
266  // write blocks and compute the needed time
267  watch.Start(kTRUE);
268 
269  read(id,bufferS_swap->GetBuffer(),bufferS_swap->Size());
270  read(id,bufferI_swap->GetBuffer(),bufferI_swap->Size());
271  read(id,bufferF_swap->GetBuffer(),bufferF_swap->Size());
272  read(id,bufferD_swap->GetBuffer(),bufferD_swap->Size());
273 
274  for (Int_t ii = 0; ii < size; ii++) {
275  Short_t s; Float_t f; Int_t i; Double_t d;
276 
277  (*bufferS_swap) >> s; (*bufferI_swap) >> i; (*bufferF_swap) >> f; (*bufferD_swap) >> d;
278 
279  Short_t stmp = ii-size/2;
280  if ( ii-size/2 < kMinShort ) stmp = kMinShort;
281  if ( ii-size/2 > kMaxShort ) stmp = kMaxShort;
282 
283  if ( s != stmp ) cout << " ERROR [short swap]" << ii-size/2 << " expected " << s << " read ! " << endl;
284  if ( i != ii-size/2 ) cout << " ERROR [int swap]" << ii-size/2 << " expected " << i << " read ! " << endl;
285  if ( f != ii-size/2 ) cout << " ERROR [float swap]" << ii-size/2 << " expected " << f << " read ! " << endl;
286  if ( d != ii-size/2 ) cout << " ERROR [double swap]" << ii-size/2 << " expected " << d << " read ! " << endl;
287  // read them with swapping
288  }
289  close(id);
290 
291  watch.Stop();
292  printf(" --> Reading rate with swapping %f MB/s (%f/%f) \n",
293  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
294  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
295 
296 }
297 
298 void WriteIO_C()
299 {
300  FILE *id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
301 
302  // to know the endian type of your machine
303  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_c"; swap = "big_c"; inv_endian = Memory::kBig; }
304  else { noswap = "big_c"; swap = "little_c"; inv_endian = Memory::kLittle; }
305 
306  cout << noswap << " endian type for this machine " << endl;
307 
308  // 32 KBYTES buffers with the same endian type that your machine
309  Buffer bufferS(sizeof(Short_t)*size),
310  bufferI(sizeof(Int_t)*size),
311  bufferF(sizeof(Float_t)*size),
312  bufferD(sizeof(Double_t)*size);
313 
314  // cout << bufferS.Size() << " " << bufferI.Size() << " " << bufferF.Size() << " " << bufferD.Size() << endl;
315  // fill the buffers and write them on disk
316  id = fopen(noswap.Data(),"w");
317  if ( id == NULL ) {
318  printf("Cannot open file %s\n",noswap.Data()); return ;
319  }
320 
321  // write blocks and compute the needed time
322  watch.Start(kTRUE);
323  for (Int_t ii = 0; ii < size; ii++) {
324  Short_t s; Float_t f; Int_t i; Double_t d;
325 
326  s = ii-size/2;
327  if ( ii-size/2 < kMinShort ) s = kMinShort;
328  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
329  i = ii-size/2;
330  f = ii-size/2;
331  d = ii-size/2;
332 
333  // write them without swapping
334  bufferS << s; if ( bufferS.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << s << " " << ii << endl;
335  bufferI << i; if ( bufferI.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << i << " " << ii << endl;
336  bufferF << f; if ( bufferF.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << f << " " << ii << endl;
337  bufferD << d; if ( bufferD.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << d << " " << ii << endl;
338  }
339  fwrite(bufferS.GetBuffer(),bufferS.Size(),1,id);
340  fwrite(bufferI.GetBuffer(),bufferI.Size(),1,id);
341  fwrite(bufferF.GetBuffer(),bufferF.Size(),1,id);
342  fwrite(bufferD.GetBuffer(),bufferD.Size(),1,id);
343 
344  fclose(id);
345 
346  watch.Stop();
347  printf(" --> Writing rate without swapping %f MB/s (%f/%f) \n",
348  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
349  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
350 
351  // fill the buffers and write them on disk
352  id = fopen(swap.Data(),"w");
353  if ( id == NULL ) {
354  printf("Cannot open file %s\n",swap.Data()); return ;
355  }
356 
357  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
358  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
359  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
360  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
361  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
362 
363  // write blocks and compute the needed time
364  watch.Start(kTRUE);
365  for (Int_t ii = 0; ii < size; ii++) {
366  Short_t s; Float_t f; Int_t i; Double_t d;
367  s = ii-size/2;
368  if ( ii-size/2 < kMinShort ) s = kMinShort;
369  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
370  i = ii-size/2;
371  f = ii-size/2;
372  d = ii-size/2;
373 
374  (*bufferS_swap) << s; if ( bufferS_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << s << " " << ii << endl;
375  (*bufferI_swap) << i; if ( bufferI_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << i << " " << ii << endl;
376  (*bufferF_swap) << f; if ( bufferF_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << f << " " << ii << endl;
377  (*bufferD_swap) << d; if ( bufferD_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << d << " " << ii << endl;
378  // write them with swapping
379  }
380  fwrite(bufferS_swap->GetBuffer(),bufferS.Size(),1,id);
381  fwrite(bufferI_swap->GetBuffer(),bufferI.Size(),1,id);
382  fwrite(bufferF_swap->GetBuffer(),bufferF.Size(),1,id);
383  fwrite(bufferD_swap->GetBuffer(),bufferD.Size(),1,id);
384 
385  fclose(id);
386 
387  watch.Stop();
388  printf(" --> Writing rate with swapping %f MB/s (%f/%f) \n",
389  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
390  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
391 
392 }
393 
394 void ReadIO_C()
395 {
396  FILE *id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
397 
398  // to know the endian type of your machine
399  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_c"; swap = "big_c"; inv_endian = Memory::kBig; }
400  else { noswap = "big_c"; swap = "little_c"; inv_endian = Memory::kLittle; }
401 
402  cout << noswap << " endian type for this machine " << endl;
403 
404  // 32 KBYTES buffers with the same endian type that your machine
405  Buffer bufferS(sizeof(Short_t)*size),
406  bufferI(sizeof(Int_t)*size),
407  bufferF(sizeof(Float_t)*size),
408  bufferD(sizeof(Double_t)*size);
409 
410  // read the buffers from disk
411  id = fopen(noswap.Data(),"r");
412  if ( id == NULL ) {
413  printf("Cannot open file %s\n",noswap.Data()); return ;
414  }
415 
416  // read blocks and compute the needed time
417  watch.Start(kTRUE);
418 
419  fread(bufferS.GetBuffer(),bufferS.Size(),1,id);
420  fread(bufferI.GetBuffer(),bufferI.Size(),1,id);
421  fread(bufferF.GetBuffer(),bufferF.Size(),1,id);
422  fread(bufferD.GetBuffer(),bufferD.Size(),1,id);
423 
424  for (Int_t ii = 0; ii < size; ii++) {
425  Short_t s; Float_t f; Int_t i; Double_t d;
426  bufferS >> s;
427  bufferI >> i;
428  bufferF >> f;
429  bufferD >> d; // read them without swapping
430 
431  Short_t stmp = ii-size/2;
432  if ( ii-size/2 < kMinShort ) stmp = kMinShort;
433  if ( ii-size/2 > kMaxShort ) stmp = kMaxShort;
434 
435  if ( s != stmp ) cout << " ERROR [short]" << ii-size/2 << " expected " << s << " read ! " << endl;
436  if ( i != ii-size/2 ) cout << " ERROR [int]" << ii-size/2 << " expected " << i << " read ! " << endl;
437  if ( f != ii-size/2 ) cout << " ERROR [float]" << ii-size/2 << " expected " << f << " read ! " << endl;
438  if ( d != ii-size/2 ) cout << " ERROR [double]" << ii-size/2 << " expected " << d << " read ! " << endl;
439  }
440  fclose(id);
441 
442  watch.Stop();
443  printf(" --> Reading rate without swapping %f MB/s (%f/%f) \n",
444  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
445  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
446 
447  // fill the buffers and write them on disk
448  id = fopen(swap.Data(),"r");
449  if ( id == NULL ) {
450  printf("Cannot open file %s\n",swap.Data()); return ;
451  }
452 
453  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
454  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
455  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
456  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
457  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
458 
459  // write blocks and compute the needed time
460  watch.Start(kTRUE);
461 
462  fread(bufferS_swap->GetBuffer(),bufferS.Size(),1,id);
463  fread(bufferI_swap->GetBuffer(),bufferI.Size(),1,id);
464  fread(bufferF_swap->GetBuffer(),bufferF.Size(),1,id);
465  fread(bufferD_swap->GetBuffer(),bufferD.Size(),1,id);
466 
467  for (Int_t ii = 0; ii < size; ii++) {
468 
469  }
470  fclose(id);
471 
472  watch.Stop();
473  printf(" --> Reading rate with swapping %f MB/s (%f/%f) \n",
474  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
475  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
476 
477 }
478 
479 
480 void WriteIO_CPP()
481 {
482  ofstream id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
483 
484  // to know the endian type of your machine
485  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_cpp"; swap = "big_cpp"; inv_endian = Memory::kBig; }
486  else { noswap = "big_cpp"; swap = "little_cpp"; inv_endian = Memory::kLittle; }
487 
488  cout << noswap << " endian type for this machine " << endl;
489 
490  // 32 KBYTES buffers with the same endian type that your machine
491  Buffer bufferS(sizeof(Short_t)*size),
492  bufferI(sizeof(Int_t)*size),
493  bufferF(sizeof(Float_t)*size),
494  bufferD(sizeof(Double_t)*size);
495 
496  // cout << bufferS.Size() << " " << bufferI.Size() << " " << bufferF.Size() << " " << bufferD.Size() << endl;
497  // fill the buffers and write them on disk
498  id.open(noswap.Data());
499  if ( !id.is_open() ) {
500  printf("Cannot open file %s\n",noswap.Data()); return ;
501  }
502 
503  // write blocks and compute the needed time
504  watch.Start(kTRUE);
505  for (Int_t ii = 0; ii < size; ii++) {
506  Short_t s; Float_t f; Int_t i; Double_t d;
507 
508  s = ii-size/2;
509  if ( ii-size/2 < kMinShort ) s = kMinShort;
510  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
511  i = ii-size/2;
512  f = ii-size/2;
513  d = ii-size/2;
514 
515  // write them without swapping
516  bufferS << s; if ( bufferS.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << s << " " << ii << endl;
517  bufferI << i; if ( bufferI.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << i << " " << ii << endl;
518  bufferF << f; if ( bufferF.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << f << " " << ii << endl;
519  bufferD << d; if ( bufferD.IsStatus(Buffer::kFail) ) cout << " PB in buffer " << d << " " << ii << endl;
520  }
521  id.write(bufferS.GetBuffer(),bufferS.Size());
522  id.write(bufferI.GetBuffer(),bufferI.Size());
523  id.write(bufferF.GetBuffer(),bufferF.Size());
524  id.write(bufferD.GetBuffer(),bufferD.Size());
525 
526  id.close();
527 
528  watch.Stop();
529  printf(" --> Writing rate without swapping %f MB/s (%f/%f) \n",
530  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
531  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
532 
533  // fill the buffers and write them on disk
534  id.open(swap.Data());
535  if ( !id.is_open() ) {
536  printf("Cannot open file %s\n",swap.Data()); return ;
537  }
538 
539  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
540  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
541  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
542  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
543  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
544 
545  // write blocks and compute the needed time
546  watch.Start(kTRUE);
547  for (Int_t ii = 0; ii < size; ii++) {
548  Short_t s; Float_t f; Int_t i; Double_t d;
549  s = ii-size/2;
550  if ( ii-size/2 < kMinShort ) s = kMinShort;
551  if ( ii-size/2 > kMaxShort ) s = kMaxShort;
552  i = ii-size/2;
553  f = ii-size/2;
554  d = ii-size/2;
555 
556  (*bufferS_swap) << s; if ( bufferS_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << s << " " << ii << endl;
557  (*bufferI_swap) << i; if ( bufferI_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << i << " " << ii << endl;
558  (*bufferF_swap) << f; if ( bufferF_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << f << " " << ii << endl;
559  (*bufferD_swap) << d; if ( bufferD_swap->IsStatus(Buffer::kFail) ) cout << " PB in swap " << d << " " << ii << endl;
560  // write them with swapping
561  }
562  id.write(bufferS_swap->GetBuffer(),bufferS.Size());
563  id.write(bufferI_swap->GetBuffer(),bufferI.Size());
564  id.write(bufferF_swap->GetBuffer(),bufferF.Size());
565  id.write(bufferD_swap->GetBuffer(),bufferD.Size());
566 
567  id.close();
568 
569  watch.Stop();
570  printf(" --> Writing rate with swapping %f MB/s (%f/%f) \n",
571  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
572  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
573 
574 }
575 
576 void ReadIO_CPP()
577 {
578  ifstream id; Memory::EEndian inv_endian; TString noswap, swap; TStopwatch watch;
579 
580  // to know the endian type of your machine
581  if ( Memory::IsBytes(Memory::kLittle) ) { noswap = "little_cpp"; swap = "big_cpp"; inv_endian = Memory::kBig; }
582  else { noswap = "big_cpp"; swap = "little_cpp"; inv_endian = Memory::kLittle; }
583 
584  cout << noswap << " endian type for this machine " << endl;
585 
586  // 32 KBYTES buffers with the same endian type that your machine
587  Buffer bufferS(sizeof(Short_t)*size),
588  bufferI(sizeof(Int_t)*size),
589  bufferF(sizeof(Float_t)*size),
590  bufferD(sizeof(Double_t)*size);
591 
592  // read the buffers from disk
593  id.open(noswap.Data());
594  if ( !id.is_open() ) {
595  printf("Cannot open file %s\n",noswap.Data()); return ;
596  }
597 
598  // read blocks and compute the needed time
599  watch.Start(kTRUE);
600 
601  id.read(bufferS.GetBuffer(),bufferS.Size());
602  id.read(bufferI.GetBuffer(),bufferI.Size());
603  id.read(bufferF.GetBuffer(),bufferF.Size());
604  id.read(bufferD.GetBuffer(),bufferD.Size());
605 
606  for (Int_t ii = 0; ii < size; ii++) {
607  Short_t s; Float_t f; Int_t i; Double_t d;
608  bufferS >> s;
609  bufferI >> i;
610  bufferF >> f;
611  bufferD >> d; // read them without swapping
612 
613  Short_t stmp = ii-size/2;
614  if ( ii-size/2 < kMinShort ) stmp = kMinShort;
615  if ( ii-size/2 > kMaxShort ) stmp = kMaxShort;
616 
617  if ( s != stmp ) cout << " ERROR [short]" << ii-size/2 << " expected " << s << " read ! " << endl;
618  if ( i != ii-size/2 ) cout << " ERROR [int]" << ii-size/2 << " expected " << i << " read ! " << endl;
619  if ( f != ii-size/2 ) cout << " ERROR [float]" << ii-size/2 << " expected " << f << " read ! " << endl;
620  if ( d != ii-size/2 ) cout << " ERROR [double]" << ii-size/2 << " expected " << d << " read ! " << endl;
621  }
622 
623  id.close();
624 
625  watch.Stop();
626  printf(" --> Reading rate without swapping %f MB/s (%f/%f) \n",
627  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
628  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
629 
630  // fill the buffers and write them on disk
631  id.open(swap.Data());
632  if ( !id.is_open() ) {
633  printf("Cannot open file %s\n",noswap.Data()); return ;
634  }
635 
636  // Best way to allocate buffers since it gives a buffer that is aware of byte swapping
637  Buffer *bufferS_swap = Buffer::New(inv_endian,sizeof(Short_t)*size);
638  Buffer *bufferI_swap = Buffer::New(inv_endian,sizeof(Int_t)*size);
639  Buffer *bufferF_swap = Buffer::New(inv_endian,sizeof(Float_t)*size);
640  Buffer *bufferD_swap = Buffer::New(inv_endian,sizeof(Double_t)*size);
641 
642  // write blocks and compute the needed time
643  watch.Start(kTRUE);
644  id.read(bufferS_swap->GetBuffer(),bufferS.Size());
645  id.read(bufferI_swap->GetBuffer(),bufferI.Size());
646  id.read(bufferF_swap->GetBuffer(),bufferF.Size());
647  id.read(bufferD_swap->GetBuffer(),bufferD.Size());
648 
649 
650  for (Int_t ii = 0; ii < size; ii++) {
651  Short_t s; Float_t f; Int_t i; Double_t d;
652 
653  (*bufferS_swap) >> s; (*bufferI_swap) >> i; (*bufferF_swap) >> f; (*bufferD_swap) >> d;
654 
655  Short_t stmp = ii-size/2;
656  if ( ii-size/2 < kMinShort ) stmp = kMinShort;
657  if ( ii-size/2 > kMaxShort ) stmp = kMaxShort;
658 
659  if ( s != stmp ) cout << " ERROR [short swap]" << ii-size/2 << " expected " << s << " read ! " << endl;
660  if ( i != ii-size/2 ) cout << " ERROR [int swap]" << ii-size/2 << " expected " << i << " read ! " << endl;
661  if ( f != ii-size/2 ) cout << " ERROR [float swap]" << ii-size/2 << " expected " << f << " read ! " << endl;
662  if ( d != ii-size/2 ) cout << " ERROR [double swap]" << ii-size/2 << " expected " << d << " read ! " << endl;
663  // read them with swapping
664  }
665 
666  id.close();
667 
668  watch.Stop();
669  printf(" --> Reading rate with swapping %f MB/s (%f/%f) \n",
670  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/(MBYTE*watch.RealTime()),
671  Float_t(bufferS.Size()+bufferI.Size()+bufferF.Size()+bufferD.Size())/MBYTE,watch.RealTime());
672 
673 }
674 
675 
676 
Gws::Memory::EEndian
EEndian
The adjectives big-endian and little-endian refer to which bytes are most significant in multi-byte d...
Definition: Memory.h:59
Gws::MBYTE
const Int_t MBYTE
Definition: Memory.h:38
WriteIO_SYS
void WriteIO_SYS()
Definition: BenchIO.C:105
printf
printf("******************************************************************** \n")
ReadIO_CPP
void ReadIO_CPP()
Definition: BenchIO.C:576
WriteIO_CPP
void WriteIO_CPP()
Definition: BenchIO.C:480
Gws::Buffer::Size
UInt_t Size() const
it returns the maximum number of bytes in this buffer
Definition: Buffer.h:165
Endian
void Endian()
Definition: BenchIO.C:26
Gws::Buffer
A buffer is used to read/write raw data buffers from/on files.
Definition: Buffer.h:43
Gws::Memory::IsBytes
static bool IsBytes(Memory::EEndian e)
check out the endian type of the running system
Definition: Memory.h:82
Gws::KBYTE
const Int_t KBYTE
Definition: Memory.h:37
Gws::Buffer::New
static Buffer * New(Memory::EEndian e, UInt_t s=32 *KBYTE)
copy n bytes from one buffer to another one
Definition: Buffer.cpp:68
Gws::Buffer::SetOffset
UInt_t SetOffset(UInt_t off=0)
change the current position.
Definition: Buffer.cpp:88
Swap
void Swap()
Definition: BenchIO.C:32
WriteIO_C
void WriteIO_C()
Definition: BenchIO.C:298
ReadIO_SYS
void ReadIO_SYS()
Definition: BenchIO.C:200
endl
ADF::LogMessage & endl(ADF::LogMessage &log)
Definition: ADFLogMessage.cpp:265
ReadIO_C
void ReadIO_C()
Definition: BenchIO.C:394
size
const Int_t size
Definition: BenchIO.C:24
Buffer.h
header file for Buffer.cpp
Gws::Buffer::GetBuffer
Char_t * GetBuffer()
Pointer to the underlying array of chars.
Definition: Buffer.h:164
Gws::EndianBuffer
A Endianbuffer is used to read/write raw data buffers from/on files.
Definition: Buffer.h:269
Gws::Buffer::IsStatus
bool IsStatus(Buffer::EStatus)
Definition: Buffer.h:156