VD_DEFINE_TEST_WITH_PARAM(ParallelDelegateSpeedTest, RunN) { RunN(GetParam()); RecordProperty("Iterations", GetIterationCount()); RecordProperty("ConnectTime", GetConnectTime()); RecordProperty("InvokeTime", GetInvokeTime()); RecordProperty("DisconnectTime", GetDisconnectTime()); }
TEST_P(Grid3DPerformanceTests, Grid3DTest) { double concentrationPerCell; size_t numElementsPerDimension; std::tie(concentrationPerCell, numElementsPerDimension) = GetParam(); size_t numElements = numElementsPerDimension * numElementsPerDimension * numElementsPerDimension; RecordProperty("ElementsPerCell", boost::to_string(concentrationPerCell)); RecordProperty("NumberOfElements", boost::to_string(numElements)); RecordProperty("Duration", boost::to_string(performTimingTest(concentrationPerCell, numElementsPerDimension))); }
virtual void SetUp() { generate_random_uri(source_root, "copyfile_timeout_source", source, 2048); generate_random_uri(destination_root, "copyfile_timeout", destination, 2048); RecordProperty("Source", source); RecordProperty("Destination", source); GError* error = NULL; int ret = generate_file_if_not_exists(handle, source, "file:///etc/hosts", &error); EXPECT_PRED_FORMAT2(AssertGfalSuccess, ret, error); }
virtual void SetUp() { mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); ASSERT_NE(EGL_NO_DISPLAY, mEglDisplay); ASSERT_EQ(EGL_SUCCESS, eglGetError()); EGLint majorVersion; EGLint minorVersion; EXPECT_TRUE(eglInitialize(mEglDisplay, &majorVersion, &minorVersion)); ASSERT_EQ(EGL_SUCCESS, eglGetError()); RecordProperty("EglVersionMajor", majorVersion); RecordProperty("EglVersionMajor", minorVersion); }
TEST(ComediTest,AnalogReadings ) { lsampl_t data; int ret; int subdev = 0; int chan = 0; int range = 0; int aref = AREF_GROUND; int num_scans = options.n_scan; int num_channels = options.n_chan; int readscans; std::string prop("/sys/class/comedi/comedi0/read_buffer_pos"); dev = comedi_open(options.filename); ASSERT_TRUE( dev ); subdev_flags = comedi_get_subdevice_flags(dev, options.subdevice); RecordProperty("NumScans", num_scans); #if 0 fprintf(stderr, "command before testing:\n"); dump_cmd(stderr, cmd); #endif prepare_cmd_lib(dev, options.subdevice, num_scans, num_channels, 1e9 / options.freq, cmd); #if 0 fprintf(stderr, "command before testing:\n"); dump_cmd(stderr, cmd); #endif /** * Setup the Command structure */ cmd->chanlist_len = 2; cmd->stop_arg = num_scans; /* verify no problems */ ret = comedi_command_test(dev, cmd); ASSERT_GE( ret, 0 ) << "Comedi Testing of command for device was ok"; /* make sure our scan number hasn't changed */ ASSERT_EQ( cmd->stop_arg , num_scans ); ASSERT_EQ( cmd->chanlist_len , 2 ); ret = comedi_command(dev, cmd); sleep(1); ASSERT_GE( ret, 0 ) << "Able to Submit comedi command\n"; /* Verify that the buffer position has in fact moved to say num_scans scans remain in it */ FILE *fp = fopen(prop.c_str(),"r"); ASSERT_TRUE( fp ) << "Able to open sysfs property file"; fscanf(fp,"%d",&readscans ); ASSERT_EQ( readscans, 4*num_scans ) << "Able to read the fifo position 4*" << num_scans << "\n"; fclose(fp); comedi_close( dev ); }
TEST_F(KTestPlayerLGStateConver, TestLGPremitToOffLine_3) { BOOL bResult = false; int nRetCode = false; RecordProperty("²âÊÔrsLG_WaitForPermitµ½rsOffline״̬ת»»", "Íæ¼Ò״̬Ϊ rsLG_WaitForPermit"); nRetCode = MakeRoleToPermitState(m_TestRoleInfo, m_dwMapIDInGC, m_nCreatedMapCopyID); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsLG_WaitForPermit); ASSERT_TRUE(nRetCode); nRetCode = m_pGameServer->DoPlayerLoginRespond(m_TestRoleInfo.dwPlayerID, FALSE); ASSERT_TRUE(nRetCode); nRetCode = GATEWAY->CheckReplyLoginData(m_TestRoleInfo.dwPlayerID, eGameLoginUnknownError); ASSERT_TRUE(nRetCode); nRetCode = GATEWAY->CheckPlayerLeaveGame(m_TestRoleInfo.szAccount); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsOffline); ASSERT_TRUE(nRetCode); }
TEST_F(TestNameProfile,LIMIT_Number) { NameProfile nameprofile; int expectedlimit_max = 22; int expectedlimit_min = 1; EXPECT_EQ(expectedlimit_max,NameProfile::limit_maxNumber); EXPECT_EQ(expectedlimit_min,NameProfile::limit_minNumber); RecordProperty("expectedlimit_max",NameProfile::limit_maxNumber); RecordProperty("expectedlimit_min",NameProfile::limit_minNumber); int lastnamenum = 15; NameProfile nameprofile2(lastnamenum); EXPECT_EQ(expectedlimit_max,NameProfile::limit_maxNumber); EXPECT_EQ(expectedlimit_max,NameProfile::limit_maxNumber); }
TEST(CheckConfig, audioEffectsConfigurationValidation) { RecordProperty("description", "Verify that the effects configuration file is valid according to the schema"); const char* xmlConfigFile = "/vendor/etc/audio_effects.xml"; // Not every device uses XML configuration, so only validate // if the XML configuration actually exists. if (access(xmlConfigFile, F_OK) == 0) { ASSERT_VALID_XML(xmlConfigFile, "/data/local/tmp/audio_effects_conf_V2_0.xsd"); } }
void timeMatrixAssembly(std::shared_ptr<DivisibleCubeRepresentation> fem) { SurgSim::Framework::Timer totalTime; totalTime.beginFrame(); for (int i = 0; i < frameCount; i++) { fem->getOdeSolver()->computeMatrices(dt, *(fem->getInitialState()), false); } totalTime.endFrame(); RecordProperty("Duration", boost::to_string(totalTime.getCumulativeTime())); }
void timeInitializeRepresentation(std::shared_ptr<DivisibleCubeRepresentation> fem) { SurgSim::Framework::Timer totalTime; totalTime.beginFrame(); for (int i = 0; i < frameCount; i++) { fem->initializeNoWakeUp(); } totalTime.endFrame(); RecordProperty("Duration", boost::to_string(totalTime.getCumulativeTime())); }
TEST_P(ComponentIntegrationSchemeAndCountParamTest, TimeMatrixInitialization) { int numCubes; SurgSim::Math::IntegrationScheme integrationScheme; SurgSim::Math::LinearSolver linearSolver; std::tie(integrationScheme, linearSolver, numCubes) = GetParam(); RecordProperty("IntegrationScheme", IntegrationSchemeNames[integrationScheme]); RecordProperty("LinearSolver", LinearSolverNames[linearSolver]); RecordProperty("CubeDivisions", boost::to_string(numCubes)); auto fem = std::make_shared<DivisibleCubeRepresentation>("cube", numCubes); // We need to add some boundary conditions for the static solver to not run into a singular matrix std::const_pointer_cast<SurgSim::Math::OdeState>(fem->getInitialState())->addBoundaryCondition(0); std::const_pointer_cast<SurgSim::Math::OdeState>(fem->getInitialState())->addBoundaryCondition(1); std::const_pointer_cast<SurgSim::Math::OdeState>(fem->getInitialState())->addBoundaryCondition(2); fem->setIntegrationScheme(integrationScheme); fem->setLinearSolver(linearSolver); timeInitializeRepresentation(fem); }
void run() { unsigned mem_operations_num = 10; size_t threads_number = 50; bool touch_memory = true; size_t size_1MB = 1024*1024; size_t alignment = 2*size_1MB; size_t alloc_size = 4*size_1MB; std::vector<Thread*> threads; std::vector<Task*> tasks; TimerSysTime timer; timer.start(); // This bug occurs more frequently under stress of multithreaded allocations. for (int i=0; i<threads_number; i++) { Task* task = new HugePageUnmap(mem_operations_num, touch_memory, alignment, alloc_size, HBW_PAGESIZE_2MB); tasks.push_back(task); threads.push_back(new Thread(task)); } float elapsed_time = timer.getElapsedTime(); ThreadsManager threads_manager(threads); threads_manager.start(); threads_manager.barrier(); threads_manager.release(); //task release for (int i=0; i<tasks.size(); i++) { delete tasks[i]; } RecordProperty("threads_number", threads_number); RecordProperty("memory_operations_per_thread", mem_operations_num); RecordProperty("elapsed_time", elapsed_time); }
void post_test(AllocatorFactory::initialization_stat &stat) { //Calculate (%) distance to the reference time for function calls. stat.ref_delta_time = allocator_factory.calc_ref_delta(ref_time, stat.total_time); std::stringstream elapsed_time; elapsed_time << stat.total_time; std::stringstream ref_delta_time; ref_delta_time << std::fixed << stat.ref_delta_time << std::endl; RecordProperty("elapsed_time", elapsed_time.str()); RecordProperty("ref_delta_time_percent_rate", ref_delta_time.str()); for (int i=0; i<stat.memory_overhead.size(); i++) { std::stringstream node; node << "memory_overhad_node_" << i; std::stringstream memory_overhead; memory_overhead << stat.memory_overhead[i]; RecordProperty(node.str(), memory_overhead.str()); } }
TEST(ObjectTests, StringObject) { String value = "abcdefghijklmnopqrstuvwxyz1234567890"; RecordProperty("value", value); ObjectPtr object = createObject(value); ASSERT_EQ(Object::STRING, object->getNativeType()); ASSERT_FALSE(object->isNil()); ASSERT_TRUE(object->getBoolean()); ASSERT_THROW(object->getNumber(), ObjectConversionException); ASSERT_EQ(value, object->getString()); ASSERT_THROW(object->getUserdata(), ObjectConversionException); ASSERT_EQ(FORMAT("\"%s\"", value.c_str()), object->getReadableString()); }
/** * Test if position PID loop works */ TEST_P(MotorEncoderTest, PositionPIDController) { Reset(); m_encoder->SetPIDSourceType(PIDSourceType::kDisplacement); PIDController pid(0.001f, 0.0005f, 0.0f, m_encoder, m_speedController); pid.SetAbsoluteTolerance(20.0f); pid.SetOutputRange(-0.3f, 0.3f); pid.SetSetpoint(2500); /* 10 seconds should be plenty time to get to the setpoint */ pid.Enable(); Wait(10.0); pid.Disable(); RecordProperty("PIDError", pid.GetError()); EXPECT_TRUE(pid.OnTarget()) << "PID loop did not converge within 10 seconds."; }
/** * Test if velocity PID loop works */ TEST_P(MotorEncoderTest, VelocityPIDController) { Reset(); m_encoder->SetPIDSourceType(PIDSourceType::kRate); PIDController pid(1e-5, 0.0f, 3e-5, 8e-5, m_encoder, m_speedController); pid.SetAbsoluteTolerance(50.0f); pid.SetToleranceBuffer(10); pid.SetOutputRange(-0.3f, 0.3f); pid.SetSetpoint(2000); /* 10 seconds should be plenty time to get to the setpoint */ pid.Enable(); Wait(10.0); RecordProperty("PIDError", pid.GetAvgError()); EXPECT_TRUE(pid.OnTarget()) << "PID loop did not converge within 10 seconds. Goal was: " << 2000 << " Error was: " << pid.GetError(); pid.Disable(); }
TEST(ObjectTests, NumberObject) { Number low = -1000; Number high = 1000; Number value = low + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (high - low))); std::stringstream ss; ss << value; RecordProperty("value", ss.str()); ObjectPtr object = createObject(value); ASSERT_EQ(Object::NUMBER, object->getNativeType()); ASSERT_FALSE(object->isNil()); ASSERT_EQ(value == 0 ? false : true, object->getBoolean()); ASSERT_EQ(value, object->getNumber()); ASSERT_EQ(FORMAT("%f", value), object->getString()); ASSERT_THROW(object->getUserdata(), ObjectConversionException); ASSERT_EQ(FORMAT("%f", value), object->getReadableString()); }
TEST_F(KTestPlayerLGStateConver, TestLGLoginToOffLine_2) { BOOL bResult = false; int nRetCode = false; RecordProperty("²âÊÔrsLG_WaitForPermitµ½rsOffline״̬ת»»", "Íæ¼Ò״̬Ϊ rsLG_WaitForLogin"); nRetCode = MakeRoleToLoginState(m_TestRoleInfo, m_dwMapIDInGC, m_nCreatedMapCopyID); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsLG_WaitForLogin); ASSERT_TRUE(nRetCode); m_pGameServer->CloseConnect(); nRetCode = GATEWAY->CheckPlayerLeaveGame(m_TestRoleInfo.szAccount); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsOffline); ASSERT_TRUE(nRetCode); }
TEST_F(KTestPlayerLGStateConver, TestLGLoginToOnLine) { BOOL bResult = false; int nRetCode = false; RecordProperty("²âÊÔrsLG_WaitForPermitµ½rsOnline״̬ת»»", "Íæ¼Ò״̬Ϊ rsOnline"); nRetCode = MakeRoleToLoginState(m_TestRoleInfo, m_dwMapIDInGC, m_nCreatedMapCopyID); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsLG_WaitForLogin); ASSERT_TRUE(nRetCode); nRetCode = m_pGameServer->DoConfirmPlayerLoginRequest(m_TestRoleInfo.dwPlayerID); ASSERT_TRUE(nRetCode); nRetCode = m_pGameServer->CheckConfirmPlayerLoginRespond(m_TestRoleInfo.dwPlayerID, TRUE); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsOnline); ASSERT_TRUE(nRetCode); }
TEST_F(KTestPlayerLGStateConver, TestLGPremitToLGLogin) { BOOL bResult = false; int nRetCode = false; RecordProperty("²âÊÔrsLG_WaitForPermitµ½rsLG_WaitForLogin״̬ת»»", "Íæ¼Ò״̬Ϊ rsLG_WaitForLogin"); nRetCode = MakeRoleToPermitState(m_TestRoleInfo, m_dwMapIDInGC, m_nCreatedMapCopyID); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsLG_WaitForPermit); ASSERT_TRUE(nRetCode); nRetCode = m_pGameServer->DoPlayerLoginRespond(m_TestRoleInfo.dwPlayerID, TRUE); ASSERT_TRUE(nRetCode); nRetCode = GATEWAY->CheckReplyLoginData(m_TestRoleInfo.dwPlayerID, eGameLoginSucceed); ASSERT_TRUE(nRetCode); nRetCode = ComparePlayerState(m_TestRoleInfo.dwPlayerID, rsLG_WaitForLogin); ASSERT_TRUE(nRetCode); }
void timeInvertSystem(std::shared_ptr<DivisibleCubeRepresentation> fem) { fem->getOdeSolver()->computeMatrices(dt, *(fem->getInitialState()), false); fem->getOdeSolver()->getLinearSolver()->setMatrix(fem->getOdeSolver()->getSystemMatrix()); std::shared_ptr<SurgSim::Math::LinearSparseSolveAndInverseCG> solver = std::dynamic_pointer_cast<SurgSim::Math::LinearSparseSolveAndInverseCG>( fem->getOdeSolver()->getLinearSolver()); if (solver != nullptr) { solver->setMaxIterations(static_cast<SurgSim::Math::SparseMatrix::Index>( maxIterationConstant * fem->getNumDof())); solver->setTolerance(tolerance); } SurgSim::Framework::Timer totalTime; totalTime.beginFrame(); for (int i = 0; i < frameCount; i++) { fem->getOdeSolver()->getLinearSolver()->getInverse(); } totalTime.endFrame(); RecordProperty("Duration", boost::to_string(totalTime.getCumulativeTime())); }
IUTEST(FlagTest, Check) { IUTEST_ASSERT_TRUE( listener->called_OnTestProgramStart ); IUTEST_ASSERT_TRUE( listener->called_OnTestIterationStart ); IUTEST_ASSERT_TRUE( listener->called_OnEnvironmentsSetUpStart ); IUTEST_ASSERT_TRUE( listener->called_OnEnvironmentsSetUpEnd ); IUTEST_ASSERT_TRUE( listener->called_OnTestCaseStart ); IUTEST_ASSERT_TRUE( listener->called_OnTestStart ); IUTEST_ASSERT_FALSE( listener->called_OnTestEnd ); IUTEST_ASSERT_FALSE( listener->called_OnTestCaseEnd ); IUTEST_ASSERT_FALSE( listener->called_OnEnvironmentsTearDownStart ); IUTEST_ASSERT_FALSE( listener->called_OnEnvironmentsTearDownEnd ); IUTEST_ASSERT_FALSE( listener->called_OnTestIterationEnd ); IUTEST_ASSERT_FALSE( listener->called_OnTestProgramEnd ); IUTEST_ASSERT_FALSE( listener->called_OnTestPartResult ); IUTEST_EXPECT_EQ(1, 2); IUTEST_ASSERT_TRUE( listener->called_OnTestPartResult ); IUTEST_ASSERT_FALSE( listener->called_OnTestRecordProperty ); RecordProperty("dummy", 0); IUTEST_ASSERT_TRUE( listener->called_OnTestRecordProperty ); }
void runTest(int prec1, int prec2, int loc1, int loc2, int matrix) { int status = 0, type; oskar_Mem *beam1, *beam2; oskar_Timer *timer1, *timer2; double time1, time2; // Create the timers. timer1 = oskar_timer_create(loc1 == OSKAR_GPU ? OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE); timer2 = oskar_timer_create(loc2 == OSKAR_GPU ? OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE); // Run first part. type = prec1 | OSKAR_COMPLEX; if (matrix) type |= OSKAR_MATRIX; beam1 = oskar_mem_create(type, loc1, num_sources, &status); oskar_mem_clear_contents(beam1, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); createTestData(prec1, loc1, matrix); oskar_timer_start(timer1); oskar_evaluate_cross_power(num_sources, num_stations, jones, 0, beam1, &status); time1 = oskar_timer_elapsed(timer1); destroyTestData(); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Run second part. type = prec2 | OSKAR_COMPLEX; if (matrix) type |= OSKAR_MATRIX; beam2 = oskar_mem_create(type, loc2, num_sources, &status); oskar_mem_clear_contents(beam2, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); createTestData(prec2, loc2, matrix); oskar_timer_start(timer2); oskar_evaluate_cross_power(num_sources, num_stations, jones, 0, beam2, &status); time2 = oskar_timer_elapsed(timer2); destroyTestData(); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Destroy the timers. oskar_timer_free(timer1); oskar_timer_free(timer2); // Compare results. check_values(beam1, beam2); // Free memory. oskar_mem_free(beam1, &status); oskar_mem_free(beam2, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Record properties for test. RecordProperty("JonesType", matrix ? "Matrix" : "Scalar"); RecordProperty("Prec1", prec1 == OSKAR_SINGLE ? "Single" : "Double"); RecordProperty("Loc1", loc1 == OSKAR_CPU ? "CPU" : "GPU"); RecordProperty("Time1_ms", int(time1 * 1000)); RecordProperty("Prec2", prec2 == OSKAR_SINGLE ? "Single" : "Double"); RecordProperty("Loc2", loc2 == OSKAR_CPU ? "CPU" : "GPU"); RecordProperty("Time2_ms", int(time2 * 1000)); #ifdef ALLOW_PRINTING // Print times. printf(" > %s.\n", matrix ? "Matrix" : "Scalar"); printf(" %s precision %s: %.2f ms, %s precision %s: %.2f ms\n", prec1 == OSKAR_SINGLE ? "Single" : "Double", loc1 == OSKAR_CPU ? "CPU" : "GPU", time1 * 1000.0, prec2 == OSKAR_SINGLE ? "Single" : "Double", loc2 == OSKAR_CPU ? "CPU" : "GPU", time2 * 1000.0); #endif }
virtual void accuracy_test_directed_packed_real_inplace_interleaved() { try { DirectedTest::ParametersPackedRealInplaceInterleaved params = GetParam(); RecordProperty("batch_size", (int)params.batch_size); RecordProperty("precision", params.precision); RecordProperty("direction", params.direction); RecordProperty("dimensions", params.dimensions); RecordProperty("length_x", (int)params.lengths[0]); if (params.dimensions >= CLFFT_2D) RecordProperty("length_y", (int)params.lengths[1]); if (params.dimensions >= CLFFT_3D) RecordProperty("length_z", (int)params.lengths[2]); if (params.input_strides.empty()) { RecordProperty("input_strides", 0); } else { RecordProperty("input_stride_x", (int)params.input_strides[0]); if (params.dimensions >= CLFFT_2D) RecordProperty("input_stride_y", (int)params.input_strides[1]); if (params.dimensions >= CLFFT_3D) RecordProperty("input_stride_z", (int)params.input_strides[2]); } if (params.output_strides.empty()) { RecordProperty("output_strides", 0); } else { RecordProperty("output_stride_x", (int)params.output_strides[0]); if (params.dimensions >= CLFFT_2D) RecordProperty("output_stride_y", (int)params.output_strides[1]); if (params.dimensions >= CLFFT_3D) RecordProperty("output_stride_z", (int)params.output_strides[2]); } RecordProperty("input_distance", (int)params.input_distance); RecordProperty("output_distance", (int)params.output_distance); RecordProperty("input_layout", params.input_layout); RecordProperty("output_layout", params.output_layout); if (params.precision == CLFFT_SINGLE) { if (params.input_layout == CLFFT_REAL) { real_to_complex<float, cl_float, fftwf_complex>(erratic, params.lengths, params.batch_size, params.input_strides, params.output_strides, params.input_distance, params.output_distance, DirectedTest::cl_layout_to_buffer_layout(params.output_layout), placeness::in_place); } else if (params.output_layout == CLFFT_REAL) { complex_to_real<float, cl_float, fftwf_complex>(erratic, params.lengths, params.batch_size, params.input_strides, params.output_strides, params.input_distance, params.output_distance, DirectedTest::cl_layout_to_buffer_layout(params.input_layout), placeness::in_place); } else { throw std::runtime_error("bad layout combination"); } } else if (params.precision == CLFFT_DOUBLE) { if (params.input_layout == CLFFT_REAL) { real_to_complex<double, cl_double, fftw_complex>(erratic, params.lengths, params.batch_size, params.input_strides, params.output_strides, params.input_distance, params.output_distance, DirectedTest::cl_layout_to_buffer_layout(params.output_layout), placeness::in_place); } else if (params.output_layout == CLFFT_REAL) { complex_to_real<double, cl_double, fftw_complex>(erratic, params.lengths, params.batch_size, params.input_strides, params.output_strides, params.input_distance, params.output_distance, DirectedTest::cl_layout_to_buffer_layout(params.input_layout), placeness::in_place); } else { throw std::runtime_error("bad layout combination"); } } else { throw std::runtime_error("Random test: this code path should never be executed"); } } catch (const std::exception& err) { handle_exception(err); } }
TEST_P( mixed_radix, double_precision_complex_to_complex_auto_generated ) { size_t problem_size = GetParam(); RecordProperty("problem_size", (int)problem_size); mixed_radix_complex_to_complex<double, cl_double, fftw_complex>(problem_size); }
void runTest(int prec1, int prec2, int loc1, int loc2, int matrix, int extended, double time_average) { int num_baselines, status = 0, type; oskar_Mem *vis1, *vis2; oskar_Timer *timer1, *timer2; double time1, time2, frequency = 100e6; // Create the timers. timer1 = oskar_timer_create(loc1 == OSKAR_GPU ? OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE); timer2 = oskar_timer_create(loc2 == OSKAR_GPU ? OSKAR_TIMER_CUDA : OSKAR_TIMER_NATIVE); // Run first part. createTestData(prec1, loc1, matrix); num_baselines = oskar_telescope_num_baselines(tel); type = prec1 | OSKAR_COMPLEX; if (matrix) type |= OSKAR_MATRIX; vis1 = oskar_mem_create(type, loc1, num_baselines, &status); oskar_mem_clear_contents(vis1, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); oskar_sky_set_use_extended(sky, extended); oskar_telescope_set_channel_bandwidth(tel, bandwidth); oskar_telescope_set_time_average(tel, time_average); oskar_timer_start(timer1); oskar_cross_correlate(vis1, oskar_sky_num_sources(sky), jones, sky, tel, u_, v_, w_, 1.0, frequency, &status); time1 = oskar_timer_elapsed(timer1); destroyTestData(); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Run second part. createTestData(prec2, loc2, matrix); num_baselines = oskar_telescope_num_baselines(tel); type = prec2 | OSKAR_COMPLEX; if (matrix) type |= OSKAR_MATRIX; vis2 = oskar_mem_create(type, loc2, num_baselines, &status); oskar_mem_clear_contents(vis2, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); oskar_sky_set_use_extended(sky, extended); oskar_telescope_set_channel_bandwidth(tel, bandwidth); oskar_telescope_set_time_average(tel, time_average); oskar_timer_start(timer2); oskar_cross_correlate(vis2, oskar_sky_num_sources(sky), jones, sky, tel, u_, v_, w_, 1.0, frequency, &status); time2 = oskar_timer_elapsed(timer2); destroyTestData(); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Destroy the timers. oskar_timer_free(timer1); oskar_timer_free(timer2); // Compare results. check_values(vis1, vis2); // Free memory. oskar_mem_free(vis1, &status); oskar_mem_free(vis2, &status); ASSERT_EQ(0, status) << oskar_get_error_string(status); // Record properties for test. RecordProperty("SourceType", extended ? "Gaussian" : "Point"); RecordProperty("JonesType", matrix ? "Matrix" : "Scalar"); RecordProperty("TimeSmearing", time_average == 0.0 ? "off" : "on"); RecordProperty("Prec1", prec1 == OSKAR_SINGLE ? "Single" : "Double"); RecordProperty("Loc1", loc1 == OSKAR_CPU ? "CPU" : "GPU"); RecordProperty("Time1_ms", int(time1 * 1000)); RecordProperty("Prec2", prec2 == OSKAR_SINGLE ? "Single" : "Double"); RecordProperty("Loc2", loc2 == OSKAR_CPU ? "CPU" : "GPU"); RecordProperty("Time2_ms", int(time2 * 1000)); #ifdef ALLOW_PRINTING // Print times. printf(" > %s. %s sources. Time smearing %s.\n", matrix ? "Matrix" : "Scalar", extended ? "Gaussian" : "Point", time_average == 0.0 ? "off" : "on"); printf(" %s precision %s: %.2f ms, %s precision %s: %.2f ms\n", prec1 == OSKAR_SINGLE ? "Single" : "Double", loc1 == OSKAR_CPU ? "CPU" : "GPU", time1 * 1000.0, prec2 == OSKAR_SINGLE ? "Single" : "Double", loc2 == OSKAR_CPU ? "CPU" : "GPU", time2 * 1000.0); #endif }
TEST_P( mixed_radix, single_precision_complex_to_complex_auto_generated ) { size_t problem_size = GetParam(); RecordProperty("problem_size", (int)problem_size); mixed_radix_complex_to_complex<float, cl_float, fftwf_complex>(problem_size); }