我需要对用 C++ 编写的库进行性能测试.该库由几组结构组成.我已经对这些类进行了序列化测试，但不确定如何对这些类进行性能测试.下面是库中结构的示例
struct X{上市:内部 p;双 q;X();~X();}结构体{浮动米；双 n;Y();~Y();}结构体{上市:std::map<std::string,boost::shared_ptr<X>>X型；std::map>类型;国际我;字符串名称；Z();~Z();} 如果提供任何示例，那将非常好.
好的，所以我在类型中添加了序列化(你为什么省略它?)
struct X{内部 p;双 q;私人的:朋友 boost::serialization::access;模板 无效序列化(Ar& ar，无符号){和BOOST_SERIALIZATION_NVP(p);和BOOST_SERIALIZATION_NVP(q);}};结构体{浮动米；双 n;私人的:朋友 boost::serialization::access;模板 无效序列化(Ar& ar，无符号){和BOOST_SERIALIZATION_NVP(m);和BOOST_SERIALIZATION_NVP(n);}};结构体{std::map>X型；std::map>类型;国际我;std::string 名称；私人的:朋友 boost::serialization::access;模板 无效序列化(Ar& ar，无符号){和BOOST_SERIALIZATION_NVP(i);和BOOST_SERIALIZATION_NVP(名称)；和BOOST_SERIALIZATION_NVP(Xtype);和BOOST_SERIALIZATION_NVP(Ytype);}}; 现在，使用
<小时>测试fixture其实做的工作比较多，定义如下:
#include //用于测试数据#include #include #include <算法>Z常量&夹具(){静态 Z const z = [] {Z Z;boost::random::mt19937 引擎；auto fgen = boost::bind(boost::random::uniform_real_distribution(), engine);auto dgen = boost::bind(boost::random::uniform_real_distribution(), engine);auto cgen = boost::bind(boost::random::uniform_int_distribution('a', 'z'), engine);auto igen = boost::bind(boost::random::uniform_int_distribution(), engine);auto sgen = [&] (int maxlen) { std::string s;std::generate_n(back_inserter(s), igen() % maxlen, cgen);返回 s;};std::generate_n(inserter(z.Ytype, z.Ytype.end()), 1000, [&] {auto py = boost::make_shared();py->m = fgen();py->n = dgen();返回 std::make_pair(sgen(32), py);});std::generate_n(inserter(z.Xtype, z.Xtype.end()), 3000, [&] {auto px = boost::make_shared();px->p = igen();px->q = dgen();返回 std::make_pair(sgen(32), px);});z.i = igen();z.name = sgen(8);返回 z;}();返回 z;} 在 Coliru
I need to do performance testing of a library written in c++. The library consist of few sets of structures. I have already done the serialization test for these class but not sure how to do perfomance test for these . Below is sample of a struct in library
struct X
{
public:
int p;
double q;
X();
~X();
}
struct Y
{
float m;
double n;
Y();
~Y();
}
struct Z
{
public:
std::map<std::string,boost::shared_ptr<X>> Xtype;
std::map<std::string,boost::shared_ptr<Y>> Ytype;
int i;
string name;
Z();
~Z();
}
If any example is provided then it will be really good.
Okay, so I added serialization to the types (why did you leave it out?)
struct X
{
int p;
double q;
private:
friend boost::serialization::access;
template <typename Ar>
void serialize(Ar& ar, unsigned) {
ar & BOOST_SERIALIZATION_NVP(p);
ar & BOOST_SERIALIZATION_NVP(q);
}
};
struct Y
{
float m;
double n;
private:
friend boost::serialization::access;
template <typename Ar>
void serialize(Ar& ar, unsigned) {
ar & BOOST_SERIALIZATION_NVP(m);
ar & BOOST_SERIALIZATION_NVP(n);
}
};
struct Z
{
std::map<std::string, boost::shared_ptr<X>> Xtype;
std::map<std::string, boost::shared_ptr<Y>> Ytype;
int i;
std::string name;
private:
friend boost::serialization::access;
template <typename Ar>
void serialize(Ar& ar, unsigned) {
ar & BOOST_SERIALIZATION_NVP(i);
ar & BOOST_SERIALIZATION_NVP(name);
ar & BOOST_SERIALIZATION_NVP(Xtype);
ar & BOOST_SERIALIZATION_NVP(Ytype);
}
};
And now, using the Nonius benchmarking mini-framework, write the following benchmarks:
Z const& fixture(); // forward
#include <nonius/main.h++>
#include <sstream>
NONIUS_BENCHMARK("text archive", [](nonius::chronometer meter) {
auto const& z = fixture();
meter.measure([&](int /*i*/) {
std::stringstream ss;
boost::archive::text_oarchive oa(ss);
oa << z;
Z clone;
boost::archive::text_iarchive ia(ss);
ia >> clone;
return ss.str().size(); // something observable to thwart the overly smart optimizer
});
})
NONIUS_BENCHMARK("binary archive", [](nonius::chronometer meter) {
auto const& z = fixture();
meter.measure([&](int /*i*/) {
std::stringstream ss;
boost::archive::binary_oarchive oa(ss);
oa << z;
Z clone;
boost::archive::binary_iarchive ia(ss);
ia >> clone;
return ss.str().size(); // something observable to thwart the overly smart optimizer
});
})
NONIUS_BENCHMARK("xml archive", [](nonius::chronometer meter) {
auto const& z = fixture();
meter.measure([&](int /*i*/) {
std::stringstream ss;
boost::archive::xml_oarchive oa(ss);
oa << boost::serialization::make_nvp("root", z);
Z clone;
boost::archive::xml_iarchive ia(ss);
ia >> boost::serialization::make_nvp("root", clone);
return ss.str().size(); // something observable to thwart the overly smart optimizer
});
})
The raw output is (for a fixture of 1000 random X and 3000 random Y values):
text archive
mean: 236.069 μs
std dev: 2.54923 μs
variance is unaffected by outliers
binary archive
mean: 92.9736 μs
std dev: 3.35504 μs
variance is moderately inflated by outliers
xml archive
mean: 786.746 μs
std dev: 4.676 μs
variance is unaffected by outliers
Interactive plot: click here
The test fixture is actually a lot more work, and is defined as follows:
#include <boost/random.hpp> // for test data
#include <boost/bind.hpp>
#include <boost/make_shared.hpp>
#include <algorithm>
Z const& fixture()
{
static Z const z = [] {
Z z;
boost::random::mt19937 engine;
auto fgen = boost::bind(boost::random::uniform_real_distribution<float>(), engine);
auto dgen = boost::bind(boost::random::uniform_real_distribution<double>(), engine);
auto cgen = boost::bind(boost::random::uniform_int_distribution<char>('a', 'z'), engine);
auto igen = boost::bind(boost::random::uniform_int_distribution<int>(), engine);
auto sgen = [&] (int maxlen) { std::string s; std::generate_n(back_inserter(s), igen() % maxlen, cgen); return s; };
std::generate_n(inserter(z.Ytype, z.Ytype.end()), 1000, [&] {
auto py = boost::make_shared<Y>();
py->m = fgen();
py->n = dgen();
return std::make_pair(sgen(32), py);
});
std::generate_n(inserter(z.Xtype, z.Xtype.end()), 3000, [&] {
auto px = boost::make_shared<X>();
px->p = igen();
px->q = dgen();
return std::make_pair(sgen(32), px);
});
z.i = igen();
z.name = sgen(8);
return z;
}();
return z;
}
On Coliru
这篇关于如何使用自定义库的 boost 库进行性能测试的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！