2003-08-14 00:02:15 +00:00
|
|
|
// The contents of this file are subject to the BOINC Public License
|
|
|
|
// Version 1.0 (the "License"); you may not use this file except in
|
|
|
|
// compliance with the License. You may obtain a copy of the License at
|
|
|
|
// http://boinc.berkeley.edu/license_1.0.txt
|
|
|
|
//
|
|
|
|
// Software distributed under the License is distributed on an "AS IS"
|
|
|
|
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
|
|
// License for the specific language governing rights and limitations
|
|
|
|
// under the License.
|
|
|
|
//
|
|
|
|
// The Original Code is the Berkeley Open Infrastructure for Network Computing.
|
|
|
|
//
|
|
|
|
// The Initial Developer of the Original Code is the SETI@home project.
|
|
|
|
// Portions created by the SETI@home project are Copyright (C) 2002
|
|
|
|
// University of California at Berkeley. All Rights Reserved.
|
|
|
|
//
|
|
|
|
// Contributor(s):
|
|
|
|
//
|
|
|
|
|
2003-09-20 17:38:13 +00:00
|
|
|
// Code to facilitate writing validators.
|
|
|
|
// Can be used as the basis for a validator that accepts everything
|
|
|
|
// (see validate_trivial.C),
|
|
|
|
// or that requires strict or fuzzy equality.
|
|
|
|
|
2003-10-21 04:06:55 +00:00
|
|
|
#include <cassert>
|
2003-09-20 17:38:13 +00:00
|
|
|
|
2003-10-21 04:06:55 +00:00
|
|
|
#include "error_numbers.h"
|
2003-08-14 00:02:15 +00:00
|
|
|
#include "parse.h"
|
2004-08-06 11:42:41 +00:00
|
|
|
#include "util.h"
|
2004-04-08 08:15:23 +00:00
|
|
|
|
|
|
|
#include "sched_util.h"
|
|
|
|
#include "sched_config.h"
|
|
|
|
#include "sched_msgs.h"
|
2003-10-21 04:06:55 +00:00
|
|
|
#include "validate_util.h"
|
2003-08-14 00:02:15 +00:00
|
|
|
|
2004-06-30 18:17:21 +00:00
|
|
|
using std::vector;
|
|
|
|
using std::string;
|
|
|
|
|
2003-09-02 21:16:55 +00:00
|
|
|
extern SCHED_CONFIG config;
|
2003-08-14 00:02:15 +00:00
|
|
|
|
|
|
|
// get the name of a result's (first) output file
|
|
|
|
//
|
2004-08-06 11:42:41 +00:00
|
|
|
int get_output_file_path(RESULT const& result, string& path_str) {
|
|
|
|
char buf[256], path[256];
|
2003-08-14 00:02:15 +00:00
|
|
|
bool flag;
|
|
|
|
|
2004-11-16 18:22:09 +00:00
|
|
|
flag = parse_str(result.xml_doc_out, "<name>", buf, sizeof(buf));
|
2003-10-21 04:06:55 +00:00
|
|
|
if (!flag) return ERR_XML_PARSE;
|
2004-08-06 11:42:41 +00:00
|
|
|
dir_hier_path(buf, config.upload_dir, config.uldl_dir_fanout, path);
|
|
|
|
path_str = path;
|
2003-08-14 00:02:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-09-20 17:38:13 +00:00
|
|
|
// If we have N correct results, compute a canonical credit as follows:
|
2003-08-14 00:02:15 +00:00
|
|
|
// - if N==1, give that credit
|
|
|
|
// - if N==2, give min credit
|
|
|
|
// - if N>2, toss out min and max, give average of rest
|
|
|
|
//
|
2003-08-26 18:33:21 +00:00
|
|
|
double median_mean_credit(vector<RESULT> const& results) {
|
2003-08-14 00:02:15 +00:00
|
|
|
typedef vector<RESULT>::const_iterator it;
|
|
|
|
|
|
|
|
it it_low = results.end(), it_high;
|
|
|
|
double credit_low = 0, credit_high = 0;
|
|
|
|
|
|
|
|
size_t n_valid = 0;
|
|
|
|
|
2003-08-26 18:33:21 +00:00
|
|
|
for (it i = results.begin(); i != results.end(); ++i) {
|
2003-08-14 00:02:15 +00:00
|
|
|
if (i->validate_state != VALIDATE_STATE_VALID) continue;
|
|
|
|
++n_valid;
|
|
|
|
if (it_low == results.end()) {
|
|
|
|
it_low = it_high = i;
|
|
|
|
credit_low = credit_high = i->claimed_credit;
|
|
|
|
} else {
|
|
|
|
if (i->claimed_credit < credit_low) {
|
|
|
|
it_low = i;
|
|
|
|
credit_low = i->claimed_credit;
|
|
|
|
}
|
|
|
|
if (i->claimed_credit > credit_high) {
|
|
|
|
it_high = i;
|
|
|
|
credit_high = i->claimed_credit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// compute a canonical credit as follows:
|
|
|
|
// - if N==1, give that credit
|
|
|
|
// - if N==2, give min credit
|
|
|
|
// - if N>2, toss out min and max, give average of rest
|
|
|
|
//
|
|
|
|
if (n_valid == 1) {
|
|
|
|
return credit_low;
|
|
|
|
} else if (n_valid == 2) {
|
|
|
|
return credit_low;
|
|
|
|
} else {
|
|
|
|
double sum = 0;
|
|
|
|
|
2003-08-26 18:33:21 +00:00
|
|
|
for (it i = results.begin(); i != results.end(); ++i) {
|
2003-08-14 00:02:15 +00:00
|
|
|
if (i == it_low) continue;
|
|
|
|
if (i == it_high) continue;
|
|
|
|
if (i->validate_state != VALIDATE_STATE_VALID) continue;
|
|
|
|
|
|
|
|
sum += i->claimed_credit;
|
|
|
|
}
|
|
|
|
return sum/(n_valid-2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-07-13 12:23:47 +00:00
|
|
|
// Generic validation function that compares each result to each other one and
|
|
|
|
// sees if there MIN_VALID results match. The comparison function is similar
|
|
|
|
// to check_pair but takes an additional data parameter.
|
2003-08-14 00:02:15 +00:00
|
|
|
//
|
|
|
|
// This function takes 3 call-back functions, each of which accept a void*
|
|
|
|
// and should return !=0 on error:
|
|
|
|
//
|
|
|
|
// 1. init_result - initialize all results - for example, call
|
|
|
|
// read_file_string and compute an MD5. Return a void*
|
|
|
|
// 2. check_pair_with_data - same as check_pair but with extra data from
|
|
|
|
// init_result
|
2003-08-18 18:49:04 +00:00
|
|
|
// 3. cleanup_result - deallocate anything created by init_result. Should
|
|
|
|
// do nothing with NULL data
|
2003-08-14 00:02:15 +00:00
|
|
|
//
|
|
|
|
// see validate_test.C example usage.
|
|
|
|
//
|
2004-07-13 12:23:47 +00:00
|
|
|
int generic_check_set(
|
2003-08-26 18:33:21 +00:00
|
|
|
vector<RESULT>& results, int& canonicalid, double& credit,
|
|
|
|
init_result_f init_result_f,
|
|
|
|
check_pair_with_data_f check_pair_with_data_f,
|
2004-07-13 12:23:47 +00:00
|
|
|
cleanup_result_f cleanup_result_f,
|
2004-07-13 13:54:09 +00:00
|
|
|
size_t min_valid)
|
2004-07-13 12:23:47 +00:00
|
|
|
{
|
2003-08-14 00:02:15 +00:00
|
|
|
assert (!results.empty());
|
2004-07-20 10:38:14 +00:00
|
|
|
assert (min_valid >= 0);
|
2003-08-14 00:02:15 +00:00
|
|
|
|
|
|
|
vector<void*> data;
|
|
|
|
vector<RESULT>::size_type i, j, neq = 0, n = results.size();
|
|
|
|
data.resize(n);
|
|
|
|
|
|
|
|
// 1. INITIALIZE DATA
|
2003-08-26 18:33:21 +00:00
|
|
|
for (i = 0; i != n; ++i) {
|
2003-08-14 00:02:15 +00:00
|
|
|
if (init_result_f(results[i], data[i])) {
|
|
|
|
log_messages.printf(
|
2004-04-08 08:15:23 +00:00
|
|
|
SCHED_MSG_LOG::CRITICAL,
|
2004-07-13 12:23:47 +00:00
|
|
|
"generic_check_set: init_result([RESULT#%d %s]) failed\n",
|
2003-08-14 00:02:15 +00:00
|
|
|
results[i].id, results[i].name);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 2. COMPARE
|
2003-08-26 18:33:21 +00:00
|
|
|
for (i = 0; i != n; ++i) {
|
2003-08-14 00:02:15 +00:00
|
|
|
vector<bool> matches;
|
|
|
|
matches.resize(n);
|
|
|
|
neq = 0;
|
|
|
|
for (j = 0; j != n; ++j) {
|
|
|
|
bool match = false;
|
|
|
|
if (i == j) {
|
|
|
|
++neq;
|
|
|
|
matches[j] = true;
|
|
|
|
} else if (check_pair_with_data_f(results[i], data[i], results[j], data[j], match)) {
|
|
|
|
log_messages.printf(
|
2004-04-08 08:15:23 +00:00
|
|
|
SCHED_MSG_LOG::CRITICAL,
|
2004-07-13 12:23:47 +00:00
|
|
|
"generic_check_set: check_pair_with_data([RESULT#%d %s], [RESULT#%d %s]) failed\n",
|
2003-08-14 00:02:15 +00:00
|
|
|
results[i].id, results[i].name, results[j].id, results[j].name);
|
|
|
|
} else if (match) {
|
|
|
|
++neq;
|
|
|
|
matches[j] = true;
|
|
|
|
}
|
|
|
|
}
|
2004-07-13 12:23:47 +00:00
|
|
|
if (neq > min_valid) {
|
2003-08-14 00:02:15 +00:00
|
|
|
// set validate state for each result
|
|
|
|
for (j = 0; j != n; ++j) {
|
|
|
|
results[j].validate_state = matches[j] ? VALIDATE_STATE_VALID : VALIDATE_STATE_INVALID;
|
|
|
|
}
|
|
|
|
canonicalid = results[i].id;
|
|
|
|
credit = median_mean_credit(results);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
// 3. CLEANUP
|
|
|
|
for (i = 0; i != n; ++i) {
|
|
|
|
cleanup_result_f(results[i], data[i]);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-07-13 12:23:47 +00:00
|
|
|
// similar to generic_check_set, but require a strict majority of results
|
|
|
|
// (N_results / 2) to be valid
|
|
|
|
int generic_check_set_majority(
|
|
|
|
vector<RESULT>& results, int& canonicalid, double& credit,
|
|
|
|
init_result_f init_result_f,
|
|
|
|
check_pair_with_data_f check_pair_with_data_f,
|
|
|
|
cleanup_result_f cleanup_result_f)
|
|
|
|
{
|
2004-07-13 13:54:09 +00:00
|
|
|
return generic_check_set(
|
|
|
|
results, canonicalid, credit,
|
|
|
|
init_result_f, check_pair_with_data_f, cleanup_result_f,
|
|
|
|
results.size() / 2);
|
2004-07-13 12:23:47 +00:00
|
|
|
}
|
|
|
|
|
2003-08-26 18:33:21 +00:00
|
|
|
int generic_check_pair(
|
2004-09-09 22:25:10 +00:00
|
|
|
RESULT & r1, RESULT const& r2,
|
2003-08-26 18:33:21 +00:00
|
|
|
init_result_f init_result_f,
|
|
|
|
check_pair_with_data_f check_pair_with_data_f,
|
|
|
|
cleanup_result_f cleanup_result_f
|
|
|
|
) {
|
2003-08-14 00:02:15 +00:00
|
|
|
void* data1;
|
|
|
|
void* data2;
|
|
|
|
int retval;
|
2004-09-09 22:25:10 +00:00
|
|
|
bool match;
|
2003-08-14 00:02:15 +00:00
|
|
|
|
|
|
|
retval = init_result_f(r1, data1);
|
|
|
|
if (retval) {
|
|
|
|
log_messages.printf(
|
2004-04-08 08:15:23 +00:00
|
|
|
SCHED_MSG_LOG::CRITICAL,
|
2003-08-14 00:02:15 +00:00
|
|
|
"[RESULT#%d %s] [RESULT#%d %s] Couldn't initialize result 1\n",
|
|
|
|
r1.id, r1.name, r2.id, r2.name
|
|
|
|
);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = init_result_f(r2, data2);
|
|
|
|
if (retval) {
|
|
|
|
log_messages.printf(
|
2004-04-08 08:15:23 +00:00
|
|
|
SCHED_MSG_LOG::CRITICAL,
|
2003-08-14 00:02:15 +00:00
|
|
|
"[RESULT#%d %s] [RESULT#%d %s] Couldn't initialize result 2\n",
|
|
|
|
r1.id, r1.name, r2.id, r2.name
|
|
|
|
);
|
|
|
|
cleanup_result_f(r1, data1);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
retval = check_pair_with_data_f(r1, data1, r2, data2, match);
|
2004-09-09 22:25:10 +00:00
|
|
|
r1.validate_state = match?VALIDATE_STATE_VALID:VALIDATE_STATE_INVALID;
|
2003-08-14 00:02:15 +00:00
|
|
|
|
|
|
|
cleanup_result_f(r1, data1);
|
|
|
|
cleanup_result_f(r2, data2);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|