Made data print out in tables. Much easier to analyze. Also I added some more data...
[charm.git] / examples / bigsim / tools / rewritelog / EventInterpolator.h
1
2 #include <gsl/gsl_multifit.h>
3 #include <iostream>
4 #include <iomanip>
5 #include <fstream>
6 #include <string>
7 #include <sstream>
8 #include <cassert>
9 #include <stdexcept>
10 #include <stdlib.h> // for rand()
11
12 #include <map>
13 #include <string>
14 #include <utility> // for std::pair
15 #include <vector>
16
17
18 using namespace std;
19
20
21
22 /**
23  @class A class for wrapping the least-square fitting portions of gsl.
24
25   Construct one of these with a filename and it will read in the file
26   containing a table of parameters and associated timings(as produced by somthing like a cycle accurate simulator).
27
28   Pass in a desired set of parameters to predictTime() to get a predicted time by evaluating the interpolating function at the given parameter vector.
29
30 */
31
32 typedef pair<string,int> funcIdentifier;
33 typedef pair<int,vector<double> > fullParams;
34 typedef multimap< pair<funcIdentifier,vector<double> >, double > timings_type;
35
36 class EventInterpolator{
37 private:
38     ofstream log1;
39
40     // For each interpolatable function we record things in these maps:
41
42     map<funcIdentifier, unsigned long> sample_count;
43     map<funcIdentifier, gsl_multifit_linear_workspace *> work;
44     map<funcIdentifier, gsl_vector *> c; // coefficients which are produced by least square fit
45     map<funcIdentifier, gsl_matrix *> cov;
46     map<funcIdentifier, double> chisqr;
47
48     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
49     map<funcIdentifier, unsigned> Xcount;  // Number of entries in X so far
50     map<funcIdentifier, gsl_vector *>y;  // vector of cycle accurate times for each input parameter set
51
52     map<pair<unsigned,unsigned>,pair<funcIdentifier,vector<double> > > eventparams;
53     timings_type accurateTimings;
54
55
56     bool canInterpolateFunc(const funcIdentifier& name);
57
58     map<funcIdentifier,double> min_interpolated_time;
59     map<funcIdentifier,double> max_interpolated_time;
60
61     unsigned exact_matches;
62     unsigned exact_positive_matches;
63     unsigned approx_matches;
64     unsigned approx_positive_matches;
65
66 public:
67
68     double haveNewTiming(const unsigned pe, const unsigned eventid);
69
70     double predictTime(const unsigned pe, const unsigned eventid);
71     double predictTime(const pair<funcIdentifier,vector<double> > &p);
72     double predictTime(const funcIdentifier &f, const vector<double> &p);
73
74     bool haveExactTime(const unsigned pe, const unsigned eventid);
75     bool haveExactTime(const pair<funcIdentifier,vector<double> > &p);
76     bool haveExactTime(const funcIdentifier& f, const vector<double> &p);
77
78
79         /** Compute average time for the provided event signature(name&parameters) */
80     double lookupExactTime(const unsigned pe, const unsigned eventid);
81         /** Compute average time for the provided event signature(name&parameters) */
82     double lookupExactTime(const pair<funcIdentifier,vector<double> > &p);
83         /** Compute average time for the provided event signature(name&parameters) */
84     double lookupExactTime(const funcIdentifier& name, const vector<double> &p);
85
86         /** Compute variance of the timings for the provided event signature(name&parameters) */
87     double lookupExactVariance(const unsigned pe, const unsigned eventid);
88         /** Compute variance of the timings for the provided event signature(name&parameters) */
89     double lookupExactVariance(const pair<funcIdentifier,vector<double> > &p);
90         /** Compute variance of the timings for the the provided event signature(name&parameters)*/
91         double lookupExactVariance(const funcIdentifier& func, const vector<double> &p);
92
93         /** Compute average timing for the provided event signature(name&parameters) */
94     double lookupExactMean(const unsigned pe, const unsigned eventid);
95         /** Compute average timing for the provided event signature(name&parameters) */
96     double lookupExactMean(const pair<funcIdentifier,vector<double> > &p);
97         /** Compute average timing for the the provided event signature(name&parameters)*/
98         double lookupExactMean(const funcIdentifier& func, const vector<double> &p);
99
100         void analyzeExactVariances();
101
102         /** Get the new timing exactly if possible otherwise predict it */
103         double getNewTiming(const unsigned pe, const unsigned eventid);
104
105     double get_chisqr(funcIdentifier funcname){if(work[funcname]!=NULL) return chisqr[funcname]; else return -1.0;}
106
107     int numCoefficients(const string &funcname);
108     fullParams parseParameters(const string &funcname, istringstream &param_stream, double &time, const bool log);
109     fullParams parseParameters(const string &funcname, istringstream &param_stream, const bool log);
110
111     void printMinInterpolatedTimes();
112
113     void printCoefficients();
114
115     void printMatches();
116
117         /**
118                 Setup an EventInterpolator object from the data in the specified file
119                 @params sample_rate specifies what fraction of the cycle accurate times
120                 to keep. The rest will be dropped prior to constructing the best fit
121                 interpolating model
122         */
123     EventInterpolator(char *table_filename, double sample_rate=1.0);
124
125     ~EventInterpolator();
126
127 };
128
129