Fixed some problems. Now a default set of parameters is assumed if no specialized...
[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     map<string, int> number_of_coefficients; // records the number of coefficients
54     timings_type accurateTimings;
55
56
57
58     bool canInterpolateFunc(const funcIdentifier& name);
59
60     map<funcIdentifier,double> min_interpolated_time;
61     map<funcIdentifier,double> max_interpolated_time;
62
63     unsigned exact_matches;
64     unsigned exact_positive_matches;
65     unsigned approx_matches;
66     unsigned approx_positive_matches;
67
68 public:
69
70     double haveNewTiming(const unsigned pe, const unsigned eventid);
71
72     double predictTime(const unsigned pe, const unsigned eventid);
73     double predictTime(const pair<funcIdentifier,vector<double> > &p);
74     double predictTime(const funcIdentifier &f, const vector<double> &p);
75
76     bool haveExactTime(const unsigned pe, const unsigned eventid);
77     bool haveExactTime(const pair<funcIdentifier,vector<double> > &p);
78     bool haveExactTime(const funcIdentifier& f, const vector<double> &p);
79
80
81         /** Compute average time for the provided event signature(name&parameters) */
82     double lookupExactTime(const unsigned pe, const unsigned eventid);
83         /** Compute average time for the provided event signature(name&parameters) */
84     double lookupExactTime(const pair<funcIdentifier,vector<double> > &p);
85         /** Compute average time for the provided event signature(name&parameters) */
86     double lookupExactTime(const funcIdentifier& name, const vector<double> &p);
87
88         /** Compute variance of the timings for the provided event signature(name&parameters) */
89     double lookupExactVariance(const unsigned pe, const unsigned eventid);
90         /** Compute variance of the timings for the provided event signature(name&parameters) */
91     double lookupExactVariance(const pair<funcIdentifier,vector<double> > &p);
92         /** Compute variance of the timings for the the provided event signature(name&parameters)*/
93         double lookupExactVariance(const funcIdentifier& func, const vector<double> &p);
94
95         /** Compute average timing for the provided event signature(name&parameters) */
96     double lookupExactMean(const unsigned pe, const unsigned eventid);
97         /** Compute average timing for the provided event signature(name&parameters) */
98     double lookupExactMean(const pair<funcIdentifier,vector<double> > &p);
99         /** Compute average timing for the the provided event signature(name&parameters)*/
100         double lookupExactMean(const funcIdentifier& func, const vector<double> &p);
101
102         void analyzeExactVariances();
103
104         /** Get the new timing exactly if possible otherwise predict it */
105         double getNewTiming(const unsigned pe, const unsigned eventid);
106
107     double get_chisqr(funcIdentifier funcname){if(work[funcname]!=NULL) return chisqr[funcname]; else return -1.0;}
108
109     int numCoefficients(const string &funcname);
110     void recordNumCoefficients(const string &f, int num_params);
111     fullParams parseParameters(const string &funcname, istringstream &param_stream);
112
113     void printMinInterpolatedTimes();
114
115     void printCoefficients();
116
117     void printMatches();
118
119         /**
120                 Setup an EventInterpolator object from the data in the specified file
121                 @params sample_rate specifies what fraction of the cycle accurate times
122                 to keep. The rest will be dropped prior to constructing the best fit
123                 interpolating model
124         */
125     EventInterpolator(char *table_filename, double sample_rate=1.0);
126
127     ~EventInterpolator();
128
129 };
130
131