156 lines
3.9 KiB
C++
156 lines
3.9 KiB
C++
//#define DEBUG 1
|
|
//#define DEBUG0_1 1
|
|
//#define DEBUG3 1
|
|
#include "headers.h"
|
|
#include "template.h"
|
|
#include "utils.h"
|
|
|
|
#include "define-float.h"
|
|
#include "avx_function_prototypes.h"
|
|
|
|
#include "define-double.h"
|
|
#include "avx_function_prototypes.h"
|
|
|
|
using namespace std;
|
|
class LoadTimeInitializer
|
|
{
|
|
public:
|
|
LoadTimeInitializer() //will be called when library is loaded
|
|
{
|
|
ConvertChar::init();
|
|
}
|
|
};
|
|
LoadTimeInitializer g_load_time_initializer;
|
|
|
|
#define BATCH_SIZE 10000
|
|
#define RUN_HYBRID
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
if(argc < 2)
|
|
{
|
|
cerr << "Needs path to input file as argument\n";
|
|
exit(0);
|
|
}
|
|
bool use_old_read_testcase = false;
|
|
if(argc >= 3 && string(argv[2]) == "1")
|
|
use_old_read_testcase = true;
|
|
|
|
if(true)
|
|
{
|
|
g_compute_full_prob_double = GEN_INTRINSIC(compute_full_prob_avx, d)<double>;
|
|
g_compute_full_prob_float = GEN_INTRINSIC(compute_full_prob_avx, s)<float>;
|
|
}
|
|
else
|
|
{
|
|
g_compute_full_prob_double = compute_full_prob<double>;
|
|
g_compute_full_prob_float = compute_full_prob<float>;
|
|
}
|
|
|
|
std::ifstream ifptr;
|
|
FILE* fptr = 0;
|
|
if(use_old_read_testcase)
|
|
{
|
|
fptr = fopen(argv[1],"r");
|
|
assert(fptr);
|
|
}
|
|
else
|
|
{
|
|
ifptr.open(argv[1]);
|
|
assert(ifptr.is_open());
|
|
}
|
|
|
|
testcase tc;
|
|
while(1)
|
|
{
|
|
int break_value = use_old_read_testcase ? read_testcase(&tc, fptr) : read_mod_testcase(ifptr,&tc,true);
|
|
if(break_value < 0)
|
|
break;
|
|
float result_avxf = g_compute_full_prob_float(&tc, 0);
|
|
double result = 0;
|
|
if (result_avxf < MIN_ACCEPTED) {
|
|
double result_avxd = g_compute_full_prob_double(&tc, 0);
|
|
result = log10(result_avxd) - log10(ldexp(1.0, 1020.0));
|
|
}
|
|
else
|
|
result = (double)(log10f(result_avxf) - log10f(ldexpf(1.f, 120.f)));
|
|
|
|
double baseline_result = compute_full_prob<double>(&tc);
|
|
baseline_result = log10(baseline_result) - log10(ldexp(1.0, 1020.0));
|
|
cout << std::scientific << baseline_result << " "<<result<<"\n";
|
|
delete tc.rs;
|
|
delete tc.hap;
|
|
}
|
|
if(use_old_read_testcase)
|
|
fclose(fptr);
|
|
else
|
|
ifptr.close();
|
|
return 0;
|
|
|
|
#if 0
|
|
float result[BATCH_SIZE], result_avxf;
|
|
double result_avxd;
|
|
struct timeval start, end;
|
|
long long aggregateTimeRead = 0L;
|
|
long long aggregateTimeCompute = 0L;
|
|
long long aggregateTimeWrite = 0L;
|
|
|
|
bool noMoreData = false;
|
|
int count =0;
|
|
while (!noMoreData)
|
|
{
|
|
int read_count = BATCH_SIZE;
|
|
gettimeofday(&start, NULL);
|
|
for (int b=0;b<BATCH_SIZE;b++)
|
|
if (read_testcase(&tc[b], NULL)==-1)
|
|
{
|
|
read_count = b;
|
|
noMoreData = true;
|
|
break;
|
|
}
|
|
gettimeofday(&end, NULL);
|
|
aggregateTimeRead += ((end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec));
|
|
|
|
gettimeofday(&start, NULL);
|
|
for (int b=0;b<read_count;b++)
|
|
{
|
|
result_avxf = compute_full_prob<float>(&tc[b]);
|
|
|
|
#ifdef RUN_HYBRID
|
|
#define MIN_ACCEPTED 1e-28f
|
|
if (result_avxf < MIN_ACCEPTED) {
|
|
count++;
|
|
result_avxd = compute_full_prob<double>(&tc[b]);
|
|
result[b] = log10(result_avxd) - log10(ldexp(1.0, 1020.f));
|
|
}
|
|
else
|
|
result[b] = log10f(result_avxf) - log10f(ldexpf(1.f, 120.f));
|
|
#endif
|
|
|
|
#ifndef RUN_HYBRID
|
|
result[b] = log10f(result_avxf) - log10f(ldexpf(1.f, 120.f));
|
|
#endif
|
|
|
|
}
|
|
gettimeofday(&end, NULL);
|
|
aggregateTimeCompute += ((end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec));
|
|
|
|
gettimeofday(&start, NULL);
|
|
for (int b=0;b<read_count;b++)
|
|
printf("%E\n", result[b]);
|
|
gettimeofday(&end, NULL);
|
|
aggregateTimeWrite += ((end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec));
|
|
|
|
}
|
|
|
|
printf("AVX Read Time: %ld\n", aggregateTimeRead);
|
|
printf("AVX Compute Time: %ld\n", aggregateTimeCompute);
|
|
printf("AVX Write Time: %ld\n", aggregateTimeWrite);
|
|
printf("AVX Total Time: %ld\n", aggregateTimeRead + aggregateTimeCompute + aggregateTimeWrite);
|
|
printf("# Double called: %d\n", count);
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
|