static int main_loop_program( const char *funcpath, struct text_list *seta, struct text_list *setb )
{
int x,i,j,c;
char line[1024];
FILE *proc[num_cores];
int xstop = text_list_size(seta);
/* for each block sized vertical stripe... */
for(x=0;x<xstop;x+=block_size) {
/* for each row in the stripe ... */
for(j=0;j<text_list_size(setb);j++) {
/* for each group of num_cores in the stripe... */
for(i=x;i<(x+block_size);i+=num_cores) {
/* make sure we don't run past the block width */
int n = MIN(num_cores,x+block_size-i);
/* make sure we don't run off the width of the array */
n = MIN(n,xstop-i);
/* start one process for each core */
/* if nindex = 2, the real xindex = index_array[0] + i; the real yindex = index_array[1] + j. */
for(c=0;c<n;c++) {
if((nindex == 2 && (index_array[0] + i + c) <= (index_array[1] + j)) || //calcuate xindex and yindex of the unit in the original matrix of allpairs_master
(is_symmetric == 0 && nindex == 0) ||
(is_symmetric && (i+c) <= j)) {
sprintf(line,"%s %s %s %s\n",funcpath,extra_arguments,text_list_get(seta,i+c),text_list_get(setb,j));
proc[c] = fast_popen(line);
if(!proc[c]) {
fprintf(stderr,"%s: couldn't execute %s: %s\n",progname,line,strerror(errno));
return 1;
}
}
}
/* then finish one process for each core */
for(c=0;c<n;c++) {
if((nindex == 2 && (index_array[0] + i + c) <= (index_array[1] + j)) ||
(is_symmetric == 0 && nindex == 0) ||
(is_symmetric && (i+c) <= j)) {
printf("%s\t%s\t",text_list_get(seta,i+c),text_list_get(setb,j));
int lines = 0;
while(fgets(line,sizeof(line),proc[c])) {
printf("%s",line);
lines++;
}
if(lines==0) printf("\n");
fast_pclose(proc[c]);
}
}
}
}
}
return 0;
}
static int main_loop_threaded( allpairs_compare_t funcptr, struct text_list *seta, struct text_list *setb )
{
int x,i,j,c;
char *xname[block_size];
char *xdata[block_size];
int xdata_length[block_size];
char *yname[num_cores];
char *ydata[num_cores];
int ydata_length[num_cores];
struct thread_args args[num_cores];
pthread_t thread[num_cores];
/* for each block sized vertical stripe... */
for(x=0;x<text_list_size(seta);x+=block_size) {
/* load the horizontal members of the stripe */
for(i=0;i<block_size;i++) {
xname[i] = text_list_get(seta,x+i);
xdata[i] = load_one_file(text_list_get(seta,x+i),&xdata_length[i]);
}
/* for each row in the stripe ... */
for(j=0;j<text_list_size(setb);j+=num_cores) {
/* don't start more threads than rows remaining. */
int n = MIN(num_cores,text_list_size(setb)-j);
/* start one thread working on a whole row. */
for(c=0;c<n;c++) {
yname[c] = text_list_get(setb,j+c);
ydata[c] = load_one_file(text_list_get(setb,j+c),&ydata_length[c]);
args[c].func = funcptr;
args[c].xname = xname;
args[c].xdata = xdata;
args[c].xdata_length = xdata_length;
args[c].yname = yname[c];
args[c].ydata = ydata[c];
args[c].ydata_length = ydata_length[c];
pthread_create(&thread[c],0,row_loop_threaded,&args[c]);
}
/* wait for each one to finish */
for(c=0;c<n;c++) {
pthread_join(thread[c],0);
free(ydata[c]);
}
}
for(i=0;i<block_size;i++) {
free(xdata[i]);
}
}
return 0;
}
struct work_queue_task * ap_task_create( struct text_list *seta, struct text_list *setb )
{
int x,y;
char *buf, *name;
if(xcurrent>=xstop) {
xcurrent=0;
ycurrent+=yblock;
}
if(ycurrent>=ystop) return 0;
char cmd[ALLPAIRS_LINE_MAX];
sprintf(cmd,"./%s -e \"%s\" A B %s%s",string_basename(allpairs_multicore_program),extra_arguments,use_external_program ? "./" : "",string_basename(allpairs_compare_program));
struct work_queue_task *task = work_queue_task_create(cmd);
if(use_external_program) {
work_queue_task_specify_file(task,allpairs_compare_program,string_basename(allpairs_compare_program),WORK_QUEUE_INPUT,WORK_QUEUE_CACHE);
}
work_queue_task_specify_file(task,allpairs_multicore_program,string_basename(allpairs_multicore_program),WORK_QUEUE_INPUT,WORK_QUEUE_CACHE);
const char *f;
list_first_item(extra_files_list);
while((f = list_next_item(extra_files_list))) {
work_queue_task_specify_file(task,f,string_basename(f),WORK_QUEUE_INPUT,WORK_QUEUE_CACHE);
}
buf = text_list_string(seta,xcurrent,xcurrent+xblock);
work_queue_task_specify_buffer(task,buf,strlen(buf),"A",WORK_QUEUE_NOCACHE);
free(buf);
buf = text_list_string(setb,ycurrent,ycurrent+yblock);
work_queue_task_specify_buffer(task,buf,strlen(buf),"B",WORK_QUEUE_NOCACHE);
free(buf);
for(x=xcurrent;x<(xcurrent+xblock);x++) {
name = text_list_get(seta,x);
if(!name) break;
work_queue_task_specify_file(task,name,string_basename(name),WORK_QUEUE_INPUT,WORK_QUEUE_CACHE);
}
for(y=ycurrent;y<(ycurrent+yblock);y++) {
name = text_list_get(setb,y);
if(!name) break;
work_queue_task_specify_file(task,name,string_basename(name),WORK_QUEUE_INPUT,WORK_QUEUE_CACHE);
}
/* advance to the next row/column */
xcurrent += xblock;
return task;
}
int block_size_estimate( struct text_list *seta )
{
int count = MIN(100,text_list_size(seta));
int i;
UINT64_T total_data = 0,free_mem,total_mem;
int block_size;
host_memory_info_get(&free_mem, &total_mem);
for(i=0;i<count;i++) {
total_data += get_file_size(text_list_get(seta,i));
}
total_mem = total_mem/2;
if(total_data>=total_mem) {
block_size = text_list_size(seta) * total_mem / total_data;
if(block_size<1) block_size = 1;
if(block_size>text_list_size(seta)) block_size = text_list_size(seta);
} else {
block_size = text_list_size(seta);
}
return block_size;
}
double estimate_run_time( struct text_list *seta, struct text_list *setb )
{
char line[ALLPAIRS_LINE_MAX];
timestamp_t starttime, stoptime;
int x,y;
fprintf(stderr, "%s: sampling execution time of %s...\n",progname,allpairs_compare_program);
starttime = timestamp_get();
for(x=0;x<xstop;x++) {
for(y=0;y<ystop;y++) {
sprintf(line,"./%s %s %s %s",
string_basename(allpairs_compare_program),
extra_arguments,
text_list_get(seta,x),
text_list_get(setb,y)
);
FILE *file = fast_popen(line);
if(!file) {
fprintf(stderr,"%s: couldn't execute %s: %s\n",progname,line,strerror(errno));
exit(1);
}
while(fgets(line,sizeof(line),file)) {
fprintf(stderr,"%s",line);
}
fast_pclose(file);
stoptime = timestamp_get();
if(stoptime-starttime>5000000) break;
}
if(stoptime-starttime>5000000) break;
}
double t = (double)(stoptime - starttime) / (x * ystop + y + 1) / 1000000;
if(t<0.01) t = 0.01;
return t;
}
char * text_list_string( struct text_list *t, int a, int b )
{
static int buffer_size = 128;
char *buffer = malloc(buffer_size);
int buffer_pos = 0;
int i;
for(i=a;i<b;i++) {
const char *str = text_list_get(t,i);
if(!str) break;
str = path_basename(str);
while( (int) (strlen(str) + buffer_pos + 3) >= buffer_size) {
buffer_size *= 2;
buffer = realloc(buffer,buffer_size);
}
buffer_pos += sprintf(&buffer[buffer_pos],"%s\n",str);
}
buffer[buffer_pos] = 0;
return buffer;
}
static batch_job_id_t batch_job_mesos_submit (struct batch_queue *q, const char *cmd,
const char *extra_input_files, const char *extra_output_files,
struct jx *envlist, const struct rmsummary *resources )
{
// Get the path to mesos python site-packages
if (!is_mesos_py_path_known) {
mesos_py_path = batch_queue_get_option(q, "mesos-path");
if (mesos_py_path != NULL) {
debug(D_INFO, "Get mesos_path %s from command line\n", mesos_py_path);
}
is_mesos_py_path_known = 1;
}
// Get the mesos master address
if (!is_mesos_master_known) {
mesos_master = batch_queue_get_option(q, "mesos-master");
if (mesos_master == NULL) {
fatal("Please specify the hostname of mesos master by using --mesos-master");
} else {
debug(D_INFO, "Get mesos_path %s from command line\n", mesos_py_path);
is_mesos_master_known = 1;
}
}
mesos_preload = batch_queue_get_option(q, "mesos-preload");
if (is_mesos_py_path_known &&
is_mesos_master_known &&
!is_scheduler_running ) {
// start mesos scheduler if it is not running
start_mesos_scheduler(q);
is_scheduler_running = 1;
}
int task_id = ++counter;
debug(D_BATCH, "task %d is ready", task_id);
struct batch_job_info *info = calloc(1, sizeof(*info));
info->started = time(0);
info->submitted = time(0);
itable_insert(q->job_table, task_id, info);
// write the ready task information as
// "task_id, task_cmd, inputs, outputs" to
// mesos_task_info, which will be scanned by
// mf_mesos_scheduler later.
FILE *task_info_fp;
if(access(FILE_TASK_INFO, F_OK) != -1) {
task_info_fp = fopen(FILE_TASK_INFO, "a+");
} else {
task_info_fp = fopen(FILE_TASK_INFO, "w+");
}
struct mesos_task *mt = mesos_task_create(task_id, cmd, extra_input_files, extra_output_files);
fprintf(task_info_fp, "%d,%s,", mt->task_id, mt->task_cmd);
if (extra_input_files != NULL && strlen(extra_input_files) != 0) {
int j = 0;
int num_input_files = text_list_size(mt->task_input_files);
for (j = 0; j < (num_input_files-1); j++) {
fprintf(task_info_fp, "%s ", text_list_get(mt->task_input_files, j));
}
fprintf(task_info_fp, "%s,", text_list_get(mt->task_input_files, num_input_files-1));
} else {
fprintf(task_info_fp, ",");
}
if (extra_output_files != NULL && strlen(extra_output_files) != 0) {
int j = 0;
int num_output_files = text_list_size(mt->task_output_files);
for (j = 0; j < (num_output_files-1); j++) {
fprintf(task_info_fp, "%s ", text_list_get(mt->task_output_files, j));
}
fprintf(task_info_fp, "%s,",text_list_get(mt->task_output_files, num_output_files-1));
} else {
fprintf(task_info_fp, ",");
}
// The default resource requirements for each task
int64_t cores = -1;
int64_t memory = -1;
int64_t disk = -1;
if (resources) {
cores = resources->cores > -1 ? resources->cores : cores;
memory = resources->memory > -1 ? resources->memory : memory;
disk = resources->disk > -1 ? resources->disk : disk;
}
fprintf(task_info_fp, "%" PRId64 ",%" PRId64 ",%" PRId64 ",", cores, memory, disk);
fputs("submitted\n", task_info_fp);
mesos_task_delete(mt);
fclose(task_info_fp);
return task_id;
}
