int FILE_INFO::parse(XML_PARSER& xp) {
bool found=false;
optional = false;
no_validate = false;
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/file_ref")) {
return found?0:ERR_XML_PARSE;
}
if (xp.parse_string("file_name", name)) {
found = true;
continue;
}
if (xp.parse_bool("optional", optional)) continue;
if (xp.parse_bool("no_validate", no_validate)) continue;
}
return ERR_XML_PARSE;
}
int OPENCL_CPU_PROP::parse(XML_PARSER& xp) {
int retval;
clear();
while (!xp.get_tag()) {
if (xp.match_tag("/opencl_cpu_prop")) {
if (!strlen(platform_vendor)) return ERR_XML_PARSE;
return 0;
}
if (xp.parse_str("platform_vendor", platform_vendor, sizeof(platform_vendor))) continue;
if (xp.match_tag("opencl_cpu_info")) {
retval = opencl_prop.parse(xp, "/opencl_cpu_info");
if (retval) return retval;
continue;
}
}
return ERR_XML_PARSE;
}
static bool parse_rsc_param(XML_PARSER& xp, const char* end_tag, int& rsc_type, double& value) {
char name[256];
bool val_found = false;
rsc_type = -1;
while (!xp.get_tag()) {
if (xp.match_tag(end_tag)) {
return (rsc_type > 0 && val_found);
}
if (xp.parse_str("name", name, sizeof(name))) {
rsc_type = rsc_index(name);
continue;
}
if (xp.parse_double("rsc_type", value)) {
val_found = true;
}
}
return false;
}
// parse feed descs from scheduler reply or feed list file
//
int parse_rss_feed_descs(XML_PARSER& xp, vector<RSS_FEED>& feeds) {
int retval;
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/rss_feeds")) return 0;
if (xp.match_tag("rss_feed")) {
RSS_FEED rf;
retval = rf.parse_desc(xp);
if (retval) {
if (log_flags.sched_op_debug) {
msg_printf(0, MSG_INFO,
"[sched_op] error in <rss_feed> element"
);
}
} else {
feeds.push_back(rf);
}
}
}
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;
return 0;
}
if (xp.parse_str("type", type, sizeof(type))) continue;
if (xp.parse_int("count", count)) 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;
}
}
return ERR_XML_PARSE;
}
int COPROCS::parse(XML_PARSER& xp) {
int retval;
clear();
n_rsc = 1;
strcpy(coprocs[0].type, "CPU");
while (!xp.get_tag()) {
if (xp.match_tag("/coprocs")) {
return 0;
}
if (xp.match_tag("coproc_cuda")) {
retval = nvidia.parse(xp);
if (retval) {
nvidia.clear();
} else {
coprocs[n_rsc++] = nvidia;
}
continue;
}
if (xp.match_tag("coproc_ati")) {
retval = ati.parse(xp);
if (retval) {
ati.clear();
} else {
coprocs[n_rsc++] = ati;
}
continue;
}
if (xp.match_tag("coproc_intel_gpu")) {
retval = intel_gpu.parse(xp);
if (retval) {
intel_gpu.clear();
} else {
coprocs[n_rsc++] = intel_gpu;
}
continue;
}
}
return ERR_XML_PARSE;
}
int APP_CONFIGS::parse(XML_PARSER& xp, PROJECT* p) {
app_configs.clear();
if (!xp.parse_start("app_config")) return ERR_XML_PARSE;
while (!xp.get_tag()) {
if (xp.match_tag("/app_config")) return 0;
if (xp.match_tag("app")) {
APP_CONFIG ac;
int retval = ac.parse(xp, p);
if (!retval) {
app_configs.push_back(ac);
}
continue;
}
if (xp.match_tag("app_version")) {
APP_VERSION_CONFIG avc;
int retval = avc.parse(xp, p);
if (!retval) {
app_version_configs.push_back(avc);
}
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_CONFIGS::parse");
}
return ERR_XML_PARSE;
}
int JOB_LIMIT::parse(XML_PARSER& xp, const char* end_tag) {
while (!xp.get_tag()) {
if (!xp.is_tag) {
continue;
}
if (xp.match_tag(end_tag)) {
return 0;
}
if (xp.parse_str("app_name", app_name, sizeof(app_name))) {
continue;
}
if (xp.match_tag("total_limit")) {
total.parse(xp, "/total_limit");
continue;
}
if (xp.match_tag("cpu_limit")) {
proc_type_limits[0].parse(xp, "/cpu_limit");
continue;
}
if (xp.match_tag("gpu_limit")) {
proc_type_limits[1].parse(xp, "/gpu_limit");
for (int i=2; i<NPROC_TYPES; i++) {
proc_type_limits[i] = proc_type_limits[1];
}
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 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 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 parse_project_files(XML_PARSER& xp, vector<FILE_REF>& project_files) {
int retval;
project_files.clear();
while (!xp.get_tag()) {
if (xp.match_tag("/project_files")) return 0;
if (xp.match_tag("file_ref")) {
FILE_REF file_ref;
retval = file_ref.parse(xp);
if (!retval) {
project_files.push_back(file_ref);
}
} else {
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] parse_project_files(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
}
return ERR_XML_PARSE;
}
void CFileListXml::SetAttribute(XML_PARSER& parser, const char* AttribName,const char* AttribValue)
{
//多字节转化为UTF-8后再保存
char* szUtf8 = CCharSetConversionUtil::MultiByteToUtf8(AttribValue, (int)strlen(AttribValue));
if (szUtf8 == NULL)
{
return;
}
else
{
parser.Set_Attribute(AttribName, szUtf8);
delete[] szUtf8;
szUtf8 = NULL;
}
}
CString CFileListXml::GetAttribute(XML_PARSER& parser, const char* AttribName)
{
std::string str = parser.GetAttributeValue(AttribName);
char* szMultiByte = CCharSetConversionUtil::Utf8ToMultiByte(str.c_str(), (int)strlen(str.c_str()));
if (szMultiByte == NULL)
{
return _T("");
}
else
{
CString strTemp = szMultiByte;
delete[] szMultiByte;
szMultiByte = NULL;
return strTemp;
}
}
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;
}
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 TEMPLATE_DESC::parse(XML_PARSER& xp) {
int retval;
string s;
while (!xp.get_tag()) {
if (xp.match_tag("input_template")) {
while (!xp.get_tag()) {
if (xp.match_tag("/input_template")) break;
if (xp.parse_string("open_name", s)) {
input_files.push_back(s);
}
}
}
if (xp.match_tag("output_template")) {
while (!xp.get_tag()) {
if (xp.match_tag("/output_template")) break;
if (xp.parse_string("open_name", s)) {
output_files.push_back(s);
}
}
}
}
return 0;
}
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 HOST::parse_net_stats(XML_PARSER& xp) {
double dtemp;
while (!xp.get_tag()) {
if (xp.match_tag("/net_stats")) return 0;
if (xp.parse_double("bwup", n_bwup)) continue;
if (xp.parse_double("bwdown", n_bwdown)) continue;
// items reported by 5.10+ clients, not currently used
//
if (xp.parse_double("avg_time_up", dtemp)) continue;
if (xp.parse_double("avg_up", dtemp)) continue;
if (xp.parse_double("avg_time_down", dtemp)) continue;
if (xp.parse_double("avg_down", dtemp)) continue;
log_messages.printf(MSG_NORMAL,
"HOST::parse_net_stats(): unrecognized: %s\n",
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 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 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;
}
// 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 NOTICE::parse_rss(XML_PARSER& xp) {
char buf[256];
clear();
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/item")) return 0;
if (xp.parse_str("title", title, sizeof(title))) continue;
if (xp.parse_str("link", link, sizeof(link))) continue;
if (xp.parse_str("guid", guid, sizeof(guid))) continue;
if (xp.parse_string("description", description)) continue;
if (xp.parse_str("pubDate", buf, sizeof(buf))) {
create_time = parse_rss_time(buf);
continue;
}
}
return ERR_XML_PARSE;
}
int CONFIG::parse(XML_PARSER& xp, LOG_FLAGS& log_flags) {
while (!xp.get_tag()) {
if (!xp.is_tag) {
continue;
}
if (xp.match_tag("/cc_config")) return 0;
if (xp.match_tag("log_flags")) {
log_flags.parse(xp);
continue;
}
if (xp.match_tag("options")) {
parse_options(xp);
continue;
}
if (xp.match_tag("options/")) continue;
if (xp.match_tag("log_flags/")) continue;
}
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;
}
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 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;
}
