// **************************************************************************** // Function: RunBenchmark // // Purpose: // Measures the floating point capability of the device for a variety of // combinations of arithmetic operations. // // Arguments: // op: the options parser / parameter database // // Returns: nothing // // Programmer: Zhi Ying([email protected]) // Jun Jin([email protected]) // // Creation: May 23, 2011 // // Modifications: // 12/12/12 - Kyle Spafford - Code style and minor integration updates // // **************************************************************************** void RunBenchmark(OptionParser &op, ResultDatabase &resultDB) { const bool verbose = op.getOptionBool("verbose"); // Quiet == no progress bar. const bool quiet = op.getOptionBool("quiet"); const unsigned int passes = op.getOptionInt("passes"); const int micdev = op.getOptionInt("target"); double repeatF = 3; cout << "Adjust repeat factor = " << repeatF << "\n"; // Initialize progress bar int totalRuns = 16*passes*2; ProgressBar pb(totalRuns); if (!verbose && !quiet) { pb.Show(stdout); } RunTest<float>(resultDB, passes, verbose, quiet, repeatF, pb, "-SP", micdev); RunTest<double>(resultDB, passes, verbose, quiet, repeatF, pb, "-DP", micdev); if (!verbose) cout << endl; }
int main (int argc, const char* argv[]) { OptionParser parser; parser.description("split input file by odd lines and even lines into two files\n" "input from stdin, output odd lines to stdout, even lines to stderr") .usage("%prog [OPTIONS] < INPUT > ODD_LINES 2> EVEN_LINES") .version("1.0") .epilog("By jadesoul @ 2013-11-19 14:47:14\n" "please report bugs to " JADESOUL_EMAIL); parser.add_option("-v", "--verbose") .action("store_true") .dest("verbose") .set_default("0") .help("print status messages to stdlog"); OptionArgs& optargs = parser.parse_args(argc, argv); bool verbose=optargs.get("verbose"); if (verbose) cout<<"begin ..."<<endl; uint i=0; string s; while (getline(cin, s)) if (++i%2==1) cout<<s<<endl; else cerr<<s<<endl; if (verbose) cout<<"finished"<<endl; return 0; }
int CDECL main(int aArgc, char* aArgv[]) { InitialisationParams* initParams = InitialisationParams::Create(); OptionParser parser; OptionUint optionDuration("-d", "--duration", 30, "Number of seconds to run the test"); parser.AddOption(&optionDuration); if (!parser.Parse(aArgc, aArgv)) { return (1); } Library* lib = new Library(initParams); std::vector<NetworkAdapter*>* subnetList = lib->CreateSubnetList(); TIpAddress subnet = (*subnetList)[0]->Subnet(); Library::DestroySubnetList(subnetList); CpStack* cpStack = lib->StartCp(subnet); // Debug::SetLevel(Debug::kTopology); ReceiverManager1Logger* logger = new ReceiverManager1Logger(*cpStack); Blocker* blocker = new Blocker(lib->Env()); blocker->Wait(optionDuration.Value()); delete blocker; delete (logger); Print("Closing ... "); delete lib; Print("closed\n"); }
void TestNetwork(const std::vector<Brn>& aArgs) { OptionParser parser; OptionUint adapter("-i", "--interface", 0, "index of network adapter to use"); parser.AddOption(&adapter); if (!parser.Parse(aArgs) || parser.HelpDisplayed()) { return; } std::vector<NetworkAdapter*>* ifs = Os::NetworkListAdapters(Net::InitialisationParams::ELoopbackUse, "TestNetwork"); ASSERT(ifs->size() > 0 && adapter.Value() < ifs->size()); TIpAddress addr = (*ifs)[adapter.Value()]->Address(); for (TUint i=0; i<ifs->size(); i++) { (*ifs)[i]->RemoveRef("TestNetwork"); } delete ifs; Endpoint endpt(0, addr); Endpoint::AddressBuf buf; endpt.AppendAddress(buf); Print("Using network interface %s\n\n", buf.Ptr()); Thread* th = new MainNetworkTestThread(addr); th->Start(); th->Wait(); delete th; }
// validate stencil-independent values void CheckOptions( const OptionParser& opts ) { // check matrix dimensions - must be 2d, must be positive std::vector<long long> arrayDims = opts.getOptionVecInt( "customSize" ); if( arrayDims.size() != 2 ) { throw InvalidArgValue( "overall size must have two dimensions" ); } if( (arrayDims[0] < 0) || (arrayDims[1] < 0) ) { throw InvalidArgValue( "each size dimension must be positive" ); } // validation error threshold must be positive float valThreshold = opts.getOptionFloat( "val-threshold" ); if( valThreshold <= 0.0f ) { throw InvalidArgValue( "validation threshold must be positive" ); } // number of validation errors to print must be non-negative int nErrsToPrint = opts.getOptionInt( "val-print-limit" ); if( nErrsToPrint < 0 ) { throw InvalidArgValue( "number of validation errors to print must be non-negative" ); } int nWarmupPasses = opts.getOptionInt( "warmupPasses" ); if( nWarmupPasses < 0 ) { throw InvalidArgValue( "number of warmup passes must be non-negative" ); } }
// parse a STATA command DwUseOptions* DwUseOptionParser::Parse(vector<string> words) { // there are 10 keywords we expect to see string keys[] = {"variables", "if", "using", "limit", "nulldata", "lowercase", "uppercase", "label_variable", "label_values", "username", "password", "database"}; size_t nkeys(sizeof(keys) / sizeof(string)); // create parser that accepts these keywords OptionParser* parser = new OptionParser( set<string>(keys, keys + nkeys) ); // prepare another vector where we can search // see if we have a using anywhere, if we do, the first part is the varlist, if not it is the tablename bool hasUsing = hasKeyword(words, "using"); // if it contains using somewhere we can start with variables (if missing it will be an empty string, if the list is there it will be expected) if( !hasUsing ) words.insert(words.begin(), "using"); else if( lowerCase(words[0]) != "if" && lowerCase(words[0]) != "using" ) words.insert(words.begin(), "variables"); // parse the options map<string,string> options = parser->Parse( words ); delete parser; // create a meaningful options object DwUseOptions* useOptions = new DwUseOptions( options ); return useOptions; }
// **************************************************************************** // Function: GPUSetup // // Purpose: // do the necessary OpenCL setup for GPU part of the test // // Arguments: // op: the options parser / parameter database // mympirank: for printing errors in case of failure // mynoderank: this is typically the device ID (the mapping done in main) // // Returns: success/failure // // Creation: 2009 // // Modifications: // // **************************************************************************** // int GPUSetup(OptionParser &op, int mympirank, int mynoderank) { addBenchmarkSpecOptions(op); if (op.getOptionBool("infoDevices")) { OpenCLNodePlatformContainer ndc1; ndc1.Print (cout); return (0); } // The device option supports specifying more than one device int platform = op.getOptionInt("platform"); int deviceIdx = mynoderank; if( deviceIdx >= op.getOptionVecInt( "device" ).size() ) { std::ostringstream estr; estr << "Warning: not enough devices specified with --device flag for task " << mympirank << " ( node rank " << mynoderank << ") to claim its own device; forcing to use first device "; std::cerr << estr.str() << std::endl; deviceIdx = 0; } int device = op.getOptionVecInt("device")[deviceIdx]; // Initialization _mpicontention_ocldev = new cl::Device( ListDevicesAndGetDevice(platform, device) ); std::vector<cl::Device> ctxDevices; ctxDevices.push_back( *_mpicontention_ocldev ); _mpicontention_ocldriver_ctx = new cl::Context( ctxDevices ); _mpicontention_ocldriver_queue = new cl::CommandQueue( *_mpicontention_ocldriver_ctx, *_mpicontention_ocldev, CL_QUEUE_PROFILING_ENABLE ); _mpicontention_gpuop = op; return 0; }
int __cdecl main(int aArgc, char* aArgv[]) { InitialisationParams* initParams = InitialisationParams::Create(); OptionParser parser; OptionUint optionDuration("-d", "--duration", 30, "Number of seconds to run the test"); parser.AddOption(&optionDuration); if (!parser.Parse(aArgc, aArgv)) { return (1); } UpnpLibrary::Initialise(initParams); UpnpLibrary::StartCp(); //Debug::SetLevel(Debug::kTopology); ReceiverManager2Logger* logger = new ReceiverManager2Logger(); Blocker* blocker = new Blocker; blocker->Wait(optionDuration.Value()); delete blocker; delete (logger); UpnpLibrary::Close(); }
BamHeader PrepareHeader(const OptionParser& parser, int argc, char** argv, const vector<string>& files) { using boost::algorithm::join; ProgramInfo program(parser.prog() + "-" + CCS_VERSION); program.Name(parser.prog()) .CommandLine(parser.prog() + " " + join(vector<string>(argv + 1, argv + argc), " ")) .Description(DESCRIPTION) .Version(CCS_VERSION); BamHeader header; header.PacBioBamVersion("3.0.1").SortOrder("unknown").Version("1.5").AddProgram(program); for (const auto& file : files) { BamFile bam(file); for (const auto& rg : bam.Header().ReadGroups()) { if (rg.ReadType() != "SUBREAD") parser.error("invalid input file, READTYPE must be SUBREAD"); ReadGroupInfo readGroup(rg.MovieName(), "CCS"); readGroup.BindingKit(rg.BindingKit()) .SequencingKit(rg.SequencingKit()) .BasecallerVersion(rg.BasecallerVersion()) .FrameRateHz(rg.FrameRateHz()); header.AddReadGroup(readGroup); } } return header; }
Options(int argc, char *argv[]) { parser = new OptionParser(argc, argv); this->init_options(); // Personnalisation éventuelle du comportement : que faire si l'utilisateur // passe une option incorrecte ? Les valeurs possibles sont : // exit (par défaut), raise, warn, ignore // Ici, on veut afficher les clés erronées tout en continuant l'analyse. // parser->on_error("warn"); // Ici, on veut arrêter le programme en cas d'option invalide. parser->on_error("exit"); // inutile car c'est "exit" par défaut // Permet des post-traitements (vérification de cohérence d'options,...) pre_process_options(); // On peut lancer l'analyse ici ou bien le faire depuis le main() de la // du programme principal. parser->parse(); // Permet des post-traitements (vérification de cohérence entre options,...) post_process_options(); // Les attributs options étant affectés, on peut supprimer le parser // sauf si on souhaite exploiter quelques-unes de ses méthodes ou attributs // e.g parser->print_values() ou parser->params // delete parser; // parser = NULL; // Utile ssi on veut pouvoir tester l'existence de parser ! }
int CDECL main(int aArgc, char* aArgv[]) { InitialisationParams* initParams = InitialisationParams::Create(); OptionParser parser; OptionUint optionDuration("-d", "--duration", 30, "Number of seconds to run the test"); parser.AddOption(&optionDuration); if (!parser.Parse(aArgc, aArgv)) { return (1); } UpnpLibrary::Initialise(initParams); std::vector<NetworkAdapter*>* subnetList = UpnpLibrary::CreateSubnetList(); TIpAddress subnet = (*subnetList)[0]->Subnet(); UpnpLibrary::DestroySubnetList(subnetList); UpnpLibrary::StartCp(subnet); // Debug::SetLevel(Debug::kTopology); ReceiverManager2Logger* logger = new ReceiverManager2Logger(); Blocker* blocker = new Blocker; blocker->Wait(optionDuration.Value()); delete blocker; delete (logger); UpnpLibrary::Close(); }
// **************************************************************************** // Function: addBenchmarkSpecOptions // // Purpose: // Add benchmark specific options parsing. The user is allowed to specify // the size of the input data in megabytes. // // Arguments: // op: the options parser / parameter database // // Programmer: Collin McCurdy // Creation: September 08, 2009 // Returns: nothing // // **************************************************************************** void addBenchmarkSpecOptions(OptionParser &op) { op.addOption("pts", OPT_INT, "0", "data size (in megabytes)"); op.addOption("pts1", OPT_INT, "0", "data size (in megabytes)"); op.addOption("pts2", OPT_INT, "0", "data size (in megabytes)"); op.addOption("2D", OPT_BOOL, "false", "2D FFT"); }
// **************************************************************************** // Function: addBenchmarkSpecOptions // // Purpose: // Add benchmark specific options parsing. The user is allowed to specify // the size of the input data in megabytes. // // Arguments: // op: the options parser / parameter database // // Programmer: Collin McCurdy // Creation: September 08, 2009 // Returns: nothing // // **************************************************************************** void addBenchmarkSpecOptions(OptionParser &op) { op.addOption("MB", OPT_INT, "0", "data size (in megabytes)"); op.addOption("use-native", OPT_BOOL, "false", "call native (HW) versions of sin/cos"); op.addOption("dump-sp", OPT_BOOL, "false", "dump result after SP fft/ifft"); op.addOption("dump-dp", OPT_BOOL, "false", "dump result after DP fft/ifft"); }
// **************************************************************************** // Function: addBenchmarkSpecOptions // // Purpose: // Add benchmark specific options parsing. // // Arguments: // op: the options parser / parameter database // // Programmer: Lukasz Wesolowski // Creation: June 21, 2010 // Returns: nothing // // **************************************************************************** void addBenchmarkSpecOptions(OptionParser &op) { op.addOption("iterations", OPT_INT, "100", "Number of SpMV iterations " "per pass"); op.addOption("mm_filename", OPT_STRING, "random", "Name of file " "which stores the matrix in Matrix Market format"); op.addOption("maxval", OPT_FLOAT, "10", "Maximum value for random " "matrices"); }
void StencilFactory<T>::ExtractOptions( const OptionParser& options, T& wCenter, T& wCardinal, T& wDiagonal ) { wCenter = options.getOptionFloat( "weight-center" ); wCardinal = options.getOptionFloat( "weight-cardinal" ); wDiagonal = options.getOptionFloat( "weight-diagonal" ); }
void OpenHome::TestFramework::Runner::Main(TInt aArgc, TChar* aArgv[], InitialisationParams* aInitParams) { OptionParser parser; OptionBool loopback("-l", "--loopback", "Use the loopback adapter only"); parser.AddOption(&loopback); if (!parser.Parse(aArgc, aArgv) || parser.HelpDisplayed()) { return; } if (loopback.Value()) { aInitParams->SetUseLoopbackNetworkInterface(); } UpnpLibrary::Initialise(aInitParams); UpnpLibrary::StartCombined(); //Debug::SetLevel(Debug::kDevice/*Debug::kXmlFetch | Debug::kHttp*/); Print("TestDviDeviceList - starting\n"); DvDevices* devices = new DvDevices; CpDevices* deviceList = new CpDevices; FunctorCpDevice added = MakeFunctorCpDevice(*deviceList, &CpDevices::Added); FunctorCpDevice removed = MakeFunctorCpDevice(*deviceList, &CpDevices::Removed); Print("Count devices implementing service1\n"); Brn domainName("a.b.c"); Brn serviceType("service1"); TUint ver = 1; CpDeviceListUpnpServiceType* list = new CpDeviceListUpnpServiceType(domainName, serviceType, ver, added, removed); Blocker* blocker = new Blocker; blocker->Wait(aInitParams->MsearchTimeSecs()); std::vector<const char*> udns; udns.push_back((const char*)gNameDevice1.Ptr()); udns.push_back((const char*)gNameDevice2.Ptr()); deviceList->Validate(udns); udns.clear(); delete list; deviceList->Clear(); Print("Count devices implementing service2\n"); serviceType.Set("service2"); list = new CpDeviceListUpnpServiceType(domainName, serviceType, ver, added, removed); blocker->Wait(aInitParams->MsearchTimeSecs()); udns.push_back((const char*)gNameDevice1_1.Ptr()); udns.push_back((const char*)gNameDevice2.Ptr()); deviceList->Validate(udns); udns.clear(); delete list; delete blocker; delete deviceList; delete devices; Print("TestDviDeviceList - completed\n"); UpnpLibrary::Close(); }
Options setupOptions(int theArgc, char * theArgv[]){ // Create the options Options opt; // Parse the options OptionParser OP; OP.setRequired(opt.required); OP.setDefaultArguments(opt.defaultArgs); // the default argument is the --configfile option OP.readArgv(theArgc, theArgv); if (OP.countOptions() == 0){ cout << "Usage: getConsecutivePhiPsi " << endl; cout << endl; cout << "\n"; cout << "pdblist PDB\n"; cout << "SSE L # L = Loop, S = Strand, H = Helix\n" cout << endl; exit(0); } opt.pdblist = OP.getString("pdblist"); if (OP.fail()){ cerr << "ERROR 1111 no pdblist specified."<<endl; exit(1111); } opt.SSE = OP.getString("sse"); if (OP.fail()){ opt.SSE = ""; } return opt; }
Options setupOptions(int theArgc, char * theArgv[]){ // Create the options Options opt; // Parse the options OptionParser OP; OP.setRequired(opt.required); OP.setDefaultArguments(opt.defaultArgs); // the default argument is the --configfile option OP.readArgv(theArgc, theArgv); if (OP.countOptions() == 0){ cout << "Usage: getTripletCaMeasurements " << endl; cout << endl; cout << "\n"; cout << "pdblist PDB\n"; cout << endl; exit(0); } opt.pdblist = OP.getString("pdblist"); if (OP.fail()){ cerr << "ERROR 1111 no pdblist specified."<<endl; exit(1111); } opt.numSamples = OP.getInt("numSamples"); if (OP.fail()){ opt.numSamples = 10000; cerr << "WARNING numSamples set to "<<opt.numSamples<<endl; } return opt; }
Options setupOptions(int theArgc, char * theArgv[]){ Options opt; OptionParser OP; OP.setRequired(opt.required); OP.setAllowed(opt.optional); OP.readArgv(theArgc, theArgv); if (OP.countOptions() == 0){ cout << "Usage:" << endl; cout << endl; cout << "createVectorHash --list pdb.list --outfile foo.vh\n"; exit(0); } opt.list = OP.getString("list"); if (OP.fail()){ cerr << "ERROR 1111 pdb not specified.\n"; exit(1111); } opt.outfile = OP.getString("outfile"); if (OP.fail()){ cerr << "WARNING outfile not specified. Using: '"<<opt.list<<".vh'"<<endl; opt.outfile = opt.list+".vh"; } return opt; }
int main(int argc, char **argv) { OptionParser cmd; cmd.option("-v", "--verbose", "enable verbose stuff", verbose); cmd.option("-r", "--required <arg>", "required arg", required); cmd.option("-o", "--optional [arg]", "optional arg", optional); cmd.parse(argc, argv); std::cout << cmd.normalize() << endl; //cmd.help(); return 0; }
void OpenHome::TestFramework::Runner::Main(TInt aArgc, TChar* aArgv[], InitialisationParams* aInitParams) { OptionParser parser; OptionBool loopback("-l", "--loopback", "Use the loopback adapter only"); parser.AddOption(&loopback); if (!parser.Parse(aArgc, aArgv) || parser.HelpDisplayed()) { return; } if (loopback.Value()) { aInitParams->SetUseLoopbackNetworkAdapter(); } aInitParams->SetMsearchTime(1); aInitParams->SetDvUpnpServerPort(0); UpnpLibrary::Initialise(aInitParams); std::vector<NetworkAdapter*>* subnetList = UpnpLibrary::CreateSubnetList(); TIpAddress subnet = (*subnetList)[0]->Subnet(); UpnpLibrary::DestroySubnetList(subnetList); UpnpLibrary::StartCombined(subnet); //Debug::SetLevel(Debug::kEvent | Debug::kDvEvent); Print("TestDvDeviceStd - starting\n"); Semaphore* sem = new Semaphore("SEM1", 0); DeviceBasic* device = new DeviceBasic(DeviceBasic::eProtocolUpnp); CpDevices* deviceList = new CpDevices(device->Device().Udn(), *sem); FunctorCpDeviceCpp added = MakeFunctorCpDeviceCpp(*deviceList, &CpDevices::Added); FunctorCpDeviceCpp removed = MakeFunctorCpDeviceCpp(*deviceList, &CpDevices::Removed); std::string domainName("openhome.org"); std::string serviceType("TestBasic"); TUint ver = 1; CpDeviceListCppUpnpServiceType* list = new CpDeviceListCppUpnpServiceType(domainName, serviceType, ver, added, removed); sem->Wait(30*1000); // allow up to 30s to find our one device try { deviceList->TestActions(); Functor cb = MakeFunctor(sem, &DeviceDisabled); device->Device().SetDisabled(cb); sem->Wait(); deviceList->TestThrows(); device->Device().SetEnabled(); deviceList->TestSubscriptions(); } catch (Exception& e) { Print("Exception %s from %s:%u\n", e.Message(), e.File(), e.Line()); ASSERTS(); } delete sem; delete list; delete deviceList; delete device; Print("TestDvDeviceStd - completed\n"); UpnpLibrary::Close(); }
virtual int proceedOpts(OptionParser &op) { op.setDescription("Metaprogramming Multi-Staged JavaScript Debugger"); if (!op.addStringOption('i', "inputfile", "filepath", "Metaprogramming JavaScript input File location") || !op.addStringOption('o', "outputfile", "filepath", "Metaprogramming JavaScript output File location") || !op.addStringOption('b', "browser", "browser execution location", "Metaprogramming JavaScript execution browser")) { return EXIT_FAILURE; } return EXIT_SUCCESS; }
virtual int handle(JSContext *cx, JSObject *global, OptionParser &op) { const char *stgInputfile = op.getStringOption("inputfile"); if(!stgInputfile) { fprintf(stderr, "Unrecognized option for %s: %s\n", "inputfile", stgInputfile); return EXIT_FAILURE; } const char *stgOutputfile = op.getStringOption("outputfile"); if(!stgOutputfile) { fprintf(stderr, "Unrecognized option for %s: %s\n", "outputfile", stgOutputfile); return EXIT_FAILURE; } const char *stgBrowser = op.getStringOption("browser"); if(!stgBrowser) { fprintf(stderr, "Unrecognized option for %s: %s\n", "browser", stgBrowser); return EXIT_FAILURE; } /* stgInputfile = "Src/examples/test.js"; stgOutputfile = "Src/examples/test_staged.js"; stgBrowser = "chrome"; */ StagingProcess::createSingleton(cx, stgOutputfile, NULL); unparse *up = unparse::getSingleton(); JS_ReportInfo(cx, "opening \"%s\".\n", stgInputfile); jschar *chars; if (!AutoFile::OpenAndReadAll(cx, stgInputfile, &chars)) return EXIT_FAILURE; uint32_t lineno = 1; ScopedJSFreePtr<char> filename; jsval rval; JS_ReportInfo(cx, "converting src to ast. "); if (!reflect_parse_from_string(cx, chars, js_strlen(chars), &rval)) { JS_ReportError(cx, "reflection parse error.\n"); return EXIT_FAILURE; } JS_ReportInfo(cx, "done.\n"); RemoteStagedDbg remoteStagedDbg(cx, JSVAL_TO_OBJECT(rval)); remoteStagedDbg.start(stgBrowser); js_free(chars); StagingProcess::destroySingleton(); JS_ReportInfo(cx, "finish.\n"); return EXIT_SUCCESS; }
void TestSsdpMListen(const std::vector<Brn>& aArgs) { OptionParser parser; OptionUint duration("-d", "--duration", 30, "Number of seconds to listen for. Defaults to 30"); parser.AddOption(&duration); OptionUint adapter("-i", "--interface", 0, "index of network adapter to use"); parser.AddOption(&adapter); if (!parser.Parse(aArgs) || parser.HelpDisplayed()) { return; } Runner runner("SSDP multicast listener\n"); runner.Add(new SuiteListen(duration.Value(), adapter.Value())); runner.Run(); }
void RunBenchmark(cl::Device& devcpp, cl::Context& ctxcpp, cl::CommandQueue& queuecpp, ResultDatabase &resultDB, OptionParser &op) { // convert from C++ bindings to C bindings // TODO propagate use of C++ bindings cl_device_id dev = devcpp(); cl_context ctx = ctxcpp(); cl_command_queue queue = queuecpp(); if (getMaxWorkGroupSize(dev) < 64) { cout << "FFT requires MaxWorkGroupSize of at least 64" << endl; fillResultDB("SP-FFT", "MaxWorkGroupSize<64", op, resultDB); fillResultDB("DP-FFT", "MaxWorkGroupSize<64", op, resultDB); return; } bool has_dp = checkExtension(dev, "cl_khr_fp64") || checkExtension(dev, "cl_amd_fp64"); if (op.getOptionBool("dump-sp")) { dump<cplxflt>(op); } else if (op.getOptionBool("dump-dp")) { if (!has_dp) { cout << "dump-dp: no double precision support!\n"; return; } dump<cplxdbl>(op); } else { // Always run single precision test runTest<cplxflt>("SP-FFT", dev, ctx, queue, resultDB, op); // If double precision is supported, run the DP test if (has_dp) { cout << "DP Supported\n"; runTest<cplxdbl>("DP-FFT", dev, ctx, queue, resultDB, op); } else { cout << "DP Not Supported\n"; fillResultDB("DP-FFT", "DP_Not_Supported", op, resultDB); } } }
void RunBenchmark(ResultDatabase &resultDB, OptionParser &op) { // Test to see if this device supports double precision cudaGetDevice(&fftDevice); cudaDeviceProp deviceProp; cudaGetDeviceProperties(&deviceProp, fftDevice); bool has_dp = (deviceProp.major == 1 && deviceProp.minor >= 3) || (deviceProp.major >= 2); cout << "Running single precision test" << endl; runTest<float2>("SP-FFT", resultDB, op); if (has_dp) { cout << "Running double precision test" << endl; runTest<double2>("DP-FFT", resultDB, op); } else { cout << "Skipping double precision test" << endl; char atts[32] = "DP_Not_Supported"; // resultDB requires neg entry for every possible result int passes = op.getOptionInt("passes"); for (int k=0; k<passes; k++) { resultDB.AddResult("DP-FFT" , atts, "GB/s", FLT_MAX); resultDB.AddResult("DP-FFT_PCIe" , atts, "GB/s", FLT_MAX); resultDB.AddResult("DP-FFT_Parity" , atts, "GB/s", FLT_MAX); resultDB.AddResult("DP-FFT-INV" , atts, "GB/s", FLT_MAX); resultDB.AddResult("DP-FFT-INV_PCIe" , atts, "GB/s", FLT_MAX); resultDB.AddResult("DP-FFT-INV_Parity" , atts, "GB/s", FLT_MAX); } } }
void CommonMICStencilFactory<T>::CheckOptions( const OptionParser& opts ) const { // let base class check its options first StencilFactory<T>::CheckOptions( opts ); // check our options std::vector<long long> arrayDims = opts.getOptionVecInt( "customSize" ); assert( arrayDims.size() == 2 ); // If both of these are zero, we're using a non-custom size, skip this test if (arrayDims[0] == 0 && arrayDims[0] == 0) { return; } size_t gRows = (size_t)arrayDims[0]; size_t gCols = (size_t)arrayDims[1]; size_t lRows = LROWS; size_t lCols = LCOLS; // verify that local dimensions evenly divide global dimensions if( ((gRows % lRows) != 0) || (lRows > gRows) ) { throw InvalidArgValue( "number of rows must be even multiple of lsize rows" ); } if( ((gCols % lCols) != 0) || (lCols > gCols) ) { throw InvalidArgValue( "number of columns must be even multiple of lsize columns" ); } // TODO ensure local dims are smaller than CUDA implementation limits }
int t1only_main(int argc, char *argv[], int nb_pars, OptionParser & options){ if (argc - nb_pars < 4) { cerr<<"too few arguments"<<endl; options.usage(); return -1; } int count_arg = nb_pars; const string inputt1(argv[count_arg]); count_arg++; const string mesh(argv[count_arg]); count_arg++; const string matrix(argv[count_arg]); count_arg++; const string outputstr(argv[count_arg]); //load the mesh Mesh m; m.load(mesh); //load the matrix trMatrix M; ifstream f(matrix.c_str()); if (f.is_open()) { f>>M.m11>>M.m12>>M.m13>>M.m14>>M.m21>>M.m22>>M.m23>>M.m24>>M.m31>>M.m32>>M.m33>>M.m34>>M.m41>>M.m42>>M.m43>>M.m44; f.close(); }
void OpenHome::TestFramework::Runner::Main(TInt aArgc, TChar* aArgv[], InitialisationParams* aInitParams) { OptionParser parser; OptionUint duration("-d", "--duration", 30, "Number of seconds to run the test"); OptionUint adapter("-i", "--interface", 0, "index of network adapter to use"); parser.AddOption(&duration); parser.AddOption(&adapter); if (!parser.Parse(aArgc, aArgv) || parser.HelpDisplayed()) { return; } UpnpLibrary::Initialise(aInitParams); std::vector<NetworkAdapter*>* ifs = Os::NetworkListAdapters(false, "TestTopology3"); ASSERT(ifs->size() > 0 && adapter.Value() < ifs->size()); TIpAddress subnet = (*ifs)[adapter.Value()]->Subnet(); for (TUint i=0; i<ifs->size(); i++) { (*ifs)[i]->RemoveRef("TestTopology3"); } delete ifs; UpnpLibrary::StartCp(subnet); Endpoint endpt(0, subnet); Endpoint::AddressBuf buf; endpt.AppendAddress(buf); Print("Using network interface %s\n\n", buf.Ptr()); // Debug::SetLevel(Debug::kTopology); // Debug::SetLevel(Debug::kAll); TopologyLogger logger; CpTopology3* topology = new CpTopology3(logger); if (topology != NULL) { Blocker* blocker = new Blocker; blocker->Wait(duration.Value()); delete blocker; } delete topology; UpnpLibrary::Close(); }
void dump2D(OptionParser& op) { int i; void* work, *temp; T2* source, * result; unsigned long bytes = 0; int probSizes[7] = { 128, 256, 512, 1024, 2048, 4096, 8192}; int sizeIndex = op.getOptionInt("pts1")-1; int sizeIndey = op.getOptionInt("pts2")-1; if (sizeIndex < 0 || sizeIndex >= 7) { cerr << "Invalid size index specified\n"; exit(-1); } if (sizeIndey < 0 || sizeIndey >= 7) { cerr << "Invalid size index specified\n"; exit(-1); } int FFTN1=probSizes[sizeIndex],FFTN2=probSizes[sizeIndey]; //int FFTN1=8192,FFTN2=512; unsigned long used_bytes = FFTN1*FFTN2*sizeof(T2); bool do_dp = dp<T2>(); init2(op, do_dp, FFTN1, FFTN2); int n_ffts = 1; double N = FFTN1*FFTN2; // allocate host and device memory allocHostBuffer((void**)&source, used_bytes); allocHostBuffer((void**)&result, used_bytes); // init host memory... for (i = 0; i < N; i++) { source[i].x = (rand()/(float)RAND_MAX)*2-1; source[i].y = (rand()/(float)RAND_MAX)*2-1; } // alloc device memory allocDeviceBuffer(&work, used_bytes); allocDeviceBuffer(&temp, used_bytes); copyToDevice(work, source, used_bytes); forward2(work, temp, n_ffts, FFTN1, FFTN2); copyFromDevice(result, work, used_bytes); #ifdef PRINT_RESULT for (i = 0; i < N; i++) { fprintf(stdout, "data[%d] (%g, %g) \n",i, result[i].x, result[i].y); } #endif freeDeviceBuffer(work); freeDeviceBuffer(temp); freeHostBuffer(source); freeHostBuffer(result); }