source: trunk/lib/symtab/driver.cxx @ 1428

Last change on this file since 1428 was 1428, checked in by vla24, 8 years ago

SymbolTable?: commit some missing files

File size: 12.2 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <string.h>
5#include <sys/types.h>
6#include <sys/stat.h>
7#include <unistd.h>
8#include <sched.h>
9
10// Test Repetitions
11#define RUNS 1
12
13// stream2runs versions
14//#define BRANCH_REDUCTION
15#include "../stream2runs/src/stream2runs.h"
16
17// Performance Measurement
18#ifdef PAPI
19#include "lib/cclib/clocker/cc.h"
20#include "lib/cclib/clocker/cc.cxx"
21CC * code_clocker;
22#endif
23
24// Parabix 1 Symbol Table implementation (STL Hash Map)
25#include "symtab.h"
26
27// Length Sorted Symbol Table
28
29#include "library_conversion.h"
30#include "ls_symbol_table.h"
31
32#include "symtab.h"
33#include "ls_symbol_table_util.h"
34
35typedef SIMD_type BytePack;
36typedef SIMD_type BitBlock;
37
38#define SIMD_REGISTER_BIT_WIDTH (sizeof(SIMD_type) << 3)
39#define REGISTER_BIT_WIDTH (sizeof(void *) << 3)
40
41#ifdef TEMPLATED_SIMD_LIB
42#define s2p_step(s0, s1, hi_mask, shift, p0, p1) \
43{\
44  BitBlock t0, t1;\
45  t0 = simd<16>::pack<h,h>(s0, s1);\
46  t1 = simd<16>::pack<l,l>(s0, s1);\
47  p0 = simd_if(hi_mask, t0, simd<16>::srli<shift>(t1));\
48  p1 = simd_if(hi_mask, simd<16>::slli<shift>(t0), t1);\
49}
50#endif
51#ifndef TEMPLATED_SIMD_LIB
52#define s2p_step(s0, s1, hi_mask, shift, p0, p1) \
53{\
54  BitBlock t0, t1;\
55  t0 = simd_pack_16_hh(s0, s1);\
56  t1 = simd_pack_16_ll(s0, s1);\
57  p0 = simd_if(hi_mask, t0, simd_srli_16(t1, shift));\
58  p1 = simd_if(hi_mask, simd_slli_16(t0, shift), t1);\
59}
60#endif
61
62static inline void s2p_bytepack(BytePack s[], BitBlock p[]) {
63#ifdef TEMPLATED_SIMD_LIB
64    BitBlock mask_2 = simd<2>::himask();
65    BitBlock mask_4 = simd<4>::himask();
66    BitBlock mask_8 = simd<8>::himask();
67#endif
68#ifndef TEMPLATED_SIMD_LIB
69    BitBlock mask_2 = simd_himask_2;
70    BitBlock mask_4 = simd_himask_4;
71    BitBlock mask_8 = simd_himask_8;
72#endif
73    BitBlock bit00224466_0, bit00224466_1, bit00224466_2, bit00224466_3;
74    BitBlock bit11335577_0, bit11335577_1, bit11335577_2, bit11335577_3;
75    BitBlock bit00004444_0, bit22226666_0, bit00004444_1, bit22226666_1;
76    BitBlock bit11115555_0, bit33337777_0, bit11115555_1, bit33337777_1;
77#if (BYTE_ORDER == BIG_ENDIAN)
78    s2p_step(s[0], s[1], mask_2, 1, bit00224466_0, bit11335577_0);
79    s2p_step(s[2], s[3], mask_2, 1, bit00224466_1, bit11335577_1);
80    s2p_step(s[4], s[5], mask_2, 1, bit00224466_2, bit11335577_2);
81    s2p_step(s[6], s[7], mask_2, 1, bit00224466_3, bit11335577_3);
82#endif
83#if (BYTE_ORDER == LITTLE_ENDIAN)
84    s2p_step(s[7], s[6], mask_2, 1, bit00224466_0, bit11335577_0);
85    s2p_step(s[5], s[4], mask_2, 1, bit00224466_1, bit11335577_1);
86    s2p_step(s[3], s[2], mask_2, 1, bit00224466_2, bit11335577_2);
87    s2p_step(s[1], s[0], mask_2, 1, bit00224466_3, bit11335577_3);
88#endif
89    s2p_step(bit00224466_0, bit00224466_1, mask_4, 2, bit00004444_0, bit22226666_0);
90    s2p_step(bit00224466_2, bit00224466_3, mask_4, 2, bit00004444_1, bit22226666_1);
91    s2p_step(bit11335577_0, bit11335577_1, mask_4, 2, bit11115555_0, bit33337777_0);
92    s2p_step(bit11335577_2, bit11335577_3, mask_4, 2, bit11115555_1, bit33337777_1);
93    s2p_step(bit00004444_0, bit00004444_1, mask_8, 4, p[0], p[4]);
94    s2p_step(bit11115555_0, bit11115555_1, mask_8, 4, p[1], p[5]);
95    s2p_step(bit22226666_0, bit22226666_1, mask_8, 4, p[2], p[6]);
96    s2p_step(bit33337777_0, bit33337777_1, mask_8, 4, p[3], p[7]);
97}
98
99#define double_int64_adc(x1, x2, y1, y2, rslt1, rslt2, carry) \
100  __asm__  ("sahf\n\t" \
101        "adc %[e1], %[z1]\n\t" \
102        "adc %[e2], %[z2]\n\t" \
103        "lahf\n\t" \
104     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
105         : "[z1]" (x1), "[z2]" (x2), \
106           [e1] "r" (y1), [e2] "r" (y2), \
107           "[carryflag]" (carry) \
108         : "cc")
109
110#define adc128(first, second, carry, sum) \
111do\
112{\
113  union {__m128i bitblock;\
114         uint64_t int64[2];} rslt;\
115\
116  union {__m128i bitblock;\
117         uint64_t int64[2];} x;\
118\
119  union {__m128i bitblock;\
120         uint64_t int64[2];} y;\
121\
122  x.bitblock = first;\
123  y.bitblock = second;\
124\
125  double_int64_adc(x.int64[0], x.int64[1], y.int64[0], y.int64[1], rslt.int64[0], rslt.int64[1], carry);\
126  sum = rslt.bitblock;\
127}while(0)
128
129#define double_int64_sbb(x1, x2, y1, y2, rslt1, rslt2, carry) \
130  __asm__  ("sahf\n\t" \
131        "sbb %[e1], %[z1]\n\t" \
132        "sbb %[e2], %[z2]\n\t" \
133        "lahf\n\t" \
134     : [z1] "=r" (rslt1), [z2] "=r" (rslt2), [carryflag] "=a" (carry) \
135         : "[z1]" (x1), "[z2]" (x2), \
136           [e1] "r" (y1), [e2] "r" (y2), \
137           "[carryflag]" (carry) \
138         : "cc")
139
140#define sbb128(first, second, carry, sum) \
141do\
142{ union {__m128i bitblock;\
143         uint64_t int64[2];} rslt;\
144\
145  union {__m128i bitblock;\
146         uint64_t int64[2];} x;\
147\
148  union {__m128i bitblock;\
149         uint64_t int64[2];} y;\
150\
151  x.bitblock = first;\
152  y.bitblock = second;\
153\
154  double_int64_sbb(x.int64[0], x.int64[1], y.int64[0], y.int64[1], \
155                   rslt.int64[0], rslt.int64[1], carry);\
156  sum = rslt.bitblock;\
157}while(0)
158
159// Mark Comma bit positions
160static inline BitBlock bytepack2bitblock(BytePack U8[]);
161static inline BitBlock bytepack2bitblock(BytePack U8[]) {
162               
163        BitBlock result;
164        BitBlock array_u8bit__5_;
165        //BitBlock AllOne = simd_const_1(1);
166        //BitBlock AllZero = simd_const_1(0);
167        BitBlock array_u8bit__2_;
168        BitBlock array_u8bit__3_;
169        BitBlock array_u8bit__4_;
170        BitBlock _strct_s2iclass__classify_bytes__temp4;
171        BitBlock _strct_s2iclass__classify_bytes__temp5;
172        BitBlock _strct_s2iclass__classify_bytes__temp2;
173        BitBlock _strct_s2iclass__classify_bytes__temp3;
174        BitBlock array_u8bit__6_;
175        BitBlock _strct_s2iclass__classify_bytes__temp1;
176        BitBlock array_u8bit__0_;
177        BitBlock array_u8bit__1_;
178        BitBlock array_u8bit__7_;       
179       
180        BitBlock u8[8];
181       
182        s2p_bytepack(U8,u8);
183        array_u8bit__0_ = u8[0];
184        array_u8bit__1_ = u8[1];
185        array_u8bit__2_ = u8[2];
186        array_u8bit__3_ = u8[3];
187        array_u8bit__4_ = u8[4];
188        array_u8bit__5_ = u8[5];
189        array_u8bit__6_ = u8[6];
190        array_u8bit__7_ = u8[7];
191
192        _strct_s2iclass__classify_bytes__temp1 = simd_or(array_u8bit__0_,array_u8bit__1_);
193        _strct_s2iclass__classify_bytes__temp2 = simd_and(array_u8bit__2_,array_u8bit__3_);
194        _strct_s2iclass__classify_bytes__temp3 = simd_andc(_strct_s2iclass__classify_bytes__temp2,_strct_s2iclass__classify_bytes__temp1);
195        _strct_s2iclass__classify_bytes__temp4 = simd_or(array_u8bit__5_,array_u8bit__6_);
196        _strct_s2iclass__classify_bytes__temp5 = simd_and(array_u8bit__4_,_strct_s2iclass__classify_bytes__temp4);     
197        result = simd_andc(_strct_s2iclass__classify_bytes__temp3,_strct_s2iclass__classify_bytes__temp5);
198       
199        return result;
200}
201
202void print_chars(const char * str, size_t length);
203void print_chars(const char * str, size_t length) {
204
205        for(int i=0;i<length;i++) {
206                printf("%c",str[i]);
207        }
208        printf("\n");
209       
210}
211
212void SetCPUAffinity();
213void SetCPUAffinity() {
214
215        printf("Setting CPU Affinity...\n");
216       
217    cpu_set_t mask;
218    unsigned int len = sizeof(mask);
219    if (sched_getaffinity(0, len, &mask) < 0) {
220        perror("sched_getaffinity");
221    }
222
223    printf("Original CPU Affinity Mask: %08lx\n", mask.__bits[0]);
224
225    //CPU_CLR(0, &mask); // (CPU 1)
226    //CPU_CLR(1, &mask); // (CPU 0)
227
228    if (sched_setaffinity(0, len, &mask) < 0) {
229       perror("sched_setaffinity");
230    }
231
232    printf("Modified CPU Affinity Mask: %08lx\n", mask.__bits[0]);
233} 
234
235int main(int argc, char * argv[]) {
236       
237  if (argc < 2) {
238    printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
239          exit(-1);
240  }
241  char * filename = argv[1];
242
243  FILE *infile, *outfile;
244  infile = fopen(filename, "rb");
245  if (!infile) {
246      fprintf(stderr, "Error: cannot open %s for input.\n", filename);
247      exit(-1);
248  }
249
250  if (argc < 3) outfile = stdout;
251  else {
252    outfile = fopen(argv[2], "wb");
253    if (!outfile) {
254      fprintf(stderr, "Error: cannot open %s for writing.\n", argv[2]);
255      exit(-1);
256    }
257  }
258
259#ifdef PAPI
260    SetCPUAffinity();
261        char * src_filename = argv[1];
262        char * cmdline = new char[strlen(argv[0]) + strlen(argv[1]) +1 +1]; 
263        strcat(cmdline, argv[0]);
264        strcat(cmdline," ");
265        strcat(cmdline,argv[1]); 
266       
267        #define NUM_EVENTS 2
268        int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
269        int cal_size = 1000;
270        code_clocker = new CC(Events,NUM_EVENTS,cal_size);
271        code_clocker->set_cmd(cmdline);
272
273#endif 
274       
275  struct stat st;
276  stat(filename, &st);
277  int filesize = st.st_size;
278  size_t bytes = filesize;
279 
280  bytes += sizeof(SIMD_type);
281 
282  // allocate byte buffer and pad with trailing zeroes
283  unsigned char * byte_buffer = (unsigned char *)simd_new(bytes); 
284 
285     
286  // slurp file
287  int chars_read = fread(byte_buffer, sizeof(char), filesize, infile);
288  while(chars_read > 0) {
289          chars_read = fread(byte_buffer+chars_read, sizeof(char), filesize, infile);
290  }
291 
292  // mask trailing zeroes
293  memset(byte_buffer + filesize, 0, sizeof(SIMD_type)); 
294 
295  // allocate bit stream buffer
296  int simd_packs = bytes/sizeof(SIMD_type);
297 
298  #ifdef BRANCH_REDUCTION
299    BitBlock * bit_stream_buffer = simd_new(simd_packs + 1); // pad at least an additional general width of bytes
300  #else 
301    BitBlock * bit_stream_buffer = simd_new(simd_packs); 
302  #endif
303   
304  if(bit_stream_buffer == NULL) {
305      fprintf(stderr, "Error: out of memory.\n");
306      exit(-1);   
307  }
308
309  cout << "Source Bytes: " << filesize << endl;
310  cout << "Allocated Bytes: " << bytes << endl;
311  cout << "SIMD Pack Count: " << simd_packs << endl; 
312  cout << "SIMD Pack Bytes: " << simd_packs * sizeof(SIMD_type) << endl << endl; 
313 
314#ifdef PAPI
315        code_clocker->start_interval();
316#endif         
317
318  for(int i=0;i<RUNS;i++) {
319
320  #ifdef PAPI
321        code_clocker->start_interval();
322  #endif       
323               
324  // convert to bit streams
325  for(int i=0,j=0;i<simd_packs;i++,j+=SIMD_REGISTER_BIT_WIDTH) {
326          bit_stream_buffer[i] = bytepack2bitblock((BytePack *)(&byte_buffer[j]));
327  }
328
329  #ifdef BRANCH_REDUCTION
330      bit_stream_buffer[simd_packs] = simd<8>::constant<0>(); // initialize the final block
331  #endif
332 
333  #ifdef PAPI
334        code_clocker->end_interval(bytes);
335  #endif       
336 
337  }
338       
339  size_t max_span_count = simd_packs * SIMD_REGISTER_BIT_WIDTH/2;       
340  size_t * starts = new size_t[max_span_count];
341  size_t * lengths = new size_t[max_span_count];
342  size_t span_count = 0;
343
344  size_t bit_stream_buffer_length;
345 
346//#ifdef PAPI
347//      code_clocker->start_interval();
348//#endif       
349 
350#ifdef BRANCH_REDUCTION
351        bit_stream_buffer_length = simd_packs * sizeof(SIMD_type);     
352        stream2runs((unsigned char *)bit_stream_buffer, bit_stream_buffer_length, starts, lengths, &span_count);
353#else
354        bit_stream_buffer_length = simd_packs * SIMD_REGISTER_BIT_WIDTH / REGISTER_BIT_WIDTH;
355        stream2runs((size_t *)bit_stream_buffer, bit_stream_buffer_length, starts, lengths, &span_count);       
356#endif
357               
358//#ifdef PAPI
359//      code_clocker->end_interval(bytes);
360//#endif       
361       
362//  for(int i =0; i<span_count; i++) {
363//      printf("Value (%zu,%zu) = ", starts[i], lengths[i]);
364//      print_chars(((char *) byte_buffer) + starts[i], lengths[i]);     
365//  }
366 
367//  for(int i=0;i<RUNS;i++) {
368//
369//  #ifdef PAPI
370//      code_clocker->start_interval();
371//  #endif     
372
373  SymbolTable symbol_table;
374
375  int * gids  = new int[span_count];
376
377  int gid = 0;
378  for(int i =0; i<span_count; i++) {
379    gids[i] = symbol_table.Lookup_or_Insert_Name((char *)(byte_buffer + starts[i]), lengths[i]);
380  }
381
382  cout << "STL Symbol Table: " << endl;
383  cout << "DOC_IDX_GID[] => ";
384 
385  for(int i=0;i<span_count;i++) {
386           cout << gids[i] << " ";
387  }
388  cout << endl << endl;
389 
390  delete [] gids;
391
392//  #ifdef PAPI
393//      code_clocker->end_interval(bytes);
394//  #endif   
395// 
396//  } 
397       
398//  for(int i=0;i<RUNS;i++) {
399   
400
401          LSSymbolTable ls_symbol_table;
402          for(int i=0; i<span_count; i++) {
403            ls_symbol_table.put(byte_buffer + starts[i], lengths[i]);
404          }               
405         
406//        #ifdef PAPI
407//                code_clocker->start_interval();
408//        #endif   
409         
410          ls_symbol_table.bind();               
411          ls_symbol_table.finalize();   
412
413//        #ifdef PAPI
414//                code_clocker->end_interval(bytes);
415//        #endif 
416         
417          cout << "Length Sorted Symbol Table:" << endl;
418          ls_symbol_table.display_flattened_symbol_values();
419          ls_symbol_table.display_flattened_gids();       
420          ls_symbol_table.clear();
421//  }
422       
423  delete [] starts;
424  delete [] lengths;
425 
426  if(byte_buffer != NULL) {
427          simd_delete((SIMD_type *)byte_buffer);
428  }
429 
430  if(bit_stream_buffer != NULL) {
431          simd_delete(bit_stream_buffer);
432  }
433
434  if(infile != NULL) {
435          fclose(infile);
436  }
437 
438  if(argc > 3) {
439          fclose(outfile);
440  }
441 
442#ifdef PAPI 
443        code_clocker->write_xml_file();
444        code_clocker->display_system_info();
445        code_clocker->display_raw_event_data();
446        delete code_clocker; 
447#endif
448       
449  fprintf(stdout, "Done.\n");
450 
451  return(0);
452}
Note: See TracBrowser for help on using the repository browser.