int
main ()
{
int rval;
uint16_t N;
uint16_t df;
uint16_t tmp[] = {0, 1, 2, 3, 4};
uint32_t *t1 = (uint32_t*)&tmp[0];
uint32_t *t2 = (uint32_t*)&tmp[1];
*t2 += *t1;
/*
rval = inner_loop(29, 5, 5, 1, 1);
if (rval) exit (rval);
*/
for (N = 29; N < 1000; N+=30) {
for (df = 5; df < N/3; df+= 5) {
rval = inner_loop(N, df, 0, 1, 1);
if (rval) exit (rval);
rval = inner_loop(N, 0, df, 1, 1);
if (rval) exit (rval);
rval = inner_loop(N, df, df, 1, 1);
if (rval) exit (rval);
}
}
printf("\nSuccess!\n");
exit (0);
}
int outer_formsee_loop(dataptr dz)
{
int exit_status;
int windows_in_buf, peakscore = 0, pitchcnt = 0;
int in_start_portion = TRUE, least = 0, descnt = 0;
if(sloom)
dz->total_samps_read = 0L;
if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
return(exit_status);
while(dz->ssampsread > 0) {
dz->flbufptr[0] = dz->bigfbuf;
windows_in_buf = dz->ssampsread/dz->wanted;
if((exit_status = inner_loop(&peakscore,&descnt,&in_start_portion,&least,&pitchcnt,windows_in_buf,dz))<0)
return(exit_status);
if((exit_status = write_samps(dz->bigfbuf,dz->ssampsread,dz))<0)
return(exit_status);
if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
return(exit_status);
}
if(dz->ssampsread < 0) {
sprintf(errstr,"Sound read error.\n");
return(SYSTEM_ERROR);
}
return renormalise_formsee(dz);
}
static int outer_loop( int max_bits,
L3_psy_xmin_t *l3_xmin, /* the allowed distortion of the scalefactor */
int ix[samp_per_frame2], /* vector of quantized values ix(0..575) */
L3_scalefac_t *scalefac, /* scalefactors */
int gr, int ch, L3_side_info_t *side_info )
{
int bits, huff_bits;
gr_info *cod_info = &side_info->gr[gr].ch[ch].tt;
cod_info->quantizerStepSize = bin_search_StepSize(max_bits,ix,cod_info);
cod_info->part2_length = part2_length(scalefac,gr,ch,side_info);
huff_bits = max_bits - cod_info->part2_length;
bits = inner_loop(ix, huff_bits, cod_info, gr, ch );
cod_info->part2_length = part2_length(scalefac,gr,ch,side_info);
cod_info->part2_3_length = cod_info->part2_length + bits;
return cod_info->part2_3_length;
}
int main(int argc, char **argv)
{
int varmax, size, repetitions;
int array[VARLIMIT];
int reps, v0;
MR_ROBDD_type *f;
millisec clock0, clock1, clock2, clock3;
float runtime, overhead, rate;
int test_nodes, overhead_nodes;
if (argc < 3) {
usage(argv[0]);
return 20;
}
if ((varmax=atoi(argv[2]))<1 || varmax>=VARLIMIT) {
usage(argv[0]);
printf("\n varmax must be between 1 <= varmax < %d\n", VARLIMIT);
return 20;
}
if ((size=atoi(argv[1]))<0 || size>=varmax) {
usage(argv[0]);
printf("\n size must be between 0 <= size < varmax\n");
return 20;
}
repetitions=(argc>3 ? atoi(argv[3]) : 1);
if (repetitions <= 0) repetitions = 1;
opcount = 0;
clock0 = milli_time();
for (reps=repetitions; reps>0; --reps) {
for (v0=0; v0<varmax; ++v0) {
init_array(size, v0, array);
f = MR_ROBDD_testing_iff_conj_array(v0, size, array);
inner_loop(varmax, f);
while (next_array(size, varmax, v0, array)) {
f = MR_ROBDD_testing_iff_conj_array(v0, size, array);
inner_loop(varmax, f);
}
}
}
clock1 = milli_time();
test_nodes = MR_ROBDD_nodes_in_use();
MR_ROBDD_initRep();
clock2 = milli_time();
for (reps=repetitions; reps>0; --reps) {
for (v0=0; v0<varmax; ++v0) {
init_array(size, v0, array);
f = MR_ROBDD_testing_iff_conj_array(v0, size, array);
dont_inner_loop(varmax, f);
while (next_array(size, varmax, v0, array)) {
f = MR_ROBDD_testing_iff_conj_array(v0, size, array);
dont_inner_loop(varmax, f);
}
}
}
clock3 = milli_time();
overhead_nodes = MR_ROBDD_nodes_in_use();
runtime = (float)(clock1-clock0)/1000;
overhead = (float)(clock3-clock2)/1000;
rate = ((float)opcount)/(runtime-overhead);
printf("%s %d %d %d: %.3f - %.3f = %.3f secs, %d ops, %d nodes, %.1f ops/sec\n",
argv[0], size, varmax, repetitions,
runtime, overhead, (runtime-overhead), opcount,
test_nodes-overhead_nodes, rate);
return 0;
}
static void sharp_execute_job_mpi (sharp_job *job, MPI_Comm comm)
{
int ntasks;
MPI_Comm_size(comm, &ntasks);
if (ntasks==1) /* fall back to scalar implementation */
{ sharp_execute_job (job); return; }
MPI_Barrier(comm);
double timer=wallTime();
job->opcnt=0;
sharp_mpi_info minfo;
sharp_make_mpi_info(comm, job, &minfo);
if (minfo.npairtotal>minfo.ntasks*300)
{
int nsub=(minfo.npairtotal+minfo.ntasks*200-1)/(minfo.ntasks*200);
for (int isub=0; isub<nsub; ++isub)
{
sharp_job ljob=*job;
// When creating a_lm, every sub-job produces a complete set of
// coefficients; they need to be added up.
if ((isub>0)&&(job->type==SHARP_MAP2ALM)) ljob.flags|=SHARP_ADD;
sharp_geom_info lginfo;
lginfo.pair=RALLOC(sharp_ringpair,(job->ginfo->npairs/nsub)+1);
lginfo.npairs=0;
lginfo.nphmax = job->ginfo->nphmax;
while (lginfo.npairs*nsub+isub<job->ginfo->npairs)
{
lginfo.pair[lginfo.npairs]=job->ginfo->pair[lginfo.npairs*nsub+isub];
++lginfo.npairs;
}
ljob.ginfo=&lginfo;
sharp_execute_job_mpi (&ljob,comm);
job->opcnt+=ljob.opcnt;
DEALLOC(lginfo.pair);
}
}
else
{
int lmax = job->ainfo->lmax;
job->norm_l = sharp_Ylmgen_get_norm (lmax, job->spin);
/* clear output arrays if requested */
init_output (job);
alloc_phase_mpi (job,job->ainfo->nm,job->ginfo->npairs,minfo.mmax+1,
minfo.npairtotal);
double *cth = RALLOC(double,minfo.npairtotal),
*sth = RALLOC(double,minfo.npairtotal);
int *mlim = RALLOC(int,minfo.npairtotal);
for (int i=0; i<minfo.npairtotal; ++i)
{
cth[i] = cos(minfo.theta[i]);
sth[i] = sin(minfo.theta[i]);
mlim[i] = sharp_get_mlim(lmax, job->spin, sth[i], cth[i]);
}
/* map->phase where necessary */
map2phase (job, minfo.mmax, 0, job->ginfo->npairs);
map2alm_comm (job, &minfo);
#pragma omp parallel if ((job->flags&SHARP_NO_OPENMP)==0)
{
sharp_job ljob = *job;
sharp_Ylmgen_C generator;
sharp_Ylmgen_init (&generator,lmax,minfo.mmax,ljob.spin);
alloc_almtmp(&ljob,lmax);
#pragma omp for schedule(dynamic,1)
for (int mi=0; mi<job->ainfo->nm; ++mi)
{
/* alm->alm_tmp where necessary */
alm2almtmp (&ljob, lmax, mi);
/* inner conversion loop */
inner_loop (&ljob, minfo.ispair, cth, sth, 0, minfo.npairtotal,
&generator, mi, mlim);
/* alm_tmp->alm where necessary */
almtmp2alm (&ljob, lmax, mi);
}
sharp_Ylmgen_destroy(&generator);
dealloc_almtmp(&ljob);
#pragma omp critical
job->opcnt+=ljob.opcnt;
} /* end of parallel region */
alm2map_comm (job, &minfo);
/* phase->map where necessary */
phase2map (job, minfo.mmax, 0, job->ginfo->npairs);
DEALLOC(mlim);
DEALLOC(cth);
DEALLOC(sth);
DEALLOC(job->norm_l);
dealloc_phase (job);
}
sharp_destroy_mpi_info(&minfo);
job->time=wallTime()-timer;
}
