TRIPLET_INFO::TRIPLET_INFO(const TRIPLET_INFO &ti) : track_mem<TRIPLET_INFO>("TRIPLET_INFO"), t(ti.t), score(ti.score),
bperiod(ti.bperiod), freq_bin(ti.freq_bin),
tpotind0_0(ti.tpotind0_0), tpotind0_1(ti.tpotind0_1),
tpotind1_0(ti.tpotind1_0), tpotind1_1(ti.tpotind1_1),
tpotind2_0(ti.tpotind2_0), tpotind2_1(ti.tpotind2_1),
time_bin(ti.time_bin), scale(ti.scale)
{
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
pot_min = (unsigned int *)calloc_a(swi.analysis_cfg.triplet_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_min == NULL) SETIERROR(MALLOC_FAILED, "copied TRIPLET_INFO pot_min == NULL");
pot_max = (unsigned int *)calloc_a(swi.analysis_cfg.triplet_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_max == NULL) SETIERROR(MALLOC_FAILED, "copied TRIPLET_INFO pot_max == NULL");
memcpy(pot_min,ti.pot_min,(swi.analysis_cfg.triplet_pot_length * sizeof(unsigned int)));
memcpy(pot_max,ti.pot_max,(swi.analysis_cfg.triplet_pot_length * sizeof(unsigned int)));
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
}
static void add_initd(struct runqueue *q, char *file, char *param)
{
static const struct runqueue_task_type initd_type = {
.run = q_initd_run,
.cancel = runqueue_process_cancel_cb,
.kill = runqueue_process_kill_cb,
};
struct initd *s;
char *p, *f;
s = calloc_a(sizeof(*s), &f, strlen(file) + 1, &p, strlen(param) + 1);
if (!s) {
ERROR("Out of memory in %s.\n", file);
return;
}
s->proc.task.type = &initd_type;
s->proc.task.complete = q_initd_complete;
if (!strcmp(param, "stop") || !strcmp(param, "shutdown"))
s->proc.task.run_timeout = 15000;
s->param = p;
s->file = f;
strcpy(s->param, param);
strcpy(s->file, file);
runqueue_task_add(q, &s->proc.task, false);
}
static struct interface* _interface_add(const char *name, int multicast, int v6)
{
struct interface *iface;
char *name_buf;
char *id_buf;
iface = calloc_a(sizeof(*iface),
&name_buf, strlen(name) + 1,
&id_buf, strlen(name) + 5);
sprintf(id_buf, "%d_%d_%s", multicast, v6, name);
iface->name = strcpy(name_buf, name);
iface->id = id_buf;
iface->ifindex = if_nametoindex(name);
iface->fd.fd = -1;
iface->multicast = multicast;
iface->v6 = v6;
if (v6)
iface->mcast_addr = MCAST_ADDR6;
else
iface->mcast_addr = MCAST_ADDR;
if (iface->ifindex <= 0)
goto error;
vlist_add(&interfaces, &iface->node, iface->id);
return iface;
error:
free(iface);
return NULL;
}
PULSE_INFO::PULSE_INFO() : track_mem<PULSE_INFO>("PULSE_INFO"), p(), score(0), freq_bin(0), time_bin(0) {
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
pot_min = (unsigned int *)calloc_a(swi.analysis_cfg.pulse_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_min == NULL) SETIERROR(MALLOC_FAILED, "new PULSE_INFO pot_min == NULL");
pot_max = (unsigned int *)calloc_a(swi.analysis_cfg.pulse_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_max == NULL) SETIERROR(MALLOC_FAILED, "new PULSE_INFO pot_max == NULL");
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
}
/*
* Public API implementation
*/
int htable_init(htable_t* ht, int size, op_unary_t do_calc_hash, op_binary_t do_compare)
{
/* because dlist_init simply assigns NULL to tail/head references,
* we can just initialize the dlist_t array with zeroes without
* explicitly calling dlist_init for each array item. */
ht->buckets = (dlist_t*)calloc_a(size, sizeof(dlist_t));
ht->do_compare = do_compare;
ht->do_calc_hash = do_calc_hash;
ht->size = size;
return 0;
}
TRIPLET_INFO::TRIPLET_INFO() : track_mem<TRIPLET_INFO>("TRIPLET_INFO"),
t(), score(0), bperiod(0), freq_bin(0), tpotind0_0(0), tpotind0_1(0),
tpotind1_0(0), tpotind1_1(0), tpotind2_0(0), tpotind2_1(0), time_bin(0),
scale(0) {
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
pot_min = (unsigned int *)calloc_a(swi.analysis_cfg.triplet_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_min == NULL) SETIERROR(MALLOC_FAILED, "new TRIPLET_INFO pot_min == NULL");
pot_max = (unsigned int *)calloc_a(swi.analysis_cfg.triplet_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_max == NULL) SETIERROR(MALLOC_FAILED, "new TRIPLET_INFO pot_max == NULL");
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
}
PULSE_INFO::PULSE_INFO(const PULSE_INFO &pi) : track_mem<PULSE_INFO>("PULSE_INFO"),
p(pi.p), score(pi.score), freq_bin(pi.freq_bin), time_bin(pi.time_bin) {
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
pot_min = (unsigned int *)calloc_a(swi.analysis_cfg.pulse_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_min == NULL) SETIERROR(MALLOC_FAILED, "copied PULSE_INFO pot_min == NULL");
pot_max = (unsigned int *)calloc_a(swi.analysis_cfg.pulse_pot_length, sizeof(unsigned int), MEM_ALIGN);
if (pot_max == NULL) SETIERROR(MALLOC_FAILED, "copied PULSE_INFO pot_max == NULL");
memcpy(pot_min,pi.pot_min,(swi.analysis_cfg.pulse_pot_length * sizeof(unsigned int)));
memcpy(pot_max,pi.pot_max,(swi.analysis_cfg.pulse_pot_length * sizeof(unsigned int)));
// debug possible heap corruption -- jeffc
#ifdef _WIN32
BOINCASSERT(_CrtCheckMemory());
#endif
}
static struct service *
service_alloc(const char *name)
{
struct service *s;
char *new_name;
s = calloc_a(sizeof(*s), &new_name, strlen(name) + 1);
strcpy(new_name, name);
vlist_init(&s->instances, avl_strcmp, service_instance_update);
s->instances.keep_old = true;
s->name = new_name;
s->avl.key = s->name;
INIT_LIST_HEAD(&s->validators);
return s;
}
int analyze_pot(float *PowerSpectrum, int NumDataPoints, ChirpFftPair_t &cfft, int offset)
{
// This function analyses Power over Time for the current data block.
// The PoT array is created by taking an array of power spectra (a
// standard row-major 2D array) and extracting the PoT as column-major
// data. We essentialy turn the array on its side.
int retval = 0,
i,
FftLength=cfft.FftLen, // Current FFT length
ThisPoT, // index of current PoT along the freq axis
PoTLen, // complement of FFT length - determines time res
PulsePoTLen, // length of PoT segment passed to pulse finders
Overlap, // PoT segment overlap in bins
TOffset, // index into ThisPoT of current pulse segment
PulsePoTNum = 0, // the oridinal position of a pulse PoT w/in a full PoT
NumPulsePoTs = 0, // the number of pulse PoTs w/in a full PoT. This is
// constant regardless of FFT or PoT length and is
// determined by slew rate.
AdvanceBy; // the number of bins to advance for the next pulse PoT
float ProgressAddFactor = 0.0, // sum of progress adds for ThisPoT
ProgressPerPulsePoT = 0.0; // for local progress display
bool SkipGauss = false,
SkipPulse = false,
SkipTriplet = false,
TOffsetOK = true;
static float *GaussPoT = NULL,
*PulsePoT = NULL;
#ifdef DEBUG_POT
fprintf(stderr, "========= FftLength = %d =========\n", FftLength);
#endif
PoTLen = NumDataPoints / FftLength; // in bins
GetPulsePoTLen(PoTLen, &PulsePoTLen, &Overlap); // in bins
AdvanceBy = PulsePoTLen - Overlap; // in bins
// Max limits how *slow* the slewrate can be, while Min limits how
// *fast* the slewrate can be. Max is limited only by the client
// memory budget.
if(PulsePoTLen > PoTInfo.TripletMax || PulsePoTLen < PoTInfo.TripletMin)
SkipTriplet = true;
SkipGauss = !(cfft.GaussFit);
SkipPulse = !(cfft.PulseFind);
if(!SkipPulse || !SkipTriplet)
{
// NumPulsePoTs is the number of PoT segments that we pass to the pulse
// detectors per frequency bin. ProgressPerPulsePoT is the inverse of
// number of pulse detection segments in the entire data block, taking
// into account that we skip the first (DC) frequency bin. An assumption
// is made here that minimum pulse/triplet PoT length will always be
// greater than 1. Otherwise, AdvanceBy can become zero and a divide by
// zero can occur. The assumption is also made that FftLength is always
// greater than 1!
NumPulsePoTs = 1 + (PoTLen-PulsePoTLen)/AdvanceBy + ((PoTLen-PulsePoTLen)%AdvanceBy ? 1 : 0);
ProgressPerPulsePoT = (float)1 / ((FftLength - 1) * NumPulsePoTs);
}
#ifdef DEBUG_POT
fprintf(stderr, "SlewRate = %f\n", PoTInfo.SlewRate);
fprintf(stderr, "PoTLen = %d\n", PoTLen);
fprintf(stderr, "MaxPoTLen = %d\n", PoTInfo.MaxPoTLen);
fprintf(stderr, "PoTDuration = %f\n", PoTInfo.WUDuration);
fprintf(stderr, "BeamRate = %f\n", PoTInfo.BeamRate);
fprintf(stderr, "PulsePoTLen = %d\n", PulsePoTLen);
fprintf(stderr, "Overlap = %d\n", Overlap);
fprintf(stderr, "AdvanceBy = %d\n", AdvanceBy);
fprintf(stderr, "min_slew = %f\n", PoTInfo.min_slew);
fprintf(stderr, "max_slew = %f\n", PoTInfo.max_slew);
fprintf(stderr, "PulseOverlapFactor = %f\n", PoTInfo.PulseOverlapFactor);
fprintf(stderr, "PulseBeams = %f\n", PoTInfo.PulseBeams);
fprintf(stderr, "PulseThresh = %f\n", PoTInfo.PulseThresh);
fprintf(stderr, "PulseMax = %d\n", PoTInfo.PulseMax);
fprintf(stderr, "PulseMin = %d\n", PoTInfo.PulseMin);
fprintf(stderr, "PulseFftMax = %d\n", PoTInfo.PulseFftMax);
fprintf(stderr, "TripletThresh = %f\n", PoTInfo.TripletThresh);
fprintf(stderr, "TripletMax = %d\n", PoTInfo.TripletMax);
fprintf(stderr, "TripletMin = %d\n", PoTInfo.TripletMin);
#endif
#ifndef USE_PULSE
SkipPulse = TRUE;
static int doneprintnopulsefind = 0;
if(!doneprintnopulsefind)
{
fprintf(stderr,"SkipPulse is set to TRUE: Not doing Pulsefinds.\n");
doneprintnopulsefind = TRUE;
}
#endif
#ifndef USE_TRIPLET
SkipTriplet = TRUE;
#endif
// Get memory fot the PoT arrays. The PoT array for gausian analysis is
// of set size. The PoT array for pulse analysis is sized to cover
// PulseBeams beams, regardless of whether this violates either the
// triplet or pulse limits on array size.
if(!GaussPoT)
{
GaussPoT = (float *)malloc_a(swi.analysis_cfg.gauss_pot_length * sizeof(float), MEM_ALIGN);
if(GaussPoT == NULL)
{
SETIERROR(MALLOC_FAILED, "GaussPoT == NULL");
}
}
if(!PulsePoT)
{
PulsePoT = (float *)calloc_a(PoTInfo.MaxPoTLen+3, sizeof(float), MEM_ALIGN);
if(PulsePoT == NULL)
{
SETIERROR(MALLOC_FAILED, "PulsePoT == NULL");
}
}
bool b_gaussStarted = false;
// Look for gaussians ---------------------------------------------------
if(!SkipGauss && (analysis_state.PoT_activity == POT_DOING_GAUSS ||
analysis_state.PoT_activity == POT_INACTIVE))
{
#ifdef BOINC_APP_GRAPHICS
if (!nographics())
strcpy(sah_graphics->status, "Searching for Gaussians");
#endif
// If we are back from being interrupted in the middle of gaussian PoT
// analysis, load state and continue. Otherwise start anew, skipping
// the DC (0) bin.
if(analysis_state.PoT_activity == POT_DOING_GAUSS)
{
ThisPoT = analysis_state.PoT_freq_bin;
}
else
{
ThisPoT = 1; // skip the DC bin on start of new cfft pair
}
// Initial display of local Progress / CPU time. Assumes that
// we start ThisPoT at 1 each time in!
#ifdef BOINC_APP_GRAPHICS
if (!nographics())
sah_graphics->local_progress = ((float)ThisPoT-1)/(FftLength-1);
#endif
#ifdef USE_CUDA
//#ifndef CUDAACC_EMULATION
if(gSetiUseCudaDevice)
{
//TODO: remove the autocorr_fftlen test when v6 fully deprecated.
bool noscore = false; //swi.analysis_cfg.autocorr_fftlen!=0 && gaussian_count!=0;
//cudaAcc_Gaussfit(FftLength, best_gauss->score, noscore);
//printf("GaussFitStart\r\n");
b_gaussStarted = true; // started earlier
//cudaAcc_GaussfitStart(FftLength, best_gauss->score, noscore);
if(PoTLen > swi.analysis_cfg.gauss_pot_length)
analysis_state.FLOP_counter+=((double)NumDataPoints+swi.analysis_cfg.gauss_pot_length * (FftLength-1)); // GetFixedPoT
// There are FftLength - 1 fixed PoTs for a chirp/fft pair, and for each fixed PoT full analysis would do
// (1 + (PoTInfo.GaussTOffsetStop - PoTInfo.GaussTOffsetStart)) GetPeak and GetTrueMean operations.
// Use (1 - PoTInfo.GaussSigma*0.09) empirically found to represent fraction of PoTs which don't
// take either of the two early out paths.
double CorrWt = (1.0 - PoTInfo.GaussSigma*0.09) * (FftLength - 1) * (1 + (PoTInfo.GaussTOffsetStop - PoTInfo.GaussTOffsetStart));
analysis_state.FLOP_counter+=6.0*floor(PoTInfo.GaussSigma+0.5) * CorrWt; // GetPeak
analysis_state.FLOP_counter+=(double)(floor(PoTInfo.GaussSigma+0.5) * 3.911+5) * CorrWt; // GetTrueMean
// Estimate one in twenty fit positions look good enough to be checked further.
analysis_state.FLOP_counter+= 0.05 * (20.0*swi.analysis_cfg.gauss_pot_length+5.0) * CorrWt; // GetChiSq / 20
progress += ProgressUnitSize * GaussianProgressUnits();
progress=std::min(progress,1.0); // prevent display of > 100%
fraction_done(progress,remaining);
}
//#endif CUDAACC_EMULATION
else
{
#endif //USE_CUDA
// loop through frequencies
/* for(; ThisPoT < FftLength; ThisPoT++)
{
// Create PowerOfTime array for gaussian fit
retval = GetFixedPoT(
PowerSpectrum,
NumDataPoints,
FftLength,
GaussPoT,
swi.analysis_cfg.gauss_pot_length,
ThisPoT
);
if (retval)
continue;
retval = GaussFit(GaussPoT, FftLength, ThisPoT);
if (retval)
SETIERROR(retval,"from GaussFit");
progress += ProgressUnitSize * GaussianProgressUnits() / (float)(FftLength - 1);
progress=std::min(progress,1.0); // prevent display of > 100%
fraction_done(progress,remaining);
// At the end of each frequency bin we update progress and save state.
#ifdef BOINC_APP_GRAPHICS
if (!nographics())
{
sah_graphics->local_progress = ((float)ThisPoT)/(FftLength-1);
}
#endif
analysis_state.PoT_freq_bin = ThisPoT;
analysis_state.PoT_activity = POT_DOING_GAUSS;
retval = checkpoint();
if (retval)
SETIERROR(retval,"from checkpoint()");
} // end loop through frequencies
*/
#ifdef USE_CUDA
}
#endif //USE_CUDA
analysis_state.PoT_freq_bin = -1;
analysis_state.PoT_activity = POT_INACTIVE;
} // end looking for gaussians
// Look for pulses -------------------------------------------------------
if(!SkipPulse || !SkipTriplet)
{
#ifdef BOINC_APP_GRAPHICS
if (!nographics())
{
strcpy(sah_graphics->status, "Searching for Pulses / Triplets");
// init local progress for pulse search
sah_graphics->local_progress = 0;
}
#endif
// If we are back from being interrupted in the middle of pulse PoT
// analysis, load state and continue. Otherwise start anew, skipping
// the DC (0) bin.
if(analysis_state.PoT_activity == POT_DOING_PULSE)
{
ThisPoT = analysis_state.PoT_freq_bin;
}
else
{
ThisPoT = 1; // skip the DC bin on start of new cfft pair
}
PulsePoTNum = 0;
#ifdef BOINC_APP_GRAPHICS
// Inital display of Local Progress
if(!nographics())
{
sah_graphics->local_progress = (((ThisPoT-1) * NumPulsePoTs) +
PulsePoTNum) *
ProgressPerPulsePoT;
}
#endif
#ifdef USE_CUDA
if(gSetiUseCudaDevice)
{
/*
if(!SkipTriplet || !SkipPulse) // do beforehand on fftstreamX
{
// CUDASYNC;
//printf("CalculateMean\r\n");
cudaAcc_calculate_mean(PulsePoTLen, 0, AdvanceBy, FftLength);
}
if(!SkipPulse)
{
//printf("FindPulses\r\n");
cudaAcc_find_pulses((float) best_pulse->score, PulsePoTLen, AdvanceBy, FftLength);
}
if(!SkipTriplet)
{
//printf("FindTriplets\r\n");
cudaAcc_find_triplets(PulsePoTLen, (float)PoTInfo.TripletThresh, AdvanceBy, FftLength);
}
*/
/*
timespec t1, t2;
t1.tv_sec = 0;
t1.tv_nsec = 5000;
while(cudaEventQuery(summaxDoneEvent) != cudaSuccess)
nanosleep(&t1, &t2);
*/
int gflags = 0;
if(b_gaussStarted)
{
//printf("fetchGaussFitFlags\r\n");
b_gaussStarted = false;
gflags = cudaAcc_fetchGaussfitFlags(FftLength, best_gauss->score);
}
//printf("fetchTripletAndPulseFlags\r\n");
int has_dataT = 0, has_dataP = 0;
if(!SkipTriplet)
has_dataT = cudaAcc_fetchTripletFlags(SkipTriplet, PulsePoTLen, AdvanceBy, FftLength, offset);
if(gflags > 0)
{
//printf("ProcessGaussFit\r\n");
cudaAcc_processGaussFit(FftLength, best_gauss->score);
}
if(!SkipTriplet)
{
if((has_dataT & 1) && !(has_dataT & 4)) // has triplet data and no error in triplet
{
//printf("processTripletResults\r\n");
cudaAcc_processTripletResults(PulsePoTLen, AdvanceBy, FftLength);
}
analysis_state.FLOP_counter+=(10.0 + PulsePoTLen) * NumPulsePoTs * (FftLength - 1);
// ! hard to estimate, so be generous and use 9
analysis_state.FLOP_counter+=810.0; // (10.0*numBinsAboveThreshold*numBinsAboveThreshold);
progress += ProgressUnitSize * TripletProgressUnits();
}
if(!SkipPulse)
has_dataP = cudaAcc_fetchPulseFlags(SkipTriplet, PulsePoTLen, AdvanceBy, FftLength, offset);
if(!SkipPulse)
{
if((has_dataP & 2) && !(has_dataP & 8)) // has pulse data and no error in pulse
{
//printf("processPulseResults\r\n");
cudaAcc_processPulseResults(PulsePoTLen, AdvanceBy, FftLength);
}
analysis_state.FLOP_counter+=(PulsePoTLen*0.1818181818182+400.0)*PulsePoTLen * NumPulsePoTs * (FftLength - 1);
progress += ProgressUnitSize * PulseProgressUnits(PulsePoTLen, FftLength - 1);
}
//#ifndef CUDAACC_EMULATION
//if(!SkipTriplet)
// cudaAcc_fetchTripletAndPulseFlags(SkipTriplet, SkipPulse, PulsePoTLen, AdvanceBy, FftLength);
progress=std::min(progress,1.0); // prevent display of > 100%
fraction_done(progress,remaining);
//if(!SkipTriplet)
// cudaAcc_processTripletResults(PulsePoTLen, AdvanceBy, FftLength);
//#endif //CUDAACC_EMULATION
}
// else
// {
#endif //USE_CUDA
// loop through frequencies
/* for(; ThisPoT < FftLength; ThisPoT++)
{
// loop through time for each frequency. PulsePoTNum is
// used only for progress calculation.
for(TOffset = 0, PulsePoTNum = 1, TOffsetOK = true;
TOffsetOK;
PulsePoTNum++, TOffset += AdvanceBy)
{
// Create PowerOfTime array for pulse detection. If there
// are not enough points left in this PoT, adjust TOffset
// to get the latest possible pulse PoT.
if(TOffset + PulsePoTLen >= PoTLen)
{
TOffsetOK = false;
TOffset = PoTLen - PulsePoTLen;
}
if (use_transposed_pot)
{
memcpy(PulsePoT, &PowerSpectrum[ThisPoT * PoTLen + TOffset], PulsePoTLen*sizeof(float));
}
else
{
for(i = 0; i < PulsePoTLen; i++)
{
PulsePoT[i] = PowerSpectrum[ThisPoT + (TOffset+i) * FftLength];
}
}
if(!SkipTriplet)
{
retval = find_triplets(PulsePoT,
PulsePoTLen,
(float)PoTInfo.TripletThresh,
TOffset,
ThisPoT);
if (retval)
SETIERROR(retval,"from find_triplets()");
}
//#ifndef CUDAACC_EMULATION
if(!SkipPulse)
{
retval = find_pulse(PulsePoT,
PulsePoTLen,
(float)PoTInfo.PulseThresh,
TOffset,
ThisPoT
);
if (retval)
SETIERROR(retval,"from find_pulse()");
}
//#endif //CUDAACC_EMULATION
// At the end of each pulse PoT we update progress. Progress
// will thus get updted several times per frequency bin.
#ifdef BOINC_APP_GRAPHICS
if (!nographics())
{
sah_graphics->local_progress = (((ThisPoT-1) * NumPulsePoTs) +
PulsePoTNum) *
ProgressPerPulsePoT;
}
#endif
if(!SkipTriplet)
{
progress += (ProgressUnitSize * TripletProgressUnits()) /
(float)(FftLength - 1) / NumPulsePoTs;
}
if(!SkipPulse)
{
progress += (ProgressUnitSize * PulseProgressUnits(PulsePoTLen, FftLength - 1)) /
(float)(FftLength - 1) / NumPulsePoTs;
}
progress=std::min(progress,1.0); // prevent display of > 100%
fraction_done(progress,remaining);
} // end loop through time for each frequency
// At the end of each frequency bin we save state.
analysis_state.PoT_activity = POT_DOING_PULSE;
analysis_state.PoT_freq_bin = ThisPoT;
retval = checkpoint();
if (retval)
SETIERROR(retval,"from checkpoint()");
} // end loop through frequencies
analysis_state.PoT_freq_bin = -1;
analysis_state.PoT_activity = POT_INACTIVE;
#ifdef USE_CUDA
}
#endif //USE_CUDA
*/
} // end looking for pulses
if(b_gaussStarted) // process results late
{
//printf("late GaussBlock\r\n");
int flags = cudaAcc_fetchGaussfitFlags(FftLength, best_gauss->score);
if(flags>0)
cudaAcc_processGaussFit(FftLength, best_gauss->score);
}
return (retval); // no error return point
}
int seti_analyze (ANALYSIS_STATE& state) {
sah_complex* DataIn = state.savedWUData;
int NumDataPoints = state.npoints;
sah_complex* ChirpedData = NULL;
sah_complex* WorkData = NULL;
float* PowerSpectrum = NULL;
float* tPowerSpectrum; // Transposed power spectra if used.
float* AutoCorrelation = NULL;
use_transposed_pot= (!notranspose_flag) &&
((app_init_data.host_info.m_nbytes != 0) &&
(app_init_data.host_info.m_nbytes >= (double)(96*1024*1024)));
int num_cfft = 0;
float chirprate;
int last_chirp_ind = - 1 << 20, chirprateind;
double progress_diff, progress_in_cfft, cputime0=0;
int retval=0;
if (swi.analysis_cfg.credit_rate != 0) LOAD_STORE_ADJUSTMENT=swi.analysis_cfg.credit_rate;
#ifndef DEBUG
int icfft;
#endif
int NumFfts, ifft, fftlen;
int CurrentSub;
int FftNum, need_transpose;
unsigned long bitfield=swi.analysis_cfg.analysis_fft_lengths;
unsigned long FftLen;
unsigned long ac_fft_len=swi.analysis_cfg.autocorr_fftlen;
#ifdef USE_IPP
IppsFFTSpec_C_32fc* FftSpec[MAX_NUM_FFTS];
int BufSize;
ippStaticInit(); // initialization of IPP library
#elif defined(USE_FFTWF)
// plan space for fftw
fftwf_plan analysis_plans[MAX_NUM_FFTS];
fftwf_plan autocorr_plan;
#else
// fields need by the ooura fft logic
int * BitRevTab[MAX_NUM_FFTS];
float * CoeffTab[MAX_NUM_FFTS];
#endif
// Allocate data array and work area arrays.
ChirpedData = state.data;
PowerSpectrum = (float*) calloc_a(NumDataPoints, sizeof(float), MEM_ALIGN);
if (PowerSpectrum == NULL) SETIERROR(MALLOC_FAILED, "PowerSpectrum == NULL");
if (use_transposed_pot) {
tPowerSpectrum = (float*) calloc_a(NumDataPoints, sizeof(float), MEM_ALIGN);
if (tPowerSpectrum == NULL) SETIERROR(MALLOC_FAILED, "tPowerSpectrum == NULL");
} else {
tPowerSpectrum=PowerSpectrum;
}
AutoCorrelation = (float*)calloc_a(ac_fft_len, sizeof(float), MEM_ALIGN);
if (AutoCorrelation == NULL) SETIERROR(MALLOC_FAILED, "AutoCorrelation == NULL");
// boinc_worker_timer();
FftNum=0;
FftLen=1;
#ifdef USE_FFTWF
double sz;
FILE *wisdom;
if ((wisdom=boinc_fopen("wisdom.sah","r"))) {
char *wiz=(char *)calloc_a(1024,64,MEM_ALIGN);
int n=0;
while (wiz && n<64*1024 && !feof(wisdom)) {
n+=fread(wiz+n,1,80,wisdom);
}
fftwf_import_wisdom_from_string(wiz);
free_a(wiz);
fclose(wisdom);
}
#endif
#ifdef BOINC_APP_GRAPHICS
if (sah_graphics) strcpy(sah_graphics->status, "Generating FFT Coefficients");
#endif
while (bitfield != 0) {
if (bitfield & 1) {
swi.analysis_fft_lengths[FftNum]=FftLen;
#ifdef USE_IPP
int order = 0;
for (int tmp = FftLen; !(tmp & 1); order++) tmp >>= 1;
if (ippsFFTInitAlloc_C_32fc(&FftSpec[FftNum], order,
IPP_FFT_NODIV_BY_ANY, ippAlgHintFast)) {
SETIERROR (MALLOC_FAILED, "ippsFFTInitAlloc failed");
}
#elif !defined(USE_FFTWF)
// See docs in fft8g.C for sizing guidelines for BitRevTab and CoeffTab.
BitRevTab[FftNum] = (int*) calloc_a(3+(int)sqrt((float)swi.analysis_fft_lengths[FftNum]), sizeof(int), MEM_ALIGN);
if (BitRevTab[FftNum] == NULL) SETIERROR(MALLOC_FAILED, "BitRevTab[FftNum] == NULL");
BitRevTab[FftNum][0] = 0;
#else
WorkData = (sah_complex *)malloc_a(FftLen * sizeof(sah_complex),MEM_ALIGN);
sah_complex *scratch=(sah_complex *)malloc_a(FftLen*sizeof(sah_complex),MEM_ALIGN);
if ((WorkData == NULL) || (scratch==NULL)) {
SETIERROR(MALLOC_FAILED, "WorkData == NULL || scratch == NULL");
}
// TODO: Deallocate these at the end of the function
analysis_plans[FftNum] = fftwf_plan_dft_1d(FftLen, scratch, WorkData, FFTW_BACKWARD, FFTW_MEASURE|FFTW_PRESERVE_INPUT);
#endif
FftNum++;
#ifdef USE_FFTWF
free_a(scratch);
free_a(WorkData);
#endif /* USE_FFTWF */
}
FftLen*=2;
bitfield>>=1;
}
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);
}
