static int vigs_device_init(PCIDevice *dev)
{
VIGSState *s = DO_UPCAST(VIGSState, dev.pci_dev, dev);
struct vigs_backend *backend = NULL;
XSetErrorHandler(x_error_handler);
XInitThreads();
vigs_display = XOpenDisplay(0);
if (!vigs_display) {
fprintf(stderr, "Cannot open X display\n");
exit(1);
}
vigs_render_queue = work_queue_create("render_queue");
vigs_log_init();
if (s->vram_size < 16 * 1024 * 1024) {
VIGS_LOG_WARN("\"vram_size\" is too small, defaulting to 16mb");
s->vram_size = 16 * 1024 * 1024;
}
if (s->ram_size < 1 * 1024 * 1024) {
VIGS_LOG_WARN("\"ram_size\" is too small, defaulting to 1mb");
s->ram_size = 1 * 1024 * 1024;
}
pci_config_set_interrupt_pin(dev->config, 1);
memory_region_init_ram(&s->vram_bar, OBJECT(s),
TYPE_VIGS_DEVICE ".vram",
s->vram_size);
memory_region_init_ram(&s->ram_bar, OBJECT(s),
TYPE_VIGS_DEVICE ".ram",
s->ram_size);
memory_region_init_io(&s->io_bar, OBJECT(s),
&vigs_io_ops,
s,
TYPE_VIGS_DEVICE ".io",
VIGS_IO_SIZE);
pci_register_bar(&s->dev.pci_dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->vram_bar);
pci_register_bar(&s->dev.pci_dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->ram_bar);
pci_register_bar(&s->dev.pci_dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->io_bar);
backend = vigs_gl_backend_create(vigs_display);
if (!backend) {
goto fail;
}
s->fenceman = vigs_fenceman_create();
s->fence_ack_bh = qemu_bh_new(vigs_fence_ack_bh, s);
s->con = graphic_console_init(DEVICE(dev), 0, &vigs_hw_ops, s);
if (!s->con) {
goto fail;
}
s->server = vigs_server_create(memory_region_get_ram_ptr(&s->vram_bar),
memory_region_get_ram_ptr(&s->ram_bar),
&vigs_dpy_ops,
s,
backend,
vigs_render_queue);
if (!s->server) {
goto fail;
}
vigs_wsi = s->dev.wsi = &s->server->wsi;
VIGS_LOG_INFO("VIGS initialized");
VIGS_LOG_DEBUG("vram_size = %u", s->vram_size);
VIGS_LOG_DEBUG("ram_size = %u", s->ram_size);
return 0;
fail:
if (backend) {
backend->destroy(backend);
}
if (s->fence_ack_bh) {
qemu_bh_delete(s->fence_ack_bh);
}
if (s->fenceman) {
vigs_fenceman_destroy(s->fenceman);
}
memory_region_destroy(&s->io_bar);
memory_region_destroy(&s->ram_bar);
memory_region_destroy(&s->vram_bar);
vigs_log_cleanup();
return -1;
}
int main(int argc, char **argv)
{
signed char c;
struct work_queue *q;
int port = WORK_QUEUE_DEFAULT_PORT;
static const char *port_file = NULL;
int work_queue_master_mode = WORK_QUEUE_MASTER_MODE_STANDALONE;
char *project = NULL;
int priority = 0;
debug_config("allpairs_master");
extra_files_list = list_create();
struct option long_options[] = {
{"debug", required_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"port", required_argument, 0, 'p'},
{"random-port", required_argument, 0, 'Z'},
{"extra-args", required_argument, 0, 'e'},
{"width", required_argument, 0, 'x'},
{"height", required_argument, 0, 'y'},
{"advertise", no_argument, 0, 'a'}, //deprecated, left here for backwards compatibility
{"project-name", required_argument, 0, 'N'},
{"debug-file", required_argument, 0, 'o'},
{"output-file", required_argument, 0, 'O'},
{"wqstats-file", required_argument, 0, 's'},
{"input-file", required_argument, 0, 'f'},
{"estimated-time", required_argument, 0, 't'},
{"priority", required_argument, 0, 'P'},
{0,0,0,0}
};
while((c = getopt_long(argc, argv, "ad:e:f:hN:p:P:t:vx:y:Z:O:o:s:", long_options, NULL)) >= 0) {
switch (c) {
case 'a':
work_queue_master_mode = WORK_QUEUE_MASTER_MODE_CATALOG;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'e':
extra_arguments = optarg;
break;
case 'f':
list_push_head(extra_files_list,optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
free(output_filename);
output_filename=xxstrdup(optarg);
break;
case 's':
free(wqstats_filename);
wqstats_filename=xxstrdup(optarg);
break;
case 'h':
show_help(progname);
exit(0);
break;
case 'N':
work_queue_master_mode = WORK_QUEUE_MASTER_MODE_CATALOG;
free(project);
project = xxstrdup(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'P':
priority = atoi(optarg);
break;
case 't':
compare_program_time = atof(optarg);
break;
case 'v':
cctools_version_print(stdout, progname);
exit(0);
break;
case 'x':
xblock = atoi(optarg);
break;
case 'y':
yblock = atoi(optarg);
break;
case 'Z':
port_file = optarg;
port = 0;
break;
default:
show_help(progname);
return 1;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if((argc - optind) < 3) {
show_help(progname);
exit(1);
}
struct text_list *seta = text_list_load(argv[optind]);
if(!seta) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind+1],strerror(errno));
return 1;
}
fprintf(stdout, "%s: %s has %d elements\n",progname,argv[optind],text_list_size(seta));
struct text_list *setb = text_list_load(argv[optind+1]);
if(!setb) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind+1],strerror(errno));
return 1;
}
fprintf(stdout, "%s: %s has %d elements\n",progname,argv[optind+1],text_list_size(setb));
if (!find_executable("allpairs_multicore","PATH",allpairs_multicore_program,sizeof(allpairs_multicore_program))) {
fprintf(stderr,"%s: couldn't find allpairs_multicore in path\n",progname);
return 1;
}
debug(D_DEBUG,"using multicore executable %s",allpairs_multicore_program);
xstop = text_list_size(seta);
ystop = text_list_size(setb);
if(allpairs_compare_function_get(argv[optind+2])) {
strcpy(allpairs_compare_program,argv[optind+2]);
debug(D_DEBUG,"using internal function %s",allpairs_compare_program);
use_external_program = 0;
} else {
if(!find_executable(argv[optind+2],"PATH",allpairs_compare_program,sizeof(allpairs_compare_program))) {
fprintf(stderr,"%s: %s is neither an executable nor an internal comparison function.\n",progname,allpairs_compare_program);
return 1;
}
debug(D_DEBUG,"using comparison executable %s",allpairs_compare_program);
use_external_program = 1;
}
if(!xblock || !yblock) {
estimate_block_size(seta,setb,&xblock,&yblock);
}
fprintf(stdout, "%s: using block size of %dx%d\n",progname,xblock,yblock);
if(work_queue_master_mode == WORK_QUEUE_MASTER_MODE_CATALOG && !project) {
fprintf(stderr, "allpairs: allpairs master running in catalog mode. Please use '-N' option to specify the name of this project.\n");
fprintf(stderr, "allpairs: Run \"%s -h\" for help with options.\n", argv[0]);
return 1;
}
q = work_queue_create(port);
//Read the port the queue is actually running, in case we just called
//work_queue_create(LINK_PORT_ANY)
port = work_queue_port(q);
if(!q) {
fprintf(stderr,"%s: could not create work queue on port %d: %s\n",progname,port,strerror(errno));
return 1;
}
if(port_file)
opts_write_port_file(port_file, port);
if(wqstats_filename)
work_queue_specify_log(q, wqstats_filename);
// advanced work queue options
work_queue_specify_master_mode(q, work_queue_master_mode);
work_queue_specify_name(q, project);
work_queue_specify_priority(q, priority);
fprintf(stdout, "%s: listening for workers on port %d...\n",progname,work_queue_port(q));
while(1) {
struct work_queue_task *task = NULL;
while(work_queue_hungry(q)) {
task = ap_task_create(seta,setb);
if(task) {
work_queue_submit(q, task);
} else {
break;
}
}
if(!task && work_queue_empty(q)) break;
task = work_queue_wait(q,5);
if(task) task_complete(task);
}
work_queue_delete(q);
return 0;
}
int main( int argc, char *argv[] )
{
char c;
const char *progname = "wavefront";
debug_config(progname);
while((c=getopt(argc,argv,"p:Pd:o:vh"))!=(char)-1) {
switch(c) {
case 'p':
port = atoi(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'v':
show_version(progname);
exit(0);
break;
case 'h':
show_help(progname);
exit(0);
break;
}
}
if( (argc-optind)!=5 ) {
show_help(progname);
exit(1);
}
function = argv[optind];
xsize=atoi(argv[optind+1]);
ysize=atoi(argv[optind+2]);
infile=argv[optind+3];
outfile=argv[optind+4];
start_time = time(0);
last_display_time = 0;
cells_total = xsize*ysize;
xsize++;
ysize++;
array = text_array_create(xsize,ysize);
if(!text_array_load(array,infile)) {
fprintf(stderr,"couldn't load %s: %s",infile,strerror(errno));
return 1;
}
int count = text_array_load(array,outfile);
if(count>0) printf("recovered %d results from %s\n",count,outfile);
logfile = fopen(outfile,"a");
if(!logfile) {
fprintf(stderr,"couldn't open %s for append: %s\n",outfile,strerror(errno));
return 1;
}
queue = work_queue_create(port);
task_prime();
struct work_queue_task *t;
while(1) {
if(time(0)!=last_display_time) display_progress(queue);
t = work_queue_wait(queue,WORK_QUEUE_WAITFORTASK);
if(!t) break;
if(t->return_status==0) {
int x,y;
if(sscanf(t->tag,"%d %d",&x,&y)==2) {
text_array_set(array,x,y,t->output);
task_complete(x,y);
fprintf(logfile,"%d %d %s\n",x,y,t->output);
fflush(logfile);
tasks_done++;
} else {
fprintf(stderr,"unexpected output: %s\nfrom command: %s\non host: %s",t->output,t->command_line,t->host);
}
} else {
fprintf(stderr,"function failed return value (%i) result (%i) on host %s. output:\n%s\n",t->return_status,t->result,t->host,t->output);
}
work_queue_task_delete(t);
if(work_queue_empty(queue))
break;
}
display_progress(queue);
return 0;
}
int main(int argc, char *argv[])
{
struct work_queue *q;
int port = 0; //pick an arbitrary port
int c;
char *sort_arguments = NULL;
const char *proj_name = NULL;
char *outfile= NULL;
int auto_partition = 0;
int sample_env = 0;
int print_runtime_estimates = 0;
int estimate_partition= 0;
struct timeval current;
long long unsigned int execn_start_time, execn_time, workload_runtime;
int keepalive_interval = 300;
int keepalive_timeout = 30;
unsigned long long records = 0;
int partitions = PARTITION_DEFAULT;
int sample_size = SAMPLE_SIZE_DEFAULT;
gettimeofday(¤t, 0);
execn_start_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
debug_flags_set("all");
if(argc < 3) {
show_help(argv[0]);
return 0;
}
while((c = getopt(argc, argv, "N:k:o:ASs:p:MR:L:I:T:B:h")) != (char) -1) {
switch (c) {
case 'N':
proj_name = strdup(optarg);
break;
case 'k':
partitions = atoi(optarg);
break;
case 'o':
outfile = strdup(optarg);
break;
case 'A':
auto_partition = 1;
break;
case 's':
sample_size = atoi(optarg);
break;
case 'S':
sample_env = 1;
break;
case 'p':
sort_arguments = strdup(optarg);
break;
case 'M':
print_runtime_estimates = 1;
break;
case 'R':
estimate_partition = atoi(optarg);
break;
case 'L':
records = atoll(optarg);
break;
case 'I':
keepalive_interval = atoi(optarg);
break;
case 'T':
keepalive_timeout = atoi(optarg);
break;
case 'B':
bandwidth_bytes_per_sec = atoi(optarg) * 1000000;
break;
case 'h':
show_help(argv[0]);
return 0;
default:
show_help(argv[0]);
return -1;
}
}
char sort_executable[256], infile[256];
off_t last_partition_offset_end = 0;
int optimal_partitions, optimal_resources, current_optimal_partitions;
double current_optimal_time = DBL_MAX;
double optimal_times[5];
int sample_partition_offset_end = 0;
int i;
sprintf(sort_executable, "%s", argv[optind]);
sprintf(infile, "%s", argv[optind+1]);
if(!outfile){
char *infile_dup = strdup(infile);
outfile = (char *) malloc((strlen(infile)+8)*sizeof(char));
sprintf(outfile, "%s.sorted", basename(infile_dup));
free(infile_dup);
}
if(records == 0) {
records = get_total_lines(infile);
fprintf(stdout, "Input file %s has %llu records to sort\n", infile, records);
if(records == 0) {
fprintf(stderr, "Error in reading records. Quitting...\n");
return 0;
}
}
if(estimate_partition) {
double *estimated_runtimes = (double *)malloc(sizeof(double) * 5);
for (i = 1; i <= 2*estimate_partition; i++) {
estimated_runtimes = sort_estimate_runtime(infile, sort_executable, records, i, estimate_partition);
if(estimated_runtimes[0] < current_optimal_time) {
current_optimal_time = estimated_runtimes[0];
optimal_times[0] = estimated_runtimes[0];
optimal_times[1] = estimated_runtimes[1];
optimal_times[2] = estimated_runtimes[2];
optimal_times[3] = estimated_runtimes[3];
optimal_times[4] = estimated_runtimes[4];
optimal_resources = i;
}
}
fprintf(stdout, "For partition %d: %d %f %f %f %f %f\n", estimate_partition, optimal_resources, optimal_times[0], optimal_times[1], optimal_times[2], optimal_times[3], optimal_times[4]);
free(estimated_runtimes);
return 1;
}
if(print_runtime_estimates) {
fprintf(stdout, "Resources \t Partitions \t Runtime \t Part time \t Merge time \t Task time \t Transfer time\n");
for (i = 1; i <= 100; i++) {
optimal_partitions = get_optimal_runtimes(infile, sort_executable, i, records, optimal_times);
fprintf(stdout, "%d \t \t %d \t %f \t %f \t %f \t %f \t %f\n", i, optimal_partitions, optimal_times[0], optimal_times[1], optimal_times[2], optimal_times[3], optimal_times[4]);
}
return 1;
}
q = work_queue_create(port);
if(!q) {
fprintf(stderr, "couldn't listen on port %d: %s\n", port, strerror(errno));
return 1;
}
fprintf(stdout, "listening on port %d...\n", work_queue_port(q));
if(proj_name){
work_queue_specify_master_mode(q, WORK_QUEUE_MASTER_MODE_CATALOG);
work_queue_specify_name(q, proj_name);
}
work_queue_specify_keepalive_interval(q, keepalive_interval);
work_queue_specify_keepalive_timeout(q, keepalive_timeout);
free((void *)proj_name);
fprintf(stdout, "%s will be run to sort contents of %s\n", sort_executable, infile);
long long unsigned int sample_start_time, sample_end_time, sample_time;
if(sample_env) {
gettimeofday(¤t, 0);
sample_start_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
int sample_record_size = (5*records)/100; //sample size is 5% of the total records
char *sample_partition_file_prefix = (char *) malloc((strlen(outfile)+8) * sizeof(char));
sprintf(sample_partition_file_prefix, "%s.sample", outfile);
char *sample_outfile = (char *) malloc((strlen(outfile)+3) * sizeof(char));
sprintf(sample_outfile, "%s.0", outfile);
sample_partition_offset_end = sample_run(q, sort_executable, sort_arguments, infile, 0, sample_partition_file_prefix, sample_outfile, sample_size, sample_record_size);
records -= sample_record_size;
free(sample_partition_file_prefix);
free(sample_outfile);
gettimeofday(¤t, 0);
sample_end_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
sample_time = sample_end_time - sample_start_time;
fprintf(stdout, "Sampling time is %llu\n", sample_time);
}
if(auto_partition) {
fprintf(stdout, "Determining optimal partition size for %s\n", infile);
for (i = 1; i <= 100; i++) {
current_optimal_partitions = get_optimal_runtimes(infile, sort_executable, i, records, optimal_times);
if (optimal_times[0] < current_optimal_time) {
current_optimal_time = optimal_times[0];
optimal_partitions = current_optimal_partitions;
optimal_resources = i;
}
}
fprintf(stdout, "Optimal partition size is %d that runs the workload in %f\n", optimal_partitions, current_optimal_time);
fprintf(stdout, "--> Please allocate %d resources for running this workload in a cost-efficient manner.\n", optimal_resources);
partitions = optimal_partitions;
}
long long unsigned int part_start_time, part_end_time, part_time;
gettimeofday(¤t, 0);
part_start_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
last_partition_offset_end = partition_tasks(q, sort_executable, sort_arguments, infile, 0+sample_partition_offset_end, outfile, partitions, records);
if(last_partition_offset_end <= 0) {
fprintf(stderr, "Partitioning failed. Quitting...\n");
return 0;
}
gettimeofday(¤t, 0);
part_end_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
part_time = part_end_time - part_start_time;
fprintf(stdout, "Partition time is %llu\n", part_time);
free(sort_arguments);
fprintf(stdout, "Waiting for tasks to complete...\n");
long long unsigned int parallel_start_time, parallel_end_time, parallel_time;
gettimeofday(¤t, 0);
parallel_start_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
char *record_task_times_file = (char *)malloc((strlen(outfile)+11) * sizeof(char));
sprintf(record_task_times_file, "%s.tasktimes", outfile);
wait_partition_tasks(q, 5, record_task_times_file);
free(record_task_times_file);
gettimeofday(¤t, 0);
parallel_end_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
parallel_time = parallel_end_time - parallel_start_time;
fprintf(stdout, "Parallel execution time is %llu\n", parallel_time);
long long unsigned int merge_start_time, merge_end_time, merge_time;
gettimeofday(¤t, 0);
merge_start_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
merge_sorted_outputs(outfile, outfile, created_partitions);
gettimeofday(¤t, 0);
merge_end_time = ((long long unsigned int) current.tv_sec) * 1000000 + current.tv_usec;
merge_time = merge_end_time - merge_start_time;
fprintf(stdout, "Merge time is %llu\n", merge_time);
fprintf(stdout, "Sorting complete. Output is at: %s!\n", outfile);
execn_time = merge_end_time - execn_start_time;
workload_runtime = merge_end_time - part_start_time;
fprintf(stdout, "Workload execn time is %llu\n", workload_runtime);
fprintf(stdout, "Total execn time is %llu\n", execn_time);
FILE *time_file = fopen("wq_sort.times", "w");
if (time_file) {
fprintf(time_file, "Partition time: %llu\n", part_time);
fprintf(time_file, "Parallel time: %llu\n", parallel_time);
fprintf(time_file, "Merge time: %llu\n", merge_time);
if(sample_env)
fprintf(time_file, "Sampling time: %llu\n", sample_time);
fprintf(time_file, "Workload execution time: %llu\n", workload_runtime);
fprintf(time_file, "Total execution time: %llu\n", execn_time);
}
fclose(time_file);
work_queue_delete(q);
free(outfile);
return 0;
}
int main(int argc, char *argv[])
{
int port = WORK_QUEUE_DEFAULT_PORT;
const char *port_file=0;
const char *project_name=0;
int monitor_flag = 0;
int c;
while((c = getopt(argc, argv, "d:o:mN:p:Z:vh"))!=-1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'm':
monitor_flag = 1;
break;
case 'N':
project_name = optarg;
break;
case 'Z':
port_file = strdup(optarg);
port = 0;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
break;
case 'h':
show_help(path_basename(argv[0]));
return 0;
default:
show_help(path_basename(argv[0]));
return 1;
}
}
struct work_queue *q = work_queue_create(port);
if(!q) fatal("couldn't listen on any port!");
printf("listening on port %d...\n", work_queue_port(q));
if(port_file) {
FILE *file = fopen(port_file,"w");
if(!file) fatal("couldn't open %s: %s",port_file,strerror(errno));
fprintf(file,"%d\n",work_queue_port(q));
fclose(file);
}
if(project_name) {
work_queue_specify_name(q,project_name);
}
if(monitor_flag) {
unlink_recursive("work-queue-test-monitor");
work_queue_enable_monitoring(q, "work-queue-test-monitor");
work_queue_specify_category_mode(q, NULL, WORK_QUEUE_ALLOCATION_MODE_MAX_THROUGHPUT);
work_queue_specify_transactions_log(q, "work-queue-test-monitor/transactions.log");
}
int result = work_queue_mainloop(q);
work_queue_delete(q);
return result;
}
int main(int argc, char *argv[])
{
struct work_queue *q;
struct work_queue_task *t;
int port = WORK_QUEUE_DEFAULT_PORT;
int taskid;
int i;
char *gzip_path;
if(argc < 2) {
printf("work_queue_example <file1> [file2] [file3] ...\n");
printf("Each file given on the command line will be compressed using a remote worker.\n");
return 0;
}
/*
Usually, we can execute the gzip utility by simply typing its name at a
terminal. However, this is not enough for work queue; we have to specify
precisely which files need to be transmitted to the workers. We record
the location of gzip in 'gzip_path', which is usually found in /bin/gzip
or /usr/bin/gzip. We use the 'access' function (from unistd.h standard C
library), and test the path for execution (X_OK) and reading (R_OK)
permissions.
*/
gzip_path = "/bin/gzip";
if(access(gzip_path, X_OK | R_OK) != 0) {
gzip_path = "/usr/bin/gzip";
if(access(gzip_path, X_OK | R_OK) != 0) {
fprintf(stderr, "gzip was not found. Please modify the gzip_path variable accordingly. To determine the location of gzip, from the terminal type: which gzip (usual locations are /bin/gzip and /usr/bin/gzip)\n");
exit(1);
}
}
/* We create the tasks queue using the default port. If this port is
* already been used by another program, you can try setting port = 0 to
* use an available port. */
q = work_queue_create(port);
if(!q) {
printf("couldn't listen on port %d: %s\n", port, strerror(errno));
return 1;
}
printf("listening on port %d...\n", work_queue_port(q));
/* We create and dispatch a task for each filename given in the argument list */
for(i = 1; i < argc; i++) {
char infile[256], outfile[256], command[256];
sprintf(infile, "%s", argv[i]);
sprintf(outfile, "%s.gz", argv[i]);
/* Note that we write ./gzip here, to guarantee that the gzip version
* we are using is the one being sent to the workers. */
sprintf(command, "./gzip < %s > %s", infile, outfile);
t = work_queue_task_create(command);
/* gzip is the same across all tasks, so we can cache it in the
* workers. Note that when specifying a file, we have to name its local
* name (e.g. gzip_path), and its remote name (e.g. "gzip"). Unlike the
* following line, more often than not these are the same. */
work_queue_task_specify_file(t, gzip_path, "gzip", WORK_QUEUE_INPUT, WORK_QUEUE_CACHE);
/* files to be compressed are different across all tasks, so we do not
* cache them. This is, of course, application specific. Sometimes you
* may want to cache an output file if is the input of a later task.*/
work_queue_task_specify_file(t, infile, infile, WORK_QUEUE_INPUT, WORK_QUEUE_NOCACHE);
work_queue_task_specify_file(t, outfile, outfile, WORK_QUEUE_OUTPUT, WORK_QUEUE_NOCACHE);
/* Once all files has been specified, we are ready to submit the task to the queue. */
taskid = work_queue_submit(q, t);
printf("submitted task (id# %d): %s\n", taskid, t->command_line);
}
printf("waiting for tasks to complete...\n");
while(!work_queue_empty(q)) {
/* Application specific code goes here ... */
/* work_queue_wait waits at most 5 seconds for some task to return. */
t = work_queue_wait(q, 5);
if(t) {
printf("task (id# %d) complete: %s (return code %d)\n", t->taskid, t->command_line, t->return_status);
if(t->return_status != 0)
{
/* The task failed. Error handling (e.g., resubmit with new parameters) here. */
}
work_queue_task_delete(t);
}
/* Application specific code goes here ... */
}
printf("all tasks complete!\n");
work_queue_delete(q);
return 0;
}
int main( int argc, char *argv[] )
{
signed char c;
int work_queue_master_mode = WORK_QUEUE_MASTER_MODE_STANDALONE;
char *work_queue_preferred_connection = NULL;
char *project = NULL;
int priority = 0;
const char *progname = "wavefront";
debug_config(progname);
enum {
LONG_OPT_PREFERRED_CONNECTION
};
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"debug", required_argument, 0, 'd'},
{"advertise", no_argument, 0, 'a'},
{"project-name", required_argument, 0, 'N'},
{"debug-file", required_argument, 0, 'o'},
{"port", required_argument, 0, 'p'},
{"priority", required_argument, 0, 'P'},
{"estimated-time", required_argument, 0, 't'},
{"random-port", required_argument, 0, 'Z'},
{"bitmap", required_argument, 0, 'B'},
{"work-queue-preferred-connection", required_argument, 0, LONG_OPT_PREFERRED_CONNECTION},
{0,0,0,0}
};
while((c=getopt_long(argc,argv,"aB:d:hN:p:P:o:v:Z:", long_options, NULL)) >= 0) {
switch(c) {
case 'a':
break;
case 'd':
debug_flags_set(optarg);
break;
case 'h':
show_help(progname);
exit(0);
break;
case 'N':
work_queue_master_mode = WORK_QUEUE_MASTER_MODE_CATALOG;
free(project);
project = xxstrdup(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'P':
priority = atoi(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'v':
cctools_version_print(stdout, progname);
exit(0);
break;
case 'Z':
port_file = optarg;
port = 0;
break;
case 'B':
progress_bitmap_file = optarg;
break;
case LONG_OPT_PREFERRED_CONNECTION:
free(work_queue_preferred_connection);
work_queue_preferred_connection = xxstrdup(optarg);
break;
default:
show_help(progname);
return 1;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if( (argc-optind)!=5 ) {
show_help(progname);
exit(1);
}
function = argv[optind];
xsize=atoi(argv[optind+1]);
ysize=atoi(argv[optind+2]);
infile=argv[optind+3];
outfile=argv[optind+4];
start_time = time(0);
last_display_time = 0;
cells_total = xsize*ysize;
xsize++;
ysize++;
array = text_array_create(xsize,ysize);
if(!text_array_load(array,infile)) {
fprintf(stderr,"couldn't load %s: %s",infile,strerror(errno));
return 1;
}
int count = text_array_load(array,outfile);
if(count>0) printf("recovered %d results from %s\n",count,outfile);
logfile = fopen(outfile,"a");
if(!logfile) {
fprintf(stderr,"couldn't open %s for append: %s\n",outfile,strerror(errno));
return 1;
}
if(work_queue_master_mode == WORK_QUEUE_MASTER_MODE_CATALOG && !project) {
fprintf(stderr, "wavefront: wavefront master running in catalog mode. Please use '-N' option to specify the name of this project.\n");
fprintf(stderr, "wavefront: Run \"%s -h\" for help with options.\n", argv[0]);
return 1;
}
queue = work_queue_create(port);
//Read the port the queue is actually running, in case we just called
//work_queue_create(LINK_PORT_ANY)
port = work_queue_port(queue);
if(!queue) {
fprintf(stderr,"%s: could not create work queue on port %d: %s\n",progname,port,strerror(errno));
return 1;
}
if(port_file)
opts_write_port_file(port_file, port);
// advanced work queue options
work_queue_specify_master_mode(queue, work_queue_master_mode);
work_queue_specify_name(queue, project);
work_queue_specify_priority(queue, priority);
if(work_queue_preferred_connection)
work_queue_master_preferred_connection(queue, work_queue_preferred_connection);
fprintf(stdout, "%s: listening for workers on port %d...\n",progname,work_queue_port(queue));
if(progress_bitmap_file)
{
bmap = bitmap_create(xsize,ysize);
wavefront_bitmap_initialize(bmap);
}
task_prime();
struct work_queue_task *t;
while(1) {
if(time(0)!=last_display_time) display_progress(queue);
t = work_queue_wait(queue,WORK_QUEUE_WAITFORTASK);
if(!t) break;
if(t->return_status==0) {
int x,y;
if(sscanf(t->tag,"%d %d",&x,&y)==2) {
text_array_set(array,x,y,t->output);
task_complete(x,y);
fprintf(logfile,"%d %d %s\n",x,y,t->output);
fflush(logfile);
tasks_done++;
} else {
fprintf(stderr,"unexpected output: %s\nfrom command: %s\non host: %s",t->output,t->command_line,t->host);
}
} else {
fprintf(stderr,"function failed return value (%i) result (%i) on host %s. output:\n%s\n",t->return_status,t->result,t->host,t->output);
}
work_queue_task_delete(t);
if(work_queue_empty(queue))
break;
}
display_progress(queue);
return 0;
}
int main(int argc, char *argv[])
{
struct work_queue *q;
struct work_queue_task *t;
int port = WORK_QUEUE_DEFAULT_PORT;
int taskid;
int i;
if(argc < 2) {
printf("work_queue_example <executable> <file1> [file2] [file3] ...\n");
printf("Each file given on the command line will be compressed using a remote worker.\n");
return 0;
}
debug_flags_set("all");
q = work_queue_create(port);
if(!q) {
printf("couldn't listen on port %d: %s\n", port, strerror(errno));
return 1;
}
printf("listening on port %d...\n", work_queue_port(q));
for(i = 1; i < argc; i++) {
char infile[256], outfile[256], command[256];
sprintf(infile, "%s", argv[i]);
sprintf(outfile, "%s.gz", argv[i]);
sprintf(command, "./gzip < %s > %s", infile, outfile);
t = work_queue_task_create(command);
if (!work_queue_task_specify_file(t, "/usr/bin/gzip", "gzip", WORK_QUEUE_INPUT, WORK_QUEUE_CACHE)) {
printf("task_specify_file() failed for /usr/bin/gzip: check if arguments are null or remote name is an absolute path.\n");
return 1;
}
if (!work_queue_task_specify_file(t, infile, infile, WORK_QUEUE_INPUT, WORK_QUEUE_NOCACHE)) {
printf("task_specify_file() failed for %s: check if arguments are null or remote name is an absolute path.\n", infile);
return 1;
}
if (!work_queue_task_specify_file(t, outfile, outfile, WORK_QUEUE_OUTPUT, WORK_QUEUE_NOCACHE)) {
printf("task_specify_file() failed for %s: check if arguments are null or remote name is an absolute path.\n", outfile);
return 1;
}
taskid = work_queue_submit(q, t);
printf("submitted task (id# %d): %s\n", taskid, t->command_line);
}
printf("waiting for tasks to complete...\n");
while(!work_queue_empty(q)) {
t = work_queue_wait(q, 5);
if(t) {
printf("task (id# %d) complete: %s (return code %d)\n", t->taskid, t->command_line, t->return_status);
work_queue_task_delete(t);
}
}
printf("all tasks complete!\n");
work_queue_delete(q);
return 0;
}
int main(int argc, char **argv)
{
char c;
struct work_queue *q;
int port = WORK_QUEUE_DEFAULT_PORT;
extra_files_list = list_create();
while((c = getopt(argc, argv, "e:f:t:x:y:p:N:E:d:vh")) != (char) -1) {
switch (c) {
case 'e':
extra_arguments = optarg;
break;
case 'f':
list_push_head(extra_files_list,optarg);
break;
case 't':
compare_program_time = atof(optarg);
break;
case 'x':
xblock = atoi(optarg);
break;
case 'y':
yblock = atoi(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'N':
setenv("WORK_QUEUE_NAME", optarg, 1);
break;
case 'E':
setenv("WORK_QUEUE_PRIORITY", optarg, 1);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'v':
show_version(progname);
exit(0);
break;
case 'h':
show_help(progname);
exit(0);
break;
default:
show_help(progname);
return 1;
}
}
if((argc - optind) < 3) {
show_help(progname);
exit(1);
}
struct text_list *seta = text_list_load(argv[optind]);
if(!seta) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind+1],strerror(errno));
return 1;
}
fprintf(stderr, "%s: %s has %d elements\n",progname,argv[optind],text_list_size(seta));
struct text_list *setb = text_list_load(argv[optind+1]);
if(!setb) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind+1],strerror(errno));
return 1;
}
fprintf(stderr, "%s: %s has %d elements\n",progname,argv[optind+1],text_list_size(setb));
if (!find_executable("allpairs_multicore","PATH",allpairs_multicore_program,sizeof(allpairs_multicore_program))) {
fprintf(stderr,"%s: couldn't find allpairs_multicore in path\n",progname);
return 1;
}
debug(D_DEBUG,"using multicore executable %s",allpairs_multicore_program);
xstop = text_list_size(seta);
ystop = text_list_size(setb);
if(allpairs_compare_function_get(argv[optind+2])) {
strcpy(allpairs_compare_program,argv[optind+2]);
debug(D_DEBUG,"using internal function %s",allpairs_compare_program);
use_external_program = 0;
} else {
if(!find_executable(argv[optind+2],"PATH",allpairs_compare_program,sizeof(allpairs_compare_program))) {
fprintf(stderr,"%s: %s is neither an executable nor an internal comparison function.\n",progname,allpairs_compare_program);
return 1;
}
debug(D_DEBUG,"using comparison executable %s",allpairs_compare_program);
use_external_program = 1;
}
if(!xblock || !yblock) {
estimate_block_size(seta,setb,&xblock,&yblock);
}
fprintf(stderr, "%s: using block size of %dx%d\n",progname,xblock,yblock);
q = work_queue_create(port);
if(!q) {
fprintf(stderr,"%s: could not create work queue on port %d: %s\n",progname,port,strerror(errno));
return 1;
}
fprintf(stderr, "%s: listening for workers on port %d...\n",progname,work_queue_port(q));
while(1) {
struct work_queue_task *task = NULL;
while(work_queue_hungry(q)) {
task = ap_task_create(seta,setb);
if(task) {
work_queue_submit(q, task);
} else {
break;
}
}
if(!task && work_queue_empty(q)) break;
task = work_queue_wait(q,5);
if(task) task_complete(task);
}
work_queue_delete(q);
return 0;
}
struct batch_queue *batch_queue_create(batch_queue_type_t type)
{
struct batch_queue *q;
if(type == BATCH_QUEUE_TYPE_UNKNOWN)
return 0;
q = malloc(sizeof(*q));
q->type = type;
q->options_text = 0;
q->job_table = itable_create(0);
q->output_table = itable_create(0);
if(type == BATCH_QUEUE_TYPE_CONDOR)
q->logfile = strdup("condor.logfile");
else if(type == BATCH_QUEUE_TYPE_WORK_QUEUE || type == BATCH_QUEUE_TYPE_WORK_QUEUE_SHAREDFS)
q->logfile = strdup("wq.log");
else
q->logfile = NULL;
if(type == BATCH_QUEUE_TYPE_WORK_QUEUE || type == BATCH_QUEUE_TYPE_WORK_QUEUE_SHAREDFS) {
q->work_queue = work_queue_create(0);
if(!q->work_queue) {
batch_queue_delete(q);
return 0;
}
} else {
q->work_queue = 0;
}
if(type == BATCH_QUEUE_TYPE_MPI_QUEUE) {
q->mpi_queue = mpi_queue_create(0);
if(!q->mpi_queue) {
batch_queue_delete(q);
return 0;
}
} else {
q->mpi_queue = 0;
}
if(type == BATCH_QUEUE_TYPE_SGE || type == BATCH_QUEUE_TYPE_MOAB || type == BATCH_QUEUE_TYPE_TORQUE || type == BATCH_QUEUE_TYPE_CLUSTER) {
batch_job_setup_cluster(q);
}
if(type == BATCH_QUEUE_TYPE_HADOOP) {
int fail = 0;
if(!getenv("HADOOP_HOME")) {
debug(D_NOTICE, "error: environment variable HADOOP_HOME not set\n");
fail = 1;
}
if(!getenv("HDFS_ROOT_DIR")) {
debug(D_NOTICE, "error: environment variable HDFS_ROOT_DIR not set\n");
fail = 1;
}
if(!getenv("HADOOP_USER_TMP")) {
debug(D_NOTICE, "error: environment variable HADOOP_USER_TMP not set\n");
fail = 1;
}
if(!getenv("HADOOP_PARROT_PATH")) {
/* Note: HADOOP_PARROT_PATH is the path to Parrot on the remote node, not on the local machine. */
debug(D_NOTICE, "error: environment variable HADOOP_PARROT_PATH not set\n");
fail = 1;
}
if(fail) {
batch_queue_delete(q);
return 0;
}
}
return q;
}
int main(int argc, char *argv[])
{
struct work_queue *q;
int port = WORK_QUEUE_DEFAULT_PORT;
if(argc != 4) {
printf("Usage: work_queue_workload_simulator <workload_spec> <logfile> <proj_name> \n");
exit(1);
}
struct list *specs = get_workload_specs(argv[1]);
if(!specs) {
printf("Failed to load a non-empty workload specification.\n");
exit(1);
}
created_files = list_create();
if(!created_files) {
printf("Failed to allocate memory for a list to store created files.\n");
exit(1);
}
// open log file
logfile = fopen(argv[2], "a");
if(!logfile) {
printf("Couldn't open logfile %s: %s\n", argv[2], strerror(errno));
exit(1);
}
q = work_queue_create(port);
if(!q) {
printf("couldn't listen on port %d: %s\n", port, strerror(errno));
goto fail;
exit(1);
}
printf("listening on port %d...\n", work_queue_port(q));
// specifying the right modes
work_queue_specify_master_mode(q, WORK_QUEUE_MASTER_MODE_CATALOG);
work_queue_specify_name(q, argv[3]);
work_queue_specify_estimate_capacity_on(q, 1); // report capacity on
int time_elapsed = 0; // in seconds
int series_id = 0;
time_t start_time = time(0);
log_work_queue_status(q);
while(1) {
struct task_series *ts = (struct task_series *)list_peek_tail(specs);
if(!ts) {
while(!work_queue_empty(q)) { // wait until all tasks to finish
wait_for_task(q, 5);
}
break;
} else {
time_elapsed = time(0) - start_time;
int time_until_next_submit = ts->submit_time - time_elapsed;
if(time_until_next_submit <=0) {
list_pop_tail(specs);
printf("time elapsed: %d seconds\n", time_elapsed);
if(!submit_task_series(q, ts, series_id)) {
// failed to submit tasks
fprintf(stderr, "Failed to submit tasks.\n");
goto fail;
}
free(ts);
series_id++;
} else {
time_t stoptime = start_time + ts->submit_time;
while(!work_queue_empty(q)) {
int timeout = stoptime - time(0);
if(timeout > 0) {
wait_for_task(q, timeout);
} else {
break;
}
}
time_t current_time = time(0);
if(current_time < stoptime) {
sleep(stoptime - current_time);
}
}
}
}
printf("all tasks complete!\n");
work_queue_delete(q);
remove_created_files();
fclose(logfile);
return 0;
fail:
remove_created_files();
fclose(logfile);
exit(1);
}
int main(int argc, char *argv[])
{
int port = WORK_QUEUE_DEFAULT_PORT;
const char *port_file=0;
const char *project_name=0;
char c;
while((c = getopt(argc, argv, "d:o:N:p:Z:vh"))!=-1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'N':
project_name = optarg;
break;
case 'Z':
port_file = strdup(optarg);
port = 0;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
break;
case 'h':
show_help(path_basename(argv[0]));
return 0;
default:
show_help(path_basename(argv[0]));
return 1;
}
}
struct work_queue *q = work_queue_create(port);
if(!q) fatal("couldn't listen on any port!");
printf("listening on port %d...\n", work_queue_port(q));
if(port_file) {
FILE *file = fopen(port_file,"w");
if(!file) fatal("couldn't open %s: %s",port_file,strerror(errno));
fprintf(file,"%d\n",work_queue_port(q));
fclose(file);
}
if(project_name) {
work_queue_specify_name(q,project_name);
}
int result = work_queue_mainloop(q);
work_queue_delete(q);
return result;
}
