Checking in this older version of rewritelog that uses an old file format. This is...
authorIsaac Dooley <idooley2@illinois.edu>
Thu, 13 Sep 2007 15:47:44 +0000 (15:47 +0000)
committerIsaac Dooley <idooley2@illinois.edu>
Thu, 13 Sep 2007 15:47:44 +0000 (15:47 +0000)
examples/bigsim/tools/rewritelog-old-format/EventInterpolator.C [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/EventInterpolator.h [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/EventInterpolator.o [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/Makefile [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/README [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/interpolatelog [new file with mode: 0755]
examples/bigsim/tools/rewritelog-old-format/interpolatelog.C [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/interpolatelog.o [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/rewritelog.C [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.C [new file with mode: 0644]
examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.h [new file with mode: 0644]

diff --git a/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.C b/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.C
new file mode 100644 (file)
index 0000000..4cf275a
--- /dev/null
@@ -0,0 +1,696 @@
+#include <EventInterpolator.h>
+
+//#define DEBUG
+#define PRETEND_NO_ENERGY
+
+using namespace std;
+
+
+/** Create a vector such that "count" items out of "length" in the vector are set to true */
+vector<bool> random_select(int count, int length){
+  vector<bool> v(length);
+  int c=0;
+  // Initialize all to false
+  for(int i=0;i<length;++i)
+       v[i] = false;
+  while(c < count){
+       // find a random entry int the vector
+       int r = rand() % length;
+       // mark it as true, incrementing c if this is the first time we mark it
+       if(v[r] == false){
+         c++;
+         v[r] = true;
+       }
+  }
+  return v;
+}
+
+template <typename T, typename T2>
+multimap<T,T2> random_select_multimap(multimap<T,T2> input_map , int count){
+    assert(input_map.size() >= count);
+    vector<bool> which_to_keep = random_select(count, input_map.size());
+    multimap<T,T2> output_map;
+    int len = which_to_keep.size();
+    typename multimap<T, T2>::iterator itr=input_map.begin();
+    for(int i=0; i<len; ++i, ++itr){
+        if(which_to_keep[i] == true){
+          // Do something like this to keep them around:
+            output_map.insert(make_pair((*itr).first, (*itr).second));
+        }
+    }
+//     assert(output_map.size()==count);
+    return output_map;
+}
+
+int EventInterpolator::numCoefficients(const string &funcname){
+// We create a dummy input stringstream and pass it to parseParameters.
+// Then we count how many parameters that function creates
+    string temp("0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0");
+    istringstream temp2(temp);
+    return parseParameters(funcname,temp2,false).second.size();
+}
+
+
+int distance(int i1, int i2, int i3, int i4, int i5, int i6){
+    int x1 =(abs(13+i1-i4)%13)*4;
+    int x2 =(abs(13+i4-i1)%13)*4;
+    int x = min(x1,x2);
+
+    int y1 =(abs(6+i2-i5)%6)*2;
+    int y2 =(abs(6+i5-i2)%6)*2;
+    int y = min(y1,y2);
+
+    int z1 =(abs(4+i3-i6)%4)*1;
+    int z2 =(abs(4+i6-i3)%4)*1;
+    int z = min(z1,z2);
+
+    return x+y+z;
+
+}
+
+pair<int,vector<double> > EventInterpolator::parseParameters(const string &funcname, istringstream &param_stream, const bool log){
+    double temp;
+    return parseParameters(funcname,param_stream,temp, log);
+}
+
+
+/** First parameter is a category or subclass for a particular timed region. For example, we wish to consider computation for adjacent patches differently than patches that are neighbors of adjacent patches. This allows a single timed region to be broken out and treated as a number of different cases. */
+pair<int,vector<double> > EventInterpolator::parseParameters(const string &funcname, istringstream &line, double &time, const bool log){
+    vector<double> params;
+    int category=0;
+
+    if( funcname == string("calc_self_energy_merge_fullelect") ||
+        funcname == string("calc_pair_energy_merge_fullelect") ||
+        funcname == string("calc_self_merge_fullelect") ||
+        funcname == string("calc_pair_merge_fullelect") ||
+        funcname == string("calc_self") ||
+        funcname == string("calc_pair") ||
+        funcname == string("calc_self_energy") ||
+        funcname == string("calc_pair_energy") ){
+
+        double d1,d2,d3,d4,d5,d6,d7,d8,d9, t1;
+        int i1,i2,i3,i4,i5,i6;
+
+        line >> d1 >> d2 >> i1 >> i2 >> i3 >> i4 >> i5 >> i6 >>
+                d3 >> d4 >> d5 >> d6 >> d7 >> d8 >> t1;
+
+        if(log)
+            log1 << funcname << "\t" << t1 << "\t"  << d1  << "\t" << d2 << "\t"  << d3  << "\t" << d4  << "\t" << d5 << "\t"  << d6  << "\t" << d7  << "\t" << d8 << "\t" << i1  << "\t" << i2 << "\t"  << i3  << "\t" << i4  << "\t" << i5 << "\t"  << i6 << "\t" << distance(i1,i2,i3,i4,i5,i6) << endl;
+
+        params.push_back( 1.0);
+
+//         params.push_back( 1.0 / distance );
+        params.push_back( d3 );
+        params.push_back( d4 );
+        params.push_back( d5 );
+               //        params.push_back( d2 );
+               //        params.push_back( d3 );
+               //        params.push_back( d4 );
+        params.push_back( min(d1,d2)*d1*d2 );
+        params.push_back( d1*d2 );
+
+        category = distance(i1,i2,i3,i4,i5,i6 );
+
+        time = t1;
+    }
+    else if(funcname == string("angle") || funcname == string("dihedrals")){
+        double d1, d2, t1;
+        line >> d1 >> d2 >> t1;
+
+        if(log)
+            log1 << funcname << "\t" << t1 << "\t"  << d1  << "\t" << d2 << endl;
+
+        params.push_back( 1.0);
+        params.push_back( d2 );
+        params.push_back( d2*d2 );
+
+        time = t1;
+
+    }
+    else if(funcname == string("*integrate*")){
+        double d1, d2, d3, d4, d5, d6, d7, d8, t1;
+        line >> d1 >> d2 >> d3 >> d4 >> d5 >> d6 >> d7 >> d8 >> t1;
+
+        if(log)
+            log1 << funcname << "\t" << t1 << "\t" << d1 << "\t" << d2 << "\t" << d3 << "\t" << d4 << "\t" << d5 << "\t" << d6 << "\t" << d7 << endl;
+
+        params.push_back( 1.0);
+        params.push_back( d2 );
+        params.push_back( d2*d2 );
+        time = t1;
+
+    }
+    else {
+        cerr << "FATAL ERROR: Don't know how to read parameters for function " << funcname << endl;
+        throw new runtime_error("unknown function");
+    }
+
+    return make_pair(category,params);
+}
+
+
+
+
+
+EventInterpolator::EventInterpolator(char *table_filename, double sample_rate){
+  std::map<string,double> cycle_accurate_time_sum;
+
+  exact_matches=0;
+  exact_positive_matches=0;
+  approx_matches=0;
+  approx_positive_matches=0;
+
+       log1.open("log1");
+
+    cout << "Loading timings file: " << table_filename << endl;
+    ifstream accurateTimeTable(table_filename);
+    if(! accurateTimeTable.good() ){
+        cerr << "FATAL ERROR: Couldn't open file(perhaps it doesn't exist): " << table_filename << endl;
+        throw new runtime_error("missing file");
+    }
+
+
+    // First pass, scan through cycle accurate time file to count
+    // how many samples there are for each function
+    while(accurateTimeTable.good()){
+        string line_s;
+        getline(accurateTimeTable,line_s);
+        istringstream line(line_s);
+
+        string temp("");
+        while(temp != string("TRACEBIGSIM") && line.good() && accurateTimeTable.good() ){
+            line >> temp;
+        }
+        line >> temp; // gobble up one more worthless bit of input line
+
+        if(line.good() && accurateTimeTable.good()){
+            string funcname;
+            line >> funcname;
+
+                       double time;
+                       fullParams params = parseParameters(funcname,line,time,false);
+            funcIdentifier func(funcname,params.first);
+            sample_count[func]++;
+                       cycle_accurate_time_sum[funcname] += time;
+
+            accurateTimings.insert(make_pair(make_pair(func,params.second),time));
+
+        }
+    }
+
+
+       std::map<string,double>::iterator cycle_i;
+       cout << "\nThe following table displays the total cycle count for each event in the \n" 
+            "cycle-accurate timings file. This may be useful for back of the envelope \n"
+            "calculations for expected performance " << endl << endl;
+       cout << "\t|=========================|===================|" << endl;
+       cout << "\t|                  event  | total cycle count |" << endl;
+       cout << "\t|-------------------------|-------------------|" << endl;
+       for(cycle_i= cycle_accurate_time_sum.begin();cycle_i!=cycle_accurate_time_sum.end();++cycle_i){
+         cout << "\t|";
+         for(int i=0;i<24-(*cycle_i).first.length();++i) 
+               cout << " ";
+         cout << (*cycle_i).first << " | ";
+         cout.width(17);
+         cout << (*cycle_i).second;
+         cout << " |" << endl;
+       }       
+       cout << "\t|=========================|===================|" << endl << endl;
+
+
+
+    unsigned long sample_keep = (unsigned long) ceil(sample_rate * accurateTimings.size());
+    if (sample_rate < 1.0){
+        cout << "Randomly dropping " << (1.0-sample_rate)*100 << "% of the cycle accurate timings" << endl;
+        accurateTimings = random_select_multimap(accurateTimings, sample_keep);
+    }
+
+       analyzeExactVariances();
+
+       cout << "\nThe following table displays the number of timing samples from \n the cycle-accurate file for each event." << endl << endl;
+       cout << "\t|=========================|==========================|" << endl;
+       cout << "\t|                  event  | number of timing samples |" << endl;
+       cout << "\t|-------------------------|--------------------------|" << endl;
+
+
+    // Create a gsl interpolator workspace for each event/function
+    for(map<funcIdentifier,unsigned long>::iterator i=sample_count.begin(); i!=sample_count.end();++i){
+        funcIdentifier func = (*i).first;
+        unsigned long samples = (*i).second;
+               
+        cout << "\t|";
+               
+               for(int i=0;i<20-func.first.length();++i)
+                 cout << " ";
+               cout << func.first << ",";
+               cout.width(3);
+               cout << func.second;
+               
+               cout << " | ";
+               cout.width(24);
+               cout << samples << " |" << endl;
+
+
+        if(samples < numCoefficients(func.first) ){
+            cerr << "FATAL ERROR: Not enough input timing samples for " << func.first << "," << func.second << " which has " << numCoefficients(func.first) << " coefficients" << endl;
+            throw new runtime_error("samples < numCoefficients");
+        }
+        else {
+            work[func] = gsl_multifit_linear_alloc(samples,numCoefficients(func.first));
+            X[func] = gsl_matrix_alloc (samples,numCoefficients(func.first));
+            y[func] = gsl_vector_alloc (samples);
+            c[func] = gsl_vector_alloc(numCoefficients(func.first));
+            cov[func] = gsl_matrix_alloc(numCoefficients(func.first),numCoefficients(func.first));
+
+            for(int i=0;i<numCoefficients(func.first);++i){
+                gsl_vector_set(c[func],i,1.0);
+            }
+
+        }
+    }
+       cout << "\t|=========================|==========================|" << endl << endl;
+
+    accurateTimeTable.close();
+
+
+#ifdef WRITESTATS
+    ofstream statfile("stats-out");
+#endif
+
+    // Fill in values for matrix X and vector Y which will be fed into the least square fit algorithm
+       // The data is currently in  accurateTimings[pair<funcIdentifier,vector<double> >(func,params.second)]=time;
+
+       //iterate through accurateTimings
+       cout << "accurateTimings.size() = " << accurateTimings.size() << endl;
+       map< pair<funcIdentifier,vector<double> >, double >::iterator itr;
+    for(itr=accurateTimings.begin();itr!=accurateTimings.end();++itr){
+         const double &time = (*itr).second;
+         const vector<double> &paramsSecond =(*itr).first.second;
+         const funcIdentifier func = (*itr).first.first;
+
+         // lookup the next unused entry in X
+         unsigned next = Xcount[func] ++;
+         gsl_matrix * x = X[func];
+
+         // copy data into array X and Y
+         for(int param_index=0;param_index<paramsSecond.size();++param_index){
+               gsl_matrix_set(x,next,param_index, paramsSecond[param_index]);
+         }
+         gsl_vector_set(y[func],next,time);
+
+       }
+
+
+#ifdef WRITESTATS
+    statfile.close();
+#endif
+
+    // Perform a sanity check now
+       int count1=0, count2=0;
+    for(map<funcIdentifier, gsl_multifit_linear_workspace *>::iterator i=work.begin();i!=work.end();++i){
+#if DEBUG
+         cout << "sample count vs Xcount (" << (*i).first.first << "): " << sample_count[(*i).first] << "?=" << Xcount[(*i).first] << " " << endl;
+#endif
+         count1 += sample_count[(*i).first];
+         count2 += Xcount[(*i).first] ;
+       }
+       cout << "Samples from cycle accurate file : " << count1 << ".  Keeping only " << count2 << " of them " << endl;
+
+    cout << "Performing Least Squared Fit to sampled time data" << endl;
+
+    //  Now do Least Square Fit: Find C where y=Xc
+       cout << "\nThe following table displays the chi^2 measure for how well the model fits the input times." << endl << endl;
+       cout << "\t|=========================|=========|=========|" << endl;
+       cout << "\t|                  event  |   chi^2 |     chi |" << endl;
+       cout << "\t|-------------------------|---------|---------|" << endl;
+
+       cout.setf(ios_base::scientific, ios_base::floatfield);
+       cout.precision(1);
+
+    map<funcIdentifier, gsl_multifit_linear_workspace *>::iterator i;
+    for(i=work.begin();i!=work.end();++i){
+        funcIdentifier func = (*i).first;
+        assert(! gsl_multifit_linear(X[func],y[func],c[func],cov[func],&chisqr[func],work[func]));
+        gsl_matrix_free(X[func]);
+        gsl_vector_free(y[func]);
+
+               cout << "\t|";
+               
+               for(int i=0;i<20-func.first.length();++i)
+                 cout << " ";
+               cout << func.first << ",";
+               cout.width(3);
+               cout << func.second;
+               
+               cout << " | ";
+               cout.width(7);
+               cout << chisqr[func];
+
+               cout << " | ";
+               cout.width(7);
+               cout << sqrt(chisqr[func]) << " |" << endl;
+
+    }
+       cout << "\t|=========================|=========|=========|" << endl << endl;
+
+    // Load in Parameter File which maps event id to function name and parameters
+    cout << "Loading parameter files" << endl;
+
+    for(int i=0;i<102400;++i){
+        char name[512];
+        sprintf(name,"param.%d",i);
+        ifstream parameterEventTable(name);
+
+        if(parameterEventTable.good()){
+#ifdef DEBUG
+            cout << "     >  Loading " << name << endl;
+#endif
+
+            while(parameterEventTable.good()){
+                string line_s;
+                getline(parameterEventTable,line_s);
+                istringstream line(line_s);
+
+                if(parameterEventTable.good()){
+                    string t1, t2;
+                    string funcname;
+                    unsigned eventid;
+
+                    line >> eventid;
+                    line >> t1 >> t2;
+                    line >> funcname;
+
+                    if(t1 == string("TRACEBIGSIM")){
+#ifdef PRETEND_NO_ENERGY
+                                           if(funcname == string("calc_pair_energy")){\
+                                                 funcname = "calc_pair";
+                                               }
+                                               else if(funcname == string("calc_self_energy")){
+                                                 funcname = "calc_self";
+                                               }
+#endif
+
+                        fullParams params = parseParameters(funcname,line,false);
+                        funcIdentifier func(funcname,params.first);
+                        Xcount[func] ++;
+                        eventparams[make_pair(i,eventid)] = make_pair(func,params.second);
+                    }
+                }
+            }
+
+        }
+        else{ // file was no good
+            break;
+        }
+
+        parameterEventTable.close();
+    }
+}
+
+
+bool EventInterpolator::haveExactTime(const unsigned pe, const unsigned eventid){
+    return haveExactTime(eventparams[make_pair(pe,eventid)]);
+}
+
+bool EventInterpolator::haveExactTime(const pair<funcIdentifier,vector<double> > &p) {
+    return haveExactTime(p.first,p.second);
+}
+
+bool EventInterpolator::haveExactTime(const funcIdentifier& func, const vector<double> &p){
+  return (accurateTimings.find(make_pair(func,p)) != accurateTimings.end());
+}
+
+double EventInterpolator::lookupExactTime(const unsigned pe, const unsigned eventid){
+    return lookupExactTime(eventparams[make_pair(pe,eventid)]);
+}
+
+double EventInterpolator::lookupExactTime(const pair<funcIdentifier,vector<double> > &p) {
+    return lookupExactTime(p.first,p.second);
+}
+
+double EventInterpolator::lookupExactTime(const funcIdentifier& func, const vector<double> &p){
+    const  pair<funcIdentifier,vector<double> > key(func,p);
+    const int count = accurateTimings.count(key);
+
+       pair<timings_type::iterator, timings_type::iterator> itrs = accurateTimings.equal_range(key);
+       double time_sum=0;
+       for(timings_type::iterator itr=itrs.first; itr!=itrs.second; ++itr){
+         time_sum += (*itr).second;
+       }
+       double time_average = time_sum / count;
+
+    exact_matches++;
+       assert(time_average >= 0.0 );
+    return time_average;
+}
+
+
+/** Print out some statistics about the timings for any parameter that has multiple associated cycle-accurate timings */
+void EventInterpolator::analyzeExactVariances(){
+
+    map< pair<funcIdentifier,vector<double> >, double > variances;
+    map< pair<funcIdentifier,vector<double> >, double > means;
+       map< funcIdentifier, double > max_std_dev;
+       map< funcIdentifier, double > associated_mean;
+
+       // Iterate through items in accurateTimings and store variances
+       timings_type::iterator itr;
+       for(itr=accurateTimings.begin();itr!=accurateTimings.end();++itr){
+         variances[(*itr).first] = lookupExactVariance( (*itr).first );
+         means[(*itr).first] = lookupExactMean( (*itr).first );
+       }
+
+       // Display the variances
+       map< pair<funcIdentifier,vector<double> >, double >::iterator vItr;
+       for(vItr = variances.begin(); vItr!=variances.end(); ++vItr){
+         double var = (*vItr).second;
+         double stddev = sqrt(var);
+         double mean = means[(*vItr).first];
+
+         if(var > 0.0){
+               if(stddev > max_std_dev[(*vItr).first.first]){
+                 max_std_dev[(*vItr).first.first] = stddev;
+                 associated_mean[(*vItr).first.first] = mean;
+               }
+         }
+       }
+       
+       // Display the max std dev for any given event
+       cout << "\nThe following events have differing exact times for one or more parameter set.\n"
+               "Each line corresponds to whichever parameter list produced the greatest variance\n"
+               "(and equivalently std dev). The mean is the mean timing value associated with the\n"
+            " same parameter list of greatest variance" << endl << endl;
+
+
+       cout << "\t|=========================|=================|=================|==============|" << endl;
+       cout << "\t|                  event  |     max std dev |            mean | sd % of mean |" << endl;
+       cout << "\t|-------------------------|-----------------|-----------------|--------------|" << endl;
+
+       cout.setf(ios_base::fixed, ios_base::floatfield);
+       cout.precision(1);
+
+       int func_name_field_width=20;
+       map< funcIdentifier, double >::iterator sItr;
+       for(sItr=max_std_dev.begin(); sItr!=max_std_dev.end(); ++sItr) {
+         double stddev = (*sItr).second;
+         double mean = associated_mean[(*sItr).first];
+         cout << "\t|";
+         for(int i=0;i<func_name_field_width-(*sItr).first.first.length();++i) 
+               cout << " ";
+         cout << (*sItr).first.first ;
+         cout << ",";
+         cout.width(3);
+         cout << (*sItr).first.second;
+         cout << " | ";
+         cout.width(15);
+         cout <<  stddev;
+         cout << " | ";
+         cout.width(15);
+         cout << mean << " | ";
+         cout.width(9);
+         cout << (stddev * 100.0 / mean) << "    | " << endl;
+       }
+       cout.setf(ios_base::fmtflags(0), ios_base::floatfield);
+       cout << "\t|=========================|=================|=================|==============|" << endl << endl;
+
+}
+
+/** Lookup the average timing for a given event and parameter list */
+double EventInterpolator::lookupExactVariance(const unsigned pe, const unsigned eventid){
+    return lookupExactVariance(eventparams[make_pair(pe,eventid)]);
+}
+
+/** Lookup the variance in the timings for a given event and parameter list */
+double EventInterpolator::lookupExactVariance(const pair<funcIdentifier,vector<double> > &p) {
+    return lookupExactVariance(p.first,p.second);
+}
+
+/** Lookup the variance in the timings for a given event and parameter list */
+double EventInterpolator::lookupExactVariance(const funcIdentifier& func, const vector<double> &p){
+    const  pair<funcIdentifier,vector<double> > key(func,p);
+    const int count = accurateTimings.count(key);
+
+       // Compute mean
+       pair<timings_type::iterator, timings_type::iterator> itrs = accurateTimings.equal_range(key);
+       double time_sum=0;
+       for(timings_type::iterator itr=itrs.first; itr!=itrs.second; ++itr){
+         time_sum += (*itr).second;
+       }
+       const double time_average = time_sum / count;
+
+       // Compute Variance
+       double V_sum=0;
+       for(timings_type::iterator itr=itrs.first; itr!=itrs.second; ++itr){
+         const double d = (*itr).second-time_average;
+         V_sum += d*d;
+       }
+       const double Var = V_sum / count;
+
+    return Var;
+}
+
+/** Lookup the average timing for a given event and parameter list */
+double EventInterpolator::lookupExactMean(const unsigned pe, const unsigned eventid){
+    return lookupExactMean(eventparams[make_pair(pe,eventid)]);
+}
+/** Lookup the average timing for a given event and parameter list */
+double EventInterpolator::lookupExactMean(const pair<funcIdentifier,vector<double> > &p) {
+    return lookupExactMean(p.first,p.second);
+}
+/** Lookup the average timing for a given event and parameter list */
+double EventInterpolator::lookupExactMean(const funcIdentifier& func, const vector<double> &p){
+    const  pair<funcIdentifier,vector<double> > key(func,p);
+    const int count = accurateTimings.count(key);
+
+       // Compute mean
+       pair<timings_type::iterator, timings_type::iterator> itrs = accurateTimings.equal_range(key);
+       double time_sum=0;
+       for(timings_type::iterator itr=itrs.first; itr!=itrs.second; ++itr){
+         time_sum += (*itr).second;
+       }
+       return time_sum / count;
+}
+
+
+/** If we have a parameterfile entry for the requested pe,eventid pair */
+double EventInterpolator::haveNewTiming(const unsigned pe, const unsigned eventid) {
+    return eventparams.find( make_pair(pe,eventid) ) != eventparams.end();
+}
+
+double EventInterpolator::predictTime(const unsigned pe, const unsigned eventid) {
+    return predictTime(eventparams[make_pair(pe,eventid)]);
+}
+
+double EventInterpolator::predictTime(const pair<funcIdentifier,vector<double> > &p) {
+    return predictTime(p.first,p.second);
+}
+
+bool EventInterpolator::canInterpolateFunc(const funcIdentifier& func){
+    return (work.find(func) != work.end());
+}
+
+
+double EventInterpolator::getNewTiming(const unsigned pe, const unsigned eventid){
+  if(haveExactTime(pe,eventid) )
+       return lookupExactTime(pe,eventid);
+  else
+       return predictTime(pe,eventid);
+}
+
+double EventInterpolator::predictTime(const funcIdentifier &func, const vector<double> &params) {
+
+    // check name
+    if(!canInterpolateFunc(func)){
+        cerr << "FATAL ERROR: function name not found in cycle accurate timing file: " << func.first << "," << func.second << endl;
+       throw new runtime_error("function name not found");
+    }
+
+    // Estimate time for a given set of parameters p
+    gsl_vector *desired_params;
+
+    desired_params = gsl_vector_alloc(numCoefficients(func.first));
+    assert(numCoefficients(func.first)==params.size());
+
+    for(int i=0;i<params.size();++i){
+        gsl_vector_set(desired_params,i,params[i]);
+    }
+
+    double desired_time, desired_time_err;
+    assert(c[func]);
+    assert(cov[func]);
+    assert(! gsl_multifit_linear_est(desired_params,c[func],cov[func],&desired_time,&desired_time_err));
+
+    gsl_vector_free(desired_params);
+
+
+    if(min_interpolated_time.find(func) == min_interpolated_time.end())
+        min_interpolated_time[func] = desired_time;
+    else
+        min_interpolated_time[func] = min( min_interpolated_time[func], desired_time);
+
+    if(max_interpolated_time.find(func) == max_interpolated_time.end())
+        max_interpolated_time[func] = desired_time;
+    else
+        max_interpolated_time[func] = max( max_interpolated_time[func], desired_time);
+
+
+    approx_matches++;
+    if(desired_time>=0.0)
+        approx_positive_matches++;
+
+//    gsl_vector_free(desired_params);
+
+
+    return desired_time;
+}
+
+
+void EventInterpolator::printMinInterpolatedTimes(){
+
+    cout << "The following functions were interpolated(as opposed to approximated:" << endl;
+
+    for(map<funcIdentifier,double>::iterator i=min_interpolated_time.begin();i!=min_interpolated_time.end();++i){
+        cout << "   > min predicted/interpolated time for function " << (*i).first.first << "," << (*i).first.second << " is " << (*i).second << " cycles " << endl;
+    }
+    for(map<funcIdentifier,double>::iterator i=max_interpolated_time.begin();i!=max_interpolated_time.end();++i){
+        cout << "   > max predicted/interpolated time for function " << (*i).first.first << "," << (*i).first.second << " is " << (*i).second << " cycles " << endl;
+    }
+
+    cout << endl;
+}
+
+void EventInterpolator::printMatches(){
+    cout << "    > Exact lookup = " << exact_matches << " (" << exact_positive_matches << " positive)" << endl;
+    cout << "    > Approximated = " << approx_matches << " (" << approx_positive_matches << " positive)" << endl;
+    cout << "    > Total        = " << approx_matches+exact_matches <<  " (" << exact_positive_matches+approx_positive_matches << " positive)" << endl;
+}
+
+void EventInterpolator::printCoefficients(){
+
+    for(map<funcIdentifier,gsl_vector*>::iterator i=c.begin();i!=c.end();++i){
+        cout << "    > Coefficients for function " << (*i).first.first << "," << (*i).first.second << " :" << endl;
+        for(int j=0; j < ((*i).second)->size; ++j){
+            cout << "    >    " << j << " is " << gsl_vector_get ((*i).second, j) << endl;
+        }
+    }
+
+}
+
+
+
+
+/** Free the gsl arrays and workspaces */
+EventInterpolator::~EventInterpolator(){
+    map<funcIdentifier, gsl_multifit_linear_workspace *>::iterator i;
+    for(i=work.begin();i!=work.end();++i){
+        const funcIdentifier &func = (*i).first;
+        gsl_multifit_linear_free(work[func]);
+        gsl_matrix_free(cov[func]);
+        gsl_vector_free(c[func]);
+    }
+       log1.close();
+}
+
+
+
+
diff --git a/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.h b/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.h
new file mode 100644 (file)
index 0000000..db882aa
--- /dev/null
@@ -0,0 +1,129 @@
+
+#include <gsl/gsl_multifit.h>
+#include <iostream>
+#include <iomanip>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include <cassert>
+#include <stdexcept>
+#include <stdlib.h> // for rand()
+
+#include <map>
+#include <string>
+#include <utility> // for std::pair
+#include <vector>
+
+
+using namespace std;
+
+
+
+/**
+ @class A class for wrapping the least-square fitting portions of gsl.
+
+  Construct one of these with a filename and it will read in the file
+  containing a table of parameters and associated timings(as produced by somthing like a cycle accurate simulator).
+
+  Pass in a desired set of parameters to predictTime() to get a predicted time by evaluating the interpolating function at the given parameter vector.
+
+*/
+
+typedef pair<string,int> funcIdentifier;
+typedef pair<int,vector<double> > fullParams;
+typedef multimap< pair<funcIdentifier,vector<double> >, double > timings_type;
+
+class EventInterpolator{
+private:
+    ofstream log1;
+
+    // For each interpolatable function we record things in these maps:
+
+    map<funcIdentifier, unsigned long> sample_count;
+    map<funcIdentifier, gsl_multifit_linear_workspace *> work;
+    map<funcIdentifier, gsl_vector *> c; // coefficients which are produced by least square fit
+    map<funcIdentifier, gsl_matrix *> cov;
+    map<funcIdentifier, double> chisqr;
+
+    map<funcIdentifier, gsl_matrix *> X;  // Each row of matrix is a set of parameters  [1, a, a^2, b, b^2, a*b] for each input parameter set
+    map<funcIdentifier, unsigned> Xcount;  // Number of entries in X so far
+    map<funcIdentifier, gsl_vector *>y;  // vector of cycle accurate times for each input parameter set
+
+    map<pair<unsigned,unsigned>,pair<funcIdentifier,vector<double> > > eventparams;
+    timings_type accurateTimings;
+
+
+    bool canInterpolateFunc(const funcIdentifier& name);
+
+    map<funcIdentifier,double> min_interpolated_time;
+    map<funcIdentifier,double> max_interpolated_time;
+
+    unsigned exact_matches;
+    unsigned exact_positive_matches;
+    unsigned approx_matches;
+    unsigned approx_positive_matches;
+
+public:
+
+    double haveNewTiming(const unsigned pe, const unsigned eventid);
+
+    double predictTime(const unsigned pe, const unsigned eventid);
+    double predictTime(const pair<funcIdentifier,vector<double> > &p);
+    double predictTime(const funcIdentifier &f, const vector<double> &p);
+
+    bool haveExactTime(const unsigned pe, const unsigned eventid);
+    bool haveExactTime(const pair<funcIdentifier,vector<double> > &p);
+    bool haveExactTime(const funcIdentifier& f, const vector<double> &p);
+
+
+       /** Compute average time for the provided event signature(name&parameters) */
+    double lookupExactTime(const unsigned pe, const unsigned eventid);
+       /** Compute average time for the provided event signature(name&parameters) */
+    double lookupExactTime(const pair<funcIdentifier,vector<double> > &p);
+       /** Compute average time for the provided event signature(name&parameters) */
+    double lookupExactTime(const funcIdentifier& name, const vector<double> &p);
+
+       /** Compute variance of the timings for the provided event signature(name&parameters) */
+    double lookupExactVariance(const unsigned pe, const unsigned eventid);
+       /** Compute variance of the timings for the provided event signature(name&parameters) */
+    double lookupExactVariance(const pair<funcIdentifier,vector<double> > &p);
+       /** Compute variance of the timings for the the provided event signature(name&parameters)*/
+       double lookupExactVariance(const funcIdentifier& func, const vector<double> &p);
+
+       /** Compute average timing for the provided event signature(name&parameters) */
+    double lookupExactMean(const unsigned pe, const unsigned eventid);
+       /** Compute average timing for the provided event signature(name&parameters) */
+    double lookupExactMean(const pair<funcIdentifier,vector<double> > &p);
+       /** Compute average timing for the the provided event signature(name&parameters)*/
+       double lookupExactMean(const funcIdentifier& func, const vector<double> &p);
+
+       void analyzeExactVariances();
+
+       /** Get the new timing exactly if possible otherwise predict it */
+       double getNewTiming(const unsigned pe, const unsigned eventid);
+
+    double get_chisqr(funcIdentifier funcname){if(work[funcname]!=NULL) return chisqr[funcname]; else return -1.0;}
+
+    int numCoefficients(const string &funcname);
+    fullParams parseParameters(const string &funcname, istringstream &param_stream, double &time, const bool log);
+    fullParams parseParameters(const string &funcname, istringstream &param_stream, const bool log);
+
+    void printMinInterpolatedTimes();
+
+    void printCoefficients();
+
+    void printMatches();
+
+       /**
+               Setup an EventInterpolator object from the data in the specified file
+               @params sample_rate specifies what fraction of the cycle accurate times
+               to keep. The rest will be dropped prior to constructing the best fit
+               interpolating model
+       */
+    EventInterpolator(char *table_filename, double sample_rate=1.0);
+
+    ~EventInterpolator();
+
+};
+
+
diff --git a/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.o b/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.o
new file mode 100644 (file)
index 0000000..bbd725d
Binary files /dev/null and b/examples/bigsim/tools/rewritelog-old-format/EventInterpolator.o differ
diff --git a/examples/bigsim/tools/rewritelog-old-format/Makefile b/examples/bigsim/tools/rewritelog-old-format/Makefile
new file mode 100644 (file)
index 0000000..2c7d793
--- /dev/null
@@ -0,0 +1,26 @@
+CHARMC=../../../../bin/charmc $(OPTS) -g
+
+INCS=-I/SW/include -I.
+LIBS=-lgsl -lgslcblas -lm -L/sw/lib
+
+interpolatelog: interpolatelog.o EventInterpolator.o
+       $(CHARMC) -seq -o interpolatelog interpolatelog.o EventInterpolator.o -lconv-bigsim-logs -lconv-util -lblue-standalone -language c++  $(LIBS)
+
+interpolatelog.o: interpolatelog.C
+       $(CHARMC) -seq -c interpolatelog.C $(INCS)
+
+EventInterpolator.o: EventInterpolator.C
+       $(CHARMC) -c EventInterpolator.C $(INCS)
+
+rewritelog: rewritelog.o
+       $(CHARMC) -seq -o rewritelog rewritelog.o -lconv-bigsim-logs -lconv-util -lblue-standalone -language c++
+
+rewritelog.o: rewritelog.C
+       $(CHARMC) -seq -c rewritelog.C
+
+clean:
+       rm -f *.o *~ moduleinit.C charmrun conv-host rewritelog
+       rm -rf *.decl.h *.def.h core *.log newtraces interpolatelog
+
+test: rewritelog
+       ./rewritelog < sample-input
diff --git a/examples/bigsim/tools/rewritelog-old-format/README b/examples/bigsim/tools/rewritelog-old-format/README
new file mode 100644 (file)
index 0000000..26ebe23
--- /dev/null
@@ -0,0 +1,68 @@
+NOTE: the instructions below represent a rapidly changing experimental
+      setup. Contact idooley2@uiuc.edu for the latest status. I am 
+      currently adding support for PAPI performance counters, so the 
+      format of the CYCLE_ACCURATE_TIMES file is under a state of flux. 
+
+
+Building / Compiling :
+  
+  Install GSL, the GNU Scientific Library. This is required 
+  to perform least square curve fitting. Make sure the local
+  makefile points to your copy of gsl. Currently this is 
+  in the variable "LIBS"
+
+  Build charm/bigemulator
+
+  Modify the file interpolatelog.C to match your particular tastes.
+    OUTPUTDIR         specifies a directory for the new logfiles
+
+    CYCLE_TIMES_FILE  specifies the file which contains accurate 
+                      timing information
+
+    time_factor       specifies a multiplier used to scale any times 
+                      that are not replaced by times approximated
+                      from available cycle-accurate times
+
+  Make the interpolation tool: 
+    > make
+
+Modifying Application:
+
+  Insert startTraceBigSim() call before a compute kernel. Add an 
+  endTraceBigSim() call after the kernel. Currently the first call
+  takes no parameters, and the second takes a name for the event
+  that is being bracketed, followed by between 0 and 20 parameters 
+  describing the computation. 
+
+  You will find the definitions of these functions in traceBigSim/
+
+  startTraceBigSim();
+  // Some serial computational kernel goes here
+  endTraceBigSim("EventName",param1,param2,param3);
+
+  Thes calls will time and produce output(to STDOUT) that lists 
+  the time, parameters, and possibly some performance counters
+  for the code executed between the calls. 
+
+  A sample output file: traceBigSim/sample_namd_timings.txt
+
+  Run the application, in serial or parallel to produce a good
+  set of samples of the timings. These timings will be used 
+  to predict the performance for the events appearing in a
+  bgTrace log files. Put all of these timings in the file
+  reference by CYCLE_TIMES_FILE in interpolatelog.C. You can 
+  grep out only the lines containing TRACEBIGSIM, and can 
+  concatenate them all together into one big file.
+
+Running The interpolation tool:
+  
+  Run a parallel version of the application to generate the bgTrace* 
+  and param* files.
+
+  Run the interpolation tool from a directory containing the bgTrace*,
+  param*, and CYCLE_TIMES_FILE files. If you want these files to be 
+  located elsewhere, you should be able to modify interpolatelog.C
+  and EventInterpolator.C easily.
+
+  A new set of bgTrace files will be produced.
\ No newline at end of file
diff --git a/examples/bigsim/tools/rewritelog-old-format/interpolatelog b/examples/bigsim/tools/rewritelog-old-format/interpolatelog
new file mode 100755 (executable)
index 0000000..6e4381c
Binary files /dev/null and b/examples/bigsim/tools/rewritelog-old-format/interpolatelog differ
diff --git a/examples/bigsim/tools/rewritelog-old-format/interpolatelog.C b/examples/bigsim/tools/rewritelog-old-format/interpolatelog.C
new file mode 100644 (file)
index 0000000..7c07772
--- /dev/null
@@ -0,0 +1,349 @@
+/*
+
+    @file interpolatelog.C
+
+       @author: Isaac Dooley
+       email : idooley2@uiuc.edu
+       date  : Jan 2007
+
+    This uses the gsl library for least-square fitting. GNU Scientific Library is available under GPL
+
+*/
+
+#include "blue.h"
+#include "blue_impl.h"
+#include "blue.h"
+#include "blue_impl.h"
+#include "blue_types.h"
+#include "bigsim_logs.h"
+#include "assert.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <EventInterpolator.h>
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <utility> // for std::pair
+#include <vector>
+
+#define KEEP_RATIO 1.0
+
+#define OUTPUTDIR "newtraces-keep1.0/"
+#define CYCLE_TIMES_FILE "nopme"
+#define sec_per_cycle 0.00000000025
+
+// Scale the duration of all unknown events by this factor
+//#define time_factor 0.2
+//#define time_factor (1.0/4.418)
+#define time_factor (1.0/6.05)
+
+// Set these for more output:
+//#define DEBUG
+#undef PRINT_NEW_TIMES
+#define WRITE_OUTPUT_FILES
+
+// Needed to communicated with the bigsim file reading and writing routines:
+extern BgTimeLineRec* currTline;
+extern int currTlineIdx;
+
+
+/** linearly map a point from an interval with sepcified bounds to a new interval linearly
+    @return a value between new_lower and new_upper
+*/
+double map_linearly_to_interval(double val, double old_lower, double old_upper, double new_lower, double new_upper){
+  double new_val;
+
+  if(val = old_lower)
+       new_val = new_lower;
+  else if(val = old_upper)
+       new_val = old_lower;
+  else
+       new_val = new_lower + ((val-old_lower)*(new_upper-new_lower))/(old_upper-old_lower);
+
+  assert(new_upper >= new_lower);
+  assert(new_val <= new_upper);
+  assert(new_val >= new_lower);
+
+  assert(old_upper >= old_lower);
+  assert(val <= old_upper);
+  assert(val >= old_lower);
+
+  return new_val;
+}
+
+int main()
+{
+    // Load in Mambo Times
+    EventInterpolator interpolator(CYCLE_TIMES_FILE, KEEP_RATIO);
+
+    int totalProcs, numX, numY, numZ, numCth, numWth, numPes;
+       double ratio_sum=0.0;
+       unsigned long ratio_count= 0;
+
+       double ratio_bracketed_sum=0.0;
+       unsigned long ratio_bracketed_count = 0;
+
+       double old_times_sum=0.0;
+       double old_bracketed_times_sum=0.0;
+       double new_bracketed_times_sum=0.0;
+
+       ofstream of_ratio_all("ratio_all");
+       ofstream of_ratio_bracketed("ratio_bracketed");
+
+       interpolator.printCoefficients();
+
+    // load bg trace summary file
+    printf("Loading bgTrace ... \n");
+    int status = BgLoadTraceSummary("bgTrace", totalProcs, numX, numY, numZ, numCth, numWth, numPes);
+    if (status == -1) exit(1);
+    printf("========= BgLog Version: %d ========= \n", bglog_version);
+    printf("Found %d (%dx%dx%d:%dw-%dc) emulated procs on %d real procs.\n", totalProcs, numX, numY, numZ, numWth, numCth, numPes);
+
+    int* allNodeOffsets = BgLoadOffsets(totalProcs,numPes);
+
+    printf("========= Loading All Logs ========= \n");
+
+    // load each individual trace file for each bg proc
+
+    unsigned found_event_count=0;
+    unsigned total_count=0;
+    bool negative_durations_occured = false;
+
+    printf("Loading bgTrace files ...\n");
+
+    // Create output directory
+    mkdir(OUTPUTDIR, 0777);
+
+
+    for (int fileNum=0; fileNum<numPes; fileNum++){
+        BgTimeLineRec *tlinerecs = new BgTimeLineRec[totalProcs/numPes+1];
+        int rec_count = 0;
+
+        for(int procNum=fileNum;procNum<totalProcs;procNum+=numPes){
+
+            BgTimeLineRec &tlinerec = tlinerecs[rec_count];
+            rec_count++;
+
+            currTline = &tlinerec;
+            currTlineIdx = procNum;
+            int fileNum = BgReadProc(procNum,numWth,numPes,totalProcs,allNodeOffsets,tlinerec);
+            CmiAssert(fileNum != -1);
+
+#ifdef DEBUG
+        printf("Load log of BG proc %d from bgTrace%d... \n", procNum, fileNum);
+#endif
+
+            BgTimeLine &timeLine = tlinerec.timeline; // Really a CkQ< BgTimeLog *>
+
+#ifdef DEBUG
+            printf("%d entries in timeLine\n", timeLine.length());
+#endif
+
+            // Scan through each event for this emulated processor
+            for(int j=0;j<timeLine.length();j++){
+                BgTimeLog* timeLog = timeLine[j];
+                std::string name(timeLog->name);
+                total_count++;
+
+                double old_start = timeLog->startTime;
+                double old_end   = timeLog->endTime;
+                double old_duration = old_end-old_start;
+
+                               double old_bracket_start=0.0;
+                               double old_bracket_end=0.0;
+
+                               int have_bracket_start=0;
+                               int have_bracket_end=0;
+
+                               double begin_piece=0.0;
+                               double middle_piece=old_duration;
+                               double end_piece=0.0;
+
+                               assert(old_duration >= 0.0);
+                               assert(old_end > 0.0);
+
+                               if(old_end > old_start){
+                                 old_times_sum += old_duration;
+
+                                 //FIXME: check only the right kind of events.
+
+                                 // Look for BG_EVENT_PRINT 'events' inside this event.
+                                 for(int i=0;i<timeLog->evts.length();i++){
+                                       char *data = (char*)timeLog->evts[i]->data;
+                                       if(strncmp(data,"startTraceBigSim",16)==0){
+                                         old_bracket_start = old_start+timeLog->evts[i]->rTime;
+                                         have_bracket_start = 1;
+                                       }
+                                       else if(strncmp(data,"endTraceBigSim",14)==0){
+                                         old_bracket_end = old_start+timeLog->evts[i]->rTime;
+                                         have_bracket_end = 1;
+                                       }
+                                 }
+
+                                 // If we have bracketed timings, the middle part will be the old
+                                 // bracketed time region, and the begin and end pieces will be non-zero
+                                 if(have_bracket_end && have_bracket_start){
+                                       begin_piece = old_bracket_start - old_start;
+                                       middle_piece = old_bracket_end - old_bracket_start;
+                                       end_piece = old_duration - begin_piece - middle_piece;
+                                       old_bracketed_times_sum += middle_piece;
+                                       assert(begin_piece >= 0.0);
+                                       assert(middle_piece >= 0.0);
+                                       assert(end_piece >= 0.0);
+                                 }
+                                 else{
+                                       old_bracket_start = old_start;
+                                       old_bracket_end = old_end;
+                                       assert(old_bracket_end - old_bracket_start >= 0.0);
+                                 }
+
+
+                                 // If this event occurs in the paramerter file and cycle-accurate simulations, use that data to predict its runtime
+
+                                 if( interpolator.haveNewTiming(procNum,timeLog->seqno) ) {
+                                       double old_middle_piece = middle_piece;
+                                       middle_piece = interpolator.getNewTiming(procNum,timeLog->seqno) * sec_per_cycle;
+                                       found_event_count ++;
+
+                                       double ratio =  old_middle_piece / middle_piece;
+                                       if(ratio > 1e-10 && ratio < 1e10){
+                                         ratio_bracketed_sum += ratio;
+                                         ratio_bracketed_count ++;
+                                         of_ratio_bracketed << ratio << endl;
+                                       }
+
+
+                                 }
+                                 // If event is not in parameter file then we just scale its duration by a simple constant
+                                 else {
+                                       middle_piece = middle_piece*time_factor ;
+                                 }
+
+
+                                 if(middle_piece < 0.0) {
+                                       middle_piece=0.0;
+                                       negative_durations_occured=true;
+                                 }
+
+                                 if(have_bracket_end && have_bracket_start){
+                                       new_bracketed_times_sum += middle_piece;
+                                 }
+
+                                 // Scale the begin and end pieces by time_factor;
+                                 begin_piece = begin_piece*time_factor;
+                                 end_piece = end_piece*time_factor;
+
+                                 assert(begin_piece >= 0.0);
+                                 assert(middle_piece >= 0.0);
+                                 assert(end_piece >= 0.0);
+
+                                 double new_start    = old_start;
+                                 double new_duration = begin_piece + middle_piece + end_piece;
+                                 double new_end      = new_start + new_duration;
+
+                                 timeLog->startTime = new_start;
+                                 timeLog->endTime   = new_end;
+                                 timeLog->execTime  = new_duration;
+
+                                 double new_bracket_start = new_start+begin_piece;
+                                 double new_bracket_end = new_start+begin_piece+middle_piece;
+
+
+#ifdef PRINT_NEW_TIMES
+                                 printf("Rewriting duration of event %d name=%s from [%.10lf , %.10lf] (%.10lf) to [%.10lf , %.10lf] (%.10lf) ratio=%.10lf\n", j, timeLog->name, old_start,old_end,old_end-old_start,new_start,new_end,new_end-new_start,(old_end-old_start)/(new_end-new_start));
+#endif
+
+                                 double ratio = (old_duration)/(new_duration);
+                                 if(ratio >= 1e-10 && ratio <= 1e10){
+                                       ratio_sum += ratio;
+                                       ratio_count ++;
+                                       of_ratio_all << ratio << endl;
+                                 }
+
+                                 // Rewrite times of messages sent from this event
+                                 for(int m=0;m<timeLog->msgs.length();m++){
+                                       double old_send = timeLog->msgs[m]->sendTime;
+                                       double new_send;
+
+                                       assert(old_send <= old_end);
+                                       assert(old_send >= old_start);
+
+                                       // We have three places where the message is coming from
+                                       // We linearly map the value into the beginning, middle, or end piece
+                                       if(old_send < old_bracket_start){
+                                         new_send = map_linearly_to_interval(old_send, old_start,old_bracket_start,new_start,new_bracket_start);
+                                       }
+                                       else if(old_send < old_bracket_end){
+                                         new_send = map_linearly_to_interval(old_send, old_bracket_start,old_bracket_end,new_bracket_start,new_bracket_end);
+                                       }
+                                       else {
+                                         new_send = map_linearly_to_interval(old_send, old_bracket_end,old_end,new_bracket_end,new_end);
+                                       }
+
+                                       timeLog->msgs[m]->sendTime = new_send;
+
+#ifdef PRINT_NEW_TIMES
+                                       printf("pe=%d changing message %d send time from %.10lf to %.10lf\n", procNum, m, old_send, new_send);
+#endif
+
+                                       assert(new_send <= new_end);
+                                       assert(new_send >= new_start);
+
+                                 }
+                               }
+
+            }
+
+
+        }
+
+#ifdef WRITE_OUTPUT_FILES
+            // Write out the file
+            cout << "writing " << rec_count << " simulated processors to this bgTrace file" << endl;
+            BgWriteTimelines(fileNum,tlinerecs,rec_count,numWth,OUTPUTDIR);
+#endif
+        delete[] tlinerecs;
+
+    }
+
+
+    if(negative_durations_occured){
+         cerr << "======================  WARNING ======================" << endl;
+         cerr << "||  One or more new durations were less than zero. \n||  This probably means your model or input times are \n||  not good enough." << endl;
+         cerr << "======================================================" << endl;
+    }
+
+    interpolator.printMinInterpolatedTimes();
+
+    printf("Writing new bgTrace files ...\n");
+
+       printf("average duration speedup(including unbracketed pieces): %.8lf\n", ratio_sum / (double)ratio_count);
+
+       printf("average bracketed speedup: %.8lf\n", ratio_bracketed_sum / (double)ratio_bracketed_count);
+
+       cout << "Sum of times of bracketed portions of input logs: " << old_bracketed_times_sum << endl;
+       cout << "Sum of times of bracketed portions of output logs: " << new_bracketed_times_sum << endl;
+
+
+
+#ifdef WRITE_OUTPUT_FILES
+    // Write out the timelines to the same number of files as we started with.
+    BgWriteTraceSummary(totalProcs, numPes, numX, numY, numZ, numCth, numWth, OUTPUTDIR);
+#endif
+
+    delete [] allNodeOffsets;
+
+    cout << "Of the " << total_count << " events found in the bgTrace files, " << found_event_count << " were found in the param files" << endl;
+
+    interpolator.printMatches();
+
+       cout << "The sum of all positive duration events from the original bgTrace files is: " << old_times_sum << endl;
+
+
+    cout << "End of program" << endl;
+
+}
+
diff --git a/examples/bigsim/tools/rewritelog-old-format/interpolatelog.o b/examples/bigsim/tools/rewritelog-old-format/interpolatelog.o
new file mode 100644 (file)
index 0000000..5f47216
Binary files /dev/null and b/examples/bigsim/tools/rewritelog-old-format/interpolatelog.o differ
diff --git a/examples/bigsim/tools/rewritelog-old-format/rewritelog.C b/examples/bigsim/tools/rewritelog-old-format/rewritelog.C
new file mode 100644 (file)
index 0000000..f1a41c7
--- /dev/null
@@ -0,0 +1,147 @@
+/*
+   rewritelog.C
+
+   Author: Isaac Dooley
+   email : idooley2@uiuc.edu
+   date  : Jan 06, 2007
+
+   This program will take in a set of bgTrace files from a run
+   of the Big Emulator and it will rewrite the files so that
+   named events can be replaced with better approximate timings
+   supplied interactively by the user of this program. For example
+   a cycle-accurate simulator might be able to give the exact times
+   for some Charm++ entry methods.
+
+   The modified bgTrace files are put into a directory called
+   "newtraces"
+
+   The user supplies durations which are used to change the end
+   times for each log entry with the associated name. Any messages
+   sent during this duration are mapped linearly onto the new times
+   range for the log entry. For example, an message sent one-third
+   the way through the old time range for the event will still occur
+   one-third the way through the new time range.
+
+   Currently nothing else in the trace files is modified.
+
+   This program was written by someone with little experience with
+   the POSE based Big Simulator, so these traces might not quite
+   act as the author expected. Please report any problems to
+   ppl@cs.uiuc.edu
+
+
+*/
+
+
+
+#include "blue.h"
+#include "blue_impl.h"
+#include "blue.h"
+#include "blue_impl.h"
+#include "blue_types.h"
+#include "bigsim_logs.h"
+#include "assert.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <string>
+#include <iostream>
+#include <map>
+
+#define OUTPUTDIR "newtraces/"
+
+
+int main()
+{
+    int totalProcs, numX, numY, numZ, numCth, numWth, numPes;
+
+    // Create output directory
+    mkdir(OUTPUTDIR, 0777);
+
+    bool done = false;
+    double newtime=1.0;
+    std::string eventname;
+    std::map<std::string,double> newtimes;
+    std::cout << "Enter event name followed by its new time duration.\nEnter \"none -1.0\" after finishing. Don't use any spaces in names." << std::endl;
+    while(!done) {
+        std::cin >> eventname >> newtime;
+        if(newtime < 0.0)
+            done = 1;
+        else
+            newtimes[eventname]=newtime;
+    }
+
+    std::cout << "You entered " << newtimes.size() << " distinct events with their associated durations" << std::endl;
+
+    // load bg trace summary file
+    printf("Loading bgTrace ... \n");
+    int status = BgLoadTraceSummary("bgTrace", totalProcs, numX, numY, numZ, numCth, numWth, numPes);
+    if (status == -1) exit(1);
+    printf("========= BgLog Version: %d ========= \n", bglog_version);
+    printf("Found %d (%dx%dx%d:%dw-%dc) emulated procs on %d real procs.\n", totalProcs, numX, numY, numZ, numWth, numCth, numPes);
+
+    int* allNodeOffsets = BgLoadOffsets(totalProcs,numPes);
+
+    printf("========= Loading All Logs ========= \n");
+
+    // load each individual trace file for each bg proc
+    for (int procNum=0; procNum<totalProcs; procNum++)
+    {
+        BgTimeLineRec tlinerec;
+
+        int procNum = i;
+        int fileNum = BgReadProc(procNum,numWth,numPes,totalProcs,allNodeOffsets,tlinerec);
+        CmiAssert(fileNum != -1);
+        printf("Load log of BG proc %d from bgTrace%d... \n", procNum, fileNum);
+
+        BgTimeLine &timeLine = tlinerec.timeline; // Really a CkQ< BgTimeLog *>
+
+        printf("%d entries in timeLine\n", timeLine.length());
+
+        // Scan through each event for this emulated processor
+        for(int j=0;j<timeLine.length();j++){
+            BgTimeLog* timeLog = timeLine[j];
+            std::string name(timeLog->name);
+
+            // If name of this event is one that needs to have its duration modified
+            if( newtimes.find(name) != newtimes.end() ) {
+                double oldstart = timeLog->startTime;
+                double oldend   = timeLog->endTime;
+                double newstart = oldstart;
+                double newend   = oldstart+newtimes[name];
+
+                timeLog->startTime = newstart;
+                timeLog->endTime   = newend;
+
+                printf("Rewriting duration of event %d name=%s from [%.10lf , %.10lf] to [%.10lf , %.10lf]\n", j, timeLog->name, oldstart,oldend,newstart,newend);
+
+                for(int m=0;m<timeLog->msgs.length();m++){
+                    double oldsendtime = timeLog->msgs[m]->sendTime;
+                    double newsendtime;
+
+                    if(oldstart == oldend){
+                        newsendtime = oldstart;
+                    } else {
+                        // Linearly map the old range onto the new range
+                        newsendtime = newstart + (oldsendtime-oldstart)/(oldend-oldstart) * (newend-newstart);
+                    }
+
+                    timeLog->msgs[m]->sendTime = newsendtime;
+                    printf("changing message %d send time from %.10lf to %.10lf\n", m, oldsendtime, newsendtime);
+                }
+
+            }
+
+        }
+
+        BgWriteTimelines(procNum, tlinerec, 1, numWth, OUTPUTDIR);
+
+    }
+
+    BgWriteTraceSummary(totalProcs, 1, numX, numY, numZ, numCth, numWth, OUTPUTDIR);
+
+    delete [] allNodeOffsets;
+    printf("End of program\n");
+}
+
+
diff --git a/examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.C b/examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.C
new file mode 100644 (file)
index 0000000..29b9fdb
--- /dev/null
@@ -0,0 +1,32 @@
+#include "charm++.h"
+#include "traceBigSim.h"
+
+CkpvDeclare(FILE*, bgfp);
+CkpvDeclare(unsigned long, bgTraceCounter);
+
+
+void initBigSimTrace()
+{
+  CkpvInitialize(FILE *, bgfp);
+  CkpvInitialize(unsigned long, bgTraceCounter);
+  CkpvAccess(bgTraceCounter) = 0;
+
+#ifdef CMK_BLUEGENE_CHARM
+  //   for bigsim emulation, write to files, one for each processor
+  char fname[128];
+  sprintf(fname, "param.%d", CkMyPe());
+  CkpvAccess(bgfp) = fopen(fname, "w");
+  if (CkpvAccess(bgfp) == NULL) 
+    CmiAbort("Failed to generated trace param file!");
+#else
+  //   for Mambo simulation, write to screen for now
+  CkpvAccess(bgfp) = stdout;
+#endif
+}
+
+void finalizeBigSimTrace()
+{
+#ifdef CMK_BLUEGENE_CHARM
+  fclose(CkpvAccess(bgfp));
+#endif  
+}
diff --git a/examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.h b/examples/bigsim/tools/rewritelog-old-format/traceBigSim/traceBigSim.h
new file mode 100644 (file)
index 0000000..3383d88
--- /dev/null
@@ -0,0 +1,228 @@
+/**
+ *  @author Isaac Dooley
+ *  
+ *  This version is quite different than the initial version.
+ */    
+
+// CMK_BLUEGENE_CHARM is used during the emulation phase, 
+// where you genereate the bgTrace logs and the parameter files
+
+#ifdef CMK_BLUEGENE_CHARM
+#include "blue.h"
+#include "blue_impl.h"
+#endif
+
+#include <stdio.h>
+#include <stdarg.h>
+
+CkpvExtern(FILE *, bgfp);
+
+extern void initBigSimTrace();
+extern void finalizeBigSimTrace();
+
+CkpvExtern(unsigned long, bgTraceCounter);
+
+
+void initBigSimTrace();
+void finalizeBigSimTrace();
+void BgSetStartEvent();
+
+
+//======================PAPI======================= 
+#define BIG_SIM_PAPI
+
+#ifdef BIG_SIM_PAPI
+
+#include <papi.h>
+
+#define NUM_PAPI_EVENTS 3
+#define BIGSIM_PAPI
+
+int errorcode; 
+int events[NUM_PAPI_EVENTS];
+long long values[NUM_PAPI_EVENTS]; 
+char errorstring[PAPI_MAX_STR_LEN+1]; 
+
+#endif
+//================================================= 
+
+
+/** @TODO, wrap this with Ckpv */
+double startTime;
+
+/** A function that starts the bigsim tracing processes with up to 20 parameters. The user should use one of the 20 aliases below which takes the right number of parameters. */
+void startTraceBigSim(){
+
+
+#if SPLIT_APART_CYCLE_ACCURATE
+  SimParameters *simParams = Node::Object()->simParameters;
+  if(simParams->bgSplitNumProcs != -1 && simParams->bgSplitMyProc!=-1){
+       if( (CkpvAccess(bgTraceCounter) % simParams->bgSplitNumProcs) == simParams->bgSplitMyProc){
+         // Do slow mambo simulation for this case!
+         CkPrintf("TRACEBIGSIM: Doing cycle accurate simulation for interesting event #%lu\n", CkpvAccess(bgTraceCounter) );
+       }
+       CkpvAccess(bgTraceCounter) ++;
+  }
+#endif  
+
+  startTime = CmiWallTimer();
+
+#ifdef BIGSIM_PAPI
+    events[0] = PAPI_TOT_CYC;
+    events[1] = PAPI_TLB_TL;
+    events[2] = PAPI_FP_INS;
+
+/* Other available events:
+                                       PAPI_BR_INS,
+                                        PAPI_BR_MSP,
+                                        PAPI_FP_INS,
+                                        PAPI_TOT_INS,
+                                        PAPI_TOT_IIS,
+                                        PAPI_L1_DCM,
+                                        PAPI_L1_LDM,
+                                        PAPI_L2_TCM,
+                                        PAPI_L3_LDM,
+                                        PAPI_RES_STL,
+                                        PAPI_LD_INS,
+                                        PAPI_TLB_TL  
+*/
+
+    errorcode = PAPI_start_counters(events, NUM_PAPI_EVENTS);
+    if (errorcode != PAPI_OK) {
+        PAPI_perror(errorcode, errorstring, PAPI_MAX_STR_LEN);
+        fprintf(stderr, "PAPI error after start_counters (%d): %s\n", errorcode, errorstring);
+    }
+
+#endif
+  
+}
+  
+
+
+void endTraceBigSim_20param(char * eventname, int num_params, double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 , double p17 , double p18 , double p19 , double p20 ) {
+    char perfCountString[1024]; 
+    perfCountString[0] = 0; 
+       char params[2048];
+
+if(num_params==0) sprintf(params, "");
+if(num_params==1) sprintf(params, "%f", p1);
+if(num_params==2) sprintf(params, "%f %f", p1, p2);
+if(num_params==3) sprintf(params, "%f %f %f", p1, p2, p3);
+if(num_params==4) sprintf(params, "%f %f %f %f", p1, p2, p3, p4);
+if(num_params==5) sprintf(params, "%f %f %f %f %f", p1, p2, p3, p4, p5);
+if(num_params==6) sprintf(params, "%f %f %f %f %f %f", p1, p2, p3, p4, p5, p6);
+if(num_params==7) sprintf(params, "%f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7);
+if(num_params==8) sprintf(params, "%f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8);
+if(num_params==9) sprintf(params, "%f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9);
+if(num_params==10) sprintf(params, "%f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+if(num_params==11) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
+if(num_params==12) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
+if(num_params==13) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
+if(num_params==14) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
+if(num_params==15) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
+if(num_params==16) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
+if(num_params==17) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
+if(num_params==18) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
+if(num_params==19) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
+if(num_params==20) sprintf(params, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
+
+       char paramString[2048];
+       
+       sprintf(paramString, "params:{ %s }", params);
+       
+
+#ifdef BIGSIM_PAPI
+    errorcode = PAPI_read_counters(values, NUM_PAPI_EVENTS); 
+    if (errorcode != PAPI_OK) { 
+        PAPI_perror(errorcode, errorstring, PAPI_MAX_STR_LEN); 
+        fprintf(stderr, "PAPI error after read counters (%d): %s\n", errorcode, errorstring); 
+    } else { 
+        sprintf(perfCountString, 
+                " PAPI:{ %lld %lld %lld }", 
+                values[0], 
+                values[1],
+               values[2] 
+                ); 
+    } 
+
+    errorcode = PAPI_stop_counters(values, NUM_PAPI_EVENTS);
+    if (errorcode != PAPI_OK) { 
+        PAPI_perror(errorcode, errorstring, PAPI_MAX_STR_LEN); 
+        fprintf(stderr, "PAPI error after stop counters (%d): %s\n", errorcode, errorstring); 
+    } 
+#endif
+       double endTime = CmiWallTimer();
+  char timeString[256];
+  sprintf(timeString, "time:{ %f }", endTime-startTime);
+
+
+#if SPLIT_APART_CYCLE_ACCURATE
+  SimParameters *simParams = Node::Object()->simParameters;
+         if(simParams->bgSplitNumProcs != -1 && simParams->bgSplitMyProc!=-1){
+       if( (CkpvAccess(bgTraceCounter) % simParams->bgSplitNumProcs) == simParams->bgSplitMyProc){
+         // Do slow mambo simulation for this case!
+         // Counter is incremented only in startTraceBigSim()
+       }
+  }
+#endif
+
+
+
+  char sequenceString[1024];
+  sequenceString[0] = 0;
+#ifdef CMK_BLUEGENE_CHARM
+  sprintf();
+
+  BgPrint("endTraceBigSim %f\n");
+  // write event ID
+  int seqno = tTIMELINEREC.length()-1;
+  //  fprintf(CkpvAccess(bgfp),"%d ",seqno);
+  sprintf(sequenceString, "seqno: { %d } ",seqno);
+
+#endif
+  fprintf(CkpvAccess(bgfp),"%s\n",params);
+
+  
+#ifdef CMK_BLUEGENE_CHARM
+  printf(CkpvAccess(bgfp), "TRACEBIGSIM: event:{ %s } %s %s %s %s\n", eventname, sequenceString, timeString, perfCountString, paramString);
+#else
+  printf("TRACEBIGSIM: event:{ %s } %s %s %s %s\n", eventname, sequenceString, timeString, perfCountString, paramString);  
+#endif
+
+
+}
+
+
+
+
+
+/** 
+       startTraceBigSim() begins tracing an event with a specified set of parameters. These are convenience
+       aliases so that a user can easily add/remove parameters while testing their application.
+       Up to 20 parameters can be specified. These just call through to startTraceBigSim_20param().
+*/
+void endTraceBigSim( char * eventName ){endTraceBigSim_20param( eventName, 0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 ){endTraceBigSim_20param( eventName, 1 , p1 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 ){endTraceBigSim_20param( eventName, 2 , p1 , p2 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 ){endTraceBigSim_20param( eventName, 3 , p1 , p2 , p3 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 ){endTraceBigSim_20param( eventName, 4 , p1 , p2 , p3 , p4 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 ){endTraceBigSim_20param( eventName, 5 , p1 , p2 , p3 , p4 , p5 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 ){endTraceBigSim_20param( eventName, 6 , p1 , p2 , p3 , p4 , p5 , p6 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 ){endTraceBigSim_20param( eventName, 7 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 ){endTraceBigSim_20param( eventName, 8 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 ){endTraceBigSim_20param( eventName, 9 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 ){endTraceBigSim_20param( eventName, 10 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 ){endTraceBigSim_20param( eventName, 11 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 ){endTraceBigSim_20param( eventName, 12 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 ){endTraceBigSim_20param( eventName, 13 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 ){endTraceBigSim_20param( eventName, 14 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 ){endTraceBigSim_20param( eventName, 15 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , 0.0 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 ){endTraceBigSim_20param( eventName, 16 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , p16 , 0.0 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 , double p17 ){endTraceBigSim_20param( eventName, 17 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , p16 , p17 , 0.0 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 , double p17 , double p18 ){endTraceBigSim_20param( eventName, 18 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , p16 , p17 , p18 , 0.0 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 , double p17 , double p18 , double p19 ){endTraceBigSim_20param( eventName, 19 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , p16 , p17 , p18 , p19 , 0.0 );}
+void endTraceBigSim( char * eventName , double p1 , double p2 , double p3 , double p4 , double p5 , double p6 , double p7 , double p8 , double p9 , double p10 , double p11 , double p12 , double p13 , double p14 , double p15 , double p16 , double p17 , double p18 , double p19 , double p20 ){endTraceBigSim_20param( eventName, 20 , p1 , p2 , p3 , p4 , p5 , p6 , p7 , p8 , p9 , p10 , p11 , p12 , p13 , p14 , p15 , p16 , p17 , p18 , p19 , p20 );}
+