int hpx_main(boost::program_options::variables_map& vm)
{
unsigned int seed = (unsigned int)std::time(nullptr);
if (vm.count("seed"))
seed = vm["seed"].as<unsigned int>();
std::cout << "using seed: " << seed << std::endl;
std::srand(seed);
for_loop_strided_test();
for_loop_strided_test_idx();
return hpx::finalize();
}
int hpx_main(boost::program_options::variables_map& vm)
{
unsigned int seed = (unsigned int)std::time(nullptr);
if (vm.count("seed"))
seed = vm["seed"].as<unsigned int>();
std::cout << "using seed: " << seed << std::endl;
std::srand(seed);
rotate_test();
rotate_exception_test();
rotate_bad_alloc_test();
return hpx::finalize();
}
void do_matchFirstNumeric(const boost::program_options::variables_map &vm, const std::string key, std::string &target, const std::string var, const std::string bound, const std::string op) {
if (vm.count(key)) {
std::vector<std::string> bounds = vm[key].as<std::vector<std::string> >();
if (bounds.size() > 1 || !target.empty())
NSC_DEBUG_MSG("Multiple boundries of the same kind is not supported");
if (bounds.size() > 0) {
std::string value = bounds.front();
if (value.size() > 3 && value[2] == ':')
target = var + "=" + bound + " " + value.substr(0,2) + " " + value.substr(3);
else
target = var + "=" + bound + op + bounds.front();
}
}
}
void SpinReader::loadTFMFromProgramOptions(const bpo::variables_map & vm)
{
RobotModel model;
if( vm.count("robot_description") )
model.addFile(vm["robot_description"].as<std::string>());
else if( ! ros::param::has("/driving/robot_description") )
BOOST_THROW_EXCEPTION(stdr::ex::ExceptionBase() <<stdr::ex::MsgInfo(
"You must provide a model description, either on the command line, or as a rosparam."));
model.addParam("/driving/robot_description");
BOOST_FOREACH(const tf::StampedTransform& t, model.getStaticTransforms()) {
tf_listener_.addStaticTransform(t);
}
}
shared_ptr<mat> filtering(const mat& mrating, mpq& msim){
cout<<"collaborative filtering..."<<endl;
shared_ptr<mat> pm_predict(new mat(mrating));
mat& m_predict = *pm_predict;
int max_row_index = base ? nitem : nuser;
for(mpq_i i=msim.begin(); i!=msim.end(); ++i){
cout<<(i->first+1) * 100 / max_row_index<<"%\r"; cout.flush();
// get current row
row ri(m_predict, i->first);
pq& q = i->second;
// pop all sim rows
for(;!q.empty(); q.pop()){
int index = q.top().first;
double sim = q.top().second;
crow rj(mrating, index);
switch(sim_summing){
case 0:
ri += rj * sim;
break;
case 1:
for(crow::const_iterator j=rj.begin(); j!=rj.end(); ++j){
int col = j.index();
double v = 1 - ( 1 - ri(col) ) * ( 1 - *j * sim );
if(v) ri(col) = v;
}
break;
default:
break;
}
}
}
cout<<endl;
if(vm.count("verbose")) cout<<"prediction matrix:\n"<<m_predict<<endl;
return pm_predict;
}
bool parse_commandline(int argc, char *argv[], po::variables_map& vm)
{
try {
po::options_description desc_cmdline ("Usage: fibonacci2 [options]");
desc_cmdline.add_options()
("help,h", "print out program usage (this message)")
("run_agas_server,r", "run AGAS server as part of this runtime instance")
("worker,w", "run this instance in worker (non-console) mode")
("config", po::value<std::string>(),
"load the specified file as an application configuration file")
("agas,a", po::value<std::string>(),
"the IP address the AGAS server is running on (default taken "
"from hpx.ini), expected format: 192.168.1.1:7912")
("hpx,x", po::value<std::string>(),
"the IP address the HPX parcelport is listening on (default "
"is localhost:7910), expected format: 192.168.1.1:7913")
("localities,l", po::value<int>(),
"the number of localities to wait for at application startup "
"(default is 1)")
("threads,t", po::value<int>(),
"the number of operating system threads to spawn for this "
"HPX locality")
("queueing,q", po::value<std::string>(),
"the queue scheduling policy to use, options are 'global' "
" and 'local' (default is 'global')")
("value,v", po::value<int>(),
"the number to be used as the argument to fib (default is 10)")
("csv,s", "generate statistics of the run in comma separated format")
("busywait,b", po::value<int>(),
"add this amount of busy wait workload to each of the iterations"
" [in microseconds], i.e. -b1000 == 1 millisecond")
;
po::store(po::command_line_parser(argc, argv)
.options(desc_cmdline).run(), vm);
po::notify(vm);
// print help screen
if (vm.count("help")) {
std::cout << desc_cmdline;
return false;
}
}
catch (std::exception const& e) {
std::cerr << "fibonacci2: exception caught: " << e.what() << std::endl;
return false;
}
return true;
}
bool readGridGraph(boost::program_options::variables_map& variableMap, int& gridDimension, std::string& message)
{
if(variableMap.count("gridGraph") != 1)
{
message = "Please enter a single value for `input' gridGraph";
return false;
}
gridDimension = variableMap["gridGraph"].as<int>();
if(gridDimension <= 0)
{
message = "Input `gridGraph' must be a positive number";
return false;
}
return true;
}
void local_tests(boost::program_options::variables_map& vm)
{
std::size_t pxthreads = 0;
if (vm.count("pxthreads"))
pxthreads = vm["pxthreads"].as<std::size_t>();
std::size_t iterations = 0;
if (vm.count("iterations"))
iterations = vm["iterations"].as<std::size_t>();
hpx::id_type here = hpx::find_here();
for (std::size_t i = 0; i < iterations; ++i)
{
boost::atomic<std::size_t> c(0);
for (std::size_t j = 0; j < pxthreads; ++j)
{
hpx::async(hpx::util::bind(&barrier_test, pxthreads + 1, j, std::ref(c)));
}
hpx::lcos::barrier b("local_barrier_test", pxthreads + 1, pxthreads);
b.wait(); // wait for all threads to enter the barrier
HPX_TEST_EQ(pxthreads, c.load());
}
}
int checkParameters(int argc,char **argv,po::variables_map & vm) {
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("r1,1", po::value<string>(), "read 1 in fastq format (gzip allowed)")
("r2,2", po::value<string>(), "read 2 in fastq format (gzip allowed)")
("output-prefix,O", po::value<string>(), "output prefix")
("rc", "reverse-complement reads");
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
if (vm.count("help") || argc==1) {
cout << desc << "\n";
exit(1);
}
if (!vm.count("r1") || !vm.count("r2") || !vm.count("output-prefix")) {
cout << "Missing input!"<<endl;
exit(1);
}
return(0);
}
void listLabels( const boost::program_options::variables_map & options )
{
std::string labelRegex = ".*";
if ( options.count( "arg1" ) > 0 )
labelRegex = options[ "arg1" ].as< std::string >();
boost::regex testExpression( labelRegex );
Osmosis::Chain::Chain chain( options[ "objectStores" ].as< std::string >(), false, false );
if ( chain.count() > 1 )
THROW( Error, "--objectStores must contain one object store in a list operation" );
Osmosis::Client::LabelOps instance( chain.single() );
std::list< std::string > result = instance.listLabels( labelRegex );
for ( auto & i : result )
std::cout << i << std::endl;
}
int hpx_main(boost::program_options::variables_map& vm)
{
bool print_header = vm.count("no-header") == 0;
bool do_child = vm.count("no-child") == 0; // fork only
bool do_parent = vm.count("no-parent") == 0; // async only
std::size_t num_cores = hpx::get_os_thread_count();
if (vm.count("num_cores") != 0)
num_cores = vm["num_cores"].as<std::size_t>();
// first collect child stealing times
double child_stealing_time = 0;
if (do_parent)
child_stealing_time = measure(hpx::launch::async);
// now collect parent stealing times
double parent_stealing_time = 0;
if (do_child)
parent_stealing_time = measure(hpx::launch::fork);
if (print_header)
{
hpx::cout
<< "num_cores,num_threads,child_stealing_time[s],parent_stealing_time[s]"
<< hpx::endl;
}
hpx::cout
<< (boost::format("%d,%d,%f,%f") %
num_cores %
iterations %
child_stealing_time %
parent_stealing_time)
<< hpx::endl;
return hpx::finalize();
}
void runConsole(const bpo::variables_map& vm)
{
boost::asio::io_service srv;
Drone drone(vm["address"].as<string>(), srv);
std::auto_ptr<UdpLogger> logger;
std::string logfileName;
if (vm.count("autolog")) {
logfileName = createLogFileName();
} else if (vm.count("loggfile")) {
logfileName = vm["logfile"].as<string>();
}
if (!logfileName.empty()) {
logger.reset(new UdpLogger(srv, 7778, logfileName));
logger->start();
}
if (vm.count("joystick")) {
runJoystickControlled(drone, vm["joystick"].as<string>());
} else {
runKeyboardControlled(drone);
}
}
int hpx_main(boost::program_options::variables_map& vm)
{
unsigned int seed = (unsigned int)std::time(nullptr);
if (vm.count("seed"))
seed = vm["seed"].as<unsigned int>();
std::cout << "using seed: " << seed << std::endl;
std::srand(seed);
test_sort1();
test_sort2();
sort_benchmark();
return hpx::finalize();
}
bool readNGraphs(boost::program_options::variables_map& variableMap, int& out)
{
if(variableMap.count("nGraphs") != 1)
{
std::cout << "Please enter a single option value for input `nGraphs'" << std::endl;
return false;
}
out = variableMap["nGraphs"].as<int>();
if(out <= 0)
{
std::cout << "Input `nGraphs' must be positive" << std::endl;
return false;
}
return true;
}
bool readInitialRadius(boost::program_options::variables_map& variableMap, int& out)
{
if(variableMap.count("initialRadius") != 1)
{
std::cout << "Please enter a single value for input `initialRadius'" << std::endl;
return false;
}
out = variableMap["initialRadius"].as<int>();
if(out < 0)
{
std::cout << "Input `initialRadius' must be nonnegative" << std::endl;
return false;
}
return true;
}
int start( const po::variables_map ¶ms )
{
if( params.count( "server" ) == 0 ) {
throw std::runtime_error("Server endpoint is not defined;\n"
"Use --help for details");
}
/// as far as we use only ONE thread for DB access
/// we don't need rpc-pool anymore
unsigned io_size = params.count( "io-pool-size" )
? params["io-pool-size"].as<unsigned>( )
: 1;
if( io_size < 1 ) {
throw std::runtime_error( "io-pool-size must be at least 1" );
}
typedef std::vector<std::string> string_vector;
string_vector servers = params["server"].as<string_vector>( );
common::pool_pair pp( io_size - 1, 1 );
lukki_db::application app( pp );
for( string_vector::const_iterator b(servers.begin( )), e(servers.end( ));
b != e; ++b)
{
std::cout << "Starting listener at '" << *b << "'...";
app.attach_start_listener( create_from_string( *b, app ) );
std::cout << "Ok\n";
}
pp.get_io_pool( ).attach( );
pp.join_all( );
return 0;
}
static void Run(const boost::program_options::variables_map& map)
{
if (map.count("filename") == 0)
{
printf("Usage:\n\n fivem formats:fraglod *.yft...\n");
return;
}
auto& entries = map["filename"].as<std::vector<boost::filesystem::path>>();
for (auto& filePath : entries)
{
RunFragment(filePath);
}
}
Config createConfig(const opts::variables_map& varMap)
{
// Get the configuration file name.
std::string configFilename = "";
if (varMap.count("config"))
configFilename = varMap["config"].as<std::string>();
pelican::Config config;
if (!configFilename.empty()) {
config = pelican::Config(QString(configFilename.c_str()));
} else {
throw QString("must specify a configuration file");
}
return config;
}
void producer_plugin::plugin_initialize(const boost::program_options::variables_map& options)
{ try {
my->_options = &options;
LOAD_VALUE_SET(options, "producer-name", my->_producers, types::account_name)
if( options.count("private-key") )
{
const std::vector<std::string> key_id_to_wif_pair_strings = options["private-key"].as<std::vector<std::string>>();
for (const std::string& key_id_to_wif_pair_string : key_id_to_wif_pair_strings)
{
auto key_id_to_wif_pair = dejsonify<std::pair<public_key_type, private_key_type>>(key_id_to_wif_pair_string);
my->_private_keys[key_id_to_wif_pair.first] = key_id_to_wif_pair.second;
}
}
} FC_LOG_AND_RETHROW() }
int hpx_main(boost::program_options::variables_map& vm)
{
unsigned int seed = (unsigned int)std::time(nullptr);
if (vm.count("seed"))
seed = vm["seed"].as<unsigned int>();
std::cout << "using seed: " << seed << std::endl;
gen.seed(seed);
for_each_n_exception_test<hpx::parallel::util::projection_identity>();
for_each_n_exception_test<projection_square>();
return hpx::finalize();
}
// handle all --options-config found on the command line
void handle_config_options(boost::program_options::variables_map& vm,
boost::program_options::options_description const& desc_cfgfile,
util::section const& ini, std::size_t node, int error_mode)
{
using boost::program_options::options_description;
if (vm.count("hpx:options-file")) {
std::vector<std::string> const &cfg_files =
vm["hpx:options-file"].as<std::vector<std::string> >();
BOOST_FOREACH(std::string const& cfg_file, cfg_files)
{
// parse a single config file and store the results
read_config_file_options(cfg_file, desc_cfgfile, vm, ini,
node, error_mode);
}
int hpx_main(boost::program_options::variables_map& vm)
{
boost::uint64_t np = vm["np"].as<boost::uint64_t>(); // Number of partitions.
boost::uint64_t nx = vm["nx"].as<boost::uint64_t>(); // Number of grid points.
boost::uint64_t nt = vm["nt"].as<boost::uint64_t>(); // Number of steps.
if (vm.count("no-header"))
header = false;
// Create the stepper object
stepper step;
// Measure execution time.
boost::uint64_t t = hpx::util::high_resolution_clock::now();
// Execute nt time steps on nx grid points and print the final solution.
hpx::future<stepper::space> result = step.do_work(np, nx, nt);
stepper::space solution = result.get();
hpx::wait_all(solution);
boost::uint64_t elapsed = hpx::util::high_resolution_clock::now() - t;
// Print the final solution
if (vm.count("results"))
{
for (std::size_t i = 0; i != np; ++i)
std::cout << "U[" << i << "] = " << solution[i].get() << std::endl;
}
boost::uint64_t const os_thread_count = hpx::get_os_thread_count();
print_time_results(os_thread_count, elapsed, nx, np, nt, header);
return hpx::finalize();
}
void CheckRequiredArgs(const po::variables_map vm)
{
if(!vm.count("input"))
{
std::cout << "input is required!" << std::endl;
exit(-1);
}
/*
if(!vm.count("output"))
{
std::cout << "output is required!" << std::endl;
exit(-1);
}
*/
}
static void parseAppOptions(int argc, char *argv[],
struct app_inst_req &req,
po::variables_map &vm)
{
parseCommandOptions(argc, argv, getAppOptions(), vm);
if (vm.count("app"))
req.appName = vm["app"].as<std::string>();
if (vm.count("pkg"))
req.pkgName = vm["pkg"].as<std::string>();
if (vm.count("path")) {
const std::vector<std::string> paths =
vm["path"].as<std::vector<std::string> >();
if (!loadPaths(paths, req)) {
po::error e("Error in parsing path arguments.");
throw e;
}
}
if (vm.count("privilege")) {
auto privVector = vm["privilege"].as<std::vector<std::string > >();
for (auto &e : privVector)
req.privileges.push_back(std::make_pair(e, std::string()));
if (req.privileges.empty()) {
po::error e("Error in parsing privilege arguments.");
throw e;
}
#ifdef BUILD_TYPE_DEBUG
LogDebug("Passed privileges:");
for (const auto &p : req.privileges) {
LogDebug(" " << p.first);
}
#endif
}
if (vm.count("uid"))
req.uid = vm["uid"].as<uid_t>();
if (vm.count("tizen"))
req.tizenVersion = vm["tizen"].as<std::string>();
if (vm.count("author-id"))
req.authorName = vm["author-id"].as<std::string>();
if (vm.count("install-type"))
req.installationType = install_type_map.at(vm["install-type"].as<std::string>());
}
std::shared_ptr<std::basic_ostream<CharT>> OpenOutput(const po::variables_map& variables)
{
if (variables.count("output"))
{
auto outputPath = variables["output"].as<std::wstring>();
std::shared_ptr<std::basic_ofstream<CharT>> out(new std::basic_ofstream<CharT>(outputPath.c_str(), std::ios_base::trunc | std::ios_base::binary));
if (!out->is_open())
{
std::wcerr << L"Failed to open output file for writing: " << outputPath << std::endl;
return std::shared_ptr<std::basic_ostream<CharT>>();
}
return out;
}
else
return std::shared_ptr<std::basic_ostream<CharT>>(new std::basic_ostream<CharT>(GetRdbuf<CharT>()));
}
void handle_opts(
po::options_description &opts_micro,
po::variables_map &vm
)
{
opts_main.add(opts_micro);
po::store(po::parse_command_line(ac, av, opts_main), vm); // could be exchanged with a config file parser
// hendling the "help" option
if (vm.count("help"))
{
std::cout << opts_main;
exit(EXIT_SUCCESS);
}
po::notify(vm); // includes checks for required options
}
void Command::setup_object_type_nrw(const boost::program_options::variables_map& vm) {
if (vm.count("object-type")) {
m_osm_entity_bits = osmium::osm_entity_bits::nothing;
for (const auto& t : vm["object-type"].as<std::vector<std::string>>()) {
if (t == "n" || t == "node") {
m_osm_entity_bits |= osmium::osm_entity_bits::node;
} else if (t == "w" || t == "way") {
m_osm_entity_bits |= osmium::osm_entity_bits::way;
} else if (t == "r" || t == "relation") {
m_osm_entity_bits |= osmium::osm_entity_bits::relation;
} else {
throw argument_error(std::string("Unknown object type '") + t + "' (Allowed are 'node', 'way', and 'relation').");
}
}
}
}
void __EditYaml(const string& key, po::variables_map& vm) {
if (vm.count(key) != 1)
return;
T v = vm[key].as<T>();
static const auto sep = boost::is_any_of(".");
vector<string> tokens;
boost::split(tokens, key, sep, boost::token_compress_on);
// Had to use a pointer to traverse the tree. Otherwise, the tree gets messed up.
YAML::Node* n = &_yaml_root;
for (string t: tokens) {
YAML::Node n1 = (*n)[t];
n = &n1;
}
*n = v;
//Cons::P(Desc());
}
bool initialise() {
cout << "Initialising program..." << endl;
bool success = true;
// seeds
if (vm.count("seed")) {
theSeed = poSeed;
}
else {
theSeed = time(NULL);
}
//initialise_end:
return success;
}
void monitor_plugin::plugin_initialize(const boost::program_options::variables_map& options) {
try {
ilog("monitor plugin: plugin_initialize() begin");
// 读取参数配置
if (options.count(MONITOR_OPT_ACTION_TYPE)) {
monitor_action_type = options[MONITOR_OPT_ACTION_TYPE].as<uint32_t>();
} else {
monitor_action_type = MONITOR_ACTION_TYPE_ALL;
}
ilog("monitor plugin: plugin_initialize() end");
} FC_LOG_AND_RETHROW()
return;
}