int result_gaussian(GAUSS_INFO &gi) {
int retval=0;
if (signal_count > swi.analysis_cfg.max_signals) {
SETIERROR(RESULT_OVERFLOW,"in result_gaussian");
}
retval = outfile.printf("%s", gi.g.print_xml(0,0,1).c_str());
if (retval >= 0) {
retval= outfile.printf("\n");
}
if (retval < 0) {
SETIERROR(WRITE_FAILED,"in result_gaussian");
} else {
signal_count++;
gaussian_count++;
}
return 0;
}
int result_spike(SPIKE_INFO &si) {
int retval=0;
if (signal_count >= swi.analysis_cfg.max_signals) {
SETIERROR(RESULT_OVERFLOW,"in result_spike");
}
retval = outfile.printf("%s", si.s.print_xml(0,0,1).c_str());
if (retval < 0) {
SETIERROR(WRITE_FAILED,"in result_spike");
} else {
signal_count++;
spike_count++;
}
return 0;
}
int main(int argc, char * argv[]) {
int i, retval, lastInversion=0, checkpointExists=0, matrixSize=0;
double fd;
char input_path[512], output_path[512], chkpt_path[512], buf[256];
MFILE out;
FILE* state, *infile;
generate_random_input_file(MATRIX_SIZE); //call this if you don't want to
//construct the input file manually
for (i=0; i<argc; i++) {
if (!strcmp(argv[i], "-early_exit")) early_exit = true;
if (!strcmp(argv[i], "-early_crash")) early_crash = true;
if (!strcmp(argv[i], "-early_sleep")) early_sleep = true;
if (!strcmp(argv[i], "-run_slow")) run_slow = true;
if (!strcmp(argv[i], "-cpu_time")) {
cpu_time = atof(argv[++i]);
}
}
retval = boinc_init();
if (retval) {
fprintf(stderr,
"%s boinc_init returned %d\n",
boinc_msg_prefix(buf, sizeof(buf)), retval
);
exit(retval);
}
// open the input file (resolve logical name first)
//
boinc_resolve_filename(INPUT_FILENAME, input_path, sizeof(input_path));
infile = boinc_fopen(input_path, "r");
if (!infile) {
fprintf(stderr,
"%s Couldn't find input file in boinc\\win_build, resolved name %s.\n",
boinc_msg_prefix(buf, sizeof(buf)), input_path
);
getchar();
exit(-1);
}
boinc_resolve_filename(OUTPUT_FILENAME, output_path, sizeof(output_path));
// See if there's a valid checkpoint file.
// If so retrieve the current matrix and inversion number
//
boinc_resolve_filename(CHECKPOINT_FILE, chkpt_path, sizeof(chkpt_path));
state = boinc_fopen(chkpt_path, "r");
if (state) {
printf("Checkpoint file is detected. Read from checkpoint file ... \n");
checkpointExists=fscanf(state, "%d", &lastInversion);
if (checkpointExists == 1) {
isStateFileInUse=true;
printf("Last inversion # is : %d\n",lastInversion);
fscanf(state,"%d",&matrixSize);
width=height=matrixSize;
printf("Initialize host ....\n");
initialize_host(state);
}
fclose(state);
} else {
printf("There's no valid checkpoint file!\n");
}
retval = out.open(output_path, "wb");
if (retval) {
fprintf(stderr,
"%s APP: matrix_inversion output open failed:\n",
boinc_msg_prefix(buf, sizeof(buf))
);
fprintf(stderr,
"%s resolved name %s, retval %d\n",
boinc_msg_prefix(buf, sizeof(buf)), output_path, retval
);
perror("open");
exit(1);
}
#ifdef APP_GRAPHICS
// create shared mem segment for graphics, and arrange to update it
//
shmem = (UC_SHMEM*)boinc_graphics_make_shmem("matrix_inversion", sizeof(UC_SHMEM));
if (!shmem) {
fprintf(stderr,
"%s failed to create shared mem segment\n",
boinc_msg_prefix(buf, sizeof(buf))
);
}
update_shmem();
boinc_register_timer_callback(update_shmem);
#endif
if (checkpointExists != 1) { //checkpoint file is not found.
matrixSize=get_matrix_size(infile);
printf("Matrix Size: width = height = %d\n",matrixSize);
width=height=matrixSize;
// Initialize Host application
printf("Initialize host ....\n");
if (initialize_host(infile)==1) {
return 1;
}
out.printf("\n----------------- Before being inversed ----------------\n\n");
printf("Computation is running ... Inverse the matrix %d times. Start at inversion #1\n",
NUM_ITERATIONS);
} else {
out.printf("\n----------------- Last checkpointed inversion #%d ----------------\n\n",
lastInversion);
printf("Computation is resumed ... Inverse the matrix %d more times. Start at inversion #%d\n",
NUM_ITERATIONS-lastInversion,lastInversion+1);
}
// Initialize OpenCL resources
if (initialize_cl()==1) {
return 1;
}
print_to_file(&out,input,matrixSize);
for (int i=lastInversion+1;i<=NUM_ITERATIONS;++i) {
//the invert function will trigger kernel calls.
invert(input,output,matrixSize);
printf("Finish inversion #%d\n",i);
for (int j=0;j<matrixSize*matrixSize;++j) {
input[j]=output[j]; //change the input for the next iteration
}
if (run_slow) {
boinc_sleep(1.);
}
if (early_exit && i>30) {
exit(-10);
}
if (early_crash && i>30) {
boinc_crash();
}
if (early_sleep && i>30) {
g_sleep = true;
while (1) boinc_sleep(1);
}
if (boinc_time_to_checkpoint()) {
printf("Perform checkpointing at inversion # %d\n",i);
//we'll need to write the current matrix to the state file.
retval = do_checkpoint(out, i, input, matrixSize);
if (retval) {
fprintf(stderr,
"%s APP: matrix_inversion checkpoint failed %d\n",
boinc_msg_prefix(buf, sizeof(buf)), retval
);
exit(retval);
}
boinc_checkpoint_completed();
}
fd = i/NUM_ITERATIONS;
if (cpu_time) fd /= 2;
boinc_fraction_done(fd);
}
out.printf("\n\n----------------- Final inversion #%d ----------------\n\n",
NUM_ITERATIONS);
print_to_file(&out,output,matrixSize);
retval = out.flush(); //force the output file to be closed.
if (retval) {
fprintf(stderr,
"%s APP: matrix_inversion flush failed %d\n",
boinc_msg_prefix(buf, sizeof(buf)), retval
);
exit(1);
}
// Releases OpenCL resources
if (cleanup_cl()==1) {
printf("Error!");
return 1;
}
// Release host resources
cleanup_host();
// burn up some CPU time if needed
//
if (cpu_time) {
printf("\nBurning up some CPU time ... \n");
double start = dtime();
for (int i=0; ; i++) {
double e = dtime()-start;
if (e > cpu_time) break;
fd = .5 + .5*(e/cpu_time);
boinc_fraction_done(fd);
if (boinc_time_to_checkpoint()) {
retval = do_checkpoint(out, NUM_ITERATIONS, input, matrixSize);
if (retval) {
fprintf(stderr,
"%s APP: maxtrix_inversion checkpoint failed %d\n",
boinc_msg_prefix(buf, sizeof(buf)), retval
);
exit(1);
}
boinc_checkpoint_completed();
}
comp_result = do_a_giga_flop(i);
}
}
boinc_fraction_done(1);
#ifdef APP_GRAPHICS
update_shmem();
#endif
printf("\nDone! Please press ENTER to exit. ");
getchar();
boinc_finish(0);
}
int ReportPulseEvent(float PulsePower,float MeanPower, float period,
int time_bin,int freq_bin, float snr, float thresh, float *folded_pot,
int scale, int write_pulse) {
PULSE_INFO pi;
pulse pulse;
int retval=0, i, len_prof=static_cast<int>(floor(period));
float step,norm,index,MinPower=PulsePower*MeanPower*scale;
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
// pulse info
pi.score=snr/thresh;
pi.p.peak_power=PulsePower-1;
pi.p.mean_power=MeanPower;
pi.p.fft_len=ChirpFftPairs[analysis_state.icfft].FftLen;
pi.p.chirp_rate=ChirpFftPairs[analysis_state.icfft].ChirpRate;
pi.p.period=static_cast<float>(period*static_cast<double>(pi.p.fft_len)/swi.subband_sample_rate);
pi.p.snr = snr;
pi.p.thresh = thresh;
pi.p.len_prof = len_prof;
pi.freq_bin=freq_bin;
pi.time_bin=time_bin;
pi.p.freq=cnvt_bin_hz(freq_bin, pi.p.fft_len);
double t_offset=(static_cast<double>(time_bin)+0.5)
*static_cast<double>(pi.p.fft_len)/
swi.subband_sample_rate;
pi.p.detection_freq=calc_detection_freq(pi.p.freq,pi.p.chirp_rate,t_offset);
pi.p.time=swi.time_recorded+t_offset/86400.0;
time_to_ra_dec(pi.p.time, &pi.p.ra, &pi.p.decl);
for (i=0;i<len_prof;i++) {
if (folded_pot[i]<MinPower) MinPower=folded_pot[i];
}
norm=255.0f/((PulsePower*MeanPower*scale-MinPower));
// Populate the min and max PoT arrays. These are only used
// for graphics.
#ifdef BOINC_APP_GRAPHICS
if (!nographics()) {
step=static_cast<float>(len_prof)/swi.analysis_cfg.pulse_pot_length;
index=0;
for (i=0;i<swi.analysis_cfg.pulse_pot_length;i++) {
pi.pot_min[i]=255;
pi.pot_max[i]=0;
int j;
for (j=0; j<step; j++) {
unsigned int pot = static_cast<unsigned int>((folded_pot[static_cast<int>(floor(index))+j]-MinPower)*norm);
if (pot<pi.pot_min[i]) {
pi.pot_min[i]=pot;
}
if (pi.pot_min[i] >= 256) pi.pot_min[i] = 255; // kludge until we fix the assert failures
BOINCASSERT(pi.pot_min[i] < 256);
if (pot>pi.pot_max[i])
pi.pot_max[i]=pot;
if (pi.pot_max[i] >= 256) pi.pot_max[i] = 255; // kludge until we fix the assert failures
BOINCASSERT(pi.pot_max[i] < 256);
}
index+=step;
}
}
#endif
// Populate the result PoT if the folded PoT will fit.
if (pi.p.len_prof < swi.analysis_cfg.pulse_pot_length) {
pi.p.pot.resize(len_prof);
for (i=0;i<len_prof;i++) {
pi.p.pot[i] = (unsigned char)((folded_pot[i]-MinPower)*norm);
}
} else {
pi.p.pot.clear();
}
// Update gdata pulse info regardless of whether it is the
// best thus far. If a pulse has made it this far, display it.
#ifdef BOINC_APP_GRAPHICS
if (!nographics()) sah_graphics->pi.copy(&pi);
#endif
// best thus far ?
if (pi.score>best_pulse->score) {
*best_pulse=pi;
}
if (write_pulse) {
if (signal_count > swi.analysis_cfg.max_signals) {
SETIERROR(RESULT_OVERFLOW,"in ReportPulseEvent");
}
//for (i=0;i<len_prof;i++) {
// sprintf(&pi.p.pot[i], "%02x",(int)((folded_pot[i]-MinPower)*norm));
// }
retval = outfile.printf("%s", pi.p.print_xml(0,0,1).c_str());
if (retval >= 0) {
outfile.printf("\n");
}
if (retval < 0) {
SETIERROR(WRITE_FAILED,"in ReportPulseEvent");
} else {
signal_count++;
pulse_count++;
}
}
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
return(retval);
}
int ReportTripletEvent(
float Power, float MeanPower, float period,
float mid_time_bin, int start_time_bin, int freq_bin,
int pot_len,const float *PoT, int write_triplet
) {
TRIPLET_INFO ti;
triplet triplet;
int retval=0, i, j;
double step,norm,index;
double max_power=0;
static int * inv;
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
if (!inv) inv = (int*)calloc_a(swi.analysis_cfg.triplet_pot_length, sizeof(int), MEM_ALIGN);
// triplet info
ti.score=Power;
ti.t.peak_power=Power;
ti.t.mean_power=MeanPower;
ti.freq_bin=freq_bin;
ti.time_bin=mid_time_bin+start_time_bin+0.5f;
ti.t.chirp_rate=ChirpFftPairs[analysis_state.icfft].ChirpRate;
ti.t.fft_len=ChirpFftPairs[analysis_state.icfft].FftLen;
ti.bperiod=period;
ti.t.period=static_cast<float>(period*static_cast<double>(ti.t.fft_len)/swi.subband_sample_rate);
ti.t.freq=cnvt_bin_hz(freq_bin, ti.t.fft_len);
double t_offset=(static_cast<double>(mid_time_bin)+start_time_bin+0.5)
*static_cast<double>(ti.t.fft_len)/
swi.subband_sample_rate;
ti.t.detection_freq=calc_detection_freq(ti.t.freq,ti.t.chirp_rate,t_offset);
ti.t.time=swi.time_recorded+t_offset/86400.0;
time_to_ra_dec(ti.t.time, &ti.t.ra, &ti.t.decl);
// Populate the min and max PoT arrays. These are only used
// for graphics.
memset(ti.pot_min,0xff,swi.analysis_cfg.triplet_pot_length*sizeof(int));
memset(ti.pot_max,0,swi.analysis_cfg.triplet_pot_length*sizeof(int));
step=static_cast<double>(pot_len)/swi.analysis_cfg.triplet_pot_length;
ti.scale=static_cast<float>(1.0/step);
index=0;
for (i=0;i<pot_len;i++) {
if (PoT[i]>max_power) max_power=PoT[i];
}
norm=255.0/max_power;
float mtb = mid_time_bin;
if (pot_len > swi.analysis_cfg.triplet_pot_length) {
ti.tpotind0_0 = ti.tpotind0_1 = static_cast<int>(((mtb-period)*swi.analysis_cfg.triplet_pot_length)/pot_len);
ti.tpotind1_0 = ti.tpotind1_1 = static_cast<int>(((mtb)*swi.analysis_cfg.triplet_pot_length)/pot_len);
ti.tpotind2_0 = ti.tpotind2_1 = static_cast<int>(((mtb+period)*swi.analysis_cfg.triplet_pot_length)/pot_len);
for (j=0; j<pot_len; j++) {
i = (j*swi.analysis_cfg.triplet_pot_length)/pot_len;
if ((PoT[j]*norm)<ti.pot_min[i]) {
ti.pot_min[i]=static_cast<unsigned int>(floor(PoT[j]*norm));
}
if ((PoT[j]*norm)>ti.pot_max[i]) {
ti.pot_max[i]=static_cast<unsigned int>(floor(PoT[j]*norm));
}
}
} else {
memset(inv, -1, sizeof(inv));
for (i=0;i<swi.analysis_cfg.triplet_pot_length;i++) {
j = (i*pot_len)/swi.analysis_cfg.triplet_pot_length;
if (inv[j] < 0) inv[j] = i;
if ((PoT[j]*norm)<ti.pot_min[i]) {
ti.pot_min[i]=static_cast<unsigned int>(floor(PoT[j]*norm));
}
if ((PoT[j]*norm)>ti.pot_max[i]) {
ti.pot_max[i]=static_cast<unsigned int>(floor(PoT[j]*norm));
}
}
ti.tpotind0_0 = inv[static_cast<int>(mtb-period)];
ti.tpotind0_1 = inv[static_cast<int>(mtb-period+1)];
ti.tpotind1_0 = (inv[static_cast<int>(mtb)]+inv[static_cast<int>(mtb+1)])/2;
ti.tpotind1_1 = (inv[static_cast<int>(mtb+1)]+inv[static_cast<int>(mtb+2)])/2;
ti.tpotind2_0 = inv[static_cast<int>(mtb+period)];
if (mtb+period+1 >= pot_len) ti.tpotind2_1 = swi.analysis_cfg.triplet_pot_length-1;
else ti.tpotind2_1 = inv[static_cast<int>(mtb+period+1)];
}
// Update sah_graphics triplet info regardless of whether it is the
// best thus far. If a triplet has made it this far, display it.
#ifdef BOINC_APP_GRAPHICS
if (!nographics()) sah_graphics->ti.copy(&ti);
#endif
// best thus far ?
if (ti.score>best_triplet->score) {
*best_triplet=ti;
}
if (write_triplet) {
if (signal_count > swi.analysis_cfg.max_signals) {
SETIERROR(RESULT_OVERFLOW,"in ReportTripletEvent");
}
retval = outfile.printf("%s", ti.t.print_xml(0,0,1).c_str());
if (retval < 0) {
SETIERROR(WRITE_FAILED,"in ReportTripletEvent");
} else {
signal_count++;
triplet_count++;
}
}
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
return(retval);
}