source: proto/gml2svg/C/parabix/cc_analyzer.cxx @ 2487

Last change on this file since 2487 was 2487, checked in by ksherdy, 7 years ago

Added total measurements statistic.

File size: 17.6 KB
Line 
1/*  markup_stats.c - parabix demo program
2    Copyright (c) 2007, Robert D. Cameron.
3    Licensed to the public under the Open Software License 3.0.
4    Licensed to International Characters, Inc., under the Academic
5    Free License 3.0.
6
7*/
8
9#define SHOW_EVENTS 1
10
11#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <errno.h>
15#include <sys/types.h>
16#include <sys/stat.h>
17#include <string>
18#include <iostream>
19using namespace std;
20
21#include "src/engine.h"
22
23/* Internals */
24#include "src/xmlmodel.h"
25#include "src/xml_error.h"
26#include "src/symtab.h"
27#include "src/bitplex.h"
28#include "src/byteplex.h"
29#include "src/xmldecl.h"
30#include "src/bitlex.h"
31
32
33#include "src/xmlmodel.c"
34#include "src/xml_error.c"
35#include "src/symtab.c"
36#include "src/bitplex.c"
37#include "src/byteplex.c"
38#include "src/xmldecl.c"
39#include "src/bitlex.c"
40#include "src/engine.c"
41
42// Undef min, max for sstream, a hack
43#undef min
44#undef max
45
46#include <vector>
47#include <map>
48#include <sstream>
49#include <algorithm>
50#include <iomanip>
51#include <cmath>
52
53/* Global declarations of parsing engine. */
54Parser_Interface * parser;
55
56/* Global declarations for statistics. */
57bool is_run_date = false;
58bool is_run_time = false;
59bool is_run_cmd = false;
60bool is_param = false;
61bool is_calibration_data = false;
62bool is_run_data = false;
63bool is_interval = false;
64
65const int cc_Precision = 5;
66
67/* Metadata */
68string run_date;
69string run_time;
70string run_cmd;
71
72vector<pair<string,string> > params;
73pair<string, string> param;
74
75/* Current map key */
76string key;
77
78/* Map of PAPI event name to vector event value elements pairs. */
79map<string, vector<pair <unsigned long long, unsigned long> > > vals;
80pair <unsigned long long, unsigned long> val_interval;
81
82/* Map of PAPI event name to vector of calibration values */
83map<string, vector<unsigned long long> > cals;
84
85/* Action routine for an XML comment in "<!--"  "-->" brackets. */
86template <class B>
87inline void ParsingEngine<B>::Comment_action(unsigned char * item, int lgth) {
88
89}
90
91/* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
92template <class B>
93inline void ParsingEngine<B>::CDATA_start_action(unsigned char * CDATA_ptr){
94
95}
96
97/* Action routine called upon recognizing "]]>" to end a CDATA section. */
98template <class B>
99inline void ParsingEngine<B>::CDATA_end_action(unsigned char * CDATA_end_ptr) {
100
101}
102
103/* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
104template <class B>
105inline void ParsingEngine<B>::PI_action(unsigned char * item, int lgth) {
106
107}
108
109/* Action routine for an empty element enclosed in "<" and "/>" brackets. Called after empty element attributes.
110 */
111template <class B>
112inline void ParsingEngine<B>::EmptyElement_action(unsigned char * item, int lgth) {
113        if((memcmp(item+1,"param",sizeof("param")-1)==0)) {
114                ::is_param = false;
115                ::param.first = "";
116                ::param.second = "";
117        } else if(memcmp(item+1,"interval",sizeof("interval")-1)==0) {
118                ::is_interval = false;
119                ::val_interval.first = 0ull;
120                ::val_interval.second = 0ul;
121        }
122}
123
124/* Action routine for a start tag enclosed in "<" and ">" brackets. */
125template <class B>
126inline void ParsingEngine<B>::StartTag_action(unsigned char * item, int lgth) {
127        if((memcmp(item+1,"run_date",sizeof("run_date")-1)==0)) {
128                ::is_run_date = true;
129        } else if((memcmp(item+1,"run_time",sizeof("run_time")-1)==0)) {
130                ::is_run_time = true;
131        } else if((memcmp(item+1,"run_cmd",sizeof("run_cmd")-1)==0)) {
132                ::is_run_cmd = true;
133        } else if((memcmp(item+1,"calibration_intervals",sizeof("calibration_intervals")-1)==0)) {
134                ::is_calibration_data = true;
135        } else if((memcmp(item+1,"run_intervals",sizeof("run_intervals")-1)==0)) {
136                ::is_run_data = true;
137        }
138}
139
140/* Action routine for an end tag enclosed in "</" and ">" brackets. */
141template <class B>
142inline void ParsingEngine<B>::EndTag_action(unsigned char * item, int lgth) {
143
144        if((memcmp(item+2,"run_date",sizeof("run_date")-1)==0)) {
145                ::is_run_date = false;
146        } else if((memcmp(item+2,"run_time",sizeof("run_time")-1)==0)) {
147                ::is_run_time = false;
148        } else if((memcmp(item+2,"run_cmd",sizeof("run_cmd")-1)==0)) {
149                ::is_run_cmd = false;
150        } else if((memcmp(item+2,"calibration_intervals",sizeof("calibration_intervals")-1)==0)) {
151                ::is_calibration_data = false;
152        } else if((memcmp(item+2,"run_intervals",sizeof("run_intervals")-1)==0)) {
153                ::is_run_data = false;
154        }
155}
156
157/* Action routine for an error item */
158template <class B>
159inline void ParsingEngine<B>::Error_action(unsigned char * item, int lgth) {
160
161}
162
163/* Action routine for a text item */
164template <class B>
165inline void ParsingEngine<B>::Text_action(unsigned char * item, int lgth, bool more) {
166
167        if(::is_run_date) {
168                ::run_date = (string ((char *) item, lgth));
169        } else if(::is_run_time){
170                ::run_time = (string ((char *) item, lgth));
171        } else if(::is_run_cmd) {
172                ::run_cmd = (string ((char *) item, lgth));
173        }
174}
175
176template <class B>
177inline void ParsingEngine<B>::Reference_action(unsigned char * item, int lgth) {
178
179}
180
181
182
183
184/* Three action routines for markup components are defined as follows.
185|ElementName_action| is the action routine called upon recognition of
186an element name immediately after the opening angle bracket of a start
187tag or empty element tag.  {\bf OR MAYBE THIS SHOULD BE DEFERRED UNTIL
188AFTER ATTRIBUTE PROCESSING SO THAT NAMESPACES ARE SET?}
189It is called with two parameters identifying the
190first and last character positions of the expected XML_name.
191vector
192Similarly, |PI_Target_action| is the action routine called upon recognition
193of the XML Name that occurs immediately after the opening "<?"
194delimiter of a processing instruction.
195
196 The third action routine for markup components is Attribute_Value_action,
197which takes three parameters rather than two.  {\bf OR POSSIBLY JUST
198THE QUOTE MARK ITEMS, RELYING ON THE END OF THE LAST COMPONENT PROCESSED
199TO MARK THE SPACE BEFORE THE ATT NAME.- REQUIRES ELEMENT_NAME_ACTION}
200*/
201
202/* Semantic action routines for markup components. */
203/* Action routine for an element name occurring immediately after the
204   opening "<" of a start tag or empty element tag. */
205template <class B>
206inline void ParsingEngine<B>::ElementName_action(unsigned char * item, int lgth) {
207
208        if(memcmp(item,"param",sizeof("param")-1)==0) {
209                ::is_param = true;
210        } else if(memcmp(item,"interval",sizeof("interval")-1)==0) {
211                ::is_interval = true;
212        }
213}
214
215/* Action routine for a processing instruction target name occurring immediately
216   after the opening "<?" of a processing instruction. */
217template <class B>
218inline void ParsingEngine<B>::PI_Target_action(unsigned char * item, int lgth) {
219}
220
221/* Action routine for an individual attribute/value pair occurring in
222   a element start tag or an empty element tag. */
223template <class B>
224inline void ParsingEngine<B>::AttributeValue_action(unsigned char * name, int name_lgth,
225                                 unsigned char * val, int val_lgth) {
226
227        if(::is_param) {
228                        if(memcmp(name, "name", sizeof("name")-1)==0) {
229                                ::param.first = string ((char *) val, val_lgth);
230                        } else if(memcmp(name, "value", sizeof("value")-1)==0) {
231                                ::param.second = string ((char *) val, val_lgth);
232                                ::params.push_back(param);
233                        }
234        } else if(::is_interval) {
235
236                if(::is_calibration_data) {
237
238                        if(memcmp(name, "event", sizeof("event")-1)==0) {
239                                ::key = (string ((char *) val, val_lgth));
240
241                        } else if(memcmp(name, "value", sizeof("value")-1)==0) {
242                                // convert string to numeric
243                                istringstream iss;
244                                unsigned long long next_cal;
245                                iss.str(string ((char *) val, val_lgth));
246                                iss >> next_cal;
247
248                                // insert
249                                map<string, vector<unsigned long long> >::iterator it = ::cals.find(::key);
250                                if(it != ::cals.end()){
251                                        (*it).second.push_back(next_cal);
252                                } else {
253                                        vector<unsigned long long> next_vector;
254                                        next_vector.push_back(next_cal);
255                                        pair<string, vector<unsigned long long> > p(::key, next_vector);
256                                        ::cals.insert(p);
257                                }
258
259                        }
260                } else if(::is_run_data) {
261
262                        if(memcmp(name, "event", sizeof("event")-1)==0) {
263                                ::key = (string ((char *) val, val_lgth));
264
265                        } else if(memcmp(name, "value", sizeof("value")-1)==0) {
266                                // convert string to numeric
267                                istringstream iss;
268                                unsigned long long next_val;
269                                iss.str(string ((char *) val, val_lgth));
270                                iss >> next_val;
271                                ::val_interval.first = next_val;
272
273                        } else if(memcmp(name, "elems", sizeof("elems")-1)==0) {
274                                // convert string to numeric
275                                istringstream iss;
276                                unsigned long long next_elems;
277                                iss.str(string ((char *) val, val_lgth));
278                                iss >> next_elems;
279                                ::val_interval.second = next_elems;
280
281                                // insert
282                                map<string, vector<pair <unsigned long long, unsigned long> > >::iterator it = ::vals.find(::key);
283                                if(it != ::vals.end()){
284                                        (*it).second.push_back(::val_interval);
285                                } else {
286                                        vector<pair <unsigned long long, unsigned long> > next_vector;
287                                        next_vector.push_back(::val_interval);
288                                        pair<string, vector<pair <unsigned long long, unsigned long> > > p(::key, next_vector);
289                                        ::vals.insert(p);
290                                }
291                        }
292                }
293        }
294}
295
296/* Action routine for an individual attribute/value pair occurring in
297   a element start tag or an empty element tag. */
298template <class B>
299inline void ParsingEngine<B>::Namespace_action(unsigned char * name, int name_lgth,
300                             unsigned char * URI, int URI_lgth) {
301}
302
303
304template <class B>
305inline void ParsingEngine<B>::FinalizeBuffer_action() {
306#ifdef DEBUG
307        printf ("FinalizeBuffer; last 16 bytes + lookahead 16 =\n");
308        cout << string((char *) GetCodeUnitPtr(AbsPos()-16), 16) << "::" << string((char *) GetCodeUnitPtr(AbsPos()), 16) << endl;
309#endif
310}
311
312
313template <class B>
314inline void ParsingEngine<B>::DocumentStart_action() {
315        ::is_run_date = false;
316        ::is_run_time = false;
317        ::is_run_cmd = false;
318        ::is_param = false;
319        ::is_calibration_data = false;
320        ::is_run_data = false;
321        ::is_interval = false;
322}
323
324template <class B>
325inline void ParsingEngine<B>::DocumentEnd_action() {
326
327}
328
329template <class B>
330inline void ParsingEngine<B>::Doctype_action(unsigned char * item, int lgth) {
331
332}
333
334template <class B>
335inline void ParsingEngine<B>::PEReference_action(unsigned char * item, int lgth) {
336}
337
338template <class B>
339inline void ParsingEngine<B>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
340
341}
342
343template <class B>
344inline void ParsingEngine<B>::Prolog_action(unsigned char * item, int lgth) {
345
346}
347
348void write_raw_event_data();
349void calc_write_cal_stats();
350void calc_write_event_stats();
351void write_ln(const string & name, const string & value);
352
353int
354main(int argc, char * argv[]) {
355
356        if (argc < 2) {
357        printf("Usage: %s <filename> [-r] [-c] [-p]\n", argv[0]);
358                exit(-1);
359        }
360        char * filename = argv[1];
361
362        bool show_raw_event_data = true;
363        bool show_calibration_results = true;
364        bool show_paramters = true;
365
366        for(int i=2; i < argc; i++)
367        {
368                if(strcmp(argv[i], "-r") == 0)
369                {
370                                show_raw_event_data = false;
371                }
372
373                if(strcmp(argv[i], "-c") == 0)
374                {
375                                show_calibration_results = false;
376                }
377
378                if(strcmp(argv[i], "-p") == 0)
379                {
380                                show_paramters = false;
381                }
382        }
383
384        parser = Parser_Interface::ParserFactory(filename);
385        parser->Parse_Prolog();
386        parser->ParseContent();
387        parser->~Parser_Interface();
388
389    cout << endl;
390        cout << "-=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=-" << endl;
391        cout << "Code Clocker Results" << endl;
392        cout << "-=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=-" << endl;
393        cout << "--------------------------------------------------------------------------------" << endl;
394        cout << "Run Parameters" << endl;
395        cout << "--------------------------------------------------------------------------------" << endl;
396        cout << endl;
397
398        write_ln("Date", ::run_date);
399        write_ln("Time", ::run_time);
400
401        if(::run_cmd.compare("")!=0) {
402                write_ln("Command Line", ::run_cmd);
403        }
404
405        if(show_paramters) {
406                for(int i=0;i< ::params.size();i++){
407                        write_ln(::params[i].first,params[i].second);
408                }
409                cout << endl;
410        }
411
412        if(show_raw_event_data)
413        {
414                write_raw_event_data();
415        }
416
417        if(show_calibration_results)
418        {
419                calc_write_cal_stats();
420        }
421
422        calc_write_event_stats();
423
424        return(0);
425}
426
427void write_raw_event_data() {
428
429        cout << "--------------------------------------------------------------------------------" << endl;
430        cout << "PAPI Raw Event Data" << endl;
431        cout << "--------------------------------------------------------------------------------" << endl;
432
433        map<string, vector<pair <unsigned long long, unsigned long> > >::iterator ii = ::vals.begin();
434
435        int num_events = (ii->second).size();
436
437        // Display raw event data values in order of insertion
438        for (int i = 0; i < num_events; i++) {
439                vector<pair <unsigned long long, unsigned long> >::iterator jj;
440
441                ostringstream raw_data_value;
442
443                for(ii = ::vals.begin(); ii != ::vals.end(); ii++) {
444                        raw_data_value << (ii->second).at(i).first;
445                        write_ln(ii->first, raw_data_value.str());
446                        raw_data_value.str("");
447                }
448        }
449
450        cout << endl;
451}
452
453void calc_write_cal_stats() {
454
455        double mean, std_dev;
456        unsigned long long min, max, sum;
457        ostringstream oss_min, oss_max, oss_mean, oss_total, oss_std_dev;
458
459        map<string, vector<unsigned long long > >::iterator ii;
460        for (ii = ::cals.begin(); ii != ::cals.end(); ii++ ) {
461                vector<unsigned long long >::iterator jj;
462
463                mean = std_dev = 0.0;
464                min = max = sum = 0;
465
466                // sort
467                sort((ii->second).begin(), (ii->second).end());
468
469                // min, max
470                oss_min << (ii->second)[0];
471                oss_max << (ii->second)[(ii->second.size())-1];
472
473                cout << "--------------------------------------------------------------------------------" << endl;
474                cout  << "Calibration " << (ii->first) << endl;
475                cout << "--------------------------------------------------------------------------------" << endl;
476                write_ln(string("Min "), oss_min.str());
477                write_ln(string("Max "), oss_max.str());
478
479                // mean and number of elements
480                for(jj = (ii->second).begin(); jj != (ii->second).end(); jj++) {
481                        sum += (*jj);
482                }
483
484          // total elements             
485                oss_total << fixed << std::setprecision(cc_Precision) << sum; 
486                write_ln(string("Total "), oss_total.str());
487
488                mean = (double)sum / (double)(ii->second).size();
489                oss_mean << fixed << std::setprecision(cc_Precision) << mean;
490                write_ln(string("Mean "), oss_mean.str());
491
492                // standard deviation
493                std_dev = 0;
494                for(jj = (ii->second).begin(); jj != (ii->second).end(); jj++) {
495                        std_dev += pow(*jj - mean, 2);
496                }
497                std_dev /= (double)(ii->second).size();
498                std_dev = sqrt(std_dev);
499
500                oss_std_dev << fixed << std::setprecision(cc_Precision) << std_dev;
501                write_ln(string("Std Dev "), oss_std_dev.str());
502
503                cout << endl;
504
505                oss_min.str("");
506                oss_max.str("");
507                oss_total.str("");
508                oss_mean.str("");
509                oss_std_dev.str("");
510        }
511
512}
513
514void calc_write_event_stats() {
515
516        double mean, std_dev, mean_per_elem, std_dev_per_elem;
517        unsigned long long min, max, sum, elems;
518        ostringstream oss_min, oss_max, oss_mean, oss_total, oss_std_dev, oss_elems, oss_mean_per_elem, oss_std_dev_per_elem;
519
520        map<string, vector<pair <unsigned long long, unsigned long> > >::iterator ii;
521        for ( ii = ::vals.begin(); ii != ::vals.end(); ii++ ) {
522                vector<pair <unsigned long long, unsigned long> >::iterator jj;
523
524                mean = std_dev = mean_per_elem = std_dev_per_elem = 0.0;
525                min = max = sum = elems = 0;
526
527                // sort
528                sort((ii->second).begin(), (ii->second).end());
529
530                // min, max
531                oss_min << (ii->second)[0].first;
532                oss_max << (ii->second)[(ii->second.size())-1].first;
533
534                cout << "--------------------------------------------------------------------------------" << endl;
535                cout << "Measured " << (ii->first) << endl;
536                cout << "--------------------------------------------------------------------------------" << endl;
537                write_ln(string("Min "), oss_min.str());
538                write_ln(string("Max "), oss_max.str());
539
540                // mean and number of elements
541                for(jj = (ii->second).begin(); jj != (ii->second).end(); jj++) {
542                        sum += (jj->first);
543                        elems += (jj->second);
544                }
545
546          // total elements             
547                oss_total << fixed << std::setprecision(cc_Precision) << sum; 
548                write_ln(string("Total "), oss_total.str());
549               
550                mean = (double)sum / (double)(ii->second).size();
551                oss_mean << fixed << std::setprecision(cc_Precision) << mean;
552                write_ln(string("Mean "), oss_mean.str());
553
554                // standard deviation
555                std_dev = 0;
556                for(jj = (ii->second).begin(); jj != (ii->second).end(); jj++) {
557                        std_dev += pow(jj->first - mean, 2);
558                }
559                std_dev /= (double)(ii->second).size();
560                std_dev = sqrt(std_dev);
561
562                oss_std_dev << fixed << std::setprecision(cc_Precision) << std_dev;
563                write_ln(string("Std Dev "), oss_std_dev.str());
564
565                oss_elems << fixed << std::setprecision(cc_Precision) << elems;
566                write_ln(string("Total Elements "), oss_elems.str());
567
568                // mean per element
569                if(elems > 0) {
570                        mean_per_elem = (double)sum/(double)(elems);
571                } else {
572                        mean_per_elem = 0;
573                }
574                oss_mean_per_elem << fixed << std::setprecision(cc_Precision) << mean_per_elem;
575                write_ln(string("Mean per Element "), oss_mean_per_elem.str());
576
577                // standard deviation per element
578                std_dev_per_elem = 0;
579                if(mean_per_elem > 0)
580                {
581                        for(jj = (ii->second).begin(); jj != (ii->second).end(); jj++) {
582                                std_dev_per_elem += pow(((jj->first)/(jj->second)) - mean_per_elem, 2);
583                        }
584                }
585
586                // standard deviation per element
587                if(elems > 0) {
588                        std_dev_per_elem /= (double)(ii->second).size();
589                } else {
590                        std_dev_per_elem = 0;
591                }
592                std_dev_per_elem = sqrt(std_dev_per_elem);
593                oss_std_dev_per_elem << fixed << std::setprecision(cc_Precision) << std_dev_per_elem;
594                write_ln(string("Std Dev per Element "), oss_std_dev_per_elem.str());
595
596                cout << endl;
597
598                oss_min.str("");
599                oss_max.str("");
600                oss_mean.str("");
601                oss_total.str("");
602                oss_std_dev.str("");
603                oss_elems.str("");
604                oss_mean_per_elem.str("");
605                oss_std_dev_per_elem.str("");
606
607        }
608}
609
610void write_ln(const string & name, const string & value) {
611
612        const unsigned int LINE_WIDTH = 80;
613        const unsigned int COL_WIDTH = 20;
614
615        cout << setiosflags(std::ios::left) << std::setfill('.') << std::setw(COL_WIDTH);
616        cout << name;
617        cout << resetiosflags(std::ios::left) << std::setw(LINE_WIDTH-COL_WIDTH)  << value << endl;
618}
Note: See TracBrowser for help on using the repository browser.