boinc/sched/hr_info.C

215 lines
6.3 KiB
C

// Berkeley Open Infrastructure for Network Computing
// http://boinc.berkeley.edu
// Copyright (C) 2008 University of California
//
// This is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation;
// either version 2.1 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Lesser General Public License for more details.
//
// To view the GNU Lesser General Public License visit
// http://www.gnu.org/copyleft/lesser.html
// or write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include <stdio.h>
#include <malloc.h>
#include <math.h>
#include "error_numbers.h"
#include "sched_msgs.h"
#include "hr_info.h"
int HR_INFO::write_file() {
int i, j;
FILE* f = fopen(HR_INFO_FILENAME, "w");
if (!f) return ERR_FOPEN;
for (i=1; i<HR_NTYPES; i++) {
fprintf(f, "--------- %s ----------\n", hr_names[i]);
for (j=0; j<hr_nclasses[i]; j++) {
fprintf(f, "%d %f\n", j, rac_per_class[i][j]);
}
}
fclose(f);
return 0;
}
int HR_INFO::read_file() {
char buf[256];
FILE* f = fopen(HR_INFO_FILENAME, "r");
if (!f) return ERR_FOPEN;
int i, j, jj;
double x;
for (i=1; i<HR_NTYPES; i++) {
char* p = fgets(buf, sizeof(buf), f);
if (!p) {
fprintf(stderr, "missing delimeter line in HR info");
exit(1);
}
for (j=0; j<hr_nclasses[i]; j++) {
char* p = fgets(buf, sizeof(buf), f);
if (!p) {
fprintf(stderr, "missing data line in HR info");
exit(1);
}
int n = sscanf(buf, "%d %lf", &jj, &x);
if (n!=2 || j!=jj) {
fprintf(stderr, "bad line %s in HR info: %d; %d != %d\n", buf, n, j, jj);
exit(1);
}
rac_per_class[i][j] = x;
}
}
fclose(f);
return 0;
}
void HR_INFO::init() {
int i;
for (i=1; i<HR_NTYPES; i++) {
rac_per_class[i] = (double*) calloc(hr_nclasses[i], sizeof(double));
max_slots[i] = (int*) calloc(hr_nclasses[i], sizeof(int));
cur_slots[i] = (int*) calloc(hr_nclasses[i], sizeof(int));
}
}
void HR_INFO::scan_db() {
DB_HOST host;
int retval;
int i, n=0;
double sum=0, sum_sqr=0;
while (1) {
retval = host.enumerate("where expavg_credit>1");
if (retval) break;
if (host.p_fpops > 1e7 && host.p_fpops < 1e13) {
n++;
sum += host.p_fpops;
sum_sqr += host.p_fpops*host.p_fpops;
}
//printf("host %d: %s | %s | %s\n", host.id, host.os_name, host.p_vendor, host.p_model);
for (i=1; i<HR_NTYPES; i++) {
if (hr_unknown_platform_type(host, i)) {
//printf("type %d: unknown\n", i);
continue;
}
int hrc = hr_class(host, i);
//printf("type %d: class %d\n", i, hrc);
if (!hrc) continue;
rac_per_class[i][hrc] += host.expavg_credit;
}
}
if (retval != ERR_DB_NOT_FOUND) {
fprintf(stderr, "host enum: %d", retval);
exit(1);
}
// if no hosts, use reasonable defaults
//
if (n) {
perf_info.host_fpops_mean = sum/n;
perf_info.host_fpops_stdev = sqrt((sum_sqr - sum*perf_info.host_fpops_mean)/n);
} else {
perf_info.host_fpops_mean = 3e9;
perf_info.host_fpops_stdev = 1e9;
}
}
void HR_INFO::allocate(int total_slots) {
int i, j;
double weight_total = 0;
for (i=1; i<HR_NTYPES; i++) {
weight_total += type_weights[i];
}
// decide how many slots to allocate to each HR type
//
for (i=1; i<HR_NTYPES; i++) {
slots_per_type[i] = (int)(total_slots*type_weights[i]/weight_total);
}
// within each type, decide how many slots to allocate to each class
//
for (i=1; i<HR_NTYPES; i++) {
int nuncom = slots_per_type[i]/2;
int ncom = slots_per_type[i] - nuncom;
log_messages.printf(MSG_DEBUG,
"type %d: %d total slots\n", i, slots_per_type[i]
);
log_messages.printf(MSG_DEBUG,
"type %d uncommitted: allocating %d slots\n", i, nuncom
);
double total_rac = 0;
for (j=1; j<hr_nclasses[i]; j++) {
total_rac += rac_per_class[i][j];
}
max_slots[i][0] = nuncom;
for (j=1; j<hr_nclasses[i]; j++) {
int n = (int)(ncom*rac_per_class[i][j]/total_rac);
// every HR class has a max of at least one,
// so that new classes can get "on the board".
// This means that the sum of the maxes can exceed the # of slots
//
if (n == 0) n = 1;
max_slots[i][j] = n;
if (n > 1) {
log_messages.printf(MSG_DEBUG,
"type %d class %d: allocating %d slots\n", i, j, n
);
}
}
for (j=0; j<hr_nclasses[i]; j++) {
cur_slots[i][j] = 0;
}
}
}
// Decide if job of the given HR type and class should be added to array,
// and if to update counts
//
bool HR_INFO::accept(int hrt, int hrc) {
if (cur_slots[hrt][hrc] >= max_slots[hrt][hrc]) {
log_messages.printf(MSG_DEBUG,
"skipping job because HR class (%d, %d) full\n", hrt, hrc
);
return false;
}
cur_slots[hrt][hrc]++;
}
void HR_INFO::show(FILE* f) {
for (int ht=1; ht<HR_NTYPES; ht++) {
fprintf(f, "HR type %s: weight %f nslots %d\n",
hr_names[ht], type_weights[ht], slots_per_type[ht]
);
for (int hc=0; hc<hr_nclasses[ht]; hc++) {
if (hc && rac_per_class[ht][hc] == 0) continue;
fprintf(f,
" class %d: rac %f max_slots %d cur_slots %d\n",
hc, rac_per_class[ht][hc], max_slots[ht][hc], cur_slots[ht][hc]
);
}
}
}
int PERF_INFO::write_file() {
FILE* f = fopen(PERF_INFO_FILENAME, "w");
if (!f) return ERR_FOPEN;
fprintf(f, "%f %f\n",
host_fpops_mean,
host_fpops_stdev
);
fclose(f);
return 0;
}