static int ufs_test_run_parallel_read_and_write_test( struct test_iosched *test_iosched) { struct test_scenario *read_data, *write_data; int i; bool changed_seed = false; struct ufs_test_data *utd = test_iosched->blk_dev_test_data; read_data = get_scenario(test_iosched, SCEN_RANDOM_READ_50); write_data = get_scenario(test_iosched, SCEN_RANDOM_WRITE_50); /* allow randomness even if user forgot */ if (utd->random_test_seed <= 0) { changed_seed = true; utd->random_test_seed = 1; } atomic_set(&utd->outstanding_threads, 0); utd->fail_threads = 0; init_completion(&utd->outstanding_complete); for (i = 0; i < (RANDOM_REQUEST_THREADS / 2); i++) { async_schedule(ufs_test_run_scenario, read_data); async_schedule(ufs_test_run_scenario, write_data); atomic_add(2, &utd->outstanding_threads); } if (!wait_for_completion_timeout(&utd->outstanding_complete, THREADS_COMPLETION_TIMOUT)) { pr_err("%s: Multi-thread test timed-out %d threads left", __func__, atomic_read(&utd->outstanding_threads)); } check_test_completion(test_iosched); /* clear random seed if changed */ if (changed_seed) utd->random_test_seed = 0; return 0; }
static int ufs_test_run_lun_depth_test(struct test_data *td) { struct test_scenario *read_data, *write_data; struct scsi_device *sdev; bool changed_seed = false; int i = 0, num_req[LUN_DEPTH_TEST_SIZE]; int lun_qdepth, nutrs, num_scenarios; BUG_ON(!td || !td->req_q || !td->req_q->queuedata); sdev = (struct scsi_device *)td->req_q->queuedata; lun_qdepth = sdev->max_queue_depth; nutrs = sdev->host->can_queue; /* allow randomness even if user forgot */ if (utd->random_test_seed <= 0) { changed_seed = true; utd->random_test_seed = 1; } /* initialize the number of request for each iteration */ num_req[i++] = ufs_test_pseudo_random_seed( &utd->random_test_seed, 1, lun_qdepth - 2); num_req[i++] = lun_qdepth - 1; num_req[i++] = lun_qdepth; num_req[i++] = lun_qdepth + 1; /* if (nutrs-lun_qdepth-2 <= 0), do not run this scenario */ if (nutrs - lun_qdepth - 2 > 0) num_req[i++] = lun_qdepth + 1 + ufs_test_pseudo_random_seed( &utd->random_test_seed, 1, nutrs - lun_qdepth - 2); /* if nutrs == lun_qdepth, do not run these three scenarios */ if (nutrs != lun_qdepth) { num_req[i++] = nutrs - 1; num_req[i++] = nutrs; num_req[i++] = nutrs + 1; } /* a random number up to 10, not to cause overflow or timeout */ num_req[i++] = nutrs + 1 + ufs_test_pseudo_random_seed( &utd->random_test_seed, 1, 10); num_scenarios = i; utd->test_stage = UFS_TEST_LUN_DEPTH_TEST_RUNNING; utd->fail_threads = 0; read_data = get_scenario(td, SCEN_RANDOM_READ_32_NO_FLUSH); write_data = get_scenario(td, SCEN_RANDOM_WRITE_32_NO_FLUSH); for (i = 0; i < num_scenarios; i++) { int reqs = num_req[i]; read_data->total_req = reqs; write_data->total_req = reqs; ufs_test_run_synchronous_scenario(read_data); ufs_test_run_synchronous_scenario(write_data); } utd->test_stage = UFS_TEST_LUN_DEPTH_DONE_ISSUING_REQ; check_test_completion(); /* clear random seed if changed */ if (changed_seed) utd->random_test_seed = 0; return 0; }
void wait::join_game(bool observe) { const bool download_res = download_level_data(); if (!download_res) { DBG_MP << "mp wait: could not download level data, quitting..."; set_result(QUIT); return; } else if (!get_scenario()["allow_new_game"].to_bool(true) && !level_.child_or_empty("multiplayer")["savegame"].to_bool(false)) { set_result(PLAY); return; } if (first_scenario_) { state_ = saved_game(); state_.classification().campaign_type = game_classification::CAMPAIGN_TYPE::MULTIPLAYER; const config* campaign = &game_config_manager::get()-> game_config().find_child("campaign", "id", level_.child("multiplayer")["mp_campaign"]); const config* scenario = &game_config_manager::get()-> game_config().find_child("multiplayer", "id", level_.child(lexical_cast<std::string>(game_classification::CAMPAIGN_TYPE::MULTIPLAYER))["id"]); const config* era = &game_config_manager::get()-> game_config().find_child("era", "id", level_.child("era")["id"]); if (*campaign) { state_.classification().difficulty = level_.child("multiplayer")["difficulty_define"].str(); state_.classification().campaign_define = (*campaign)["define"].str(); state_.classification().campaign_xtra_defines = utils::split((*campaign)["extra_defines"]); } if (*scenario) state_.classification().scenario_define = (*scenario)["define"].str(); if (*era) state_.classification().era_define = (*era)["define"].str(); BOOST_FOREACH(const config& mod, level_.child_range("modification")) { const config* modification = &game_config_manager::get()-> game_config().find_child("modification", "id", mod["id"]); if (*modification) { state_.classification().mod_defines.push_back( (*modification)["define"].str()); } } // Make sure that we have the same config as host, if possible. game_config_manager::get()-> load_game_config_for_game(state_.classification()); } // Add the map name to the title. append_to_title(": " + get_scenario()["name"].t_str()); if (!observe) { //search for an appropriate vacant slot. If a description is set //(i.e. we're loading from a saved game), then prefer to get the side //with the same description as our login. Otherwise just choose the first //available side. const config *side_choice = NULL; int side_num = -1, nb_sides = 0; BOOST_FOREACH(const config &sd, get_scenario().child_range("side")) { DBG_MP << "*** side " << nb_sides << "***\n" << sd.debug() << "***\n"; if (sd["controller"] == "reserved" && sd["current_player"] == preferences::login()) { side_choice = &sd; side_num = nb_sides; break; } if (sd["controller"] == "network" && sd["player_id"].empty()) { if (!side_choice) { // found the first empty side side_choice = &sd; side_num = nb_sides; } if (sd["current_player"] == preferences::login()) { side_choice = &sd; side_num = nb_sides; break; // found the preferred one } } ++nb_sides; } if (!side_choice) { size_t count = 0; for(config::child_itors its = get_scenario().child_range("side"); its.second != its.first; ++its.first) { ++count; } DBG_MP << "could not find a side, all " << count << " sides were unsuitable\n"; set_result(QUIT); return; } bool allow_changes = (*side_choice)["allow_changes"].to_bool(true); //if the client is allowed to choose their team, instead of having //it set by the server, do that here. if(allow_changes) { events::event_context context; const config &era = level_.child("era"); /** @todo Check whether we have the era. If we don't inform the user. */ if (!era) throw config::error(_("No era information found.")); config::const_child_itors possible_sides = era.child_range("multiplayer_side"); if (possible_sides.first == possible_sides.second) { set_result(QUIT); throw config::error(_("No multiplayer sides found")); } int color = side_num; const std::string color_str = (*side_choice)["color"]; if (!color_str.empty()) color = game_config::color_info(color_str).index() - 1; std::vector<const config*> era_factions; BOOST_FOREACH(const config &side, possible_sides) { era_factions.push_back(&side); } const bool lock_settings = get_scenario()["force_lock_settings"].to_bool(); const bool use_map_settings = level_.child("multiplayer")["mp_use_map_settings"].to_bool(); const bool saved_game = level_.child("multiplayer")["savegame"].to_bool(); ng::flg_manager flg(era_factions, *side_choice, lock_settings, use_map_settings, saved_game, color); std::vector<std::string> choices; BOOST_FOREACH(const config *s, flg.choosable_factions()) { const config &side = *s; const std::string &name = side["name"]; const std::string &icon = side["image"]; if (!icon.empty()) { std::string rgb = side["flag_rgb"]; if (rgb.empty()) rgb = "magenta"; choices.push_back(IMAGE_PREFIX + icon + "~RC(" + rgb + ">" + lexical_cast<std::string>(color+1) + ")" + COLUMN_SEPARATOR + name); } else { choices.push_back(name); } } std::vector<gui::preview_pane* > preview_panes; leader_preview_pane leader_selector(disp(), flg, color); preview_panes.push_back(&leader_selector); const int faction_choice = gui::show_dialog(disp(), NULL, _("Choose your faction:"), _("Starting position: ") + lexical_cast<std::string>(side_num + 1), gui::OK_CANCEL, &choices, &preview_panes); if(faction_choice < 0) { set_result(QUIT); return; } config faction; config& change = faction.add_child("change_faction"); change["change_faction"] = true; change["name"] = preferences::login(); change["faction"] = flg.current_faction()["id"]; change["leader"] = flg.current_leader(); change["gender"] = flg.current_gender(); network::send_data(faction, 0); } }