23 #ifndef XRANLIB_COMMON_HPP 24 #define XRANLIB_COMMON_HPP 27 #pragma warning(disable : 191) 28 #pragma warning(disable : 186) 29 #pragma warning(disable : 192) 37 #include <immintrin.h> 43 #include <rte_config.h> 44 #include <rte_malloc.h> 47 #include "gtest/gtest.h" 55 #define ASSERT_ARRAY_NEAR(reference, actual, size, precision) \ 56 assert_array_near(reference, actual, size, precision) 58 #define ASSERT_ARRAY_EQ(reference, actual, size) \ 59 assert_array_eq(reference, actual, size) 61 #define ASSERT_AVG_GREATER_COMPLEX(reference, actual, size, precision) \ 62 assert_avg_greater_complex(reference, actual, size, precision) 73 const char *
what ()
const throw ()
override {
74 return "JSON file cannot be opened!";
80 const char *
what ()
const throw ()
override {
81 return "Input file cannot be read!";
106 std::vector<unsigned>
get_sequence(
const unsigned number);
172 std::cout <<
"[----------] SetUpTestCase failed: " << e.
what() << std::endl;
180 std::cout <<
"[----------] SetUpTestCase failed: TSC recovery failed" << std::endl;
196 return json_data[type].
size();
200 std::cout <<
"[----------] get_number_of_cases failed: " << e.
what() << std::endl;
204 catch(std::domain_error &e)
206 std::cout <<
"[----------] get_number_of_cases failed: " << e.what() << std::endl;
207 std::cout <<
"[----------] Use a default value: 0" << std::endl;
214 double division_factor = 1.0;
215 std::string result_units =
"None";
216 int parallelization_factor = 1;
224 division_factor = factor;
233 result_units = units;
242 parallelization_factor = factor;
252 template <
typename F,
typename ... Args>
258 const auto scaled_mean = result.first / division_factor / tsc;
259 const auto scaled_stddev = result.second / division_factor / tsc;
261 print_and_store_results(isa, get_case_name(), module_name, get_case_name(), result_units,
262 parallelization_factor, scaled_mean, scaled_stddev);
272 print_and_store_results(isa, get_case_name(), module_name, get_case_name(), result_units,
273 parallelization_factor, 0, 0);
289 template <
typename T>
294 return get_parameter<T>(
"parameters", parameter_name);
296 catch (std::domain_error &e)
298 std::cout <<
"[----------] get_input_parameter (" << parameter_name
299 <<
") failed: " << e.what()
300 <<
". Did you mispell the parameter name?" << std::endl;
305 std::cout <<
"[----------] get_input_parameter (" << parameter_name
306 <<
") failed: " << e.
what() << std::endl;
311 template <
typename T>
316 return get_parameter<T>(
"references", parameter_name);
318 catch (std::domain_error &e)
320 std::cout <<
"[----------] get_reference_parameter (" << parameter_name
321 <<
") failed: " << e.what()
322 <<
". Did you mispell the parameter name?" << std::endl;
327 std::cout <<
"[----------] get_reference_parameter (" << parameter_name
328 <<
") failed: " << e.
what() << std::endl;
342 return conf[test_type][GetParam()][
"name"];
344 catch (std::domain_error &e)
346 std::cout <<
"[----------] get_case_name failed: " << e.what()
347 <<
". Did you specify a test name in JSON?" << std::endl;
348 std::cout <<
"[----------] Using a default name instead" << std::endl;
350 return "Default test name";
361 const std::string name = get_case_name();
362 std::cout <<
"[----------] Test case: " << name << std::endl;
366 static unsigned long tsc;
370 static T read_parameter(
const int index,
const std::string &type,
371 const std::string ¶meter_name)
373 return conf[test_type][index][type][parameter_name];
378 struct data_reader<std::vector<T>> {
379 static std::vector<T> read_parameter(
const int index,
const std::string &type,
380 const std::string ¶meter_name)
382 auto array_size = conf[test_type][index][type][parameter_name].
size();
384 std::vector<T> result(array_size);
386 for(
unsigned number = 0; number < array_size; number++)
387 result.at(number) = conf[test_type][index][type][parameter_name][number];
394 struct data_reader<T*> {
395 static T* read_parameter(
const int index,
const std::string &type,
396 const std::string ¶meter_name)
402 template <
typename T>
403 T get_parameter(
const std::string &type,
const std::string ¶meter_name)
405 return data_reader<T>::read_parameter(GetParam(), type, parameter_name);
408 void print_and_store_results(
const std::string &isa,
409 const std::string ¶meters,
411 const std::string &test_name,
412 const std::string &unit,
413 const int para_factor,
415 const double stddev);
424 template <
typename F,
typename ... Args>
430 const auto start_time = __rdtsc();
434 const auto end_time = __rdtsc();
435 results.push_back(end_time - start_time);
447 template <
typename T>
450 for(
int index = 0; index < size ; index++)
452 ASSERT_EQ(reference[index], actual[index])
453 <<
"The wrong number is index: "<< index;
464 template <
typename T>
465 void assert_array_near(
const T* reference,
const T* actual,
const int size,
const double precision)
467 for(
int index = 0; index < size ; index++)
469 ASSERT_NEAR(reference[index], actual[index], precision)
470 <<
"The wrong number is index: "<< index;
477 for(
int index = 0; index < size ; index++)
479 ASSERT_NEAR(reference[index].re, actual[index].re, precision)
480 <<
"The wrong number is RE, index: "<< index;
481 ASSERT_NEAR(reference[index].im, actual[index].im, precision)
482 <<
"The wrong number is IM, index: "<< index;
497 double avgMSEDB = 0.0;
498 for (
int index = 0; index < size; index++) {
499 T refReal = reference[2*index];
500 T refImag = reference[(2*index)+1];
501 T resReal = actual[2*index];
502 T resImag = actual[(2*index)+1];
504 T errReal = resReal - refReal;
505 T errIm = resImag - refImag;
510 if (refReal == 0 && refImag == 0)
511 MSE = (float)(errReal*errReal + errIm*errIm)/(float)(refReal*refReal + refImag*refImag + 1);
513 MSE = (float)(errReal*errReal + errIm*errIm)/(float)(refReal*refReal + refImag*refImag);
516 mseDB = (float)(-100.0);
518 mseDB = (float)(10.0) * (float)log10(MSE);
520 avgMSEDB += (double)mseDB;
525 ASSERT_GT(precision, avgMSEDB);
543 template <
typename T>
547 return (T*) rte_malloc(NULL,
sizeof(T) * size, alignment);
550 return (T*) memalign(alignment,
sizeof(T) * size);
565 template <
typename T>
569 rte_free((
void*)ptr);
575 _aligned_free((
void *)ptr);
592 template <
typename T,
typename U>
595 auto array = (T*) aligned_malloc<char>(size *
sizeof(T), alignment);
597 std::random_device random_device;
598 std::default_random_engine generator(random_device());
600 for(
long i = 0; i < size; i++)
601 array[i] = (T)distribution(generator);
617 template <
typename T>
620 std::uniform_int_distribution<> random(0, 255);
622 return (T*)generate_random_numbers<char, std::uniform_int_distribution<>>(size *
sizeof(T), alignment, random);
639 template <
typename T>
643 std::uniform_int_distribution<T> random(lo_range, up_range);
645 return generate_random_numbers<T, std::uniform_int_distribution<T>>(size, alignment, random);
662 template <
typename T>
666 std::uniform_real_distribution<T> distribution(lo_range, up_range);
668 return generate_random_numbers<T, std::uniform_real_distribution<T>>(size, alignment, distribution);
671 #endif //XRANLIB_COMMON_HPP std::vector< unsigned > get_sequence(const unsigned number)
For a given number return sequence of number from 0 to number - 1.
#define _aligned_malloc(x, y)
void print_test_description(const std::string &isa, const std::string &module_name)
Print unique test description to the results xml file.
unsigned long tsc_tick()
Return the current value of the TSC.
static unsigned get_number_of_cases(const std::string &type)
size_type size() const noexcept
returns the number of elements
T * generate_random_numbers(const long size, const unsigned alignment, U &distribution)
generate random numbers.
basic_json<> json
default JSON class
a class to store JSON values
void performance(const std::string &isa, const std::string &module_name, F function, Args ... args)
Run performance test case for a given function.
void assert_avg_greater_complex(const T *reference, const T *actual, const int size, const double precision)
Assert average diff of two arrays. It calls ASSERT_GT to check the average.
std::pair< double, double > calculate_statistics(const std::vector< long > values)
Calculate the mean and variance from the result of the run_benchmark.
static std::string test_type
void assert_array_near< complex_float >(const complex_float *reference, const complex_float *actual, const int size, const double precision)
void assert_array_eq(const T *reference, const T *actual, const int size)
Assert elements of two arrays. It calls ASSERT_EQ for each element of the array.
void aligned_free(T *ptr)
Frees memory pointed by the given pointer.
std::pair< double, double > run_benchmark(F function, Args ... args)
Run the given function and return the mean run time and stddev.
T * generate_random_data(const long size, const unsigned alignment)
generate random data.
T get_reference_parameter(const std::string ¶meter_name)
void set_results_units(const std::string &units)
Set reults units.
T * generate_random_int_numbers(const long size, const unsigned alignment, const T lo_range, const T up_range)
generate integer random numbers.
const char * what() const override
void init_test(const std::string &type)
Defines section in the conf.json that is used to load parameters from.
unsigned long tsc_recovery()
Measure the TSC on the machine.
This header file defines those data type both used by eNB and UE.
json read_json_from_file(const std::string &filename)
Read JSON from the given file.
T * generate_random_real_numbers(const long size, const unsigned alignment, const T lo_range, const T up_range)
generate real random numbers.
const std::string get_case_name()
Get name of the test case from JSON file.
const std::string module_name
int bind_to_cpu(const unsigned cpu)
Attach current process to the selected core.
T get_input_parameter(const std::string ¶meter_name)
Load selected data from a JSON object. get_input_parameter loads data from parameters section of the ...
static void SetUpTestCase()
void set_parallelization_factor(const int factor)
Set size of processed data.
static void TearDownTestCase()
char * read_data_to_aligned_array(const std::string &filename)
Read binary data from the file.
Defines 64-bit complex structure; both real part and image part have 32 bit width.
void set_division_factor(const double factor)
Set division factor.
void assert_array_near(const T *reference, const T *actual, const int size, const double precision)
Assert elements of two arrays. It calls ASSERT_NEAR for each element of the array.
T * aligned_malloc(const int size, const unsigned alignment)
Allocates memory of the given size.