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;
}
// parse a feed descriptor (in scheduler reply or feed list file)
//
int RSS_FEED::parse_desc(XML_PARSER& xp) {
strcpy(url, "");
poll_interval = 0;
next_poll_time = 0;
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/rss_feed")) {
if (!poll_interval || !strlen(url)) {
if (log_flags.notice_debug) {
msg_printf(0, MSG_INFO,
"[notice] URL or poll interval missing in sched reply feed"
);
}
return ERR_XML_PARSE;
}
safe_strcpy(url_base, url);
char* p = strchr(url_base, '?');
if (p) *p = 0;
return 0;
}
if (xp.parse_str("url", url, sizeof(url))) {
xml_unescape(url);
}
if (xp.parse_double("poll_interval", poll_interval)) continue;
if (xp.parse_double("next_poll_time", next_poll_time)) continue;
}
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 APP_VERSION_CONFIG::parse(
XML_PARSER& xp, MSG_VEC& mv, LOG_FLAGS& log_flags
) {
char buf[1024];
memset(this, 0, sizeof(APP_VERSION_CONFIG));
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_version")) return 0;
if (xp.parse_str("app_name", app_name, 256)) continue;
if (xp.parse_str("plan_class", plan_class, 256)) continue;
if (xp.parse_str("cmdline", cmdline, 256)) continue;
if (xp.parse_double("avg_ncpus", avg_ncpus)) continue;
if (xp.parse_double("ngpus", ngpus)) continue;
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_VERSION_CONFIG::parse");
}
mv.push_back(string("Missing </app_version> in app_config.xml"));
return ERR_XML_PARSE;
}
int APP_CONFIG::parse_gpu_versions(
XML_PARSER& xp, MSG_VEC& mv, LOG_FLAGS& log_flags
) {
double x;
char buf[1024];
while (!xp.get_tag()) {
if (xp.match_tag("/gpu_versions")) return 0;
else if (xp.parse_double("gpu_usage", x)) {
if (x <= 0) {
mv.push_back(string("gpu_usage must be positive in app_config.xml"));
} else {
gpu_gpu_usage = x;
}
continue;
}
else if (xp.parse_double("cpu_usage", x)) {
if (x < 0) {
mv.push_back(string("cpu_usage must be non-negative in app_config.xml"));
} else {
gpu_cpu_usage = x;
}
continue;
}
if (log_flags.unparsed_xml) {
sprintf(buf, "Unparsed line in app_config.xml: %s", xp.parsed_tag);
mv.push_back(string(buf));
}
}
mv.push_back(string("Missing </gpu_versions> in app_config.xml"));
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 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 IP_RESULT::parse(XML_PARSER& xp) {
report_deadline = 0;
cpu_time_remaining = 0;
strcpy(name, "");
while (!xp.get_tag()) {
if (xp.match_tag("/ip_result")) return 0;
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_double("report_deadline", report_deadline)) continue;
if (xp.parse_double("cpu_time_remaining", cpu_time_remaining)) continue;
}
return ERR_XML_PARSE;
}
int NORMAL_DIST::parse(XML_PARSER& xp, const char* end_tag) {
while(!xp.get_tag()) {
if (!xp.is_tag) return ERR_XML_PARSE;
if (xp.parse_double("mean", mean)) continue;
else if (xp.parse_double("std_dev", std_dev)) continue;
else if (xp.match_tag(end_tag)) return 0;
else {
printf("unrecognized: %s\n", xp.parsed_tag);
return ERR_XML_PARSE;
}
}
return ERR_XML_PARSE;
}
int UNIFORM_DIST::parse(XML_PARSER& xp, const char* end_tag) {
while (!xp.get_tag()) {
if (!xp.is_tag) return ERR_XML_PARSE;
if (xp.parse_double("lo", lo)) continue;
else if (xp.parse_double("hi", hi)) continue;
else if (xp.match_tag(end_tag)) return 0;
else {
printf("unrecognized: %s\n", xp.parsed_tag);
return ERR_XML_PARSE;
}
}
return ERR_XML_PARSE;
}
int HOST::parse_disk_usage(XML_PARSER& xp) {
while (!xp.get_tag()) {
if (xp.match_tag("/disk_usage")) return 0;
if (xp.parse_double("d_boinc_used_total", d_boinc_used_total)) continue;
if (xp.parse_double("d_boinc_used_project", d_boinc_used_project)) continue;
if (xp.parse_double("d_project_share", d_project_share)) continue;
log_messages.printf(MSG_NORMAL,
"HOST::parse_disk_usage(): unrecognized: %s\n",
xp.parsed_tag
);
}
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 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 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 NORMAL_DIST::parse(XML_PARSER& xp, const char* end_tag) {
char tag[256];
bool is_tag;
while(!xp.get(tag, sizeof(tag), is_tag)) {
if (!is_tag) return ERR_XML_PARSE;
if (xp.parse_double(tag, "mean", mean)) continue;
else if (xp.parse_double(tag, "std_dev", std_dev)) continue;
else if (!strcmp(tag, end_tag)) return 0;
else {
printf("unrecognized: %s\n", tag);
return ERR_XML_PARSE;
}
}
return ERR_XML_PARSE;
}
int RANDOM_PROCESS::parse(XML_PARSER& xp, const char* end_tag) {
while (!xp.get_tag()) {
if (!xp.is_tag) return ERR_XML_PARSE;
if (xp.parse_double("lambda", lambda)) continue;
else if (xp.parse_double("frac", frac)) continue;
else if (xp.match_tag(end_tag)) {
init(frac, lambda);
return 0;
} else {
printf("unrecognized: %s\n", xp.parsed_tag);
return ERR_XML_PARSE;
}
}
return ERR_XML_PARSE;
}
int UNIFORM_DIST::parse(XML_PARSER& xp, const char* end_tag) {
char tag[256];
bool is_tag;
while (!xp.get(tag, sizeof(tag), is_tag)) {
if (!is_tag) return ERR_XML_PARSE;
if (xp.parse_double(tag, "lo", lo)) continue;
else if (xp.parse_double(tag, "hi", hi)) continue;
else if (!strcmp(tag, end_tag)) return 0;
else {
printf("unrecognized: %s\n", tag);
return ERR_XML_PARSE;
}
}
return ERR_XML_PARSE;
}
static int set_debt(XML_PARSER& xp) {
bool is_tag;
char tag[256], url[256];
double short_term_debt = 0, long_term_debt = 0, cuda_debt=0, ati_debt=0;
bool got_std=false, got_ltd=false, got_cuda_debt=false, got_ati_debt=false;
strcpy(url, "");
while (!xp.get(tag, sizeof(tag), is_tag)) {
if (!strcmp(tag, "/project")) {
if (!strlen(url)) return ERR_XML_PARSE;
canonicalize_master_url(url);
PROJECT* p = gstate.lookup_project(url);
if (!p) return ERR_NOT_FOUND;
if (got_std) {
p->cpu_pwf.short_term_debt = short_term_debt;
p->cuda_pwf.short_term_debt = short_term_debt;
p->ati_pwf.short_term_debt = short_term_debt;
}
if (got_ltd) p->cpu_pwf.long_term_debt = long_term_debt;
if (got_cuda_debt) p->cuda_pwf.long_term_debt = cuda_debt;
if (got_ati_debt) p->ati_pwf.long_term_debt = ati_debt;
return 0;
}
if (xp.parse_str(tag, "master_url", url, sizeof(url))) continue;
if (xp.parse_double(tag, "short_term_debt", short_term_debt)) {
got_std = true;
continue;
}
if (xp.parse_double(tag, "long_term_debt", long_term_debt)) {
got_ltd = true;
continue;
}
if (xp.parse_double(tag, "cuda_debt", cuda_debt)) {
got_cuda_debt = true;
continue;
}
if (xp.parse_double(tag, "ati_debt", ati_debt)) {
got_ati_debt = true;
continue;
}
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] set_debt: unrecognized %s", tag
);
}
xp.skip_unexpected(tag, log_flags.unparsed_xml, "set_debt");
}
return 0;
}
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;
}
// 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;
}
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_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;
}
int APP_VERSION_CONFIG::parse(XML_PARSER& xp, PROJECT* p) {
memset(this, 0, sizeof(APP_VERSION_CONFIG));
while (!xp.get_tag()) {
if (xp.match_tag("/app_version")) return 0;
if (xp.parse_str("app_name", app_name, 256)) continue;
if (xp.parse_str("cmdline", cmdline, 256)) continue;
if (xp.parse_double("avg_ncpus", avg_ncpus)) continue;
if (xp.parse_double("ngpus", ngpus)) 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_VERSION_CONFIG::parse");
}
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 HOST::parse_time_stats(XML_PARSER& xp) {
while (!xp.get_tag()) {
if (xp.match_tag("/time_stats")) return 0;
if (xp.parse_double("on_frac", on_frac)) continue;
if (xp.parse_double("connected_frac", connected_frac)) continue;
if (xp.parse_double("active_frac", active_frac)) continue;
#if 0
if (xp.match_tag("outages")) continue;
if (xp.match_tag("outage")) continue;
if (xp.match_tag("start")) continue;
if (xp.match_tag("end")) continue;
log_messages.printf(MSG_NORMAL,
"HOST::parse_time_stats(): unrecognized: %s\n",
xp.parsed_tag
);
#endif
}
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 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 COPROC_REQ::parse(XML_PARSER& xp) {
strcpy(type, "");
count = 0;
while (!xp.get_tag()) {
if (xp.match_tag("/coproc")) {
if (!strlen(type)) return ERR_XML_PARSE;
return 0;
}
if (xp.parse_str("type", type, sizeof(type))) continue;
if (xp.parse_double("count", count)) continue;
}
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;
}
