int PROXY_INFO::parse(XML_PARSER& xp) { memset(this, 0, sizeof(PROXY_INFO)); while (!xp.get_tag()) { if (xp.match_tag("/proxy_info")) { present = false; if (strlen(http_server_name)) present = true; if (strlen(socks_server_name)) present = true; return 0; } if (xp.parse_bool("use_http_proxy", use_http_proxy)) continue; if (xp.parse_bool("use_socks_proxy", use_socks_proxy)) continue; if (xp.parse_bool("use_http_auth", use_http_auth)) continue; if (xp.parse_str("socks_server_name", socks_server_name, sizeof(socks_server_name))) continue; if (xp.parse_int("socks_server_port", socks_server_port)) continue; if (xp.parse_str("http_server_name", http_server_name, sizeof(http_server_name))) continue; if (xp.parse_int("http_server_port", http_server_port)) continue; if (xp.parse_str("socks5_user_name", socks5_user_name,sizeof(socks5_user_name))) continue; if (xp.parse_str("socks5_user_passwd", socks5_user_passwd,sizeof(socks5_user_passwd))) continue; if (xp.parse_bool("socks5_remote_dns", socks5_remote_dns)) continue; if (xp.parse_str("http_user_name", http_user_name,sizeof(http_user_name))) continue; if (xp.parse_str("http_user_passwd", http_user_passwd,sizeof(http_user_passwd))) continue; if (xp.parse_str("no_proxy", noproxy_hosts, sizeof(noproxy_hosts))) continue; if (xp.parse_bool("no_autodetect", no_autodetect)) continue; } return ERR_XML_PARSE; }
int SCHED_DB_RESULT::parse_from_client(XML_PARSER& xp) { double dtemp; bool btemp; string stemp; int itemp; // should be non-zero if exit_status is not found exit_status = ERR_NO_EXIT_STATUS; memset(this, 0, sizeof(*this)); while (!xp.get_tag()) { if (xp.match_tag("/result")) { return 0; } if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_int("state", client_state)) continue; if (xp.parse_double("final_cpu_time", cpu_time)) continue; if (xp.parse_double("final_elapsed_time", elapsed_time)) continue; if (xp.parse_int("exit_status", exit_status)) continue; if (xp.parse_int("app_version_num", app_version_num)) continue; if (xp.match_tag("file_info")) { string s; xp.copy_element(s); safe_strcat(xml_doc_out, s.c_str()); continue; } if (xp.match_tag("stderr_out" )) { copy_element_contents(xp.f->f, "</stderr_out>", stderr_out, sizeof(stderr_out)); continue; } if (xp.parse_string("platform", stemp)) continue; if (xp.parse_int("version_num", itemp)) continue; if (xp.parse_string("plan_class", stemp)) continue; if (xp.parse_double("completed_time", dtemp)) continue; if (xp.parse_string("file_name", stemp)) continue; if (xp.match_tag("file_ref")) { xp.copy_element(stemp); continue; } if (xp.parse_string("open_name", stemp)) continue; if (xp.parse_bool("ready_to_report", btemp)) continue; if (xp.parse_double("report_deadline", dtemp)) continue; if (xp.parse_string("wu_name", stemp)) continue; // deprecated stuff if (xp.parse_double("fpops_per_cpu_sec", dtemp)) continue; if (xp.parse_double("fpops_cumulative", dtemp)) continue; if (xp.parse_double("intops_per_cpu_sec", dtemp)) continue; if (xp.parse_double("intops_cumulative", dtemp)) continue; log_messages.printf(MSG_NORMAL, "RESULT::parse_from_client(): unrecognized: %s\n", xp.parsed_tag ); } return ERR_XML_PARSE; }
int HOST::parse(XML_PARSER& xp) { p_ncpus = 1; double dtemp; string stemp; while (!xp.get_tag()) { if (xp.match_tag("/host_info")) return 0; if (xp.parse_int("timezone", timezone)) continue; if (xp.parse_str("domain_name", domain_name, sizeof(domain_name))) continue; if (xp.parse_str("ip_addr", last_ip_addr, sizeof(last_ip_addr))) continue; if (xp.parse_str("host_cpid", host_cpid, sizeof(host_cpid))) continue; if (xp.parse_int("p_ncpus", p_ncpus)) continue; if (xp.parse_str("p_vendor", p_vendor, sizeof(p_vendor))) continue; if (xp.parse_str("p_model", p_model, sizeof(p_model))) continue; if (xp.parse_double("p_fpops", p_fpops)) continue; if (xp.parse_double("p_iops", p_iops)) continue; if (xp.parse_double("p_membw", p_membw)) continue; if (xp.parse_str("os_name", os_name, sizeof(os_name))) continue; if (xp.parse_str("os_version", os_version, sizeof(os_version))) continue; if (xp.parse_double("m_nbytes", m_nbytes)) continue; if (xp.parse_double("m_cache", m_cache)) continue; if (xp.parse_double("m_swap", m_swap)) continue; if (xp.parse_double("d_total", d_total)) continue; if (xp.parse_double("d_free", d_free)) continue; if (xp.parse_double("n_bwup", n_bwup)) continue; if (xp.parse_double("n_bwdown", n_bwdown)) continue; if (xp.parse_str("p_features", p_features, sizeof(p_features))) continue; if (xp.parse_str("virtualbox_version", virtualbox_version, sizeof(virtualbox_version))) continue; if (xp.parse_bool("p_vm_extensions_disabled", p_vm_extensions_disabled)) continue; // parse deprecated fields to avoid error messages // if (xp.parse_double("p_calculated", dtemp)) continue; if (xp.match_tag("p_fpop_err")) continue; if (xp.match_tag("p_iop_err")) continue; if (xp.match_tag("p_membw_err")) continue; // fields reported by 5.5+ clients, not currently used // if (xp.parse_string("p_capabilities", stemp)) continue; if (xp.parse_string("accelerators", stemp)) continue; #if 1 // not sure where these fields belong in the above categories // if (xp.parse_string("cpu_caps", stemp)) continue; if (xp.parse_string("cache_l1", stemp)) continue; if (xp.parse_string("cache_l2", stemp)) continue; if (xp.parse_string("cache_l3", stemp)) continue; #endif log_messages.printf(MSG_NORMAL, "HOST::parse(): unrecognized: %s\n", xp.parsed_tag ); } return ERR_XML_PARSE; }
int PCI_INFO::parse(XML_PARSER& xp) { present = false; bus_id = device_id = domain_id = 0; while (!xp.get_tag()) { if (xp.match_tag("/pci_info")) { return 0; } if (xp.parse_int("bus_id", bus_id)) continue; if (xp.parse_int("device_id", device_id)) continue; if (xp.parse_int("domain_id", domain_id)) continue; } return ERR_XML_PARSE; }
int HOST_INFO::parse(XML_PARSER& xp, bool benchmarks_only) { while (!xp.get_tag()) { if (xp.match_tag("/host_info")) return 0; if (xp.parse_double("p_fpops", p_fpops)) { // fix foolishness that could result in negative value here // if (p_fpops < 0) p_fpops = -p_fpops; continue; } if (xp.parse_double("p_iops", p_iops)) { if (p_iops < 0) p_iops = -p_iops; continue; } if (xp.parse_double("p_membw", p_membw)) { if (p_membw < 0) p_membw = -p_membw; continue; } if (xp.parse_double("p_calculated", p_calculated)) continue; if (xp.parse_bool("p_vm_extensions_disabled", p_vm_extensions_disabled)) continue; if (benchmarks_only) continue; // WARNING: NOTHING AFTER HERE IS READ FROM STATE FILE ON THE CLIENT if (xp.parse_int("timezone", timezone)) continue; if (xp.parse_str("domain_name", domain_name, sizeof(domain_name))) continue; if (xp.parse_str("ip_addr", ip_addr, sizeof(ip_addr))) continue; if (xp.parse_str("host_cpid", host_cpid, sizeof(host_cpid))) continue; if (xp.parse_int("p_ncpus", p_ncpus)) continue; if (xp.parse_str("p_vendor", p_vendor, sizeof(p_vendor))) continue; if (xp.parse_str("p_model", p_model, sizeof(p_model))) continue; if (xp.parse_str("p_features", p_features, sizeof(p_features))) { downcase_string(p_features); continue; } if (xp.parse_double("m_nbytes", m_nbytes)) continue; if (xp.parse_double("m_cache", m_cache)) continue; if (xp.parse_double("m_swap", m_swap)) continue; if (xp.parse_double("d_total", d_total)) continue; if (xp.parse_double("d_free", d_free)) continue; if (xp.parse_str("os_name", os_name, sizeof(os_name))) continue; if (xp.parse_str("os_version", os_version, sizeof(os_version))) continue; if (xp.parse_str("virtualbox_version", virtualbox_version, sizeof(virtualbox_version))) continue; if (xp.match_tag("coprocs")) { this->coprocs.parse(xp); } } return ERR_XML_PARSE; }
// parse a <result> element from scheduling server. // int RESULT::parse_server(XML_PARSER& xp) { FILE_REF file_ref; clear(); while (!xp.get_tag()) { if (xp.match_tag("/result")) return 0; if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_str("wu_name", wu_name, sizeof(wu_name))) continue; if (xp.parse_double("report_deadline", report_deadline)) continue; if (xp.parse_str("platform", platform, sizeof(platform))) continue; if (xp.parse_str("plan_class", plan_class, sizeof(plan_class))) continue; if (xp.parse_int("version_num", version_num)) continue; if (xp.match_tag("file_ref")) { file_ref.parse(xp); output_files.push_back(file_ref); continue; } if (xp.parse_bool("report_immediately", report_immediately)) continue; if (log_flags.unparsed_xml) { msg_printf(0, MSG_INFO, "[unparsed_xml] RESULT::parse(): unrecognized: %s\n", xp.parsed_tag ); } xp.skip_unexpected(); } return ERR_XML_PARSE; }
// This is to parse our own XML. // parse_rss() parses an RSS feed item. // int NOTICE::parse(XML_PARSER& xp) { clear(); while (!xp.get_tag()) { if (!xp.is_tag) continue; if (xp.match_tag("/notice")) { if (strcasestr(description.c_str(), "youtube.com")) { is_youtube_video = true; } return 0; } if (xp.parse_int("seqno", seqno)) continue; if (xp.parse_str("title", title, sizeof(title))) continue; if (xp.parse_string("description", description)) { xml_unescape(description); // 2nd pass continue; } if (xp.parse_double("create_time", create_time)) continue; if (xp.parse_double("arrival_time", arrival_time)) continue; if (xp.parse_bool("is_private", is_private)) continue; if (xp.parse_str("category", category, sizeof(category))) continue; if (xp.parse_str("link", link, sizeof(link))) continue; if (xp.parse_str("project_name", project_name, sizeof(project_name))) continue; if (xp.parse_str("guid", guid, sizeof(guid))) continue; if (xp.parse_str("feed_url", feed_url, sizeof(feed_url))) continue; } return ERR_XML_PARSE; }
int COPROC::parse(XML_PARSER& xp) { char buf[256]; strcpy(type, ""); clear(); for (int i=0; i<MAX_COPROC_INSTANCES; i++) { device_nums[i] = i; } while (!xp.get_tag()) { if (!xp.is_tag) continue; if (xp.match_tag("/coproc")) { if (!strlen(type)) return ERR_XML_PARSE; clear_usage(); return 0; } if (xp.parse_str("type", type, sizeof(type))) continue; if (xp.parse_int("count", count)) continue; if (xp.parse_double("req_secs", req_secs)) continue; if (xp.parse_double("req_instances", req_instances)) continue; if (xp.parse_double("peak_flops", peak_flops)) continue; if (xp.parse_str("device_nums", buf, sizeof(buf))) { int i=0; char* p = strtok(buf, " "); while (p && i<MAX_COPROC_INSTANCES) { device_nums[i++] = atoi(p); p = strtok(NULL, " "); } continue; } if (xp.parse_bool("non_gpu", non_gpu)) continue; } return ERR_XML_PARSE; }
int APP_CONFIG::parse(XML_PARSER& xp, PROJECT* p) { memset(this, 0, sizeof(APP_CONFIG)); while (!xp.get_tag()) { if (xp.match_tag("/app")) return 0; if (xp.parse_str("name", name, 256)) continue; if (xp.parse_int("max_concurrent", max_concurrent)) { if (max_concurrent) have_max_concurrent = true; continue; } if (xp.match_tag("gpu_versions")) { while (!xp.get_tag()) { if (xp.match_tag("/gpu_versions")) break; if (xp.parse_double("gpu_usage", gpu_gpu_usage)) continue; if (xp.parse_double("cpu_usage", gpu_cpu_usage)) continue; } continue; } if (log_flags.unparsed_xml) { msg_printf(p, MSG_INFO, "Unparsed line in app_info.xml: %s", xp.parsed_tag ); } xp.skip_unexpected(log_flags.unparsed_xml, "APP_CONFIG::parse"); } return ERR_XML_PARSE; }
int APP_CONFIG::parse(XML_PARSER& xp, MSG_VEC& mv, LOG_FLAGS& log_flags) { char buf[1024]; memset(this, 0, sizeof(APP_CONFIG)); while (!xp.get_tag()) { if (xp.match_tag("/app")) return 0; if (xp.parse_str("name", name, 256)) continue; if (xp.parse_int("max_concurrent", max_concurrent)) { if (max_concurrent) have_max_concurrent = true; continue; } if (xp.match_tag("gpu_versions")) { int retval = parse_gpu_versions(xp, mv, log_flags); if (retval) return retval; continue; } if (xp.parse_bool("fraction_done_exact", fraction_done_exact)) { continue; } if (xp.parse_bool("report_results_immediately", report_results_immediately)) { continue; } // unparsed XML not considered an error; maybe it should be? // if (log_flags.unparsed_xml) { sprintf(buf, "Unparsed line in app_config.xml: %s", xp.parsed_tag); mv.push_back(string(buf)); } xp.skip_unexpected(log_flags.unparsed_xml, "APP_CONFIG::parse"); } mv.push_back(string("Missing </app> in app_config.xml")); return ERR_XML_PARSE; }
int TASK::parse(XML_PARSER& xp) { char buf[8192]; weight = 1; current_cpu_time = 0; final_cpu_time = 0; stat_first = true; pid = 0; is_daemon = false; multi_process = false; append_cmdline_args = false; time_limit = 0; priority = PROCESS_PRIORITY_LOWEST; while (!xp.get_tag()) { if (!xp.is_tag) { fprintf(stderr, "%s TASK::parse(): unexpected text %s\n", boinc_msg_prefix(buf, sizeof(buf)), xp.parsed_tag ); continue; } if (xp.match_tag("/task")) { return 0; } else if (xp.parse_string("application", application)) continue; else if (xp.parse_str("exec_dir", buf, sizeof(buf))) { macro_substitute(buf); exec_dir = buf; continue; } else if (xp.parse_str("setenv", buf, sizeof(buf))) { macro_substitute(buf); vsetenv.push_back(buf); continue; } else if (xp.parse_string("stdin_filename", stdin_filename)) continue; else if (xp.parse_string("stdout_filename", stdout_filename)) continue; else if (xp.parse_string("stderr_filename", stderr_filename)) continue; else if (xp.parse_str("command_line", buf, sizeof(buf))) { macro_substitute(buf); command_line = buf; continue; } else if (xp.parse_string("checkpoint_filename", checkpoint_filename)) continue; else if (xp.parse_string("fraction_done_filename", fraction_done_filename)) continue; else if (xp.parse_double("weight", weight)) continue; else if (xp.parse_bool("daemon", is_daemon)) continue; else if (xp.parse_bool("multi_process", multi_process)) continue; else if (xp.parse_bool("append_cmdline_args", append_cmdline_args)) continue; else if (xp.parse_double("time_limit", time_limit)) continue; else if (xp.parse_int("priority", priority)) continue; } return ERR_XML_PARSE; }
int DAILY_XFER::parse(XML_PARSER& xp) { char tag[1024]; bool is_tag; while (!xp.get(tag, sizeof(tag), is_tag)) { if (!strcmp(tag, "/dx")) return 0; if (xp.parse_int(tag, "when", when)) continue; if (xp.parse_double(tag, "up", up)) continue; if (xp.parse_double(tag, "down", down)) continue; } return ERR_XML_PARSE; }
int COMPLETED_JOB_DESC::parse(XML_PARSER& xp) { canonical_resultid = 0; error_mask = 0; error_resultid = 0; exit_status = 0; elapsed_time = 0; cpu_time = 0; while (!xp.get_tag()) { if (xp.match_tag("/completed_job")) return 0; if (xp.parse_int("canonical_resultid", canonical_resultid)) continue; if (xp.parse_int("error_mask", error_mask)) continue; if (xp.parse_int("error_resultid", error_resultid)) continue; if (xp.parse_int("exit_status", exit_status)) continue; if (xp.parse_double("elapsed_time", elapsed_time)) continue; if (xp.parse_double("cpu_time", cpu_time)) continue; if (xp.parse_string("stderr_out", stderr_out)) { xml_unescape(stderr_out); continue; } } return ERR_XML_PARSE; }
int WORKUNIT::parse(XML_PARSER& xp) { FILE_REF file_ref; double dtemp; strcpy(name, ""); strcpy(app_name, ""); version_num = 0; command_line = ""; //strcpy(env_vars, ""); app = NULL; project = NULL; // Default these to very large values (1 week on a 1 cobblestone machine) // so we don't keep asking the server for more work rsc_fpops_est = 1e9*SECONDS_PER_DAY*7; rsc_fpops_bound = 4e9*SECONDS_PER_DAY*7; rsc_memory_bound = 1e8; rsc_disk_bound = 1e9; while (!xp.get_tag()) { if (xp.match_tag("/workunit")) return 0; if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_str("app_name", app_name, sizeof(app_name))) continue; if (xp.parse_int("version_num", version_num)) continue; if (xp.parse_string("command_line", command_line)) { strip_whitespace(command_line); continue; } //if (xp.parse_str("env_vars", env_vars, sizeof(env_vars))) continue; if (xp.parse_double("rsc_fpops_est", rsc_fpops_est)) continue; if (xp.parse_double("rsc_fpops_bound", rsc_fpops_bound)) continue; if (xp.parse_double("rsc_memory_bound", rsc_memory_bound)) continue; if (xp.parse_double("rsc_disk_bound", rsc_disk_bound)) continue; if (xp.match_tag("file_ref")) { file_ref.parse(xp); #ifndef SIM input_files.push_back(file_ref); #endif continue; } // unused stuff if (xp.parse_double("credit", dtemp)) continue; if (log_flags.unparsed_xml) { msg_printf(0, MSG_INFO, "[unparsed_xml] WORKUNIT::parse(): unrecognized: %s\n", xp.parsed_tag ); } xp.skip_unexpected(); } return ERR_XML_PARSE; }
int VBOX_PORT_FORWARD::parse(XML_PARSER& xp) { while (!xp.get_tag()) { if (xp.match_tag("/port_forward")) { if (!host_port) { vboxlog_msg("VBOX_PORT_FORWARD::parse(): unspecified host port"); return ERR_XML_PARSE; } if (!guest_port) { vboxlog_msg("VBOX_PORT_FORWARD::parse(): unspecified guest port"); return ERR_XML_PARSE; } return 0; } else if (xp.parse_bool("is_remote", is_remote)) continue; else if (xp.parse_int("host_port", host_port)) continue; else if (xp.parse_int("guest_port", guest_port)) continue; else if (xp.parse_int("nports", nports)) continue; else { vboxlog_msg("VBOX_PORT_FORWARD::parse(): unexpected text %s", xp.parsed_tag); } } return ERR_XML_PARSE; }
int FILE_INFO::parse(XML_PARSER& xp) { memset(this, 0, sizeof(*this)); while (!xp.get_tag()) { if (xp.match_tag("/file_info")) { if (!strlen(name)) return ERR_XML_PARSE; return 0; } if (xp.parse_str("name", name, 256)) continue; if (xp.parse_double("nbytes", nbytes)) continue; if (xp.parse_int("status", status)) continue; if (xp.parse_bool("sticky", sticky)) continue; } return ERR_XML_PARSE; }
int CLIENT_APP_VERSION::parse(XML_PARSER& xp) { double x; memset(this, 0, sizeof(*this)); host_usage.avg_ncpus = 1; while (!xp.get_tag()) { if (xp.match_tag("/app_version")) { app = ssp->lookup_app_name(app_name); if (!app) return ERR_NOT_FOUND; double pf = host_usage.avg_ncpus * g_reply->host.p_fpops; if (host_usage.ncudas && g_request->coprocs.nvidia.count) { pf += host_usage.ncudas*g_request->coprocs.nvidia.peak_flops; } if (host_usage.natis && g_request->coprocs.ati.count) { pf += host_usage.natis*g_request->coprocs.ati.peak_flops; } host_usage.peak_flops = pf; return 0; } if (xp.parse_str("app_name", app_name, 256)) continue; if (xp.parse_str("platform", platform, 256)) continue; if (xp.parse_str("plan_class", plan_class, 256)) continue; if (xp.parse_int("version_num", version_num)) continue; if (xp.parse_double("avg_ncpus", x)) { if (x>0) host_usage.avg_ncpus = x; continue; } if (xp.parse_double("flops", x)) { if (x>0) host_usage.projected_flops = x; continue; } if (xp.match_tag("coproc")) { COPROC_REQ coproc_req; int retval = coproc_req.parse(xp); if (!retval && !strcmp(coproc_req.type, "CUDA")) { host_usage.ncudas = coproc_req.count; } if (!retval && !strcmp(coproc_req.type, "NVIDIA")) { host_usage.ncudas = coproc_req.count; } if (!retval && !strcmp(coproc_req.type, "ATI")) { host_usage.natis = coproc_req.count; } continue; } } return ERR_XML_PARSE; }
int CLIENT_APP_VERSION::parse(XML_PARSER& xp) { double x; memset(this, 0, sizeof(*this)); host_usage.avg_ncpus = 1; while (!xp.get_tag()) { if (xp.match_tag("/app_version")) { app = ssp->lookup_app_name(app_name); if (!app) return ERR_NOT_FOUND; double pf = host_usage.avg_ncpus * g_reply->host.p_fpops; if (host_usage.proc_type != PROC_TYPE_CPU) { COPROC* cp = g_request->coprocs.type_to_coproc(host_usage.proc_type); pf += host_usage.gpu_usage*cp->peak_flops; } host_usage.peak_flops = pf; return 0; } if (xp.parse_str("app_name", app_name, 256)) continue; if (xp.parse_str("platform", platform, 256)) continue; if (xp.parse_str("plan_class", plan_class, 256)) continue; if (xp.parse_int("version_num", version_num)) continue; if (xp.parse_double("avg_ncpus", x)) { if (x>0) host_usage.avg_ncpus = x; continue; } if (xp.parse_double("flops", x)) { if (x>0) host_usage.projected_flops = x; continue; } if (xp.match_tag("coproc")) { COPROC_REQ coproc_req; int retval = coproc_req.parse(xp); if (!retval) { int rt = coproc_type_name_to_num(coproc_req.type); if (!rt) { log_messages.printf(MSG_NORMAL, "UNKNOWN COPROC TYPE %s\n", coproc_req.type ); continue; } host_usage.proc_type = rt; host_usage.gpu_usage = coproc_req.count; } continue; } } return ERR_XML_PARSE; }
int OTHER_RESULT::parse(XML_PARSER& xp) { strcpy(name, ""); have_plan_class = false; app_version = -1; while (!xp.get_tag()) { if (xp.match_tag("/other_result")) { if (!strcmp(name, "")) return ERR_XML_PARSE; return 0; } if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_int("app_version", app_version)) continue; if (xp.parse_str("plan_class", plan_class, sizeof(plan_class))) { have_plan_class = true; continue; } } return ERR_XML_PARSE; }
int RSC_JOB_LIMIT::parse(XML_PARSER& xp, const char* end_tag) { per_proc = false; while (!xp.get_tag()) { if (!xp.is_tag) { continue; } if (xp.match_tag(end_tag)) { return 0; } if (xp.parse_int("jobs", base_limit)) { continue; } if (xp.parse_bool("per_proc", per_proc)) { continue; } } return ERR_XML_PARSE; }
int APP::parse(XML_PARSER& xp) { strcpy(name, ""); strcpy(user_friendly_name, ""); project = NULL; non_cpu_intensive = false; while (!xp.get_tag()) { if (xp.match_tag("/app")) { if (!strlen(user_friendly_name)) { safe_strcpy(user_friendly_name, name); } return 0; } if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_str("user_friendly_name", user_friendly_name, sizeof(user_friendly_name))) continue; if (xp.parse_bool("non_cpu_intensive", non_cpu_intensive)) continue; #ifdef SIM if (xp.parse_double("latency_bound", latency_bound)) continue; if (xp.parse_double("fpops_est", fpops_est)) continue; if (xp.parse_double("weight", weight)) continue; if (xp.parse_double("working_set", working_set)) continue; if (xp.match_tag("fpops")) { fpops.parse(xp, "/fpops"); continue; } if (xp.parse_int("max_concurrent", max_concurrent)) { if (max_concurrent) have_max_concurrent = true; continue; } if (xp.match_tag("checkpoint_period")) { checkpoint_period.parse(xp, "/checkpoint_period"); continue; } #endif if (log_flags.unparsed_xml) { msg_printf(0, MSG_INFO, "[unparsed_xml] APP::parse(): unrecognized: %s\n", xp.parsed_tag ); } xp.skip_unexpected(); } return ERR_XML_PARSE; }
int APP_CONFIGS::parse(XML_PARSER& xp, MSG_VEC& mv, LOG_FLAGS& log_flags) { char buf[1024]; int n; clear(); while (!xp.get_tag()) { if (!xp.is_tag) { sprintf(buf, "unexpected text '%s' in app_config.xml", xp.parsed_tag); mv.push_back(string(buf)); return ERR_XML_PARSE; } if (xp.match_tag("/app_config")) return 0; if (xp.match_tag("app")) { APP_CONFIG ac; int retval = ac.parse(xp, mv, log_flags); if (retval) return retval; app_configs.push_back(ac); continue; } if (xp.match_tag("app_version")) { APP_VERSION_CONFIG avc; int retval = avc.parse(xp, mv, log_flags); if (retval) return retval; app_version_configs.push_back(avc); continue; } if (xp.parse_int("project_max_concurrent", n)) { if (n >= 0) { have_max_concurrent = true; project_max_concurrent = n; } continue; } if (xp.parse_bool("report_results_immediately", report_results_immediately)) { continue; } sprintf(buf, "Unknown tag in app_config.xml: %s", xp.parsed_tag); mv.push_back(string(buf)); xp.skip_unexpected(log_flags.unparsed_xml, "APP_CONFIGS::parse"); } mv.push_back(string("Missing </app_config> in app_config.xml")); return ERR_XML_PARSE; }
int GLOBAL_PREFS::parse_day(XML_PARSER& xp) { int day_of_week = -1; bool has_cpu = false; bool has_net = false; double start_hour = 0; double end_hour = 0; double net_start_hour = 0; double net_end_hour = 0; while (!xp.get_tag()) { if (!xp.is_tag) continue; if (xp.match_tag("/day_prefs")) { if (day_of_week < 0 || day_of_week > 6) return ERR_XML_PARSE; if (has_cpu) { cpu_times.week.set(day_of_week, start_hour, end_hour); } if (has_net) { net_times.week.set(day_of_week, net_start_hour, net_end_hour); } return 0; } if (xp.parse_int("day_of_week", day_of_week)) continue; if (xp.parse_double("start_hour", start_hour)) { has_cpu = true; continue; } if (xp.parse_double("end_hour", end_hour)) { has_cpu = true; continue; } if (xp.parse_double("net_start_hour", net_start_hour)) { has_net = true; continue; } if (xp.parse_double("net_end_hour", net_end_hour)) { has_net = true; continue; } xp.skip_unexpected(true, "GLOBAL_PREFS::parse_day"); } return ERR_XML_PARSE; }
int EXCLUDE_GPU::parse(XML_PARSER& xp) { bool found_url = false; type = ""; appname = ""; device_num = -1; while (!xp.get_tag()) { if (!xp.is_tag) continue; if (xp.match_tag("/exclude_gpu")) { if (!found_url) return ERR_XML_PARSE; return 0; } if (xp.parse_string("url", url)) { canonicalize_master_url(url); found_url = true; continue; } if (xp.parse_int("device_num", device_num)) continue; if (xp.parse_string("type", type)) continue; if (xp.parse_string("app", appname)) continue; } return ERR_XML_PARSE; }
// Parse XML information about a persistent file transfer // int PERS_FILE_XFER::parse(XML_PARSER& xp) { while (!xp.get_tag()) { if (xp.match_tag("/persistent_file_xfer")) return 0; else if (xp.parse_int("num_retries", nretry)) continue; else if (xp.parse_double("first_request_time", first_request_time)) { continue; } else if (xp.parse_double("next_request_time", next_request_time)) { continue; } else if (xp.parse_double("time_so_far", time_so_far)) continue; else if (xp.parse_double("last_bytes_xferred", last_bytes_xferred)) continue; else if (xp.parse_bool("is_upload", is_upload)) continue; else { if (log_flags.unparsed_xml) { msg_printf(NULL, MSG_INFO, "[unparsed_xml] Unparsed line in file transfer info: %s", xp.parsed_tag ); } } } return ERR_XML_PARSE; }
int ACTIVE_TASK::parse(XML_PARSER& xp) { char result_name[256], project_master_url[256]; int n, dummy; unsigned int i; PROJECT* project=0; double x; safe_strcpy(result_name, ""); safe_strcpy(project_master_url, ""); while (!xp.get_tag()) { if (xp.match_tag("/active_task")) { project = gstate.lookup_project(project_master_url); if (!project) { msg_printf( NULL, MSG_INTERNAL_ERROR, "State file error: project %s not found for task\n", project_master_url ); return ERR_NULL; } result = gstate.lookup_result(project, result_name); if (!result) { msg_printf( project, MSG_INTERNAL_ERROR, "State file error: result %s not found for task\n", result_name ); return ERR_NULL; } // various sanity checks // if (result->got_server_ack || result->ready_to_report || result->state() != RESULT_FILES_DOWNLOADED ) { return ERR_BAD_RESULT_STATE; } wup = result->wup; app_version = gstate.lookup_app_version( result->app, result->platform, result->version_num, result->plan_class ); if (!app_version) { msg_printf( project, MSG_INTERNAL_ERROR, "State file error: app %s platform %s version %d not found\n", result->app->name, result->platform, result->version_num ); return ERR_NULL; } // make sure no two active tasks are in same slot // for (i=0; i<gstate.active_tasks.active_tasks.size(); i++) { ACTIVE_TASK* atp = gstate.active_tasks.active_tasks[i]; if (atp->slot == slot) { msg_printf(project, MSG_INTERNAL_ERROR, "State file error: two tasks in slot %d\n", slot ); return ERR_BAD_RESULT_STATE; } } // for 6.2/6.4 transition // if (checkpoint_elapsed_time == 0) { elapsed_time = checkpoint_cpu_time; checkpoint_elapsed_time = elapsed_time; } // for 6.12.25-26 transition; // old clients write fraction_done to state file; // new clients don't if (fraction_done && checkpoint_elapsed_time) { checkpoint_fraction_done = fraction_done; checkpoint_fraction_done_elapsed_time = checkpoint_elapsed_time; fraction_done_elapsed_time = checkpoint_elapsed_time; } else { fraction_done = checkpoint_fraction_done; fraction_done_elapsed_time = checkpoint_fraction_done_elapsed_time; } return 0; } else if (xp.parse_str("result_name", result_name, sizeof(result_name))) continue; else if (xp.parse_str("project_master_url", project_master_url, sizeof(project_master_url))) continue; else if (xp.parse_int("slot", slot)) continue; else if (xp.parse_int("active_task_state", dummy)) continue; else if (xp.parse_double("checkpoint_cpu_time", checkpoint_cpu_time)) continue; else if (xp.parse_double("checkpoint_elapsed_time", checkpoint_elapsed_time)) continue; else if (xp.parse_double("checkpoint_fraction_done", checkpoint_fraction_done)) continue; else if (xp.parse_double("checkpoint_fraction_done_elapsed_time", checkpoint_fraction_done_elapsed_time)) continue; else if (xp.parse_bool("once_ran_edf", once_ran_edf)) continue; else if (xp.parse_double("fraction_done", fraction_done)) continue; // deprecated - for backwards compat else if (xp.parse_int("app_version_num", n)) continue; else if (xp.parse_double("swap_size", procinfo.swap_size)) continue; else if (xp.parse_double("working_set_size", procinfo.working_set_size)) continue; else if (xp.parse_double("working_set_size_smoothed", procinfo.working_set_size_smoothed)) continue; else if (xp.parse_double("page_fault_rate", procinfo.page_fault_rate)) continue; else if (xp.parse_double("current_cpu_time", x)) continue; else if (xp.parse_double("bytes_sent", bytes_sent)) continue; else if (xp.parse_double("bytes_received", bytes_received)) continue; else { if (log_flags.unparsed_xml) { msg_printf(project, MSG_INFO, "[unparsed_xml] ACTIVE_TASK::parse(): unrecognized %s\n", xp.parsed_tag ); } } } return ERR_XML_PARSE; }
int PLAN_CLASS_SPEC::parse(XML_PARSER& xp) { char buf[256]; while (!xp.get_tag()) { if (xp.match_tag("/plan_class")) { return 0; } if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_int("min_core_client_version", min_core_client_version)) continue; if (xp.parse_int("max_core_client_version", max_core_client_version)) continue; if (xp.parse_str("gpu_type", gpu_type, sizeof(gpu_type))) continue; if (xp.parse_bool("cuda", cuda)) continue; if (xp.parse_bool("cal", cal)) continue; if (xp.parse_bool("opencl", opencl)) continue; if (xp.parse_bool("virtualbox", virtualbox)) continue; if (xp.parse_bool("is64bit", is64bit)) continue; if (xp.parse_str("cpu_feature", buf, sizeof(buf))) { cpu_features.push_back(" " + (string)buf + " "); continue; } if (xp.parse_double("min_ncpus", min_ncpus)) continue; if (xp.parse_int("max_threads", max_threads)) continue; if (xp.parse_double("projected_flops_scale", projected_flops_scale)) continue; if (xp.parse_str("os_regex", buf, sizeof(buf))) { if (regcomp(&(os_regex), buf, REG_EXTENDED|REG_NOSUB) ) { log_messages.printf(MSG_CRITICAL, "BAD REGEXP: %s\n", buf); return ERR_XML_PARSE; } have_os_regex = true; continue; } if (xp.parse_str("project_prefs_tag", project_prefs_tag, sizeof(project_prefs_tag))) continue; if (xp.parse_str("project_prefs_regex", buf, sizeof(buf))) { if (regcomp(&(project_prefs_regex), buf, REG_EXTENDED|REG_NOSUB) ) { log_messages.printf(MSG_CRITICAL, "BAD REGEXP: %s\n", buf); return ERR_XML_PARSE; } have_project_prefs_regex = true; continue; } if (xp.parse_double("avg_ncpus", avg_ncpus)) continue; if (xp.parse_double("cpu_frac", cpu_frac)) continue; if (xp.parse_double("min_gpu_ram_mb", min_gpu_ram_mb)) continue; if (xp.parse_double("gpu_ram_used_mb", gpu_ram_used_mb)) continue; if (xp.parse_double("gpu_peak_flops_scale", gpu_peak_flops_scale)) continue; if (xp.parse_double("ngpus", ngpus)) continue; if (xp.parse_int("min_driver_version", min_driver_version)) continue; if (xp.parse_int("max_driver_version", max_driver_version)) continue; if (xp.parse_str("gpu_utilization_tag", gpu_utilization_tag, sizeof(gpu_utilization_tag))) continue; if (xp.parse_bool("need_ati_libs", need_ati_libs)) continue; if (xp.parse_int("min_cal_target", min_cal_target)) continue; if (xp.parse_int("max_cal_target", max_cal_target)) continue; if (xp.parse_int("min_nvidia_compcap", min_nvidia_compcap)) continue; if (xp.parse_int("max_nvidia_compcap", max_nvidia_compcap)) continue; if (xp.parse_int("min_cuda_version", min_cuda_version)) continue; if (xp.parse_int("max_cuda_version", max_cuda_version)) continue; if (xp.parse_int("min_opencl_version", min_opencl_version)) continue; if (xp.parse_int("max_opencl_version", max_opencl_version)) continue; if (xp.parse_int("min_vbox_version", min_vbox_version)) continue; if (xp.parse_int("max_vbox_version", max_vbox_version)) continue; } return ERR_XML_PARSE; }
// parse project fields from client_state.xml // int PROJECT::parse_state(XML_PARSER& xp) { char buf[256]; std::string sched_url, stemp; string str1, str2; int retval, rt; double x; bool btemp; init(); while (!xp.get_tag()) { if (xp.match_tag("/project")) { if (cpid_time == 0) { cpid_time = user_create_time; } if (dont_use_dcf) { duration_correction_factor = 1; } return 0; } if (xp.parse_string("scheduler_url", sched_url)) { scheduler_urls.push_back(sched_url); continue; } if (xp.parse_str("master_url", master_url, sizeof(master_url))) continue; if (xp.parse_str("project_name", project_name, sizeof(project_name))) continue; if (xp.parse_str("symstore", symstore, sizeof(symstore))) continue; if (xp.parse_str("user_name", user_name, sizeof(user_name))) continue; if (xp.parse_str("team_name", team_name, sizeof(team_name))) continue; if (xp.parse_str("host_venue", host_venue, sizeof(host_venue))) continue; if (xp.parse_str("email_hash", email_hash, sizeof(email_hash))) continue; if (xp.parse_str("cross_project_id", cross_project_id, sizeof(cross_project_id))) continue; if (xp.parse_str("external_cpid", external_cpid, sizeof(external_cpid))) continue; if (xp.parse_double("cpid_time", cpid_time)) continue; if (xp.parse_double("user_total_credit", user_total_credit)) continue; if (xp.parse_double("user_expavg_credit", user_expavg_credit)) continue; if (xp.parse_double("user_create_time", user_create_time)) continue; if (xp.parse_int("rpc_seqno", rpc_seqno)) continue; if (xp.parse_int("userid", userid)) continue; if (xp.parse_int("teamid", teamid)) continue; if (xp.parse_int("hostid", hostid)) continue; if (xp.parse_double("host_total_credit", host_total_credit)) continue; if (xp.parse_double("host_expavg_credit", host_expavg_credit)) continue; if (xp.parse_double("host_create_time", host_create_time)) continue; if (xp.match_tag("code_sign_key")) { retval = copy_element_contents( xp.f->f, "</code_sign_key>", code_sign_key, sizeof(code_sign_key) ); if (retval) return retval; strip_whitespace(code_sign_key); continue; } if (xp.parse_int("nrpc_failures", nrpc_failures)) continue; if (xp.parse_int("master_fetch_failures", master_fetch_failures)) continue; if (xp.parse_double("min_rpc_time", x)) continue; if (xp.parse_bool("master_url_fetch_pending", master_url_fetch_pending)) continue; if (xp.parse_int("sched_rpc_pending", sched_rpc_pending)) continue; if (xp.parse_double("next_rpc_time", next_rpc_time)) continue; if (xp.parse_bool("trickle_up_pending", trickle_up_pending)) continue; if (xp.parse_int("send_time_stats_log", send_time_stats_log)) continue; if (xp.parse_int("send_job_log", send_job_log)) continue; if (xp.parse_bool("send_full_workload", send_full_workload)) continue; if (xp.parse_bool("dont_use_dcf", dont_use_dcf)) continue; if (xp.parse_bool("non_cpu_intensive", non_cpu_intensive)) continue; if (xp.parse_bool("verify_files_on_app_start", verify_files_on_app_start)) continue; if (xp.parse_bool("suspended_via_gui", suspended_via_gui)) continue; if (xp.parse_bool("dont_request_more_work", dont_request_more_work)) continue; if (xp.parse_bool("detach_when_done", detach_when_done)) continue; if (xp.parse_bool("ended", ended)) continue; if (xp.parse_double("rec", pwf.rec)) continue; if (xp.parse_double("rec_time", pwf.rec_time)) continue; if (xp.parse_double("cpu_backoff_interval", rsc_pwf[0].backoff_interval)) continue; if (xp.parse_double("cpu_backoff_time", rsc_pwf[0].backoff_time)) { if (rsc_pwf[0].backoff_time > gstate.now + 28*SECONDS_PER_DAY) { rsc_pwf[0].backoff_time = gstate.now + 28*SECONDS_PER_DAY; } continue; } if (xp.match_tag("rsc_backoff_interval")) { if (parse_rsc_param(xp, "/rsc_backoff_interval", rt, x)) { rsc_pwf[rt].backoff_interval = x; } continue; } if (xp.match_tag("rsc_backoff_time")) { if (parse_rsc_param(xp, "/rsc_backoff_time", rt, x)) { rsc_pwf[rt].backoff_time = x; } continue; } if (xp.parse_double("resource_share", resource_share)) continue; // not authoritative if (xp.parse_double("duration_correction_factor", duration_correction_factor)) continue; if (xp.parse_bool("attached_via_acct_mgr", attached_via_acct_mgr)) continue; if (xp.parse_bool("no_cpu_apps", btemp)) { if (btemp) handle_no_rsc_apps(this, "CPU"); continue; } // deprecated if (xp.parse_bool("no_cuda_apps", btemp)) { if (btemp) handle_no_rsc_apps(this, GPU_TYPE_NVIDIA); continue; } if (xp.parse_bool("no_ati_apps", btemp)) { if (btemp) handle_no_rsc_apps(this, GPU_TYPE_ATI); continue; } if (xp.parse_str("no_rsc_apps", buf, sizeof(buf))) { handle_no_rsc_apps(this, buf); continue; } if (xp.parse_bool("no_cpu_ams", btemp)) { if (btemp) handle_no_rsc_ams(this, "CPU"); continue; } if (xp.parse_bool("no_cuda_ams", btemp)) { if (btemp) handle_no_rsc_ams(this, GPU_TYPE_NVIDIA); continue; } if (xp.parse_bool("no_ati_ams", btemp)) { if (btemp) handle_no_rsc_ams(this, GPU_TYPE_ATI); continue; } if (xp.parse_bool("no_intel_gpu_ams", btemp)) { if (btemp) handle_no_rsc_ams(this, GPU_TYPE_INTEL); continue; } if (xp.parse_str("no_rsc_ams", buf, sizeof(buf))) { handle_no_rsc_ams(this, buf); continue; } if (xp.parse_str("no_rsc_pref", buf, sizeof(buf))) { handle_no_rsc_pref(this, buf); continue; } // backwards compat - old state files had ams_resource_share = 0 if (xp.parse_double("ams_resource_share_new", ams_resource_share)) continue; if (xp.parse_double("ams_resource_share", x)) { if (x > 0) ams_resource_share = x; continue; } if (xp.parse_bool("scheduler_rpc_in_progress", btemp)) continue; if (xp.parse_bool("use_symlinks", use_symlinks)) continue; if (xp.parse_bool("anonymous_platform", btemp)) continue; if (xp.parse_string("trickle_up_url", stemp)) { trickle_up_ops.push_back(new TRICKLE_UP_OP(stemp)); continue; } if (xp.parse_double("desired_disk_usage", desired_disk_usage)) continue; if (xp.parse_int("njobs_success", njobs_success)) continue; if (xp.parse_int("njobs_error", njobs_error)) continue; if (xp.parse_double("elapsed_time", elapsed_time)) continue; if (xp.parse_double("last_rpc_time", last_rpc_time)) continue; #ifdef SIM if (xp.match_tag("available")) { available.parse(xp, "/available"); continue; } #endif if (log_flags.unparsed_xml) { msg_printf(0, MSG_INFO, "[unparsed_xml] PROJECT::parse_state(): unrecognized: %s", xp.parsed_tag ); } xp.skip_unexpected(); } return ERR_XML_PARSE; }
// Parse global prefs, overriding whatever is currently in the structure. // // If host_venue is nonempty and we find an element of the form // <venue name="X"> // ... // </venue> // where X==host_venue, then parse that and ignore the rest. // Otherwise ignore <venue> elements. // // The start tag may or may not have already been parsed // int GLOBAL_PREFS::parse_override( XML_PARSER& xp, const char* host_venue, bool& found_venue, GLOBAL_PREFS_MASK& mask ) { char buf2[256], attrs[256]; bool in_venue = false, in_correct_venue=false; double dtemp; int itemp; found_venue = false; mask.clear(); while (!xp.get_tag(attrs, sizeof(attrs))) { if (!xp.is_tag) continue; if (xp.match_tag("global_preferences")) continue; if (xp.match_tag("/global_preferences")) { return 0; } if (in_venue) { if (xp.match_tag("/venue")) { if (in_correct_venue) { return 0; } else { in_venue = false; continue; } } else { if (!in_correct_venue) continue; } } else { if (strstr(xp.parsed_tag, "venue")) { in_venue = true; parse_attr(attrs, "name", buf2, sizeof(buf2)); if (!strcmp(buf2, host_venue)) { defaults(); clear_bools(); mask.clear(); in_correct_venue = true; found_venue = true; } else { in_correct_venue = false; } continue; } } if (xp.parse_str("source_project", source_project, sizeof(source_project))) continue; if (xp.parse_str("source_scheduler", source_scheduler, sizeof(source_scheduler))) { continue; } if (xp.parse_double("mod_time", mod_time)) { double now = dtime(); if (mod_time > now) { mod_time = now; } continue; } if (xp.parse_double("battery_charge_min_pct", battery_charge_min_pct)) { mask.battery_charge_min_pct = true; continue; } if (xp.parse_double("battery_max_temperature", battery_max_temperature)) { mask.battery_max_temperature = true; continue; } if (xp.parse_bool("run_on_batteries", run_on_batteries)) { mask.run_on_batteries = true; continue; } if (xp.parse_bool("run_if_user_active", run_if_user_active)) { mask.run_if_user_active = true; continue; } if (xp.parse_bool("run_gpu_if_user_active", run_gpu_if_user_active)) { mask.run_gpu_if_user_active = true; continue; } if (xp.parse_double("idle_time_to_run", idle_time_to_run)) { mask.idle_time_to_run = true; continue; } if (xp.parse_double("suspend_if_no_recent_input", suspend_if_no_recent_input)) { mask.suspend_if_no_recent_input = true; continue; } if (xp.parse_double("suspend_cpu_usage", suspend_cpu_usage)) { mask.suspend_cpu_usage = true; continue; } if (xp.parse_double("start_hour", cpu_times.start_hour)) { mask.start_hour = true; continue; } if (xp.parse_double("end_hour", cpu_times.end_hour)) { mask.end_hour = true; continue; } if (xp.parse_double("net_start_hour", net_times.start_hour)) { mask.net_start_hour = true; continue; } if (xp.parse_double("net_end_hour", net_times.end_hour)) { mask.net_end_hour = true; continue; } if (xp.match_tag("day_prefs")) { parse_day(xp); continue; } if (xp.parse_bool("leave_apps_in_memory", leave_apps_in_memory)) { mask.leave_apps_in_memory = true; continue; } if (xp.parse_bool("confirm_before_connecting", confirm_before_connecting)) { mask.confirm_before_connecting = true; continue; } if (xp.parse_bool("hangup_if_dialed", hangup_if_dialed)) { mask.hangup_if_dialed = true; continue; } if (xp.parse_bool("dont_verify_images", dont_verify_images)) { mask.dont_verify_images = true; continue; } if (xp.parse_double("work_buf_min_days", work_buf_min_days)) { if (work_buf_min_days < 0) work_buf_min_days = 0; mask.work_buf_min_days = true; continue; } if (xp.parse_double("work_buf_additional_days", work_buf_additional_days)) { if (work_buf_additional_days < 0) work_buf_additional_days = 0; mask.work_buf_additional_days = true; continue; } if (xp.parse_double("max_ncpus_pct", max_ncpus_pct)) { if (max_ncpus_pct < 0) max_ncpus_pct = 0; if (max_ncpus_pct > 100) max_ncpus_pct = 100; mask.max_ncpus_pct = true; continue; } if (xp.parse_int("max_cpus", max_ncpus)) { if (max_ncpus < 0) max_ncpus = 0; mask.max_ncpus = true; continue; } if (xp.parse_double("disk_interval", disk_interval)) { if (disk_interval<0) disk_interval = 0; mask.disk_interval = true; continue; } if (xp.parse_double("cpu_scheduling_period_minutes", cpu_scheduling_period_minutes)) { if (cpu_scheduling_period_minutes < 0.0001) cpu_scheduling_period_minutes = 60; mask.cpu_scheduling_period_minutes = true; continue; } if (xp.parse_double("disk_max_used_gb", disk_max_used_gb)) { mask.disk_max_used_gb = true; continue; } if (xp.parse_double("disk_max_used_pct", disk_max_used_pct)) { mask.disk_max_used_pct = true; continue; } if (xp.parse_double("disk_min_free_gb", disk_min_free_gb)) { mask.disk_min_free_gb = true; continue; } if (xp.parse_double("vm_max_used_pct", dtemp)) { vm_max_used_frac = dtemp/100; mask.vm_max_used_frac = true; continue; } if (xp.parse_double("ram_max_used_busy_pct", dtemp)) { if (!dtemp) dtemp = 100; ram_max_used_busy_frac = dtemp/100; mask.ram_max_used_busy_frac = true; continue; } if (xp.parse_double("ram_max_used_idle_pct", dtemp)) { if (!dtemp) dtemp = 100; ram_max_used_idle_frac = dtemp/100; mask.ram_max_used_idle_frac = true; continue; } if (xp.parse_double("max_bytes_sec_up", max_bytes_sec_up)) { if (max_bytes_sec_up < 0) max_bytes_sec_up = 0; mask.max_bytes_sec_up = true; continue; } if (xp.parse_double("max_bytes_sec_down", max_bytes_sec_down)) { if (max_bytes_sec_down < 0) max_bytes_sec_down = 0; mask.max_bytes_sec_down = true; continue; } if (xp.parse_double("cpu_usage_limit", dtemp)) { if (dtemp > 0 && dtemp <= 100) { cpu_usage_limit = dtemp; mask.cpu_usage_limit = true; } continue; } if (xp.parse_double("daily_xfer_limit_mb", dtemp)) { if (dtemp >= 0) { daily_xfer_limit_mb = dtemp; mask.daily_xfer_limit_mb = true; } continue; } if (xp.parse_int("daily_xfer_period_days", itemp)) { if (itemp >= 0) { daily_xfer_period_days = itemp; mask.daily_xfer_period_days = true; } continue; } if (xp.parse_bool("network_wifi_only", network_wifi_only)) { continue; } if (xp.parse_bool("host_specific", host_specific)) { continue; } // false means don't print anything xp.skip_unexpected(false, "GLOBAL_PREFS::parse_override"); } return ERR_XML_PARSE; }
int OPENCL_DEVICE_PROP::parse(XML_PARSER& xp, const char* end_tag) { int n; unsigned long long ull; while (!xp.get_tag()) { if (xp.match_tag(end_tag)) { get_device_version_int(); get_opencl_driver_revision(); return 0; } if (xp.parse_str("name", name, sizeof(name))) continue; if (xp.parse_str("vendor", vendor, sizeof(vendor))) continue; if (xp.parse_ulonglong("vendor_id", ull)) { vendor_id = ull; continue; } if (xp.parse_int("available", n)) { available = n; continue; } if (xp.parse_ulonglong("half_fp_config", ull)) { half_fp_config = ull; continue; } if (xp.parse_ulonglong("single_fp_config", ull)) { single_fp_config = ull; continue; } if (xp.parse_ulonglong("double_fp_config", ull)) { double_fp_config = ull; continue; } if (xp.parse_int("endian_little", n)) { endian_little = n; continue; } if (xp.parse_ulonglong("execution_capabilities", ull)) { execution_capabilities = ull; continue; } if (xp.parse_str("extensions", extensions, sizeof(extensions) )) { continue; } if (xp.parse_ulonglong("global_mem_size", ull)) { global_mem_size = ull; continue; } if (xp.parse_ulonglong("local_mem_size", ull)) { local_mem_size = ull; continue; } if (xp.parse_int("max_clock_frequency", n)) { max_clock_frequency = n; continue; } if (xp.parse_int("max_compute_units", n)) { max_compute_units = n; continue; } if (xp.parse_str("opencl_platform_version", opencl_platform_version, sizeof(opencl_platform_version) )) { continue; } if (xp.parse_str("opencl_device_version", opencl_device_version, sizeof(opencl_device_version) )) { continue; } if (xp.parse_str("opencl_driver_version", opencl_driver_version, sizeof(opencl_driver_version) )) { continue; } // The following are used only in the // COPROC_INFO_FILENAME temporary file if (xp.parse_int("is_used", n)) { is_used = (COPROC_USAGE)n; continue; } if (xp.parse_int("device_num", n)) { device_num = n; continue; } if (xp.parse_double("peak_flops", peak_flops)) continue; if (xp.parse_double("opencl_available_ram", opencl_available_ram)) continue; if (xp.parse_int("opencl_device_index", n)) { opencl_device_index = n; continue; } } return ERR_XML_PARSE; }