LISTELEMENT* add_jobs (WSET *ws1, WSET *ws2, LISTELEMENT *listpointer)
{
int i,k,kk;
JOB *j;
for(k=0;k<=ws1->deg-1;k++)
for(kk=0;kk<=ws2->deg-1;kk++)
{
j = (JOB *) calloc (1, sizeof(JOB));
make_job(j,ws1->num_eqns,ws2->num_eqns);
/* witness point 1 */
for(i=0;i<=ws1->num_eqns-1;i++)
j->source_1[i]=ws1->source[i];
j->num_eqns_1 = ws1->num_eqns;
j->num_vars_1 = ws1->num_vars;
j->dim_1 = ws1->dim;
j->deg_1 = ws1->deg;
/*j->solution_1 = ws1->sols[k]; */
/* witness point 2 */
for(i=0;i<=ws2->num_eqns-1;i++)
j->source_2[i]=ws2->source[i];
j->num_eqns_2 = ws2->num_eqns;
j->num_vars_2 = ws2->num_vars;
j->dim_2 = ws2->dim;
j->deg_2 = ws2->deg;
/*j->solution_2 = ws2->sols[kk]; */
listpointer = additem(listpointer, j);
}
if(v>3) printf("adding jobs is DONE\n");
return listpointer;
}
int Connector::getAllTasks() {
unsigned int numberOfJobs = 0;
unsigned int *numrows = &numberOfJobs;
MYSQL_RES *res_set; /* Create a pointer to recieve the return value.*/
MYSQL_ROW row; /* Assign variable for rows. */
string a =
"SELECT tasks.idreceptor, receptors.name, receptors.pdb, receptors.conf_name, receptors.conf, tasks.idligand, ligands.name, ligands.pdb, tasks.experiment from tasks, receptors, ligands WHERE tasks.status = 0 and receptors.idreceptors = tasks.idreceptor and ligands.idligands = tasks.idligand LIMIT 0,1000";
string b = ";";
string sql = a + b;
mysql_query(connect, sql.c_str());
/* Send a query to the database. */
//unsigned int i = 0; /* Create a counter for the rows */
res_set = mysql_store_result(connect); /* Receive the result and store it in res_set */
*numrows = mysql_num_rows(res_set); /* Create the count to print all rows */
log_messages.printf(MSG_DEBUG, "Making %d jobs\n", *numrows);
if (*numrows > 0) {
fprintf(stderr, "adding tasks\n");
unsigned int n;
for (n = 0; n < *numrows; n++) {
struct jobstruct job;
row = mysql_fetch_row(res_set);
job.idreceptor = row[0];
job.namereceptor = row[1];
job.pdbreceptor = row[2];
job.confname = row[3];
job.pdbconf = row[4];
job.idligand = row[5];
job.nameligand = row[6];
job.pdbligand = row[7];
job.experiment = row[8];
//printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",row[0],row[1],row[2],row[3],row[4],row[5],row[6],row[7]); /* Print the row data */
int retval = make_job(job);
if (retval) {
log_messages.printf(MSG_CRITICAL, "can't make job: %s\n",
boincerror(retval));
exit(retval);
}
markTaskAsRunning(job.idreceptor, job.idligand);
}
}
mysql_free_result(res_set);
return 0;
}
void main_loop() {
int retval;
int node=0,n;
while (node<n1) {
check_stop_daemons();
retval = count_unsent_results(n, 0);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"count_unsent_jobs() failed: %s\n", boincerror(retval)
);
exit(retval);
}
if (n > CUSHION) {
daemon_sleep(5);
} else {
// int njobs = (CUSHION-n)/REPLICATION_FACTOR;
log_messages.printf(MSG_DEBUG,
"Making job for %d\n", node
);
// for (int i=0; i<njobs; i++) {
for (int i=0; i<n1; i+=CLIENT_LIMIT)
{
retval = make_job(node,i);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"can't make job: %s\n", boincerror(retval)
);
exit(retval);
}
}
// }
// Now sleep for a few seconds to let the transitioner
// create instances for the jobs we just created.
// Otherwise we could end up creating an excess of jobs.
double now = dtime();
while (1) {
daemon_sleep(5);
double x;
retval = min_transition_time(x);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"min_transition_time failed: %s\n", boincerror(retval)
);
exit(retval);
}
if (x > now) break;
}
}
node++;
}
}
void main_loop() {
int retval;
while (1) {
check_stop_daemons();
long n;
retval = count_unsent_results(n, app.id);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"count_unsent_jobs() failed: %s\n", boincerror(retval)
);
exit(retval);
}
if (n > CUSHION) {
daemon_sleep(10);
} else {
int njobs = (CUSHION-n)/REPLICATION_FACTOR;
log_messages.printf(MSG_DEBUG,
"Making %d jobs\n", njobs
);
for (int i=0; i<njobs; i++) {
retval = make_job();
if (retval) {
log_messages.printf(MSG_CRITICAL,
"can't make job: %s\n", boincerror(retval)
);
exit(retval);
}
}
// Wait for the transitioner to create instances
// of the jobs we just created.
// Otherwise we'll create too many jobs.
//
double now = dtime();
while (1) {
daemon_sleep(5);
double x;
retval = min_transition_time(x);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"min_transition_time failed: %s\n", boincerror(retval)
);
exit(retval);
}
if (x > now) break;
}
}
}
}
void test_mm(void) {
int max_threads = 8;
thread_pool_t *thread_pool = create_thread_pool(max_threads);
int m = 8192;
int n = 1024;
int k = 1024;
double *a = make_array(m, k);
double *b = make_array(k, n);
double *o = make_array(m, n);
int tile_sizes[5] = {1024, 64, 64, 8, 8};
int num_threads = 8;
job_t *job = make_job(0, m, 1024, num_threads, 1);
vm_args_t vm_args;
vm_args.a = a;
vm_args.b = b;
vm_args.out = o;
vm_args.m = m;
vm_args.n = n;
vm_args.k = k;
struct timeval start, end, result;
gettimeofday(&start, NULL);
launch_job(thread_pool, &vm2, &vm_args, job, tile_sizes, 1);
wait_for_job(thread_pool);
gettimeofday(&end, NULL);
double t;
timersub(&end, &start, &result);
t = result.tv_sec + result.tv_usec / 1000000.0;
printf("Parallel runtime: %f\n", t);
int pass = 1;
// int i, j, l;
// double sum;
// gettimeofday(&start, NULL);
// for (i = 0; i < m; ++i) {
// for (j = 0; j < n; ++j) {
// sum = 0.0;
// for (l = 0; l < k; ++l) {
// sum += a[i*k + l] * b[j*k + l];
// }
// pass = pass && (abs(sum - o[i*n + j]) < 1e-4);
// }
// }
// gettimeofday(&end, NULL);
CU_ASSERT(pass);
// double naive_time;
// timersub(&end, &start, &result);
// naive_time = result.tv_sec + result.tv_usec / 1000000.0;
// printf("Naive time: %f\n", naive_time);
destroy_thread_pool(thread_pool);
free_job(job);
free_array(a);
free_array(b);
free_array(o);
}
// simulate trying to do an RPC;
// return true if we actually did one
//
bool CLIENT_STATE::simulate_rpc(PROJECT* p) {
char buf[256], buf2[256];
vector<IP_RESULT> ip_results;
vector<RESULT*> new_results;
bool avail;
if (p->last_rpc_time) {
double delta = now - p->last_rpc_time;
avail = p->available.sample(delta);
} else {
avail = p->available.sample(0);
}
p->last_rpc_time = now;
if (!avail) {
sprintf(buf, "RPC to %s skipped - project down<br>", p->project_name);
html_msg += buf;
msg_printf(p, MSG_INFO, "RPC skipped: project down");
gstate.scheduler_op->project_rpc_backoff(p, "project down");
p->master_url_fetch_pending = false;
return false;
}
// save request params for WORK_FETCH::handle_reply
//
double save_cpu_req_secs = rsc_work_fetch[0].req_secs;
for (int i=1; i<coprocs.n_rsc; i++) {
COPROC& cp = coprocs.coprocs[i];
if (!strcmp(cp.type, "NVIDIA")) {
coprocs.nvidia.req_secs = rsc_work_fetch[i].req_secs;
}
if (!strcmp(cp.type, "ATI")) {
coprocs.ati.req_secs = rsc_work_fetch[i].req_secs;
}
if (!strcmp(cp.type, "intel_gpu")) {
coprocs.intel_gpu.req_secs = rsc_work_fetch[i].req_secs;
}
}
if (!server_uses_workload) {
for (int i=0; i<coprocs.n_rsc; i++) {
rsc_work_fetch[i].estimated_delay = rsc_work_fetch[i].busy_time_estimator.get_busy_time();
}
}
for (unsigned int i=0; i<app_versions.size(); i++) {
app_versions[i]->dont_use = false;
}
work_fetch.request_string(buf2, sizeof(buf2));
sprintf(buf, "RPC to %s: %s<br>", p->project_name, buf2);
html_msg += buf;
msg_printf(p, MSG_INFO, "RPC: %s", buf2);
handle_completed_results(p);
if (server_uses_workload) {
get_workload(ip_results);
}
bool sent_something = false;
while (!existing_jobs_only) {
vector<APP*> apps;
get_apps_needing_work(p, apps);
if (apps.empty()) break;
RESULT* rp = new RESULT;
WORKUNIT* wup = new WORKUNIT;
make_job(p, wup, rp, apps);
double et = wup->rsc_fpops_est / rp->avp->flops;
if (server_uses_workload) {
IP_RESULT c(rp->name, rp->report_deadline-now, et);
if (check_candidate(c, ncpus, ip_results)) {
ip_results.push_back(c);
} else {
msg_printf(p, MSG_INFO, "job for %s misses deadline sim\n", rp->app->name);
APP_VERSION* avp = rp->avp;
delete rp;
delete wup;
avp->dont_use = true;
continue;
}
} else {
double est_delay = get_estimated_delay(rp);
if (est_delay + et > wup->app->latency_bound) {
msg_printf(p, MSG_INFO,
"job for %s misses deadline approx: del %f + et %f > %f\n",
rp->app->name,
est_delay, et, wup->app->latency_bound
);
APP_VERSION* avp = rp->avp;
delete rp;
delete wup;
avp->dont_use = true;
continue;
}
}
sent_something = true;
rp->set_state(RESULT_FILES_DOWNLOADED, "simulate_rpc");
results.push_back(rp);
new_results.push_back(rp);
#if 0
sprintf(buf, "got job %s: CPU time %.2f, deadline %s<br>",
rp->name, rp->final_cpu_time, time_to_string(rp->report_deadline)
);
html_msg += buf;
#endif
decrement_request(rp);
}
njobs += (int)new_results.size();
msg_printf(0, MSG_INFO, "Got %lu tasks", new_results.size());
sprintf(buf, "got %lu tasks<br>", new_results.size());
html_msg += buf;
SCHEDULER_REPLY sr;
rsc_work_fetch[0].req_secs = save_cpu_req_secs;
work_fetch.handle_reply(p, &sr, new_results);
p->nrpc_failures = 0;
p->sched_rpc_pending = 0;
//p->min_rpc_time = now + 900;
p->min_rpc_time = now;
if (sent_something) {
request_schedule_cpus("simulate_rpc");
request_work_fetch("simulate_rpc");
}
sim_results.nrpcs++;
return true;
}
