sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

stats: delete mysql support

Browse source 
we can add it back within python in some future changeset
This commit is contained in:
Nathan Binkert 2011-05-12 11:19:35 -07:00
parent 1177e7a3c8
commit f7b3900c13
9 changed files with 1 additions and 1704 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

39
SConstruct
View file

@ -708,32 +708,6 @@ if not have_fenv:
print "Warning: Header file <fenv.h> not found." print "Warning: Header file <fenv.h> not found."
print " This host has no IEEE FP rounding mode control." print " This host has no IEEE FP rounding mode control."
######################################################################
#
# Check for mysql.
#
mysql_config = WhereIs('mysql_config')
have_mysql = bool(mysql_config)
# Check MySQL version.
if have_mysql:
mysql_version = readCommand(mysql_config + ' --version')
min_mysql_version = '4.1'
if compareVersions(mysql_version, min_mysql_version) < 0:
print 'Warning: MySQL', min_mysql_version, 'or newer required.'
print ' Version', mysql_version, 'detected.'
have_mysql = False
# Set up mysql_config commands.
if have_mysql:
mysql_config_include = mysql_config + ' --include'
if os.system(mysql_config_include + ' > /dev/null') != 0:
# older mysql_config versions don't support --include, use
# --cflags instead
mysql_config_include = mysql_config + ' --cflags | sed s/\\\'//g'
# This seems to work in all versions
mysql_config_libs = mysql_config + ' --libs'
###################################################################### ######################################################################
# #
# Finish the configuration # Finish the configuration
@ -820,7 +794,6 @@ sticky_vars.AddVariables(
BoolVariable('USE_SSE2', BoolVariable('USE_SSE2',
'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts', 'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
False), False),
BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock), BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv), BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False), BoolVariable('USE_CHECKER', 'Use checker for detailed CPU models', False),
@ -829,7 +802,7 @@ sticky_vars.AddVariables(
) )
# These variables get exported to #defines in config/*.hh (see src/SConscript). # These variables get exported to #defines in config/*.hh (see src/SConscript).
export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL', export_vars += ['FULL_SYSTEM', 'USE_FENV',
'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC', 'FAST_ALLOC_STATS', 'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC', 'FAST_ALLOC_STATS',
'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE', 'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE',
'USE_POSIX_CLOCK' ] 'USE_POSIX_CLOCK' ]
@ -994,16 +967,6 @@ for variant_path in variant_paths:
if env['EFENCE']: if env['EFENCE']:
env.Append(LIBS=['efence']) env.Append(LIBS=['efence'])
if env['USE_MYSQL']:
if not have_mysql:
print "Warning: MySQL not available; " \
"forcing USE_MYSQL to False in", variant_dir + "."
env['USE_MYSQL'] = False
else:
print "Compiling in", variant_dir, "with MySQL support."
env.ParseConfig(mysql_config_libs)
env.ParseConfig(mysql_config_include)
# Save sticky variable settings back to current variables file # Save sticky variable settings back to current variables file
sticky_vars.Save(current_vars_file, env) sticky_vars.Save(current_vars_file, env)

4
src/base/SConscript
View file

@ -73,10 +73,6 @@ Source('loader/symtab.cc')
Source('stats/text.cc') Source('stats/text.cc')
if env['USE_MYSQL']:
Source('mysql.cc')
Source('stats/mysql.cc')
TraceFlag('Annotate', "State machine annotation debugging") TraceFlag('Annotate', "State machine annotation debugging")
TraceFlag('AnnotateQ', "State machine annotation queue debugging") TraceFlag('AnnotateQ', "State machine annotation queue debugging")
TraceFlag('AnnotateVerbose', "Dump all state machine annotation details") TraceFlag('AnnotateVerbose', "Dump all state machine annotation details")

113
src/base/mysql.cc
View file

@ -1,113 +0,0 @@
/*
* Copyright (c) 2004-2005 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.
*
* Authors: Nathan Binkert
*/
#include <iostream>
#include "base/mysql.hh"
#include "base/trace.hh"
#include "debug/SQL.hh"
using namespace std;
namespace MySQL {
inline const char *
charstar(const string &string)
{
return string.empty() ? NULL : string.c_str();
}
ostream &
operator<<(ostream &stream, const Error &error)
{
stream << error.string();
return stream;
}
/*
* The connection class
*/
Connection::Connection()
: valid(false)
{
}
Connection::~Connection()
{
if (valid)
close();
}
bool
Connection::connect(const string &xhost, const string &xuser,
const string &xpasswd, const string &xdatabase)
{
if (connected())
return error.set("Already Connected");
_host = xhost;
_user = xuser;
_passwd = xpasswd;
_database = xdatabase;
error.clear();
mysql_init(&mysql);
mysql_options(&mysql, MYSQL_OPT_COMPRESS, 0); // might want to be 1
mysql_options(&mysql, MYSQL_READ_DEFAULT_GROUP, "odbc");
if (!mysql_real_connect(&mysql, charstar(_host), charstar(_user),
charstar(_passwd), charstar(_database),
0, NULL, 0))
return error.set(mysql_error(&mysql));
valid = true;
return false;
}
void
Connection::close()
{
mysql_close(&mysql);
}
bool
Connection::query(const string &sql)
{
DPRINTF(SQL, "Sending SQL query to server:\n%s", sql);
error.clear();
if (mysql_real_query(&mysql, sql.c_str(), sql.size()))
error.set(mysql_error(&mysql));
return error;
}
} // namespace MySQL

426
src/base/mysql.hh
View file

@ -1,426 +0,0 @@
/*
* Copyright (c) 2004-2005 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.
*
* Authors: Nathan Binkert
*/
#ifndef __BASE_MYSQL_HH__
#define __BASE_MYSQL_HH__
#define TO_BE_INCLUDED_LATER 0
#include <mysql.h>
#include <mysql_version.h>
#include <cassert>
#include <iosfwd>
#include <sstream>
#include <string>
namespace MySQL {
class Error
{
protected:
const char *error;
public:
Error() : error(NULL) {}
Error &clear() { error = NULL; return *this; }
Error &set(const char *err) { error = err; return *this; }
const char *string() const { return error; }
operator bool() const { return error != NULL; }
bool operator!() const { return error == NULL; }
};
std::ostream &operator<<(std::ostream &stream, const Error &error);
class Result
{
private:
MYSQL_RES *result;
int *refcount;
void
decref()
{
if (!refcount)
return;
*refcount -= 1;
if (*refcount == 0) {
mysql_free_result(result);
delete refcount;
}
refcount = NULL;
}
public:
Result()
: result(0), refcount(NULL)
{ }
Result(MYSQL_RES *res)
: result(res)
{
if (result)
refcount = new int(1);
else
refcount = NULL;
}
Result(const Result &result)
: result(result.result), refcount(result.refcount)
{
if (result)
*refcount += 1;
}
~Result()
{
decref();
}
const Result &
operator=(MYSQL_RES *res)
{
decref();
result = res;
if (result)
refcount = new int(1);
return *this;
}
const Result &
operator=(const Result &res)
{
decref();
result = res.result;
refcount = res.refcount;
if (result)
*refcount += 1;
return *this;
}
operator bool() const { return result != NULL; }
bool operator!() const { return result == NULL; }
unsigned
num_fields()
{
assert(result);
return mysql_num_fields(result);
}
MYSQL_ROW
fetch_row()
{
return mysql_fetch_row(result);
}
unsigned long *
fetch_lengths()
{
return mysql_fetch_lengths(result);
}
};
typedef MYSQL_ROW Row;
class Connection
{
protected:
MYSQL mysql;
bool valid;
protected:
std::string _host;
std::string _user;
std::string _passwd;
std::string _database;
public:
Connection();
virtual ~Connection();
bool connected() const { return valid; }
bool connect(const std::string &host, const std::string &user,
const std::string &passwd, const std::string &database);
void close();
public:
Error error;
operator MYSQL *() { return &mysql; }
public:
bool query(const std::string &sql);
bool
query(const std::stringstream &sql)
{
return query(sql.str());
}
bool
autocommit(bool mode)
{
return mysql_autocommit(&mysql, mode);
}
bool
commit()
{
return mysql_commit(&mysql);
}
bool
rollback()
{
return mysql_rollback(&mysql);
}
unsigned
field_count()
{
return mysql_field_count(&mysql);
}
unsigned
affected_rows()
{
return mysql_affected_rows(&mysql);
}
unsigned
insert_id()
{
return mysql_insert_id(&mysql);
}
Result
store_result()
{
error.clear();
Result result = mysql_store_result(&mysql);
if (!result)
error.set(mysql_error(&mysql));
return result;
}
};
#if 0
class BindProxy
{
MYSQL_BIND *bind;
BindProxy(MYSQL_BIND *b) : bind(b) {}
void operator=(bool &buffer)
{
bind->buffer_type = MYSQL_TYPE_TINY;
bind->buffer = (char *)&buffer;
}
void operator=(int8_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_TINY;
bind->buffer = (char *)&buffer;
}
void operator=(int16_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_SHORT;
bind->buffer = (char *)&buffer;
}
void operator=(int32_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_LONG;
bind->buffer = (char *)&buffer;
}
void operator=(int64_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_LONGLONG;
bind->buffer = (char *)&buffer;
}
void operator=(uint8_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_TINY;
bind->buffer = (char *)&buffer;
}
void operator=(uint16_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_SHORT;
bind->buffer = (char *)&buffer;
}
void operator=(uint32_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_LONG;
bind->buffer = (char *)&buffer;
}
void operator=(uint64_t &buffer)
{
bind->buffer_type = MYSQL_TYPE_LONGLONG;
bind->buffer = (char *)&buffer;
}
void operator=(float &buffer)
{
bind->buffer_type = MYSQL_TYPE_FLOAT;
bind->buffer = (char *)&buffer;
}
void operator=(double &buffer)
{
bind->buffer_type = MYSQL_TYPE_DOUBLE;
bind->buffer = (char *)&buffer;
}
void operator=(Time &buffer)
{
bind->buffer_type = MYSQL_TYPE_DATE;
bind->buffer = (char *)&buffer;
}
void operator=(const char *buffer)
{
bind->buffer_type = MYSQL_TYPE_VAR_STRING;
bind->buffer = buffer;
}
void operator=(const std::string &buffer)
{
bind->buffer_type = MYSQL_TYPE_VAR_STRING;
bind->buffer = (char *)&buffer;
bind->length = buffer.length;
}
bool
set_null(bool null)
{
bind->is_null = null;
}
};
class Statement
{
protected:
Error &error;
MYSQL_STMT *stmt;
MYSQL_BIND *bind;
int size;
public:
Statement(Connection &mysql)
: error(mysql.error), bind(NULL), size(0)
{
stmt = mysql_stmt_init(mysql);
assert(valid() && "mysql_stmt_init(), out of memory\n");
}
~Statement()
{
assert(valid());
error.clear();
if (mysql_stmt_close(stmt))
error.set(mysql_stmt_error(stmt));
if (bind)
delete [] bind;
}
bool valid()
{
return stmt != NULL;
}
void prepare(const std::string &query)
{
assert(valid());
mysql.error.clear();
if (mysql_stmt_prepare(mysql, query, strlen(query)))
mysql.error.set(mysql_stmt_error(stmt));
int size = count();
bind = new MYSQL_BIND[size];
}
unsigned count()
{
assert(valid());
return mysql_stmt_param_count(stmt);
}
unsigned affected()
{
assert(valid());
return mysql_stmt_affected_rows(stmt);
}
void bind(MYSQL_BIND *bind)
{
mysql.error.clear();
if (mysql_stmt_bind_param(stmt, bind))
mysql.error.set(mysql_stmt_error(stmt));
}
BindProxy operator[](int index)
{
assert(index > 0 && index < N);
return &bind[N];
}
operator MYSQL_BIND *()
{
return bind;
}
void operator()()
{
assert(valid());
error.clear();
if (mysql_stmt_execute(stmt))
error.set(mysql_stmt_error(stmt));
}
}
#endif
} // namespace MySQL
#endif // __BASE_MYSQL_HH__

852
src/base/stats/mysql.cc
View file

@ -1,852 +0,0 @@
/*
* Copyright (c) 2004-2005 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.
*
* Authors: Nathan Binkert
*/
#include <cassert>
#include <cstdio>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include "base/stats/info.hh"
#include "base/stats/mysql.hh"
#include "base/stats/mysql_run.hh"
#include "base/stats/types.hh"
#include "base/misc.hh"
#include "base/mysql.hh"
#include "base/statistics.hh"
#include "base/str.hh"
#include "base/types.hh"
#include "base/userinfo.hh"
#include "sim/core.hh"
using namespace std;
namespace Stats {
void
MySqlRun::connect(const string &host, const string &user, const string &passwd,
const string &db, const string &name, const string &sample,
const string &project)
{
if (connected())
panic("can only get one database connection at this time!");
mysql.connect(host, user, passwd, db);
if (mysql.error)
panic("could not connect to database server\n%s\n", mysql.error);
if (mysql.autocommit(false))
panic("could not set autocommit\n%s\n", mysql.error);
remove(name);
//cleanup();
setup(name, sample, user, project);
}
void
MySqlRun::setup(const string &name, const string &sample, const string &user,
const string &project)
{
assert(mysql.connected());
stringstream insert;
ccprintf(insert,
"INSERT INTO "
"runs(rn_name,rn_sample,rn_user,rn_project,rn_date,rn_expire)"
"values(\"%s\", \"%s\", \"%s\", \"%s\", NOW(),"
"DATE_ADD(CURDATE(), INTERVAL 31 DAY))",
name, sample, user, project);
mysql.query(insert);
if (mysql.error)
panic("could not get a run\n%s\n", mysql.error);
run_id = mysql.insert_id();
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
void
MySqlRun::remove(const string &name)
{
assert(mysql.connected());
stringstream sql;
ccprintf(sql, "DELETE FROM runs WHERE rn_name=\"%s\"", name);
mysql.query(sql);
if (mysql.error)
panic("could not delete run\n%s\n", mysql.error);
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
void
MySqlRun::cleanup()
{
assert(mysql.connected());
mysql.query("DELETE data "
"FROM data "
"LEFT JOIN runs ON dt_run=rn_id "
"WHERE rn_id IS NULL");
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
mysql.query("DELETE formula_ref "
"FROM formula_ref "
"LEFT JOIN runs ON fr_run=rn_id "
"WHERE rn_id IS NULL");
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
mysql.query("DELETE formulas "
"FROM formulas "
"LEFT JOIN formula_ref ON fm_stat=fr_stat "
"WHERE fr_stat IS NULL");
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
mysql.query("DELETE stats "
"FROM stats "
"LEFT JOIN data ON st_id=dt_stat "
"WHERE dt_stat IS NULL");
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
mysql.query("DELETE subdata "
"FROM subdata "
"LEFT JOIN data ON sd_stat=dt_stat "
"WHERE dt_stat IS NULL");
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
void
SetupStat::init()
{
name = "";
descr = "";
type = "";
print = false;
prereq = 0;
prec = -1;
nozero = false;
nonan = false;
total = false;
pdf = false;
cdf = false;
min = 0;
max = 0;
bktsize = 0;
size = 0;
}
unsigned
SetupStat::setup(MySqlRun *run)
{
MySQL::Connection &mysql = run->conn();
stringstream insert;
ccprintf(insert,
"INSERT INTO "
"stats(st_name, st_descr, st_type, st_print, st_prereq, "
"st_prec, st_nozero, st_nonan, st_total, st_pdf, st_cdf, "
"st_min, st_max, st_bktsize, st_size)"
"values(\"%s\",\"%s\",\"%s\","
" %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
name, descr, type, print, prereq, (int)prec, nozero, nonan,
total, pdf, cdf,
min, max, bktsize, size);
mysql.query(insert);
if (!mysql.error) {
int id = mysql.insert_id();
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
return id;
}
stringstream select;
ccprintf(select, "SELECT * FROM stats WHERE st_name=\"%s\"", name);
mysql.query(select);
MySQL::Result result = mysql.store_result();
if (!result)
panic("could not find stat\n%s\n", mysql.error);
assert(result.num_fields() == 16);
MySQL::Row row = result.fetch_row();
if (!row)
panic("could not get stat row\n%s\n", mysql.error);
bool tb;
int8_t ti8;
uint16_t tu16;
int64_t ti64;
uint64_t tu64;
if (name != (char *)row[1])
panic("failed stat check on %s:name. %s != %s\n",
name, name, row[1]);
if (descr != (char *)row[2])
panic("failed stat check on %s:descr. %s != %s\n",
name, descr, row[2]);
if (type != (char *)row[3])
panic("failed stat check on %s:type. %s != %s\n",
name, type, row[3]);
if (!to_number(row[4], tb) || print != tb)
panic("failed stat check on %s:print. %d != %d\n",
name, print, tb);
if (!to_number(row[6], ti8) || prec != ti8)
panic("failed stat check on %s:prec. %d != %d\n",
name, prec, ti8);
if (!to_number(row[7], tb) || nozero != tb)
panic("failed stat check on %s:nozero. %d != %d\n",
name, nozero, tb);
if (!to_number(row[8], tb) || nonan != tb)
panic("failed stat check on %s:nonan. %d != %d\n",
name, nonan, tb);
if (!to_number(row[9], tb) || total != tb)
panic("failed stat check on %s:total. %d != %d\n",
name, total, tb);
if (!to_number(row[10], tb) || pdf != tb)
panic("failed stat check on %s:pdf. %d != %d\n",
name, pdf, tb);
if (!to_number(row[11], tb) || cdf != tb)
panic("failed stat check on %s:cdf. %d != %d\n",
name, cdf, tb);
if (!to_number(row[12], ti64) || min != ti64)
panic("failed stat check on %s:min. %d != %d\n",
name, min, ti64);
if (!to_number(row[13], ti64) || max != ti64)
panic("failed stat check on %s:max. %d != %d\n",
name, max, ti64);
if (!to_number(row[14], tu64) || bktsize != tu64)
panic("failed stat check on %s:bktsize. %d != %d\n",
name, bktsize, tu64);
if (!to_number(row[15], tu16) || size != tu16)
panic("failed stat check on %s:size. %d != %d\n",
name, size, tu16);
to_number(row[5], prereq);
uint16_t statid;
to_number(row[0], statid);
return statid;
}
InsertData::InsertData(MySqlRun *_run)
: run(_run)
{
query = new char[maxsize + 1];
size = 0;
flush();
}
InsertData::~InsertData()
{
delete [] query;
}
void
InsertData::flush()
{
if (size) {
MySQL::Connection &mysql = run->conn();
assert(mysql.connected());
mysql.query(query);
if (mysql.error)
panic("could not insert data\n%s\n", mysql.error);
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
query[0] = '\0';
size = 0;
first = true;
strcpy(query, "INSERT INTO "
"data(dt_stat,dt_x,dt_y,dt_run,dt_tick,dt_data) "
"values");
size = strlen(query);
}
void
InsertData::insert()
{
if (size + 1024 > maxsize)
flush();
if (!first) {
query[size++] = ',';
query[size] = '\0';
}
first = false;
size += sprintf(query + size, "(%u,%d,%d,%u,%llu,\"%f\")",
stat, x, y, run->run(), (unsigned long long)tick,
data);
}
struct InsertSubData
{
uint16_t stat;
int16_t x;
int16_t y;
string name;
string descr;
void setup(MySqlRun *run);
};
void
InsertSubData::setup(MySqlRun *run)
{
MySQL::Connection &mysql = run->conn();
assert(mysql.connected());
stringstream insert;
ccprintf(insert,
"INSERT INTO subdata(sd_stat,sd_x,sd_y,sd_name,sd_descr) "
"values(%d,%d,%d,\"%s\",\"%s\")",
stat, x, y, name, descr);
mysql.query(insert);
// if (mysql.error)
// panic("could not insert subdata\n%s\n", mysql.error);
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
MySql::MySql()
: run(new MySqlRun), newdata(run)
{}
MySql::~MySql()
{
delete run;
}
void
MySql::connect(const string &host, const string &user, const string &passwd,
const string &db, const string &name, const string &sample,
const string &project)
{
run->connect(host, user, passwd, db, name, sample, project);
}
bool
MySql::connected() const
{
return run->connected();
}
void
MySql::configure()
{
/*
* set up all stats!
*/
MySQL::Connection &mysql = run->conn();
list<Info *>::const_iterator i, end = statsList().end();
for (i = statsList().begin(); i != end; ++i) {
Info *info = *i;
info->visit(*this);
}
for (i = statsList().begin(); i != end; ++i) {
Info *info = *i;
if (info->prereq) {
// update the prerequisite
uint16_t stat_id = find(info->id);
uint16_t prereq_id = find(info->prereq->id);
assert(stat_id && prereq_id);
stringstream update;
ccprintf(update, "UPDATE stats SET st_prereq=%d WHERE st_id=%d",
prereq_id, stat_id);
mysql.query(update);
if (mysql.error)
panic("could not update prereq\n%s\n", mysql.error);
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
}
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
configured = true;
}
bool
MySql::configure(const Info &info, string type)
{
stat.init();
stat.name = info.name;
stat.descr = info.desc;
stat.type = type;
stat.print = info.flags & display;
stat.prec = info.precision;
stat.nozero = info.flags & nozero;
stat.nonan = info.flags & nonan;
stat.total = info.flags & total;
stat.pdf = info.flags & pdf;
stat.cdf = info.flags & cdf;
return stat.print;
}
void
MySql::configure(const ScalarInfo &info)
{
if (!configure(info, "SCALAR"))
return;
insert(info.id, stat.setup(run));
}
void
MySql::configure(const VectorInfo &info)
{
if (!configure(info, "VECTOR"))
return;
uint16_t statid = stat.setup(run);
if (!info.subnames.empty()) {
InsertSubData subdata;
subdata.stat = statid;
subdata.y = 0;
for (off_type i = 0; i < info.subnames.size(); ++i) {
subdata.x = i;
subdata.name = info.subnames[i];
subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i];
if (!subdata.name.empty() || !subdata.descr.empty())
subdata.setup(run);
}
}
insert(info.id, statid);
}
void
MySql::configure(const DistInfo &info)
{
if (!configure(info, "DIST"))
return;
const DistStor::Params *params =
dynamic_cast<const DistStor::Params *>(info.storageParams);
if (params) {
assert(params->type == Dist);
stat.size = params->buckets;
stat.min = params->min;
stat.max = params->max;
stat.bktsize = params->bucket_size;
}
insert(info.id, stat.setup(run));
}
void
MySql::configure(const VectorDistInfo &info)
{
if (!configure(info, "VECTORDIST"))
return;
const DistStor::Params *params =
dynamic_cast<const DistStor::Params *>(info.storageParams);
if (params) {
assert(params->type == Dist);
stat.size = params->buckets;
stat.min = params->min;
stat.max = params->max;
stat.bktsize = params->bucket_size;
}
uint16_t statid = stat.setup(run);
if (!info.subnames.empty()) {
InsertSubData subdata;
subdata.stat = statid;
subdata.y = 0;
for (off_type i = 0; i < info.subnames.size(); ++i) {
subdata.x = i;
subdata.name = info.subnames[i];
subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i];
if (!subdata.name.empty() || !subdata.descr.empty())
subdata.setup(run);
}
}
insert(info.id, statid);
}
void
MySql::configure(const Vector2dInfo &info)
{
if (!configure(info, "VECTOR2D"))
return;
uint16_t statid = stat.setup(run);
if (!info.subnames.empty()) {
InsertSubData subdata;
subdata.stat = statid;
subdata.y = -1;
for (off_type i = 0; i < info.subnames.size(); ++i) {
subdata.x = i;
subdata.name = info.subnames[i];
subdata.descr = info.subdescs.empty() ? "" : info.subdescs[i];
if (!subdata.name.empty() || !subdata.descr.empty())
subdata.setup(run);
}
}
if (!info.y_subnames.empty()) {
InsertSubData subdata;
subdata.stat = statid;
subdata.x = -1;
subdata.descr = "";
for (off_type i = 0; i < info.y_subnames.size(); ++i) {
subdata.y = i;
subdata.name = info.y_subnames[i];
if (!subdata.name.empty())
subdata.setup(run);
}
}
insert(info.id, statid);
}
void
MySql::configure(const FormulaInfo &info)
{
MySQL::Connection &mysql = run->conn();
assert(mysql.connected());
configure(info, "FORMULA");
insert(info.id, stat.setup(run));
uint16_t stat = find(info.id);
string formula = info.str();
stringstream insert_formula;
ccprintf(insert_formula,
"INSERT INTO formulas(fm_stat,fm_formula) values(%d, \"%s\")",
stat, formula);
mysql.query(insert_formula);
// if (mysql.error)
// panic("could not insert formula\n%s\n", mysql.error);
stringstream insert_ref;
ccprintf(insert_ref,
"INSERT INTO formula_ref(fr_stat,fr_run) values(%d, %d)",
stat, run->run());
mysql.query(insert_ref);
// if (mysql.error)
// panic("could not insert formula reference\n%s\n", mysql.error);
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
bool
MySql::valid() const
{
return run->connected();
}
void
MySql::begin()
{
assert(valid());
if (!configured)
configure();
// store sample #
newdata.tick = curTick();
}
void
MySql::end()
{
newdata.flush();
}
void
MySql::commit()
{
MySQL::Connection &mysql = run->conn();
if (mysql.commit())
panic("could not commit transaction\n%s\n", mysql.error);
}
void
MySql::output(const ScalarInfo &info)
{
if (!(info.flags & display))
return;
newdata.stat = find(info.id);
newdata.x = 0;
newdata.y = 0;
newdata.data = info.value();
newdata.insert();
commit();
}
void
MySql::output(const VectorInfo &info)
{
if (!(info.flags & display))
return;
newdata.stat = find(info.id);
newdata.y = 0;
const VCounter &cvec = info.value();
size_type size = info.size();
for (off_type x = 0; x < size; x++) {
newdata.x = x;
newdata.data = cvec[x];
newdata.insert();
}
commit();
}
void
MySql::output(const DistData &data, const DistParams *params)
{
const int db_sum = -1;
const int db_squares = -2;
const int db_samples = -3;
const int db_min_val = -4;
const int db_max_val = -5;
const int db_underflow = -6;
const int db_overflow = -7;
newdata.x = db_sum;
newdata.data = data.sum;
newdata.insert();
newdata.x = db_squares;
newdata.data = data.squares;
newdata.insert();
newdata.x = db_samples;
newdata.data = data.samples;
newdata.insert();
if (data.samples && params->type == Dist) {
newdata.x = db_min_val;
newdata.data = data.min_val;
newdata.insert();
newdata.x = db_max_val;
newdata.data = data.max_val;
newdata.insert();
newdata.x = db_underflow;
newdata.data = data.underflow;
newdata.insert();
newdata.x = db_overflow;
newdata.data = data.overflow;
newdata.insert();
size_type size = data.cvec.size();
for (off_type x = 0; x < size; x++) {
newdata.x = x;
newdata.data = data.cvec[x];
newdata.insert();
}
}
commit();
}
void
MySql::output(const DistInfo &info)
{
if (!(info.flags & display))
return;
newdata.stat = find(info.id);
newdata.y = 0;
output(info.data, safe_cast<const DistParams *>(info.storageParams));
commit();
}
void
MySql::output(const VectorDistInfo &info)
{
if (!(info.flags & display))
return;
newdata.stat = find(info.id);
size_type size = info.data.size();
for (off_type y = 0; y < size; ++y) {
newdata.y = y;
output(info.data[y],
safe_cast<const DistParams *>(info.storageParams));
}
commit();
}
void
MySql::output(const Vector2dInfo &info)
{
if (!(info.flags & display))
return;
newdata.stat = find(info.id);
off_type index = 0;
for (off_type x = 0; x < info.x; x++) {
newdata.x = x;
for (off_type y = 0; y < info.y; y++) {
newdata.y = y;
newdata.data = info.cvec[index++];
newdata.insert();
}
}
commit();
}
void
MySql::output(const FormulaInfo &info)
{
}
/*
* Implement the visitor
*/
void
MySql::visit(const ScalarInfo &info)
{
if (!configured)
configure(info);
else
output(info);
}
void
MySql::visit(const VectorInfo &info)
{
if (!configured)
configure(info);
else
output(info);
}
void
MySql::visit(const DistInfo &info)
{
return;
if (!configured)
configure(info);
else
output(info);
}
void
MySql::visit(const VectorDistInfo &info)
{
return;
if (!configured)
configure(info);
else
output(info);
}
void
MySql::visit(const Vector2dInfo &info)
{
return;
if (!configured)
configure(info);
else
output(info);
}
void
MySql::visit(const FormulaInfo &info)
{
if (!configured)
configure(info);
else
output(info);
}
Output *
initMySQL(string host, string user, string password, string database,
string project, string name, string sample)
{
static MySql mysql;
if (mysql.connected()) {
mysql.connect(host, user, password, database, name, sample, project);
}
return &mysql;
}
} // namespace Stats

190
src/base/stats/mysql.hh
View file

@ -1,190 +0,0 @@
/*
* Copyright (c) 2004-2005 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.
*
* Authors: Nathan Binkert
*/
#ifndef __BASE_STATS_MYSQL_HH__
#define __BASE_STATS_MYSQL_HH__
#include <cstdio>
#include <list>
#include <map>
#include <string>
#include "base/stats/output.hh"
#include "base/types.hh"
#include "config/use_mysql.hh"
namespace MySQL { class Connection; }
namespace Stats {
class DistData;
class DistParams;
class MySqlRun;
struct SetupStat
{
std::string name;
std::string descr;
std::string type;
bool print;
uint16_t prereq;
int8_t prec;
bool nozero;
bool nonan;
bool total;
bool pdf;
bool cdf;
double min;
double max;
double bktsize;
uint16_t size;
void init();
unsigned setup(MySqlRun *run);
};
class InsertData
{
private:
char *query;
std::size_t size;
bool first;
static const std::size_t maxsize = 1024*1024;
public:
MySqlRun *run;
public:
uint64_t tick;
double data;
uint16_t stat;
int16_t x;
int16_t y;
public:
InsertData(MySqlRun *_run);
~InsertData();
void flush();
void insert();
};
class MySql : public Output
{
protected:
MySqlRun *run; /* Hide the implementation so we don't have a
#include mess */
SetupStat stat;
InsertData newdata;
std::list<FormulaInfo *> formulas;
bool configured;
protected:
std::map<int, int> idmap;
void
insert(int sim_id, int db_id)
{
using namespace std;
idmap.insert(make_pair(sim_id, db_id));
}
int
find(int sim_id)
{
using namespace std;
map<int,int>::const_iterator i = idmap.find(sim_id);
assert(i != idmap.end());
return (*i).second;
}
public:
MySql();
~MySql();
void connect(const std::string &host, const std::string &user,
const std::string &passwd, const std::string &db,
const std::string &name, const std::string &sample,
const std::string &project);
bool connected() const;
public:
// Implement Visit
virtual void visit(const ScalarInfo &info);
virtual void visit(const VectorInfo &info);
virtual void visit(const DistInfo &info);
virtual void visit(const VectorDistInfo &info);
virtual void visit(const Vector2dInfo &info);
virtual void visit(const FormulaInfo &info);
// Implement Output
virtual bool valid() const;
virtual void begin();
virtual void end();
protected:
// Output helper
void commit();
void output(const ScalarInfo &info);
void output(const VectorInfo &info);
void output(const DistInfo &info);
void output(const VectorDistInfo &info);
void output(const Vector2dInfo &info);
void output(const FormulaInfo &info);
void output(const DistData &data, const DistParams *params);
void configure();
bool configure(const Info &info, std::string type);
void configure(const ScalarInfo &info);
void configure(const VectorInfo &info);
void configure(const DistInfo &info);
void configure(const VectorDistInfo &info);
void configure(const Vector2dInfo &info);
void configure(const FormulaInfo &info);
};
Output *initMySQL(std::string host, std::string database, std::string user,
std::string passwd, std::string project, std::string name,
std::string sample);
#if !USE_MYSQL
inline Output *
initMySQL(std::string host, std::string user, std::string password,
std::string database, std::string project, std::string name,
std::string sample)
{
return NULL;
}
#endif
} // namespace Stats
#endif // __BASE_STATS_MYSQL_HH__

67
src/base/stats/mysql_run.hh
View file

@ -1,67 +0,0 @@
/*
* Copyright (c) 2004-2005 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.
*
* Authors: Nathan Binkert
*/
#ifndef __BASE_STATS_MYSQL_RUN_HH__
#define __BASE_STATS_MYSQL_RUN_HH__
#include <string>
#include "base/mysql.hh"
#include "base/types.hh"
namespace Stats {
struct MySqlRun
{
private:
MySQL::Connection mysql;
uint16_t run_id;
protected:
void setup(const std::string &name, const std::string &sample,
const std::string &user, const std::string &project);
void remove(const std::string &name);
void cleanup();
public:
bool connected() const { return mysql.connected(); }
void connect(const std::string &host, const std::string &user,
const std::string &passwd, const std::string &db,
const std::string &name, const std::string &sample,
const std::string &project);
MySQL::Connection &conn() { return mysql; }
uint16_t run() const { return run_id; }
};
} // namespace Stats
#endif // __BASE_STATS_MYSQL_RUN_HH__

10
src/python/m5/stats/__init__.py
View file

@ -39,16 +39,6 @@ def initText(filename, desc=True):
output = internal.stats.initText(filename, desc) output = internal.stats.initText(filename, desc)
outputList.append(output) outputList.append(output)
def initMySQL(host, database, user='', passwd='', project='test', name='test',
sample='0'):
if not user:
import getpass
user = getpass.getuser()
output = internal.stats.initMySQL(host, database, user, passwd,
project, name, sample)
outputList.append(output)
def initSimStats(): def initSimStats():
internal.stats.initSimStats() internal.stats.initSimStats()

4
src/python/swig/stats.i
View file

@ -36,7 +36,6 @@
%include <stdint.i> %include <stdint.i>
%{ %{
#include "base/stats/mysql.hh"
#include "base/stats/text.hh" #include "base/stats/text.hh"
#include "base/stats/types.hh" #include "base/stats/types.hh"
#include "base/callback.hh" #include "base/callback.hh"
@ -141,9 +140,6 @@ template <class T> T cast_info(Info *info);
void initSimStats(); void initSimStats();
Output *initText(const std::string &filename, bool desc); Output *initText(const std::string &filename, bool desc);
Output *initMySQL(std::string host, std::string database, std::string user,
std::string passwd, std::string project, std::string name,
std::string sample);
void schedStatEvent(bool dump, bool reset, void schedStatEvent(bool dump, bool reset,
Tick when = curTick(), Tick repeat = 0); Tick when = curTick(), Tick repeat = 0);