The Big Programming Thread - Page 545

#include<iostream>
#include<functional>
#include<memory>
#include<vector>
#include<type_traits>
#include<seq/sequence.hpp>
#include<abstract/abstract.hpp>
#include<abstract/deconstruct.hpp>
#include<../cppcon14/variant.h>
#include<../core/include/core/variant.hpp>
#include<boost/variant.hpp>
#include<seq/seq.hpp>
#define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 5
#include<boost/variant/multivisitors.hpp>
#include<time.h>
#include<random>
#include<pthread.h>

long operator-(const timespec& end,const timespec& start)
{
	if ((end.tv_nsec-start.tv_nsec)<0) {
		return 1000000000+end.tv_nsec-start.tv_nsec;
	} else {
		return end.tv_nsec-start.tv_nsec;
	}
}


const int N=100000;
const int M=2;

std::random_device rd;
std::default_random_engine e1(rd());
std::uniform_int_distribution<int> dist(0,M-1);

template<int i> struct type{};

template<template<class...> class,class> struct variant_maker;

template<template<class...> class variant,int... index> 
struct variant_maker<variant,seq::integer_sequence<index...>>{ using output=variant<type<index>...>; };

template<template<class...> class variant>
using make_variant=typename variant_maker<variant,seq::integer_range<0,M>>::output;

using abstract_t=make_variant<jeh::abstract>;
using jason_variant_t=make_variant<cppcon14::variant::variant_t>;
using core_variant_t=make_variant<core::variant>;
using boost_variant_t=make_variant<boost::variant>;

struct unary_t:boost::static_visitor<void>{
	using fn1_t=void();
	template<class T>
	void operator()(const T&){}	
};
unary_t unary;
struct binary_t:boost::static_visitor<void>{
	using fn2_t=void();
	template<class T,class U>
	void operator()(const T&,const U&){}
};
binary_t binary;
struct tetriary_t:boost::static_visitor<void>{
	template<class... T>
	void operator()(const T&...){}
};
tetriary_t tetriary;

timespec t0,t1;

template<class variant,int i>
variant random_maker(){ return variant((type<i>())); }

template<class variant>
using random_makers_t=std::array<variant(*)(),M>;

template<class variant,int... I>
constexpr random_makers_t<variant> random_makers(const seq::integer_sequence<I...>&){
	return {random_maker<variant,I>...}; 
}

template<class variant>
variant make_random(){
	static constexpr auto make_randoms
		=random_makers<variant>(seq::integer_range<0,M>());
	return make_randoms[dist(e1)](); 
}

template<class predicate,class variant>
using dispatch_enabler=std::enable_if_t<std::is_same<variant,predicate>::value,long>;

template<class variant>
dispatch_enabler<jason_variant_t,variant>
	timed_unary_dispatch()
{
	auto var=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	cppcon14::variant::apply(unary,var);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
dispatch_enabler<variant,abstract_t>
	timed_unary_dispatch()
{
	auto var=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	jeh::deconstruct<void>(unary,var);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
dispatch_enabler<variant,core_variant_t>
	timed_unary_dispatch()
{
	auto var=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	var.visit(unary);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
dispatch_enabler<variant,boost_variant_t>
	timed_unary_dispatch()
{
	auto var=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	boost::apply_visitor(unary,var);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
long unary_test(){
	std::vector<long> times;
	for(int i=0;i<N;++i){
		times.push_back(timed_unary_dispatch<variant>());
	}
	return std::accumulate(std::begin(times),std::end(times),0)/times.size(); 
}

template<class variant>
dispatch_enabler<variant,boost_variant_t>
	timed_binary_dispatch()
{
	auto var0=make_random<variant>();
	auto var1=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	boost::apply_visitor(binary,var0,var1);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}


template<class variant>
dispatch_enabler<variant,jason_variant_t>
	timed_binary_dispatch()
{
	auto var0=make_random<variant>();
	auto var1=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	cppcon14::variant::apply(binary,var0,var1);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}


template<class variant>
dispatch_enabler<variant,abstract_t>
	timed_binary_dispatch()
{
	auto var0=make_random<variant>();
	auto var1=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	jeh::deconstruct<void>(binary,var0,var1);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
long binary_test(){
	std::vector<long> times;
	for(int i=0;i<N;++i){
		times.push_back(timed_binary_dispatch<variant>());
	}
	return std::accumulate(std::begin(times),std::end(times),0)/times.size(); 
}

template<class variant>
dispatch_enabler<variant,abstract_t>
	timed_tetriary_dispatch()
{
	auto var0=make_random<variant>();
	auto var1=make_random<variant>();
	auto var2=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	jeh::deconstruct<void>(tetriary,var0,var1,var2);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}
template<class variant>
dispatch_enabler<variant,boost_variant_t>
	timed_tetriary_dispatch()
{
	auto var0=make_random<variant>();
	auto var1=make_random<variant>();
	auto var2=make_random<variant>();
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t0);
	boost::apply_visitor(tetriary,var0,var1,var2);
	clock_gettime(CLOCK_THREAD_CPUTIME_ID,&t1);
	return(t1-t0);
}

template<class variant>
long tetriary_test(){
	std::vector<long> times;
	for(int i=0;i<N;++i){
		times.push_back(timed_tetriary_dispatch<variant>());
	}
	return std::accumulate(std::begin(times),std::end(times),0)/times.size(); 
}


int main(){

	std::cout<<"\n---------- unary visit    ----------\n\n";
	std::cout<<"  jason: "<<unary_test<jason_variant_t>()<<std::endl;
	std::cout<<"  core:  "<<unary_test<core_variant_t>()<<std::endl;
	std::cout<<"  jeh:   "<<unary_test<abstract_t>()<<std::endl;
	std::cout<<"  boost: "<<unary_test<boost_variant_t>()<<std::endl;
	std::cout<<"\n------------------------------------\n\n";
	

	std::cout<<"---------- binary visit   ----------\n\n";
	std::cout<<"  jason: "<<binary_test<jason_variant_t>()<<std::endl;
	std::cout<<"  boost: "<<binary_test<boost_variant_t>()<<std::endl;
	std::cout<<"  jeh:   "<<binary_test<abstract_t>()<<std::endl;
	std::cout<<"\n------------------------------------\n\n";

	std::cout<<"---------- tetriary visit   ----------\n\n";
	std::cout<<"  boost: "<<tetriary_test<boost_variant_t>()<<std::endl;
	std::cout<<"  jeh:   "<<tetriary_test<abstract_t>()<<std::endl;
	std::cout<<"\n------------------------------------\n\n";

}