virtual const VCounter &value() const = 0;
virtual const VResult &result() const = 0;
virtual Result total() const = 0;
- void update()
+
+ void
+ update()
{
if (!subnames.empty()) {
int s = size();
virtual void reset() { s.reset(); }
virtual size_t size() const { return s.size(); }
- virtual VCounter &value() const
+
+ virtual VCounter &
+ value() const
{
s.value(cvec);
return cvec;
}
- virtual const VResult &result() const
+
+ virtual const VResult &
+ result() const
{
s.result(rvec);
return rvec;
}
+
virtual Result total() const { return s.total(); }
- virtual void visit(Visit &visitor)
+
+ virtual void
+ visit(Visit &visitor)
{
update();
s.update(this);
virtual bool check() const { return s.check(); }
virtual void reset() { s.reset(); }
virtual bool zero() const { return s.zero(); }
- virtual void visit(Visit &visitor)
+
+ virtual void
+ visit(Visit &visitor)
{
s.update(this);
visitor.visit(*this);
mutable VResult rvec;
virtual size_t size() const = 0;
- void update()
+
+ void
+ update()
{
int s = size();
if (subnames.size() < s)
virtual void reset() { s.reset(); }
virtual size_t size() const { return s.size(); }
virtual bool zero() const { return s.zero(); }
- virtual void visit(Visit &visitor)
+
+ virtual void
+ visit(Visit &visitor)
{
update();
s.update(this);
mutable int x;
mutable int y;
- void update()
+ void
+ update()
{
if (subnames.size() < x)
subnames.resize(x);
virtual bool check() const { return s.check(); }
virtual void reset() { s.reset(); }
virtual bool zero() const { return s.zero(); }
- virtual void visit(Visit &visitor)
+
+ virtual void
+ visit(Visit &visitor)
{
update();
s.update(this);
Parent &self() { return *reinterpret_cast<Parent *>(this); }
protected:
- Data<Child> *statData()
+ Data<Child> *
+ statData()
{
StatData *__data = DataAccess::statData();
Data<Child> *ptr = dynamic_cast<Data<Child> *>(__data);
}
public:
- const Data<Child> *statData() const
+ const Data<Child> *
+ statData() const
{
const StatData *__data = DataAccess::statData();
const Data<Child> *ptr = dynamic_cast<const Data<Child> *>(__data);
* Copy constructor, copies are not allowed.
*/
Wrap(const Wrap &stat);
+
/**
* Can't copy stats.
*/
* @param name The new name.
* @return A reference to this stat.
*/
- Parent &name(const std::string &_name)
+ Parent &
+ name(const std::string &_name)
{
Data<Child> *data = this->statData();
data->name = _name;
* @param desc The new description.
* @return A reference to this stat.
*/
- Parent &desc(const std::string &_desc)
+ Parent &
+ desc(const std::string &_desc)
{
this->statData()->desc = _desc;
return this->self();
* @param p The new precision
* @return A reference to this stat.
*/
- Parent &precision(int _precision)
+ Parent &
+ precision(int _precision)
{
this->statData()->precision = _precision;
return this->self();
* @param f The new flags.
* @return A reference to this stat.
*/
- Parent &flags(StatFlags _flags)
+ Parent &
+ flags(StatFlags _flags)
{
this->statData()->flags |= _flags;
return this->self();
* @return A reference to this stat.
*/
template <class Stat>
- Parent &prereq(const Stat &prereq)
+ Parent &
+ prereq(const Stat &prereq)
{
this->statData()->prereq = prereq.statData();
return this->self();
* @param name The new name of the subfield.
* @return A reference to this stat.
*/
- Parent &subname(int index, const std::string &name)
+ Parent &
+ subname(int index, const std::string &name)
{
std::vector<std::string> &subn = this->statData()->subnames;
if (subn.size() <= index)
* @param desc The new description of the subfield
* @return A reference to this stat.
*/
- Parent &subdesc(int index, const std::string &desc)
+ Parent &
+ subdesc(int index, const std::string &desc)
{
std::vector<std::string> &subd = this->statData()->subdescs;
if (subd.size() <= index)
* @warning This makes the assumption that if you're gonna subnames a 2d
* vector, you're subnaming across all y
*/
- Parent &ysubnames(const char **names)
+ Parent &
+ ysubnames(const char **names)
{
Data<Child> *data = this->statData();
data->y_subnames.resize(this->y);
data->y_subnames[i] = names[i];
return this->self();
}
- Parent &ysubname(int index, const std::string subname)
+
+ Parent &
+ ysubname(int index, const std::string subname)
{
Data<Child> *data = this->statData();
assert(index < this->y);
* @param val The new count.
* @param p The parameters for this storage.
*/
- void set(Counter val, Params &p) {
+ void
+ set(Counter val, Params &p) {
total += current * (curTick - last);
last = curTick;
current = val;
* @param p The parameters for this storage.
* @return The current average.
*/
- Result result(const Params &p) const
+ Result
+ result(const Params &p) const
{
total += current * (curTick - last);
last = curTick;
/**
* Reset stat value to default
*/
- void reset()
+ void
+ reset()
{
total = 0;
last = curTick;
~ValueBase() { if (proxy) delete proxy; }
template <class T>
- void scalar(T &value)
+ void
+ scalar(T &value)
{
proxy = new ValueProxy<T>(value);
setInit();
}
template <class T>
- void functor(T &func)
+ void
+ functor(T &func)
{
proxy = new FunctorProxy<T>(func);
setInit();
* @param sp The proxy to copy.
* @return A reference to this proxy.
*/
- const ScalarProxy &operator=(const ScalarProxy &sp) {
+ const ScalarProxy &
+ operator=(const ScalarProxy &sp) {
stat = sp.stat;
index = sp.index;
return *this;
* @param v The new value.
*/
template <typename U>
- void operator=(const U &v) { stat->data(index)->set(v, stat->params); }
+ void
+ operator=(const U &v)
+ {
+ stat->data(index)->set(v, stat->params);
+ }
/**
* Increment the stat by the given value. This calls the associated
* @param v The value to add.
*/
template <typename U>
- void operator+=(const U &v) { stat->data(index)->inc(v, stat->params); }
+ void
+ operator+=(const U &v)
+ {
+ stat->data(index)->inc(v, stat->params);
+ }
/**
* Decrement the stat by the given value. This calls the associated
* @param v The value to substract.
*/
template <typename U>
- void operator-=(const U &v) { stat->data(index)->dec(v, stat->params); }
+ void
+ operator-=(const U &v)
+ {
+ stat->data(index)->dec(v, stat->params);
+ }
/**
* Return the number of elements, always 1 for a scalar.
}
public:
- void value(VCounter &vec) const
+ void
+ value(VCounter &vec) const
{
vec.resize(size());
for (int i = 0; i < size(); ++i)
* Copy the values to a local vector and return a reference to it.
* @return A reference to a vector of the stat values.
*/
- void result(VResult &vec) const
+ void
+ result(VResult &vec) const
{
vec.resize(size());
for (int i = 0; i < size(); ++i)
* Return a total of all entries in this vector.
* @return The total of all vector entries.
*/
- Result total() const {
+ Result
+ total() const
+ {
Result total = 0.0;
for (int i = 0; i < size(); ++i)
total += data(i)->result(params);
return *this;
}
- ScalarProxy<Stat> operator[](int index)
+ ScalarProxy<Stat>
+ operator[](int index)
{
assert (index >= 0 && index < size());
return ScalarProxy<Stat>(stat, offset + index);
* @param number The number of times to add the value.
* @param params The paramters of the distribution.
*/
- void sample(Counter val, int number, const Params ¶ms)
+ void
+ sample(Counter val, int number, const Params ¶ms)
{
if (val < params.min)
underflow += number;
else if (val > params.max)
overflow += number;
else {
- int index = (int)std::floor((val - params.min) / params.bucket_size);
+ size_t index = std::floor((val - params.min) / params.bucket_size);
assert(index < size(params));
cvec[index] += number;
}
* @param params The paramters of the distribution.
* @return True if any values have been sampled.
*/
- bool zero(const Params ¶ms) const
+ bool
+ zero(const Params ¶ms) const
{
return samples == Counter();
}
- void update(DistDataData *data, const Params ¶ms)
+ void
+ update(DistDataData *data, const Params ¶ms)
{
data->min = params.min;
data->max = params.max;
/**
* Reset stat value to default
*/
- void reset()
+ void
+ reset()
{
min_val = CounterLimits::max();
max_val = CounterLimits::min();
* @param number The number of times to add the value.
* @param p The parameters of this stat.
*/
- void sample(Counter val, int number, const Params &p)
+ void
+ sample(Counter val, int number, const Params &p)
{
Counter value = val * number;
sum += value;
samples += number;
}
- void update(DistDataData *data, const Params ¶ms)
+ void
+ update(DistDataData *data, const Params ¶ms)
{
data->sum = sum;
data->squares = squares;
/**
* Reset stat value to default
*/
- void reset()
+ void
+ reset()
{
sum = Counter();
squares = Counter();
* @param number The number of times to add the value.
* @param p The paramters of the distribution.
*/
- void sample(Counter val, int number, const Params &p)
+ void
+ sample(Counter val, int number, const Params &p)
{
Counter value = val * number;
sum += value;
squares += value * value;
}
- void update(DistDataData *data, const Params ¶ms)
+ void
+ update(DistDataData *data, const Params ¶ms)
{
data->sum = sum;
data->squares = squares;
* @return 1.
*/
size_t size(const Params ¶ms) const { return 1; }
+
/**
* Return true if no samples have been added.
* @return True if the sum is zero.
*/
bool zero(const Params ¶ms) const { return sum == Counter(); }
+
/**
* Reset stat value to default
*/
- void reset()
+ void
+ reset()
{
sum = Counter();
squares = Counter();
* Retrieve the storage.
* @return The storage object for this stat.
*/
- Storage *data()
+ Storage *
+ data()
{
return reinterpret_cast<Storage *>(storage);
}
*/
bool zero() const { return data()->zero(params); }
- void update(DistData *base)
+ void
+ update(DistData *base)
{
base->data.fancy = Storage::fancy;
data()->update(&(base->data), params);
: stat(sp.stat), index(sp.index)
{}
- const DistProxy &operator=(const DistProxy &sp)
+ const DistProxy &
+ operator=(const DistProxy &sp)
{
stat = sp.stat;
index = sp.index;
VectorDistBase<Storage>::total(int index) const
{
int total = 0;
- for (int i = 0; i < x_size(); ++i) {
+ for (int i = 0; i < x_size(); ++i)
total += data(i)->result(stat->params);
- }
}
#endif
public:
ScalarStatNode(const ScalarData *d) : data(d), vresult(1) {}
- virtual const VResult &result() const
+
+ virtual const VResult &
+ result() const
{
vresult[0] = data->result();
return vresult;
}
+
virtual Result total() const { return data->result(); };
virtual size_t size() const { return 1; }
public:
ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
const VResult &result() const { return vresult; }
- virtual Result total() const
+
+ virtual Result
+ total() const
{
int size = this->size();
Result tmp = 0;
for (int i = 0; i < size; i++)
- {
tmp += vresult[i];
- }
return tmp;
}
+
virtual size_t size() const { return vresult.size(); }
- virtual std::string str() const
+ virtual std::string
+ str() const
{
int size = this->size();
std::string tmp = "(";
for (int i = 0; i < size; i++)
- {
tmp += csprintf("%s ",to_string(vresult[i]));
- }
tmp += ")";
return tmp;
}
public:
UnaryNode(NodePtr &p) : l(p) {}
- const VResult &result() const
+ const VResult &
+ result() const
{
const VResult &lvec = l->result();
int size = lvec.size();
return vresult;
}
- Result total() const
+ Result
+ total() const
{
const VResult &vec = this->result();
Result total = 0;
virtual size_t size() const { return l->size(); }
- virtual std::string str() const
+ virtual std::string
+ str() const
{
return OpString<Op>::str() + l->str();
}
public:
BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
- const VResult &result() const
+ const VResult &
+ result() const
{
Op op;
const VResult &lvec = l->result();
return vresult;
}
- Result total() const
+ Result
+ total() const
{
const VResult &vec = this->result();
Result total = 0;
return total;
}
- virtual size_t size() const {
+ virtual size_t
+ size() const
+ {
int ls = l->size();
int rs = r->size();
- if (ls == 1)
+ if (ls == 1) {
return rs;
- else if (rs == 1)
+ } else if (rs == 1) {
return ls;
- else {
+ } else {
assert(ls == rs && "Node vector sizes are not equal");
return ls;
}
}
- virtual std::string str() const
+ virtual std::string
+ str() const
{
return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
}
public:
SumNode(NodePtr &p) : l(p), vresult(1) {}
- const VResult &result() const
+ const VResult &
+ result() const
{
const VResult &lvec = l->result();
int size = lvec.size();
return vresult;
}
- Result total() const
+ Result
+ total() const
{
const VResult &lvec = l->result();
int size = lvec.size();
virtual size_t size() const { return 1; }
- virtual std::string str() const
+ virtual std::string
+ str() const
{
return csprintf("total(%s)", l->str());
}
typedef ValueBase Base;
template <class T>
- Value &scalar(T &value)
+ Value &
+ scalar(T &value)
{
Base::scalar(value);
return *this;
}
template <class T>
- Value &functor(T &func)
+ Value &
+ functor(T &func)
{
Base::functor(func);
return *this;
* @param v The new value.
*/
template <typename U>
- void operator=(const U &v) { Base::operator=(v); }
+ void
+ operator=(const U &v)
+ {
+ Base::operator=(v);
+ }
};
/**
* @param size The new size.
* @return A reference to this stat.
*/
- Vector &init(size_t size) {
+ Vector &
+ init(size_t size)
+ {
this->doInit(size);
return *this;
}
* @param size The new size.
* @return A reference to this stat.
*/
- AverageVector &init(size_t size) {
+ AverageVector &
+ init(size_t size)
+ {
this->doInit(size);
return *this;
}
: public WrapVec2d<Vector2d<N>, Vector2dBase<StatStor>, Vector2dStatData>
{
public:
- Vector2d &init(size_t x, size_t y) {
+ Vector2d &
+ init(size_t x, size_t y)
+ {
this->doInit(x, y);
return *this;
}
* @param bkt The number of values in each bucket.
* @return A reference to this distribution.
*/
- Distribution &init(Counter min, Counter max, Counter bkt) {
+ Distribution &
+ init(Counter min, Counter max, Counter bkt)
+ {
this->params.min = min;
this->params.max = max;
this->params.bucket_size = bkt;
/**
* Construct and initialize this distribution.
*/
- StandardDeviation() {
+ StandardDeviation()
+ {
this->doInit();
}
};
* @param bkt The number of values in each bucket.
* @return A reference to this distribution.
*/
- VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) {
+ VectorDistribution &
+ init(int size, Counter min, Counter max, Counter bkt)
+ {
this->params.min = min;
this->params.max = max;
this->params.bucket_size = bkt;
* @param size The size of the vector.
* @return A reference to this distribution.
*/
- VectorStandardDeviation &init(int size) {
+ VectorStandardDeviation &
+ init(int size)
+ {
this->doInit(size);
return *this;
}
* @param size The size of the vector.
* @return A reference to this distribution.
*/
- VectorAverageDeviation &init(int size) {
+ VectorAverageDeviation &
+ init(int size)
+ {
this->doInit(size);
return *this;
}
virtual void reset() { s.reset(); }
virtual size_t size() const { return s.size(); }
- virtual const VResult &result() const
+
+ virtual const VResult &
+ result() const
{
s.result(vec);
return vec;
}
virtual Result total() const { return s.total(); }
virtual VCounter &value() const { return cvec; }
- virtual void visit(Visit &visitor)
+
+ virtual void
+ visit(Visit &visitor)
{
update();
s.update(this);
visitor.visit(*this);
}
+
virtual std::string str() const { return s.str(); }
};
*/
template <int N>
Temp(const Scalar<N> &s)
- : node(new ScalarStatNode(s.statData())) { }
+ : node(new ScalarStatNode(s.statData()))
+ { }
/**
* Create a new ScalarStatNode.
* @param s The ScalarStat to place in a node.
*/
Temp(const Value &s)
- : node(new ScalarStatNode(s.statData())) { }
+ : node(new ScalarStatNode(s.statData()))
+ { }
/**
* Create a new ScalarStatNode.
*/
template <int N>
Temp(const Average<N> &s)
- : node(new ScalarStatNode(s.statData())) { }
+ : node(new ScalarStatNode(s.statData()))
+ { }
/**
* Create a new VectorStatNode.
*/
template <int N>
Temp(const Vector<N> &s)
- : node(new VectorStatNode(s.statData())) { }
+ : node(new VectorStatNode(s.statData()))
+ { }
/**
*
*/
Temp(const Formula &f)
- : node(new FormulaNode(f)) { }
+ : node(new FormulaNode(f))
+ { }
/**
* Create a new ScalarProxyNode.
*/
template <class Stat>
Temp(const ScalarProxy<Stat> &p)
- : node(new ScalarProxyNode<Stat>(p)) { }
+ : node(new ScalarProxyNode<Stat>(p))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(signed char value)
- : node(new ConstNode<signed char>(value)) {}
+ : node(new ConstNode<signed char>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(unsigned char value)
- : node(new ConstNode<unsigned char>(value)) {}
+ : node(new ConstNode<unsigned char>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(signed short value)
- : node(new ConstNode<signed short>(value)) {}
+ : node(new ConstNode<signed short>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(unsigned short value)
- : node(new ConstNode<unsigned short>(value)) {}
+ : node(new ConstNode<unsigned short>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(signed int value)
- : node(new ConstNode<signed int>(value)) {}
+ : node(new ConstNode<signed int>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(unsigned int value)
- : node(new ConstNode<unsigned int>(value)) {}
+ : node(new ConstNode<unsigned int>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(signed long value)
- : node(new ConstNode<signed long>(value)) {}
+ : node(new ConstNode<signed long>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(unsigned long value)
- : node(new ConstNode<unsigned long>(value)) {}
+ : node(new ConstNode<unsigned long>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(signed long long value)
- : node(new ConstNode<signed long long>(value)) {}
+ : node(new ConstNode<signed long long>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(unsigned long long value)
- : node(new ConstNode<unsigned long long>(value)) {}
+ : node(new ConstNode<unsigned long long>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(float value)
- : node(new ConstNode<float>(value)) {}
+ : node(new ConstNode<float>(value))
+ { }
/**
* Create a ConstNode
* @param value The value of the const node.
*/
Temp(double value)
- : node(new ConstNode<double>(value)) {}
+ : node(new ConstNode<double>(value))
+ { }
};
projects / gem5.git / commitdiff