sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases 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 " 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
@ -820,7 +794,6 @@ sticky_vars.AddVariables(
BoolVariable('USE_SSE2',
'Compile for SSE2 (-msse2) to get IEEE FP on x86 hosts',
False),
BoolVariable('USE_MYSQL', 'Use MySQL for stats output', have_mysql),
BoolVariable('USE_POSIX_CLOCK', 'Use POSIX Clocks', have_posix_clock),
BoolVariable('USE_FENV', 'Use <fenv.h> IEEE mode control', have_fenv),
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).
export_vars += ['FULL_SYSTEM', 'USE_FENV', 'USE_MYSQL',
export_vars += ['FULL_SYSTEM', 'USE_FENV',
'NO_FAST_ALLOC', 'FORCE_FAST_ALLOC', 'FAST_ALLOC_STATS',
'SS_COMPATIBLE_FP', 'USE_CHECKER', 'TARGET_ISA', 'CP_ANNOTATE',
'USE_POSIX_CLOCK' ]
@ -994,16 +967,6 @@ for variant_path in variant_paths:
if env['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
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')
if env['USE_MYSQL']:
Source('mysql.cc')
Source('stats/mysql.cc')
TraceFlag('Annotate', "State machine annotation debugging")
TraceFlag('AnnotateQ', "State machine annotation queue debugging")
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)
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():
internal.stats.initSimStats()

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

@ -36,7 +36,6 @@
%include <stdint.i>
%{
#include "base/stats/mysql.hh"
#include "base/stats/text.hh"
#include "base/stats/types.hh"
#include "base/callback.hh"
@ -141,9 +140,6 @@ template <class T> T cast_info(Info *info);
void initSimStats();
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,
Tick when = curTick(), Tick repeat = 0);