570 lines
12 KiB
C++
570 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2003 The Regents of The University of Michigan
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met: redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer;
|
|
* redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution;
|
|
* neither the name of the copyright holders nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <unistd.h>
|
|
|
|
#include "base/cprintf.hh"
|
|
#include "base/misc.hh"
|
|
#include "base/statistics.hh"
|
|
#include "base/stats/text.hh"
|
|
#include "base/stats/python.hh"
|
|
#include "base/stats/mysql.hh"
|
|
#include "sim/host.hh"
|
|
|
|
using namespace std;
|
|
using namespace Stats;
|
|
|
|
Tick curTick = 0;
|
|
Tick ticksPerSecond = ULL(2000000000);
|
|
|
|
Scalar<> s1;
|
|
Scalar<> s2;
|
|
Average<> s3;
|
|
Scalar<MainBin> s4;
|
|
Vector<MainBin> s5;
|
|
Distribution<MainBin> s6;
|
|
Vector<MainBin> s7;
|
|
AverageVector<> s8;
|
|
StandardDeviation<> s9;
|
|
AverageDeviation<> s10;
|
|
Scalar<> s11;
|
|
Distribution<> s12;
|
|
VectorDistribution<> s13;
|
|
VectorStandardDeviation<> s14;
|
|
VectorAverageDeviation<> s15;
|
|
Vector2d<> s16;
|
|
|
|
Formula f1;
|
|
Formula f2;
|
|
Formula f3;
|
|
Value f4;
|
|
Value f5;
|
|
Formula f6;
|
|
Formula f7;
|
|
|
|
MainBin bin1("bin1");
|
|
MainBin bin2("bin2");
|
|
|
|
ostream *outputStream = &cout;
|
|
|
|
double
|
|
testfunc()
|
|
{
|
|
return 9.8;
|
|
}
|
|
|
|
class TestClass {
|
|
public:
|
|
double operator()() { return 9.7; }
|
|
};
|
|
|
|
char *progname = "";
|
|
|
|
void
|
|
usage()
|
|
{
|
|
panic("incorrect usage.\n"
|
|
"usage:\n"
|
|
"\t%s [-p <python file>] [-t [-c] [-d]]\n", progname);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
bool descriptions = false;
|
|
bool compat = false;
|
|
bool text = false;
|
|
string pyfile;
|
|
string mysql_name;
|
|
string mysql_host;
|
|
string mysql_user = "binkertn";
|
|
string mysql_passwd;
|
|
|
|
char c;
|
|
progname = argv[0];
|
|
while ((c = getopt(argc, argv, "cdh:P:p:s:tu:")) != -1) {
|
|
switch (c) {
|
|
case 'c':
|
|
compat = true;
|
|
break;
|
|
case 'd':
|
|
descriptions = true;
|
|
break;
|
|
case 'h':
|
|
mysql_host = optarg;
|
|
break;
|
|
case 'P':
|
|
mysql_passwd = optarg;
|
|
break;
|
|
case 'p':
|
|
pyfile = optarg;
|
|
break;
|
|
case 's':
|
|
mysql_name = optarg;
|
|
break;
|
|
case 't':
|
|
text = true;
|
|
break;
|
|
case 'u':
|
|
mysql_user = optarg;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
if (!text && (compat || descriptions))
|
|
usage();
|
|
|
|
s5.init(5);
|
|
s6.init(1, 100, 13);
|
|
s7.init(7);
|
|
s8.init(10);
|
|
s12.init(1, 100, 13);
|
|
s13.init(4, 0, 99, 10);
|
|
s14.init(9);
|
|
s15.init(10);
|
|
s16.init(2, 9);
|
|
|
|
s1
|
|
.name("Stat01")
|
|
.desc("this is statistic 1")
|
|
;
|
|
|
|
s2
|
|
.name("Stat02")
|
|
.desc("this is statistic 2")
|
|
.prereq(s11)
|
|
;
|
|
|
|
s3
|
|
.name("Stat03")
|
|
.desc("this is statistic 3")
|
|
.prereq(f7)
|
|
;
|
|
|
|
s4
|
|
.name("Stat04")
|
|
.desc("this is statistic 4")
|
|
.prereq(s11)
|
|
;
|
|
|
|
s5
|
|
.name("Stat05")
|
|
.desc("this is statistic 5")
|
|
.prereq(s11)
|
|
.subname(0, "foo1")
|
|
.subname(1, "foo2")
|
|
.subname(2, "foo3")
|
|
.subname(3, "foo4")
|
|
.subname(4, "foo5")
|
|
;
|
|
|
|
s6
|
|
.name("Stat06")
|
|
.desc("this is statistic 6")
|
|
.prereq(s11)
|
|
;
|
|
|
|
s7
|
|
.name("Stat07")
|
|
.desc("this is statistic 7")
|
|
.precision(1)
|
|
.flags(pdf | total)
|
|
.prereq(s11)
|
|
;
|
|
|
|
s8
|
|
.name("Stat08")
|
|
.desc("this is statistic 8")
|
|
.precision(2)
|
|
.prereq(s11)
|
|
.subname(4, "blarg")
|
|
;
|
|
|
|
s9
|
|
.name("Stat09")
|
|
.desc("this is statistic 9")
|
|
.precision(4)
|
|
.prereq(s11)
|
|
;
|
|
|
|
s10
|
|
.name("Stat10")
|
|
.desc("this is statistic 10")
|
|
.prereq(s11)
|
|
;
|
|
|
|
s12
|
|
.name("Stat12")
|
|
.desc("this is statistic 12")
|
|
;
|
|
|
|
s13
|
|
.name("Stat13")
|
|
.desc("this is statistic 13")
|
|
;
|
|
|
|
s14
|
|
.name("Stat14")
|
|
.desc("this is statistic 14")
|
|
;
|
|
|
|
s15
|
|
.name("Stat15")
|
|
.desc("this is statistic 15")
|
|
;
|
|
|
|
s16
|
|
.name("Stat16")
|
|
.desc("this is statistic 16")
|
|
.flags(total)
|
|
.subname(0, "sub0")
|
|
.subname(1, "sub1")
|
|
.ysubname(0, "y0")
|
|
.ysubname(1, "y1")
|
|
;
|
|
|
|
f1
|
|
.name("Formula1")
|
|
.desc("this is formula 1")
|
|
.prereq(s11)
|
|
;
|
|
|
|
f2
|
|
.name("Formula2")
|
|
.desc("this is formula 2")
|
|
.prereq(s11)
|
|
.precision(1)
|
|
;
|
|
|
|
f3
|
|
.name("Formula3")
|
|
.desc("this is formula 3")
|
|
.prereq(s11)
|
|
.subname(0, "bar1")
|
|
.subname(1, "bar2")
|
|
.subname(2, "bar3")
|
|
.subname(3, "bar4")
|
|
.subname(4, "bar5")
|
|
;
|
|
|
|
f4
|
|
.functor(testfunc)
|
|
.name("Formula4")
|
|
.desc("this is formula 4")
|
|
;
|
|
|
|
TestClass testclass;
|
|
f5
|
|
.functor(testclass)
|
|
.name("Formula5")
|
|
.desc("this is formula 5")
|
|
;
|
|
|
|
f6
|
|
.name("Formula6")
|
|
.desc("this is formula 6")
|
|
;
|
|
|
|
f1 = s1 + s2;
|
|
f2 = (-s1) / (-s2) * (-s3 + ULL(100) + s4);
|
|
f3 = sum(s5) * s7;
|
|
f6 += constant(10.0);
|
|
f6 += s5[3];
|
|
f7 = constant(1);
|
|
|
|
check();
|
|
reset();
|
|
|
|
bin1.activate();
|
|
|
|
s16[1][0] = 1;
|
|
s16[0][1] = 3;
|
|
s16[0][0] = 2;
|
|
s16[1][1] = 9;
|
|
s16[1][1] += 9;
|
|
s16[1][8] += 8;
|
|
s16[1][7] += 7;
|
|
s16[1][6] += 6;
|
|
s16[1][5] += 5;
|
|
s16[1][4] += 4;
|
|
|
|
s11 = 1;
|
|
s3 = 9;
|
|
s8[3] = 9;
|
|
s15[0].sample(1234);
|
|
s15[1].sample(1234);
|
|
s15[2].sample(1234);
|
|
s15[3].sample(1234);
|
|
s15[4].sample(1234);
|
|
s15[5].sample(1234);
|
|
s15[6].sample(1234);
|
|
s15[7].sample(1234);
|
|
s15[8].sample(1234);
|
|
s15[9].sample(1234);
|
|
|
|
s10.sample(1000000000);
|
|
curTick += ULL(1000000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s10.sample(100000);
|
|
s13[0].sample(12);
|
|
s13[1].sample(29);
|
|
s13[2].sample(12);
|
|
s13[3].sample(29);
|
|
s13[0].sample(42);
|
|
s13[1].sample(29);
|
|
s13[2].sample(42);
|
|
s13[3].sample(32);
|
|
s13[0].sample(52);
|
|
s13[1].sample(49);
|
|
s13[2].sample(42);
|
|
s13[3].sample(25);
|
|
s13[0].sample(32);
|
|
s13[1].sample(49);
|
|
s13[2].sample(22);
|
|
s13[3].sample(49);
|
|
s13[0].sample(62);
|
|
s13[1].sample(99);
|
|
s13[2].sample(72);
|
|
s13[3].sample(23);
|
|
s13[0].sample(52);
|
|
s13[1].sample(78);
|
|
s13[2].sample(69);
|
|
s13[3].sample(49);
|
|
|
|
s14[0].sample(1234);
|
|
s14[1].sample(4134);
|
|
s14[4].sample(1213);
|
|
s14[3].sample(1124);
|
|
s14[2].sample(1243);
|
|
s14[7].sample(1244);
|
|
s14[4].sample(7234);
|
|
s14[2].sample(9234);
|
|
s14[3].sample(1764);
|
|
s14[7].sample(1564);
|
|
s14[3].sample(3234);
|
|
s14[1].sample(2234);
|
|
s14[5].sample(1234);
|
|
s14[2].sample(4334);
|
|
s14[2].sample(1234);
|
|
s14[4].sample(4334);
|
|
s14[6].sample(1234);
|
|
s14[8].sample(8734);
|
|
s14[1].sample(5234);
|
|
s14[3].sample(8234);
|
|
s14[7].sample(5234);
|
|
s14[4].sample(4434);
|
|
s14[3].sample(7234);
|
|
s14[2].sample(1934);
|
|
s14[1].sample(9234);
|
|
s14[5].sample(5634);
|
|
s14[3].sample(1264);
|
|
s14[7].sample(5223);
|
|
s14[0].sample(1234);
|
|
s14[0].sample(5434);
|
|
s14[3].sample(8634);
|
|
s14[1].sample(1234);
|
|
|
|
|
|
s15[0].sample(1234);
|
|
s15[1].sample(4134);
|
|
curTick += ULL(1000000);
|
|
s15[4].sample(1213);
|
|
curTick += ULL(1000000);
|
|
s15[3].sample(1124);
|
|
curTick += ULL(1000000);
|
|
s15[2].sample(1243);
|
|
curTick += ULL(1000000);
|
|
s15[7].sample(1244);
|
|
curTick += ULL(1000000);
|
|
s15[4].sample(7234);
|
|
s15[2].sample(9234);
|
|
s15[3].sample(1764);
|
|
s15[7].sample(1564);
|
|
s15[3].sample(3234);
|
|
s15[1].sample(2234);
|
|
curTick += ULL(1000000);
|
|
s15[5].sample(1234);
|
|
curTick += ULL(1000000);
|
|
s15[9].sample(4334);
|
|
curTick += ULL(1000000);
|
|
s15[2].sample(1234);
|
|
curTick += ULL(1000000);
|
|
s15[4].sample(4334);
|
|
s15[6].sample(1234);
|
|
curTick += ULL(1000000);
|
|
s15[8].sample(8734);
|
|
curTick += ULL(1000000);
|
|
s15[1].sample(5234);
|
|
curTick += ULL(1000000);
|
|
s15[3].sample(8234);
|
|
curTick += ULL(1000000);
|
|
s15[7].sample(5234);
|
|
s15[4].sample(4434);
|
|
s15[3].sample(7234);
|
|
s15[2].sample(1934);
|
|
s15[1].sample(9234);
|
|
curTick += ULL(1000000);
|
|
s15[5].sample(5634);
|
|
s15[3].sample(1264);
|
|
s15[7].sample(5223);
|
|
s15[0].sample(1234);
|
|
s15[0].sample(5434);
|
|
s15[3].sample(8634);
|
|
curTick += ULL(1000000);
|
|
s15[1].sample(1234);
|
|
|
|
s4 = curTick;
|
|
|
|
s8[3] = 99999;
|
|
|
|
s3 = 12;
|
|
s3++;
|
|
curTick += 9;
|
|
|
|
s1 = 9;
|
|
s1 += 9;
|
|
s1 -= 11;
|
|
s1++;
|
|
++s1;
|
|
s1--;
|
|
--s1;
|
|
|
|
s2 = 9;
|
|
|
|
s5[0] += 1;
|
|
s5[1] += 2;
|
|
s5[2] += 3;
|
|
s5[3] += 4;
|
|
s5[4] += 5;
|
|
|
|
s7[0] = 10;
|
|
s7[1] = 20;
|
|
s7[2] = 30;
|
|
s7[3] = 40;
|
|
s7[4] = 50;
|
|
s7[5] = 60;
|
|
s7[6] = 70;
|
|
|
|
s6.sample(0);
|
|
s6.sample(1);
|
|
s6.sample(2);
|
|
s6.sample(3);
|
|
s6.sample(4);
|
|
s6.sample(5);
|
|
s6.sample(6);
|
|
s6.sample(7);
|
|
s6.sample(8);
|
|
s6.sample(9);
|
|
|
|
bin2.activate();
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(10);
|
|
s6.sample(11);
|
|
s6.sample(19);
|
|
s6.sample(20);
|
|
s6.sample(20);
|
|
s6.sample(21);
|
|
s6.sample(21);
|
|
s6.sample(31);
|
|
s6.sample(98);
|
|
s6.sample(99);
|
|
s6.sample(99);
|
|
s6.sample(99);
|
|
|
|
s7[0] = 700;
|
|
s7[1] = 600;
|
|
s7[2] = 500;
|
|
s7[3] = 400;
|
|
s7[4] = 300;
|
|
s7[5] = 200;
|
|
s7[6] = 100;
|
|
|
|
s9.sample(100);
|
|
s9.sample(100);
|
|
s9.sample(100);
|
|
s9.sample(100);
|
|
s9.sample(10);
|
|
s9.sample(10);
|
|
s9.sample(10);
|
|
s9.sample(10);
|
|
s9.sample(10);
|
|
|
|
curTick += 9;
|
|
s4 = curTick;
|
|
s6.sample(100);
|
|
s6.sample(100);
|
|
s6.sample(100);
|
|
s6.sample(101);
|
|
s6.sample(102);
|
|
|
|
s12.sample(100);
|
|
|
|
if (text) {
|
|
Text out(cout);
|
|
out.descriptions = descriptions;
|
|
out.compat = compat;
|
|
out();
|
|
}
|
|
|
|
if (!pyfile.empty()) {
|
|
Python out(pyfile);
|
|
out();
|
|
}
|
|
|
|
if (!mysql_name.empty()) {
|
|
MySql out;
|
|
out.connect(mysql_host, mysql_user, mysql_passwd, "m5stats",
|
|
mysql_name, "test");
|
|
out();
|
|
}
|
|
|
|
return 0;
|
|
}
|