void save_gat(int f)
{
long l;
l=((long)gat_section)*GATSECLEN;
sh_lseek(f,l,SEEK_SET);
sh_write(f,(void *)gat,4096);
lock_status();
status.filechange[filechange_posts]++;
save_status();
}
void savebase(int b)
/* saves message information in memory to disk */
{
int f;
char s[81];
sprintf(s, "%s%s.SUB", syscfg.datadir, subboards[b].filename);
f = sh_open(s, O_RDWR | O_BINARY | O_TRUNC | O_CREAT, S_IREAD | S_IWRITE);
sh_lseek(f, 0L, SEEK_SET);
msgs[0].owneruser = nummsgs;
sh_write(f, (void *)(&msgs[0]), ((nummsgs+1) * sizeof(postrec)));
sh_close(f);
if (nummsgs) {
sub_dates[b]=msgs[nummsgs].qscan;
} else {
sub_dates[b]=1;
}
lock_status();
status.filechange[filechange_posts]++;
save_status();
}
void Slave::migrate_old_status(){
std::string old_key = "new.slave.status|" + this->id_;
std::string val;
int old_found = meta->raw_get(old_key, &val);
if(!old_found){
return;
}
if(val.size() < sizeof(uint64_t)){
log_error("invalid format of status");
return;
}
last_seq = *((uint64_t *)(val.data()));
last_key.assign(val.data() + sizeof(uint64_t), val.size() - sizeof(uint64_t));
// migrate old status
log_info("migrate old version slave status to new format, last_seq: %" PRIu64 ", last_key: %s",
last_seq, hexmem(last_key.data(), last_key.size()).c_str());
save_status();
if(meta->raw_del(old_key) == -1){
log_fatal("meta db error!");
exit(1);
}
}
int main( int argc, char *argv[] )
{
signed char c;
const char *progname = "wavefront";
debug_config(progname);
progress_log_file = stdout;
struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"debug", required_argument, 0, 'd'},
{"jobs", required_argument, 0, 'n'},
{"block-size", required_argument, 0, 'b'},
{"debug-file", required_argument, 0, 'o'},
{"log-file", required_argument, 0, 'l'},
{"bitmap", required_argument, 0, 'B'},
{"bitmap-interval", required_argument, 0, 'i'},
{"auto", no_argument, 0, 'A'},
{"local", no_argument, 0, 'L'},
{"batch-type", required_argument, 0, 'T'},
{"verify", no_argument, 0, 'V'},
{0,0,0,0}
};
while((c=getopt_long(argc,argv,"n:b:d:o:l:B:i:qALDT:VX:Y:vh", long_options, NULL)) > -1) {
switch(c) {
case 'n':
manual_max_jobs_running = atoi(optarg);
break;
case 'b':
manual_block_size = atoi(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'B':
progress_bitmap_file = optarg;
break;
case 'i':
progress_bitmap_interval = atoi(optarg);
break;
case 'l':
progress_log_file = fopen(optarg,"w");
if(!progress_log_file) {
fprintf(stderr,"couldn't open %s: %s\n",optarg,strerror(errno));
return 1;
}
break;
case 'A':
wavefront_mode = WAVEFRONT_MODE_AUTO;
break;
case 'L':
wavefront_mode = WAVEFRONT_MODE_MULTICORE;
break;
case 'T':
wavefront_mode = WAVEFRONT_MODE_DISTRIBUTED;
batch_system_type = batch_queue_type_from_string(optarg);
if(batch_system_type==BATCH_QUEUE_TYPE_UNKNOWN) {
fprintf(stderr,"unknown batch system type: %s\n",optarg);
exit(1);
}
break;
case 'V':
verify_mode = 1;
break;
case 'X':
xstart = atoi(optarg);
break;
case 'Y':
ystart = atoi(optarg);
break;
case 'v':
cctools_version_print(stdout, progname);
exit(0);
break;
case 'h':
show_help(progname);
exit(0);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if( (argc-optind<3) ) {
show_help(progname);
exit(1);
}
function = argv[optind];
xsize=atoi(argv[optind+1]);
ysize=atoi(argv[optind+2]);
total_cells = xsize*ysize;
if(!verify_mode && !check_configuration(function,xsize,ysize)) exit(1);
int ncpus = load_average_get_cpus();
if(wavefront_mode!=WAVEFRONT_MODE_MULTICORE) {
double task_time = measure_task_time();
printf("Each function takes %.02lfs to run.\n",task_time);
block_size = find_best_block_size(xsize,1000,2,task_time,average_dispatch_time);
double distributed_time = wavefront_distributed_model(xsize,1000,2,task_time,block_size,average_dispatch_time);
double multicore_time = wavefront_multicore_model(xsize,ncpus,task_time);
double ideal_multicore_time = wavefront_multicore_model(xsize,xsize,task_time);
double sequential_time = wavefront_multicore_model(xsize,1,task_time);
printf("---------------------------------\n");
printf("This workload would take:\n");
printf("%.02lfs sequentially\n",sequential_time);
printf("%.02lfs on this %d-core machine\n",multicore_time,ncpus);
printf("%.02lfs on a %d-core machine\n",ideal_multicore_time,xsize);
printf("%.02lfs on a 1000-node distributed system with block size %d\n",distributed_time,block_size);
printf("---------------------------------\n");
if(wavefront_mode==WAVEFRONT_MODE_AUTO) {
if(multicore_time < distributed_time*2) {
wavefront_mode = WAVEFRONT_MODE_MULTICORE;
} else {
wavefront_mode = WAVEFRONT_MODE_DISTRIBUTED;
}
}
}
if(wavefront_mode==WAVEFRONT_MODE_MULTICORE) {
batch_system_type = BATCH_QUEUE_TYPE_LOCAL;
max_jobs_running = ncpus;
} else {
max_jobs_running = 1000;
}
if(manual_block_size!=0) {
block_size = manual_block_size;
}
if(manual_max_jobs_running!=0) {
max_jobs_running = manual_max_jobs_running;
}
if(wavefront_mode==WAVEFRONT_MODE_MULTICORE) {
printf("Running in multicore mode with %d CPUs.\n",max_jobs_running);
} else {
printf("Running in distributed mode with block size %d on up to %d CPUs\n",block_size,max_jobs_running);
}
batch_q = batch_queue_create(batch_system_type);
if(verify_mode) exit(0);
struct bitmap * b = bitmap_create(xsize+1,ysize+1);
struct list *ready_list = list_create();
struct itable *running_table = itable_create(0);
struct batch_job_info info;
UINT64_T jobid;
struct wavefront_task *task;
wavefront_task_initialize(b,ready_list);
printf("Starting workload...\n");
fprintf(progress_log_file,"# elapsed time : waiting jobs / running jobs / cells complete (percent complete)\n");
while(1) {
if(abort_mode) {
while((task=list_pop_tail(ready_list))) {
wavefront_task_delete(task);
}
itable_firstkey(running_table);
while(itable_nextkey(running_table,&jobid,(void**)&task)) {
batch_job_remove(batch_q,jobid);
}
}
if(list_size(ready_list)==0 && itable_size(running_table)==0) break;
while(1) {
if(itable_size(running_table)>=max_jobs_running) break;
task = list_pop_tail(ready_list);
if(!task) break;
jobid = wavefront_task_submit(task);
if(jobid>0) {
itable_insert(running_table,jobid,task);
wavefront_task_mark_range(task,b,WAVEFRONT_TASK_STATE_RUNNING);
} else {
abort();
sleep(1);
list_push_head(ready_list,task);
}
}
save_status(b,ready_list,running_table);
jobid = batch_job_wait(batch_q,&info);
if(jobid>0) {
task = itable_remove(running_table,jobid);
if(task) {
if(info.exited_normally && info.exit_code==0) {
total_dispatch_time += info.started-info.submitted;
total_execute_time += MAX(info.finished-info.started,1);
total_cells_complete+=task->width*task->height;
total_jobs_complete++;
average_dispatch_time = 1.0*total_dispatch_time / total_jobs_complete;
average_task_time = 1.0*total_execute_time / total_cells_complete;
wavefront_task_complete(b,ready_list,task);
} else {
printf("job %" PRIu64 " failed, aborting this workload\n",jobid);
abort_mode = 1;
}
}
}
}
save_status(b,ready_list,running_table);
if(abort_mode) {
printf("Workload was aborted.\n");
} else {
printf("Workload complete.\n");
}
return 0;
}
void post(void)
{
messagerec m;
postrec p;
char s[121];
int i,dm,a,flag;
time_t time1, time2;
flag=0;
m.storage_type=subboards[curlsub].storage_type;
a=0;
time1=time(NULL);
// write_inst(INST_LOC_POST,curlsub,INST_FLAGS_NONE);
// inmsg(&m,p.title,&a,1,(subboards[curlsub].filename),ALLOW_FULLSCREEN,
// subboards[curlsub].name, (subboards[curlsub].anony&anony_no_tag)?1:0);
savefile(buffer,length,&m,(subboards[curlsub].filename));
if (m.stored_as!=0xffffffff)
{
p.anony=a;
p.msg=m;
p.ownersys=0;
p.owneruser=usernum;
lock_status();
p.qscan=status.qscanptr++;
save_status();
time((long *)(&p.daten));
p.status=0;
open_sub(1);
if ((xsubs[curlsub].num_nets) &&
(subboards[curlsub].anony & anony_val_net) && (!lcs() || irt[0])) {
p.status |= status_pending_net;
dm=1;
for (i=nummsgs; (i>=1) && (i>(nummsgs-28)); i--) {
if (get_post(i)->status & status_pending_net) {
dm=0;
break;
}
}
if (dm) {
sprintf(s,get_stringx(1,37),subboards[curlsub].name);
ssm(1,0,s);
}
}
if (nummsgs>=subboards[curlsub].maxmsgs) {
i=1;
dm=0;
while ((dm==0) && (i<=nummsgs)) {
if ((get_post(i)->status & status_no_delete)==0)
dm=i;
++i;
}
if (dm==0)
dm=1;
delete(dm);
}
add_post(&p);
lock_status();
++status.msgposttoday;
++status.localposts;
save_status();
close_sub();
if (xsubs[curlsub].num_nets) {
if (!(p.status & status_pending_net))
send_net_post(&p, subboards[curlsub].filename, curlsub);
}
}
}
void savefile(char *b, long l1, messagerec *m1, char *aux)
/* saves a message in memory to disk */
{
int f,gatp,i5,i4,gati[128];
messagerec m;
char s[81],s1[81];
int section;
long l2;
setcbrk(0);
m=*m1;
switch(m.storage_type) {
case 0:
case 1:
lock_status();
m.stored_as=status.qscanptr++;
save_status();
ltoa(m.stored_as,s1,16);
strcpy(s,syscfg.msgsdir);
if (m.storage_type==1) {
strcat(s,aux);
strcat(s,"\\");
}
strcat(s,s1);
f=sh_open(s,O_RDWR | O_CREAT | O_BINARY,S_IREAD | S_IWRITE);
sh_write(f, (void *)b,l1);
sh_close(f);
break;
case 2:
f=open_file(aux);
if (f>0) {
for (section=0; section<1024; section++) {
set_gat_section(f,section);
gatp=0;
i5=(int) ((l1 + 511L)/512L);
i4=1;
while ((gatp<i5) && (i4<2048)) {
if (gat[i4]==0)
gati[gatp++]=i4;
++i4;
}
if (gatp>=i5) {
l2=MSG_STARTING;
gati[gatp]=-1;
for (i4=0; i4<i5; i4++) {
sh_lseek(f,l2 + 512L * (long)(gati[i4]),SEEK_SET);
sh_write(f,(void *)(&b[i4*512]),512);
gat[gati[i4]]=gati[i4+1];
}
save_gat(f);
break;
}
}
sh_close(f);
}
m.stored_as=((long) gati[0]) + ((long)gat_section)*2048L;
break;
case 255:
f=sh_open(aux,O_RDWR | O_CREAT | O_BINARY,S_IREAD | S_IWRITE);
sh_write(f, (void *)b,l1);
sh_close(f);
break;
default:
break;
}
farfree((void *)b);
*m1=m;
}
void send_email2(void)
{
char s[81],scratch[81],log[81];
int f, i;
long len,len2;
char *b;
long thetime,dat;
int len3;
mailrec m,m1;
userrec ur;
messagerec msg;
struct date dt;
struct time tm;
char *month[] = {"Bug","Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec"};
m.touser=user_to_num;
time(&thetime);
len=(unsigned) strlen(buffer);
len2=len;
b=((char *)malloc(len+1024));
len=0;
sprintf(log,"þ Incoming mail for %s from %s (%s)\n",fido_to_user,fido_from_user,origi_node);
write_log(log);
sprintf(s,"%s (%s)",fido_from_user,origi_node);
addline(b,s,&len);
/* Get date/time of Email creation. */
/* Ditto the \015 for the time/date string. */
strncpy(scratch,fido_date_line,20);
scratch[20]='\0';
/* Build the date - cumbersome, but it needs to be done */
/* Build tblock as we go along so we can have a pretty date */
scratch[2] = '\0'; /* make day a string */
dt.da_day = atoi(scratch);
for (i=1;i<13;i++)
if (strncmpi(month[i],&scratch[3],3) == 0)
{
dt.da_mon = i;
break;
}
scratch[9] = '\0'; /* make year a string */
dt.da_year = atoi(&scratch[7]);
if (dt.da_year>90)
dt.da_year += 1900;
else
dt.da_year += 2000;
scratch[13] = '\0'; /* make hour a string */
tm.ti_hour = atoi(&scratch[11]);
scratch[16] = '\0'; /* make minute a string */
tm.ti_min = atoi(&scratch[14]);
scratch[19] = '\0'; /* make second a string */
tm.ti_sec = atoi(&scratch[17]);
tm.ti_hund = 0;
dat = dostounix(&dt,&tm);
strncpy(scratch,ctime(&(time_t)dat),24);
scratch[24]='\0';
strcat(scratch,"\r\n");
strcpy(s,scratch);
addline(b,s,&len);
strcat(b,buffer);
len += len2;
len=(unsigned) strlen(b);
if (b[len-1]!=26)
b[len++]=26;
m.msg.storage_type=2;
msg.stored_as=0L;
msg.storage_type=2;
savefile(b,len,&msg,"EMAIL");
m.msg=msg;
i=0;
strcpy(m.title,fido_title);
// i=strlen(m.title);
// m.title[i+1]=net_num;
// m.title[i+2]=0;
m.title[80]=net_num;
m.title[81]=0;
// i=0;
read_user(user_to_num,&ur);
++ur.waiting;
write_user(user_to_num,&ur);
lock_status();
save_status();
m.anony=i;
m.fromsys=atoi(wwiv_node);
m.fromuser=0;
m.tosys=0;
m.status=status_new_net;
time((long *)&(m.daten));
f=open_email(1);
len3=(int) filelength(f)/sizeof(mailrec);
if (len3==0)
i=0;
else
{
i=len3-1;
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_read(f,(void *)&m1,sizeof(mailrec));
while ((i>0) && (m1.tosys==0) && (m1.touser==0))
{
--i;
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_read(f,(void *)&m1,sizeof(mailrec));
}
if ((m1.tosys) || (m1.touser))
++i;
}
sh_lseek(f,((long) (i))*(sizeof(mailrec)), SEEK_SET);
sh_write(f,(void *)&m,sizeof(mailrec));
sh_close(f);
free(buffer);
}
int LdaExecutorInit::run(int32_t _num_iters) {
int suc;
int64_t accum_time = 0;
int64_t last_time = timer_st();
int64_t run_time;
if(exemode == ExeInitRun || exemode == ExeInitOnly) {
try {
extern_data_loader = new BufferManager(KNumExternDataBuffs*buffsize, buffsize, diskio);
} catch(...) {
return -1;
}
suc = task_buffer_mgr->init(internbase + ".task");
if(suc < 0) return -1;
suc = extern_data_loader->init_sequen_extern(extern_data_paths);
if(suc < 0) return -1;
suc = data_buffer_mgr->init(internbase + ".data");
if(suc < 0) return -1;
std::cout << "start initializing task buffers curr_time = " << accum_time << std::endl;
last_time = timer_st();
suc = init_task_buffers();
assert(suc == 0);
if(suc < 0) return -1;
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "done initializing task buffers curr_time = " << accum_time << std::endl;
std::cout << "start initializing data buffers curr_time = " << accum_time << std::endl;
last_time = timer_st();
suc = init_data_buffers();
assert(suc == 0);
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "done initializing data buffers curr_time = " << accum_time << std::endl;
if(suc < 0) return -1;
save_status();
if(exemode == ExeInitOnly) {
int32_t i;
for(i = 0; i < num_my_init_data_buffs; ++i) {
suc = data_buffer_mgr->putback(my_init_data_buffs[i], BufPolicyWriteBack);
assert(suc == 0);
}
for(i = 0; i < num_my_task_buffs; ++i) {
task_buffer_mgr->putback(my_task_buffs[i], BufPolicyWriteBack);
assert(suc == 0);
}
delete extern_data_loader;
extern_data_loader = NULL;
data_buffer_mgr->stop();
task_buffer_mgr->stop();
return 0;
}
delete extern_data_loader;
extern_data_loader = NULL;
data_buffer_mgr->stop();
task_buffer_mgr->stop();
}
int32_t num_task_iters = _num_iters;
if(num_my_task_buffs == num_total_task_buffs)
--num_task_iters;
if(_num_iters > 0) {
suc = task_buffer_mgr->init_sequen(internbase + ".task", num_my_task_buffs, _num_iters,
num_total_task_buffs);
assert(suc == 0);
std::cout << "task_buffer_mgr init_sequen done" << std::endl;
}
int32_t num_data_iters = (num_total_task_buffs + num_task_buffs - 1)/num_task_buffs;
suc = data_buffer_mgr->init_sequen(internbase + ".data", num_my_init_data_buffs,
num_data_iters*_num_iters, num_total_data_buffs);
assert(suc == 0);
std::cout << "start executing tasks curr_time = " << accum_time << std::endl;
int32_t iter;
for(iter = 0; iter < _num_iters; ++iter) {
last_time = timer_st();
suc = execute_all_tasks(iter);
if(suc < 0) return -1;
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "executed iteration = " << iter << " curr_time = " << accum_time << std::endl;
}
data_buffer_mgr->stop();
task_buffer_mgr->stop();
return 0;
}
