小编Eit*_*tan的帖子

我试图想出一个启发式来估计一个进程或一个线程在两个时间点之间消耗了多少能量(例如,在焦耳中).这是在PC(Linux/x86)上,而不是移动设备,因此统计数据将用于比较采用类似挂钟时间的计算的相对能效.

这个想法是收集或采样硬件统计数据,如周期计数器,p/c状态或动态频率,总线访问等,并提出一个合理的测量间能量使用公式.我问的是这是否可能,以及这个公式可能是什么样子.

想到的一些挑战:1)正确地考虑到其他进程(或线程)的上下文切换.

2)正确计算CPU外部使用的能量.如果我们假设I/O可以忽略不计,这意味着主要是RAM.分配数量和/或访问模式如何影响能源使用？(也就是说,假设我有办法测量动态内存分配,例如,使用修改后的分配器.)

3)使用CPU时间作为估计仅限于粗粒度和错误计算,仅限 CPU能量使用,并假设固定时钟频率.它包括但不能很好地考虑等待RAM的时间.

这是一个场景:我想拥有一个可以拥有可变数量的mixins的宿主类(对于可变参数模板来说并不太难 - 请参阅http://citeseerx.ist.psu.edu/viewdoc/summary?doi = 10.1.1.103.144).但是,我也喜欢使用主机类参数化mixins,以便它们可以引用其公共类型(使用CRTP惯用法).当试图混合两者时出现问题 - 我不清楚正确的语法.例如,以下代码无法使用g ++ 4.4.1进行编译:

template <template<class> class... Mixins>
class Host : public Mixins<Host<Mixins>>... {
  public:
    template <class... Args>
    Host(Args&&... args) : Mixins<Host>(std::forward<Args>(args))... {}
};

template <class Host> struct Mix1 {};

template <class Host> struct Mix2 {};

typedef Host<Mix1, Mix2> TopHost;
TopHost *th = new TopHost(Mix1<TopHost>(), Mix2<TopHost>());

有错误:

tst.cpp: In constructor ‘Host<Mixins>::Host(Args&& ...) [with Args = Mix1<Host<Mix1, Mix2> >, Mix2<Host<Mix1, Mix2> >, Mixins = Mix1, Mix2]’:

tst.cpp:33:   instantiated from here

tst.cpp:18: error: type ‘Mix1<Host<Mix1, …

我正在尝试编写一个基于策略的宿主类(即一个继承自其模板类的类),其中一个扭曲,其中策略类也由宿主类进行模板化,以便它可以访问其类型.这可能有用的一个例子是策略(实际上像mixin一样使用),使用多态clone()方法扩充宿主类.这是我正在尝试做的最小例子:

template <template <class> class P>
struct Host : public P<Host<P> > {
  typedef P<Host<P> > Base;
  typedef Host* HostPtr;
  Host(const Base& p) : Base(p) {}
};

template <class H>
struct Policy {
  typedef typename H::HostPtr Hptr;
  Hptr clone() const {
    return Hptr(new H((Hptr)this));
  }
};

Policy<Host<Policy> > p;
Host<Policy> h(p);

int main() {
  return 0;
}

遗憾的是,这不能编译,在我看来像循环类型依赖:

try.cpp: In instantiation of ‘Host<Policy>’:
try.cpp:10:   instantiated from ‘Policy<Host<Policy> >’
try.cpp:16:   instantiated from here
try.cpp:2: error: invalid use of incomplete type ‘struct …

我正在为类模板寻找一个抽象工厂,其中类在静态初始化时自动注册.对于常规(非模板化)类,使用静态成员的解决方案非常简单.以下是一个(相当简单)解决方案的示例,它可以正常工作:

#include <cassert>
#include <iostream>

class Base {
 public:
  virtual size_t id() const = 0;
  virtual const char* name() const = 0;
  virtual ~Base() {}
};

typedef Base* (*CreateFunc)(void);

class SimpleFactory {
 private:
  static const size_t NELEM = 2;
  static size_t id_;
  static CreateFunc creators_[NELEM];

 public:
  static size_t registerFunc(CreateFunc creator) {
    assert(id_ < NELEM);
    assert(creator);
    creators_[id_] = creator;
    return id_++;
  }

  static Base* create(size_t id) { assert(id < NELEM); return (creators_[id])(); }
};

size_t SimpleFactory::id_ = 0;
CreateFunc SimpleFactory::creators_[NELEM];


class …

我希望能够定义一个接口的函数,但可以使用提供相同功能的委托或函数来实现.例如,在C++中,我可以编写如下内容:

typedef std::function<int (float)> toInt;

void fun(toInt dg) { ... }

struct impl1 {
    int operator()(float x) { ... }
};

int impl2(float x) { ... }

然后使用任一实现调用它:

fun(impl1());
fun(&impl2);

(这个float-> int转换只是一个简单的例子来说明原理,而不是我的实际功能).

我想在D中实现类似的东西.我天真的尝试是这样的:

interface toInt {
    int opCall(float);
}

void fun(toInt dg) { ... }

int impl2(float x) { ... }

fun(impl2);

编译器在最后一行抱怨它不能隐式地将impl2转换为toInt类型.我可能只是添加一个重载的实现的乐趣并使转换显式,但我想知道是否有更优雅和一般的方式这样做,如上面的C++示例.

我有一个无状态的抽象基类,各种具体的类从中继承.其中一些派生类也是无状态的.因为它们中的许多都是在运行期间创建的,所以我希望通过重写operator new()/ delete()来让所有无状态派生类模拟单例来节省内存和开销.一个简化的例子看起来像这样:

#include <memory>

struct Base {
  virtual ~Base() {}
 protected:
  Base() {}   // prevent concrete Base objects
};

struct D1 : public Base {  // stateful object--default behavior
  int dummy;
};

struct D2 : public Base {  // stateless object--don't allocate memory
  void* operator new(size_t size)
  {
    static D2 d2;
    return &d2;
  }
  void operator delete(void *p) {}
};

int main() {
  Base* p1 = new D1();
  Base* p2 = new D1();
  Base* s1 = new D2();
  Base* …

我最近解决了构造函数问题，其中相互装饰的各种mixins类（和最顶层的宿主类）具有不同的构造函数签名。为了在产生的修饰类中维护单个构造函数，并且不添加init函数，我找到了以下解决方案。它对mixin类的唯一限制是，如果其构造函数使用多个参数，则应将它们全部封装在一个元组中。（使用g ++编译此代码需要-std = c ++ 0x标志）

#include <boost/tuple/tuple.hpp>

// Base class for all mixins
struct Host {
    float f_;
    int i_;

    Host(float f, int i) : f_(f), i_(i) {}
};

// First mixin--constructs with 1 parameter
template <class B>
struct M1 : public B {
    char c_;

    template <class... A>
    M1(char c, const A&... a) : B(a...), c_(c) {}
};

// Second mixin--constructs with 3 parameters
template <class B>
struct M2 : public B {
    double d_;
    short …