static inline void gettest(int me, int iterations, int T, int S, int P)
{
int i;
if (me == 1) {
pre_op_check(__func__, target[T], iterations, 1);
shmem_int_p(&source[S], iterations, 0);
shmem_fence();
for (i = 0; i < iterations; i++)
target[T] = shmem_int_g(&source[S], 0);
shmem_int_p(&sync_pes[P], iterations, 0);
post_op_check("get", target[T], iterations, 1);
} else
wait_until(&sync_pes[P], iterations, 0);
if (verbose) {
if (me == 0)
printf("SHMEM %s finished\n", __func__);
}
}
int
main ()
{
int me, npes, src;
int i;
struct timeval start, end;
long time_taken, start_time, end_time;
for (i = 0; i < _SHMEM_BCAST_SYNC_SIZE; i += 1) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
src = me - 1;
time_taken = 0;
for (i = 0; i < 10000; i++) {
if (me != 0) {
shmem_int_p (&x, src * (i + 1), me - 1);
}
else {
shmem_int_p (&x, src * (i + 1), npes - 1);
}
shmem_barrier_all ();
gettimeofday (&start, NULL);
start_time = (start.tv_sec * 1000000.0) + start.tv_usec;
shmem_barrier (0, 0, npes, pSync);
gettimeofday (&end, NULL);
end_time = (end.tv_sec * 1000000.0) + end.tv_usec;
time_taken = time_taken + (end_time - start_time);
}
/* printf("%d: x = %d\n", me, x); */
if (me == 0) {
printf
("Time required for a barrier, with %d PEs is %ld microseconds\n",
npes, time_taken / 10000);
}
shmem_finalize ();
return 0;
}
static inline void cswaptest(int me, int iterations, int T, int S, int P)
{
int i;
source[S] = -100;
target[T] = 0;
shmem_barrier_all();
if (me == 1) {
pre_op_check(__func__, source[S], iterations, 1);
for (i = 0; i < iterations; i++)
source[S] = shmem_int_cswap(&(target[T]), i, (i+1), 0);
shmem_int_p(&sync_pes[P], i, 0);
post_op_check("cswap", source[S], (iterations-1), 1);
} else {
wait_until(&sync_pes[P], iterations, 0);
if (target[T] != iterations) {
fprintf(stderr, "cswap ERR: PE 1 target = %d != %d\n",
target[T], iterations);
shmem_global_exit(EXIT_FAILURE);
}
}
if (verbose) {
if (me == 1)
printf("SHMEM %s finished\n", __func__);
}
}
int
main (int argc, char **argv)
{
int npes;
int me;
int *ip;
start_pes (0);
npes = shmem_n_pes ();
me = shmem_my_pe ();
/* fire off allocation */
ip = shmalloc_nb (sizeof (*ip));
printf ("PE %d / %d does some other work in the middle of shmalloc_nb\n", me, npes);
/* now wait for all PEs to be ready */
shmem_barrier_all ();
if (me == 0)
{
/* PE 0 writes number of PEs to top PE */
shmem_int_p (ip, npes, npes - 1);
}
shmem_barrier_all ();
printf ("PE %d / %d says \"ip\" = %d\n", me, npes, *ip);
shfree_nb (ip);
printf ("PE %d / %d does some other work in the middle of shfree_nb\n", me, npes);
return 0;
}
/*
* from a given PE, I want to update index "idx", which might be
* stored somewhere else
*/
void
table_update (int nv, int idx)
{
const int q = OWNER (idx); /* PE that owns this index */
const int off = OFFSET (idx); /* local table offset */
shmem_set_lock (& lock[idx]);
shmem_int_p (& table[off], nv, q);
shmem_clear_lock (& lock[idx]);
}
static inline void putfence(int me, int iterations, int T)
{
int i;
if (me == 1)
pre_op_check(__func__, target[T], iterations, 1);
if (me == 0) {
for (i = 1; i < iterations; i++) {
shmem_int_p(&target[T], i, 1);
shmem_fence();
}
shmem_int_p(&target[T], i, 1);
} else
wait_until(&target[T], iterations, 1);
if (verbose)
if (me == 0)
printf("SHMEM %s finished\n", __func__);
}
static inline void swaptest(int me, int iterations, int T, int S, int P)
{
int i;
const int tswap = 5, sswap = 2;
target[T] = tswap;
source[S] = sswap;
shmem_barrier_all(); /* Ensure target/source initialization completed */
if (me == 0)
pre_op_check(__func__, source[S], iterations, 0);
if (me == 0) {
for (i = 0; i < iterations; i++)
source[S] = shmem_int_swap(&target[T], source[S], 1);
shmem_int_p(&sync_pes[P], i, 1);
if (debug)
printf("AFTER flag PE 0 value of source is %d"
" = 5?\n", source[S]);
if (((iterations % 2 == 1) && (source[S] != tswap)) ||
((iterations % 2 == 0) &&
(source[S] != sswap))) {
fprintf(stderr, "swap ERR: PE 0 source = %d\n",
source[S]);
shmem_global_exit(EXIT_FAILURE);
}
} else {
wait_until(&sync_pes[P], iterations, 1);
if (((iterations % 2 == 1) && (target[T] != sswap)) ||
((iterations % 2 == 0) &&
(target[T] != tswap))) {
fprintf(stderr, "swap ERR: PE 0 target = %d \n",
target[T]);
shmem_global_exit(EXIT_FAILURE);
}
}
if (verbose) {
if (me == 0)
printf("SHMEM %s finished\n", __func__);
}
}
static void wait_for_completion(int *wait_variable, int pe, int *rc)
{
pthread_t wait_check_thread;
wait_check_data_t wait_data;
shmem_fence();
*wait_variable = 0;
shmem_barrier_all();
shmem_int_p(wait_variable,1, pe );
wait_data.wait_item = wait_variable;
wait_data.wait_value = 0;
wait_data.rc = rc;
pthread_create(&wait_check_thread,NULL, &check_for_wait, (void *) &wait_data);
shmem_int_wait(wait_variable,0);
if (*rc == TC_PASS)
pthread_cancel(wait_check_thread);
}
int main(void)
{
int i, me, npes;
for (i = 0; i < _SHMEM_BARRIER_SYNC_SIZE; i += 1){
pSync[i] = _SHMEM_SYNC_VALUE;
}
start_pes(0);
me = _my_pe();
npes = _num_pes();
if(me % 2 == 0){
x = 1000 + me;
/*put to next even PE in a circular fashion*/
shmem_int_p(&x, 4, (me+2)%npes);
/*synchronize all even pes*/
shmem_barrier(0, 1, (npes/2 + npes%2), pSync);
}
printf("%d: x = %d\n", me, x);
return 0;
}
int
main()
{
int me;
int i;
for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i += 1) {
pSync[i] = SHMEM_SYNC_VALUE;
}
shmem_init();
me = shmem_my_pe();
shmem_barrier_all();
if (me == 0) {
shmem_int_p(&x, 4, 1);
}
if (me == 2) {
printf("Process %d going to sleep\n", me);
sleep(3);
printf("Process %d out from sleep\n", me);
}
printf("Process %d before barrier\n", me);
if (me == 2 || me == 3) {
shmem_barrier(2, 0, 2, pSync);
}
printf("Process %d after barrier\n", me);
printf("%d: x = %d\n", me, x);
shmem_finalize();
return 0;
}
int main(int argc, char *argv[])
{
int size, rank, world_rank, my_group;
int num_lsms; // number of parallel LSMS instances
int size_lsms; // number of atoms in a lsms instance
int num_steps; // number of energy calculations
int initial_steps; // number of steps before sampling starts
int stepCount=0; // count the Monte Carlo steps executed
double max_time; // maximum walltime for this run in seconds
bool restrict_time = false; // was the maximum time specified?
bool restrict_steps = false; // or the max. numer of steps?
int align; // alignment of lsms_instances
double magnetization;
double energy_accumulator; // accumulates the enegy to calculate the mean
int energies_accumulated;
int new_peid,new_root;
static int op,flag;
double *evec,*r_values;
evec=(double *)shmalloc(sizeof(double)*3*size_lsms);
r_values=(double *)shmalloc(sizeof(double)*(R_VALUE_OFFSET+3*(size_lsms+1)));
energy_accumulator=0.0;
energies_accumulated=0;
double walltime_0,walltime;
double restartWriteFrequency=30.0*60.0;
double nextWriteTime=restartWriteFrequency;
MPI_Comm local_comm;
int *lsms_rank0;
MPI_Status status;
char prefix[40];
char i_lsms_name[64];
char gWL_in_name[64], gWL_out_name[64];
char mode_name[64];
char energy_calculation_name[64];
char stupid[37];
char step_out_name[64];
char wl_step_out_name[128];
char *wl_stepf=NULL;
bool step_out_flag=false;
std::ofstream step_out_file;
typedef enum {Constant, Random, WangLandau_1d, ExhaustiveIsing, WangLandau_2d} EvecGenerationMode;
typedef enum {MagneticMoment, MagneticMomentZ, MagneticMomentX, MagneticMomentY} SecondDimension;
EvecGenerationMode evec_generation_mode = Constant;
SecondDimension second_dimension = MagneticMoment;
double ev0[3];
bool return_moments_flag=true; // true-> return all magnetic moments from lsms run at each step.
bool generator_needs_moment=false;
typedef enum {OneStepEnergy, MultiStepEnergy, ScfEnergy} EnergyCalculationMode;
EnergyCalculationMode energyCalculationMode = OneStepEnergy;
int energyIndex=1; // index for the return value to use for the MC step (0: total energy, 1: band energy)
ev0[0]=ev0[1]=0.0; ev0[2]=1.0;
// size has to be align + size_lsms*num_lsms
align=1;
num_lsms=1;
size_lsms=-1;
my_group=-1;
num_steps=1;
initial_steps=0;
sprintf(i_lsms_name,"i_lsms");
gWL_in_name[0]=gWL_out_name[0]=0;
mode_name[0]=0;
energy_calculation_name[0]=0;
// check command line arguments
for(int i=0; i<argc; i++)
{
if(!strcmp("-num_lsms",argv[i])) num_lsms=atoi(argv[++i]);
if(!strcmp("-size_lsms",argv[i])) size_lsms=atoi(argv[++i]);
if(!strcmp("-align",argv[i])) align=atoi(argv[++i]);
if(!strcmp("-num_steps",argv[i])) {num_steps=atoi(argv[++i]); restrict_steps=true;}
if(!strcmp("-initial_steps",argv[i])) initial_steps=atoi(argv[++i]);
if(!strcmp("-walltime",argv[i])) {max_time=60.0*atof(argv[++i]); restrict_time=true;}
if(!strcmp("-i",argv[i])) strncpy(i_lsms_name,argv[++i],64);
if(!strcmp("-random_dir",argv[i])) {evec_generation_mode = Random;}
if(!strcmp("-step_out",argv[i]))
{strncpy(step_out_name,argv[++i],64); step_out_flag=true;
return_moments_flag=true;}
if(!strcmp("-wl_out", argv[i])) strncpy(gWL_out_name,argv[++i],64);
if(!strcmp("-wl_in", argv[i])) strncpy(gWL_in_name,argv[++i],64);
if(!strcmp("-mode", argv[i])) strncpy(mode_name,argv[++i],64);
if(!strcmp("-energy_calculation",argv[i])) strncpy(energy_calculation_name,argv[++i],64);
}
if(!(restrict_steps || restrict_time)) restrict_steps=true;
if(mode_name[0]!=0)
{
if(!strcmp("constant",mode_name)) evec_generation_mode = Constant;
if(!strcmp("random",mode_name)) evec_generation_mode = Random;
if(!strcmp("1d",mode_name)) evec_generation_mode = WangLandau_1d;
if(!strcmp("ising",mode_name)) evec_generation_mode = ExhaustiveIsing;
if(!strcmp("2d",mode_name)) evec_generation_mode = WangLandau_2d;
if(!strcmp("2d-m",mode_name)) {evec_generation_mode = WangLandau_2d; second_dimension=MagneticMoment;}
if(!strcmp("2d-x",mode_name)) {evec_generation_mode = WangLandau_2d; second_dimension=MagneticMomentX;}
if(!strcmp("2d-y",mode_name)) {evec_generation_mode = WangLandau_2d; second_dimension=MagneticMomentY;}
if(!strcmp("2d-z",mode_name)) {evec_generation_mode = WangLandau_2d; second_dimension=MagneticMomentZ;}
}
if(energy_calculation_name[0]!=0)
{
if(energy_calculation_name[0]=='o') { energyCalculationMode = OneStepEnergy; energyIndex=1; }
if(energy_calculation_name[0]=='m') { energyCalculationMode = MultiStepEnergy; energyIndex=1; }
if(energy_calculation_name[0]=='s') { energyCalculationMode = ScfEnergy; energyIndex=0; }
}
#ifdef USE_PAPI
#define NUM_PAPI_EVENTS 4
int hw_counters = PAPI_num_counters();
if(hw_counters>NUM_PAPI_EVENTS) hw_counters=NUM_PAPI_EVENTS;
int papi_events[NUM_PAPI_EVENTS]; // = {PAPI_TOT_INS,PAPI_TOT_CYC,PAPI_FP_OPS,PAPI_VEC_INS};
char *papi_event_name[] = {"PAPI_TOT_INS","PAPI_FP_OPS",
"RETIRED_SSE_OPERATIONS:DOUBLE_ADD_SUB_OPS:DOUBLE_MUL_OPS:DOUBLE_DIV_OPS:OP_TYPE",
"RETIRED_SSE_OPERATIONS:SINGLE_ADD_SUB_OPS:SINGLE_MUL_OPS:SINGLE_DIV_OPS:OP_TYPE"};
// "RETIRED_INSTRUCTIONS",
// "RETIRED_MMX_AND_FP_INSTRUCTIONS:PACKED_SSE_AND_SSE2",
// "RETIRED_SSE_OPERATIONS:DOUBLE_ADD_SUB_OPS:DOUBLE_MUL_OPS:DOUBLE_DIV_OPS:1",
// "RETIRED_SSE_OPERATIONS:SINGLE_ADD_SUB_OPS:SINGLE_MUL_OPS:SINGLE_DIV_OPS:1"
// get events from names:
for(int i=0; i<NUM_PAPI_EVENTS; i++)
{
if(PAPI_event_name_to_code(papi_event_name[i],&papi_events[i]) != PAPI_OK)
{
// printline("Error in obtaining PAPI event code for: "+ttos(papi_event_name[i]),
// std::cerr,parameters.myrankWorld);
// printline("Skipping all following events",
// std::cerr,parameters.myrankWorld);
if(hw_counters>i) hw_counters=i;
}
}
long long papi_values[NUM_PAPI_EVENTS+4];
// printline("PAPI: "+ttos(hw_counters)+" counters available",std::cout,parameters.myrankWorld);
if(hw_counters>NUM_PAPI_EVENTS) hw_counters=NUM_PAPI_EVENTS;
long long papi_real_cyc_0 = PAPI_get_real_cyc();
long long papi_real_usec_0 = PAPI_get_real_usec();
long long papi_virt_cyc_0 = PAPI_get_virt_cyc();
long long papi_virt_usec_0 = PAPI_get_virt_usec();
PAPI_start_counters(papi_events,hw_counters);
#endif
lsms_rank0=(int *)malloc(sizeof(int)*(num_lsms+1));
// initialize MPI:
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
world_rank=rank;
MPI_Comm_size(MPI_COMM_WORLD, &size);
walltime_0 = get_rtc();
#ifndef SVN_REV
#define SVN_REV "unknown"
#endif
// make sure 'return_moments_flag' is set correctly
switch(evec_generation_mode)
{
case Constant : break;
case Random : break;
case WangLandau_1d :
return_moments_flag = true;
generator_needs_moment = true;
break;
case ExhaustiveIsing : break;
case WangLandau_2d :
return_moments_flag = true;
generator_needs_moment = true;
break;
default: std::cout<<" ERROR: UNKNOWN EVEC GENERATION MODE\n"; exit(1);
}
if(rank==0)
{
std::cout<<"LSMS_3"<<std::endl;
std::cout<<" SVN revision "<<SVN_REV<<std::endl<<std::endl;
#ifdef USE_PAPI
std::cout<<" Using Papi counters"<<std::endl<<std::endl;
#endif
std::cout<<" Size of LSMS instances = "<<size_lsms<<" atoms\n";
std::cout<<" Number of LSMS instances = "<<num_lsms<<std::endl;
std::cout<<" LSMS Energy calculated using ";
switch(energyCalculationMode)
{
case OneStepEnergy: std::cout<<"oneStepEnergy [frozen potential band energy]"<<std::endl; break;
case MultiStepEnergy: std::cout<<"multiStepEnergy [frozen potential band energy with converged Fermi energy]"<<std::endl; break;
case ScfEnergy: std::cout<<"scfEnergy [self-consistent total energy]"<<std::endl; break;
default: std::cout<<"UNKNOWN ENERGY CALCULATION METHOD"<<std::endl; exit(1);
}
if(restrict_steps) std::cout<<" Number of gWL steps = "<<num_steps<<std::endl;
if(restrict_time) std::cout<<" Maximum walltime = "<<max_time<<"s\n";
std::cout<<" Processor alignment (process allocation quantization) = "<<align<<std::endl;
switch(evec_generation_mode)
{
case Constant : std::cout<<" Constant moments direction along "
<<ev0[0]<<" "<<ev0[1]<<" "<<ev0[2]<<std::endl;
break;
case Random : std::cout<<" Random distribution of moments (no Wang-Landau)"<<std::endl;
break;
case WangLandau_1d : std::cout<<" Wang-Landau for one continuous variable (energy)"<<std::endl;
// return_moments_flag = true;
// generator_needs_moment = true;
break;
case ExhaustiveIsing : std::cout<<" Exhaustive Ising sampling"<<std::endl; break;
case WangLandau_2d : std::cout<<" Wang-Landau for two continuous variable (energy, ";
switch(second_dimension)
{
case MagneticMoment : std::cout<<"magnitude of magnetization)"; break;
case MagneticMomentX : std::cout<<"x component of magnetization)"; break;
case MagneticMomentY : std::cout<<"y component of magnetization)"; break;
case MagneticMomentZ : std::cout<<"z component of magnetization)"; break;
}
std::cout<<std::endl;
// return_moments_flag = true;
// generator_needs_moment = true;
break;
default: std::cout<<" ERROR: UNKNOWN EVEC GENERATION MODE\n"; exit(1);
}
if(step_out_flag) std::cout<<" Step output written to: "<<step_out_name<<std::endl;
std::cout<<std::endl;
if(step_out_flag && (evec_generation_mode==WangLandau_1d))
{
// step_out_flag=false;
snprintf(wl_step_out_name,127,"wl1d_%s",step_out_name);
wl_stepf=wl_step_out_name;
}
if(step_out_flag)
{
step_out_file.open(step_out_name);
step_out_file<<"#";
for(int i=0; i<argc; i++) step_out_file<<" "<<argv[i];
step_out_file<<std::endl<<size_lsms<<std::endl;
}
}
if(generator_needs_moment) return_moments_flag=true;
if(num_lsms==1)
{
SHMEM_activeset local_comm;
local_comm.rank=shmem_my_pe();
local_comm.size=shmem_n_pes();
local_comm.start_pe=0;
local_comm.logPE_stride=0;
LSMS lsms_calc(local_comm,i_lsms_name,"1_");
if(rank==0)
{
std::cout<<"executing LSMS(C++) for "<<lsms_calc.numSpins()<<" atoms\n";
std::cout<<" LSMS version = "<<lsms_calc.version()<<std::endl;
}
if(energyCalculationMode==OneStepEnergy)
std::cout<<"one step Energy = "<<lsms_calc.oneStepEnergy()<<std::endl;
else if(energyCalculationMode==MultiStepEnergy)
std::cout<<"multi-step Energy = "<<lsms_calc.multiStepEnergy()<<std::endl;
else if(energyCalculationMode==ScfEnergy)
std::cout<<"self-consistent Energy = "<<lsms_calc.scfEnergy()<<std::endl;
else
{
printf("ERROR: Unknown energy calculation mode for lsms_calc in wl-lsms main!\n");
// MPI_Abort(MPI_COMM_WORLD,5);
exit(5);
}
}
else
{
// build the communicators
//int color=MPI_UNDEFINED;
//Assuming user passes a power of two while using "-align"
int s = align;
int comm_size=(size-align)/num_lsms;
int world_rank;
for(int i=0; i<num_lsms; i++)
{
if((world_rank>=s) && (world_rank<s+comm_size))
{
my_group=i;
//color=i;
new_peid=world_rank-s;
new_root=s;
}
lsms_rank0[i]=s;
s+=comm_size;
}
if(world_rank==0){
//color=num_lsms;
new_peid=0;
comm_size=1;
new_root=0;
}
//MPI_Comm_split(MPI_COMM_WORLD, color, 0, &local_comm);
SHMEM_activeset local_comm;
local_comm.rank=new_peid;
local_comm.size=comm_size;
local_comm.start_pe=new_root;
local_comm.logPE_stride=0;
std::cout<<"world_rank="<<world_rank<<" -> group="<<my_group<<std::endl;
snprintf(prefix,38,"Group %4d: ",my_group);
// now we get ready to do some calculations...
if(my_group>=0)
{
double energy;
double band_energy;
int static i_values[10];
double static r_values[10];
static int op;
//MPI_Comm_rank(local_comm, &rank);
rank = local_comm.rank;
snprintf(prefix,38,"%d_",my_group);
// to use the ramdisk on jaguarpf:
// snprintf(prefix,38,"/tmp/ompi/%d_",my_group);
LSMS lsms_calc(local_comm,i_lsms_name,prefix);
snprintf(prefix,38,"Group %4d: ",my_group);
if(rank==0 && my_group==0)
{
std::cout<<prefix<<"executing LSMS(C++) for "<<lsms_calc.numSpins()<<" atoms\n";
std::cout<<prefix<<" LSMS version = "<<lsms_calc.version()<<std::endl;
}
// wait for commands from master
bool finished=false;
while(!finished)
{
if(rank==0)
{
//MPI_Recv(evec,3*size_lsms,MPI_DOUBLE,0,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
//op =status.MPI_TAG;
if (lsms_rank0[0]==world_rank)
shmem_barrier(0, lsms_rank0[0], 2, pSync1);
}
//MPI_Bcast(&op,1,MPI_INT,0,local_comm);
shmem_broadcast32(&op, &op, 1, local_comm.start_pe, local_comm.start_pe, local_comm.logPE_stride, local_comm.size, pSync2);
/* recognized opcodes:
5: calculate energy
recognized energy calculation modes:
OneStepEnergy : calclulate frozen potential band energy in one step (don't converge Ef)
use only if the Fermi energy will not change due to MC steps!
The only method available in LSMS_1.9
MultiStepEnergy : calculate frozen potential band energy after converging Fermi energy
This should be the new default method. If the Fermi energy doesn't change
multiStepEnergy only performs one step and should be equivalent to oneStepEnergy
The tolerance for Ef convergence can be set with LSMS::setEfTol(Real).
The default tolerance is set in the LSMS::LSMS constructor (currently 1.0e-6).
The maximum number of steps is read from the LSMS input file 'nscf' parameter.
ScfEnergy : this will calculate the selfconsistent total energy.
The maximum number of steps is read from the LSMS input file 'nscf' parameter.
NOT IMPLEMENTED YET!!!
10: get number of sites
*/
if(op==5)
{
lsms_calc.setEvec(evec);
if(energyCalculationMode==OneStepEnergy)
energy=lsms_calc.oneStepEnergy(&band_energy);
else if(energyCalculationMode==MultiStepEnergy)
band_energy=energy=lsms_calc.multiStepEnergy();
else if(energyCalculationMode==ScfEnergy)
energy=lsms_calc.scfEnergy(&band_energy);
else
{
printf("ERROR: Unknown energy calculation mode for lsms_calc in wl-lsms main!\n");
//MPI_Abort(MPI_COMM_WORLD,5);
exit(5);
}
r_values[0]=energy;
r_values[1]=band_energy;
if(return_moments_flag)
{
lsms_calc.getMag(&r_values[R_VALUE_OFFSET]);
}
if(rank==0)
{
if(return_moments_flag)
{
//MPI_Send(r_values,R_VALUE_OFFSET+3*size_lsms,MPI_DOUBLE,0,1005,MPI_COMM_WORLD);
shmem_double_put(r_values, r_values, R_VALUE_OFFSET+3*size_lsms, 0);
} else {
//MPI_Send(r_values,R_VALUE_OFFSET,MPI_DOUBLE,0,1005,MPI_COMM_WORLD);
shmem_double_put(r_values, r_values, R_VALUE_OFFSET, 0);
}
shmem_fence();
shmem_int_swap(&flag, world_rank, 0);
}
} else if(op==10) {
i_values[0]=lsms_calc.numSpins();
//MPI_Send(i_values,10,MPI_INT,0,1010,MPI_COMM_WORLD);
shmem_int_put(i_values, i_values, 10, 0);
} else {
// printf("world rank %d: recieved exit\n",world_rank);
finished=true;
}
}
shfree(evec);
//shfree(r_values);
}
else if(world_rank==0)
{
int running;
double **evecs;
//double *r_values;
//int i_values[10];
int *init_steps;
int total_init_steps;
bool accepted;
char *wl_inf=NULL;
char *wl_outf=NULL;
if(gWL_in_name) wl_inf=gWL_in_name;
if(gWL_out_name) wl_outf=gWL_out_name;
EvecGenerator *generator;
/*
// get number of spins from first LSMS instance
// temp r_values:
r_values=(double *)malloc(sizeof(double)*10);
MPI_Send(r_values,1,MPI_DOUBLE, lsms_rank0[0], 10, MPI_COMM_WORLD);
free(r_values);
MPI_Recv(i_values,10,MPI_INT,lsms_rank0[0],1010,MPI_COMM_WORLD,&status);
if(i_values[0]!=size_lsms)
{
printf("Size specified for Wang-Landau and in LSMS input file don't match!\n");
size_lsms=i_values[0];
}
*/
evecs=(double **)shmalloc(sizeof(double *)*num_lsms);
init_steps=(int *)shmalloc(sizeof(int)*num_lsms);
for(int i=0; i<num_lsms; i++)
{
evecs[i]=(double *)shmalloc(sizeof(double)*3*size_lsms);
init_steps[i]=initial_steps;
}
total_init_steps=num_lsms*initial_steps;
// Initialize the correct evec generator
switch(evec_generation_mode)
{
case Random : generator = new RandomEvecGenerator(size_lsms);
break;
case Constant: generator = new ConstantEvecGenerator(size_lsms, ev0, num_lsms);
break;
//case WangLandau_1d : generator = new WL1dEvecGenerator<std::mt19937>(size_lsms, num_lsms,
// evecs, wl_inf, wl_outf, wl_stepf);
case WangLandau_1d : generator = new WL1dEvecGenerator<boost::mt19937>(size_lsms, num_lsms,
evecs, wl_inf, wl_outf, wl_stepf);
break;
case ExhaustiveIsing : generator = new ExhaustiveIsing1dEvecGenerator(size_lsms, num_lsms,
evecs, wl_inf, wl_outf);
break;
//case WangLandau_2d : generator = new WL2dEvecGenerator<std::mt19937>(size_lsms, num_lsms,
// evecs, wl_inf, wl_outf, wl_stepf);
case WangLandau_2d : generator = new WL2dEvecGenerator<boost::mt19937>(size_lsms, num_lsms,
evecs, wl_inf, wl_outf, wl_stepf);
break;
default: std::cerr<<"The code should never arrive here: UNKNOWN EVEC GENERATION MODE\n";
exit(1);
}
for(int i=0; i<num_lsms; i++)
{
generator->initializeEvec(i,evecs[i]);
}
std::cout<<"This is the master node\n";
// issue initial commands to all LSMS instances
running=0;
bool more_work=true;
if(total_init_steps>0)
{
for(int i=0; i<num_lsms; i++)
{
std::cout<<"starting initial calculation in group "<<i<<std::endl;
//MPI_Send(evecs[i], 3*size_lsms, MPI_DOUBLE, lsms_rank0[i], 5, MPI_COMM_WORLD);
shmem_double_put(evec, evecs[i], 3*size_lsms, lsms_rank0[i]);
shmem_int_p(&op, 5, lsms_rank0[i]);
shmem_fence();
num_steps--; running++; stepCount++;
if(restrict_steps) std::cout<<" "<<num_steps<<" steps remaining\n";
}
shmem_barrier(0, lsms_rank0[0], 2, pSync1);
// first deal with the initial steps:
while(running>0)
{
//if(return_moments_flag)
// MPI_Recv(r_values,R_VALUE_OFFSET+3*size_lsms,MPI_DOUBLE,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
//else
// MPI_Recv(r_values,R_VALUE_OFFSET,MPI_DOUBLE,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
shmem_int_wait(&flag,-1);
running--;
// std::cout<<"received energy E_tot ="<<r_values[0]<<std::endl;
// std::cout<<" band energy E_band="<<r_values[1]<<std::endl;
if(total_init_steps>0)
{
//int r_group=(status.MPI_SOURCE-align)/comm_size;
int r_group=(flag-align)/comm_size;
std::cout<<"starting additional calculation in group "<<r_group<<std::endl;
if(init_steps[r_group]>0)
{
more_work = !(generator->generateUnsampledEvec(r_group,evecs[r_group],r_values[energyIndex]));
init_steps[r_group]--; total_init_steps--;
}
//MPI_Send(evecs[r_group], 3*size_lsms, MPI_DOUBLE, lsms_rank0[r_group], 5, MPI_COMM_WORLD);
shmem_double_put(r_values, evecs[r_group], 3*size_lsms, lsms_rank0[r_group]); //TODO check this
shmem_fence();
num_steps--; running++; stepCount++;
if(restrict_steps && num_steps<=0) more_work=false;
if(restrict_steps) std::cout<<" "<<num_steps<<" steps remaining\n";
walltime = get_rtc() - walltime_0;
if(restrict_time && walltime>=max_time) more_work=false;
if(restrict_time) std::cout<<" "<<max_time-walltime<<" seconds remaining\n";
}
}
}
more_work=true;
running=0;
for(int i=0; i<num_lsms; i++)
{
std::cout<<"starting main calculation in group "<<i<<std::endl;
//MPI_Send(evecs[i], 3*size_lsms, MPI_DOUBLE, lsms_rank0[i], 5, MPI_COMM_WORLD);
shmem_double_put(evec, evecs[i], 3*size_lsms, lsms_rank0[i]);
shmem_int_p(&op, 5, lsms_rank0[i]);
shmem_fence();
num_steps--; running++; stepCount++;
if(restrict_steps) std::cout<<" "<<num_steps<<" steps remaining\n";
}
shmem_barrier(0, lsms_rank0[0], 2, pSync1);
generator->startSampling();
// wait for results and issue new commands or wind down
while(running>0)
{
//MPI_Recv(r_values,R_VALUE_OFFSET+3*size_lsms,MPI_DOUBLE,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
shmem_int_wait(&flag,-1);
running--;
std::cout<<"received energy E_tot ="<<r_values[0]<<std::endl;
std::cout<<" band energy E_band="<<r_values[1]<<std::endl;
// printf("from status.MPI_SOURCE=%d\n",status.MPI_SOURCE);
energy_accumulator+=r_values[0]; energies_accumulated++;
if(more_work)
{
int r_group=(status.MPI_SOURCE-align)/comm_size;
std::cout<<"starting additional calculation in group "<<r_group<<std::endl;
if(generator_needs_moment)
{
double m0,m1,m2;
m0=0.0; m1=0.0; m2=0.0;
for(int i=0; i<3*size_lsms; i+=3)
{
m0+=r_values[R_VALUE_OFFSET+i];
m1+=r_values[R_VALUE_OFFSET+i+1];
m2+=r_values[R_VALUE_OFFSET+i+2];
}
switch(second_dimension)
{
case MagneticMoment : magnetization=std::sqrt(m0*m0+m1*m1+m2*m2); break;
case MagneticMomentX : magnetization=m0; break;
case MagneticMomentY : magnetization=m1; break;
case MagneticMomentZ : magnetization=m2; break;
}
if(generator->generateEvec(r_group,evecs[r_group],r_values[energyIndex],magnetization, &accepted))
more_work=false;
} else {
if(generator->generateEvec(r_group,evecs[r_group],r_values[energyIndex], &accepted)) more_work=false;
}
//MPI_Send(evecs[r_group], 3*size_lsms, MPI_DOUBLE, lsms_rank0[r_group], 5, MPI_COMM_WORLD);
shmem_double_put(r_values, evecs[r_group], 3*size_lsms, lsms_rank0[r_group]); //TODO check this
shmem_fence();
num_steps--; running++; stepCount++;
if(restrict_steps && num_steps<=0) more_work=false;
if(restrict_steps) std::cout<<" "<<num_steps<<" steps remaining\n";
walltime = get_rtc() - walltime_0;
if(restrict_time && walltime>=max_time) more_work=false;
if(restrict_time) std::cout<<" "<<max_time-walltime<<" seconds remaining\n";
}
else
{
// send an exit message to this instance of LSMS
int r_group=(status.MPI_SOURCE-align)/comm_size;
MPI_Send(evecs[r_group], 3*size_lsms, MPI_DOUBLE, lsms_rank0[r_group], 2, MPI_COMM_WORLD);
}
if(step_out_flag && accepted)
{
step_out_file<<"# iteration "<<energies_accumulated<<std::endl;
step_out_file.precision(15);
step_out_file<<energies_accumulated<<std::endl;
step_out_file<<r_values[0]<<" "<<r_values[1]<<std::endl;
for(int j=0; j<3*size_lsms; j+=3)
{
step_out_file<<r_values[j+R_VALUE_OFFSET]<<" "<<r_values[j+R_VALUE_OFFSET+1]
<<" "<<r_values[j+R_VALUE_OFFSET+2]<<std::endl;
}
}
// write restart file every restartWriteFrequency seconds
if(walltime>nextWriteTime)
{
generator->writeState("WLrestart.jsn");
nextWriteTime+=restartWriteFrequency;
}
}
generator->writeState("WLrestart.jsn");
/*
if(evec_generation_mode==WangLandau_1d)
(static_cast<WL1dEvecGenerator<std::mt19937> *>(generator))->writeState("WLrestart.state");
if(evec_generation_mode==ExhaustiveIsing)
(static_cast<ExhaustiveIsing1dEvecGenerator *>(generator))->writeState("WLrestart.state");
*/
for(int i=0; i<num_lsms; i++) free(evecs[i]);
shfree(evecs);
//shfree(r_values);
}
}
if(world_rank==0)
{
if(step_out_flag)
{
step_out_file<<"# end\n-1\n"
<<energy_accumulator/double(energies_accumulated)<<std::endl;
step_out_file.close();
}
std::cout<<"Finished all scheduled calculations. Freeing resources.\n";
std::cout<<"Energy mean = "<<energy_accumulator/double(energies_accumulated)<<"Ry\n";
}
if(num_lsms>1)
{
// make sure averyone arrives here:
MPI_Bcast(stupid,37,MPI_CHAR,0,MPI_COMM_WORLD);
if(world_rank==0)
{
MPI_Comm_free(&local_comm);
}
else if(my_group>=0)
{
MPI_Comm_free(&local_comm);
}
}
if(world_rank==0)
{
double walltime = get_rtc() - walltime_0;
std::cout<<" WL-LSMS finished in "<<walltime<<" seconds.\n";
std::cout<<" Monte-Carlo steps / walltime = "
<<double(stepCount)/walltime<<"/sec\n";
}
#ifdef USE_PAPI
PAPI_stop_counters(papi_values,hw_counters);
papi_values[hw_counters ] = PAPI_get_real_cyc()-papi_real_cyc_0;
papi_values[hw_counters+1] = PAPI_get_real_usec()-papi_real_usec_0;
papi_values[hw_counters+2] = PAPI_get_virt_cyc()-papi_virt_cyc_0;
papi_values[hw_counters+3] = PAPI_get_virt_usec()-papi_virt_usec_0;
long long accumulated_counters[NUM_PAPI_EVENTS+4];
/*
for(int i=0; i<hw_counters; i++)
{
printline(ttos(papi_event_name[i])+" = "+ttos(papi_values[i]),
std::cout,parameters.myrankWorld);
}
printline("PAPI real cycles : "+ttos(papi_values[hw_counters]),
std::cout,parameters.myrankWorld);
printline("PAPI real usecs : "+ttos(papi_values[hw_counters+1]),
std::cout,parameters.myrankWorld);
printline("PAPI user cycles : "+ttos(papi_values[hw_counters+2]),
std::cout,parameters.myrankWorld);
printline("PAPI user usecs : "+ttos(papi_values[hw_counters+3]),
std::cout,parameters.myrankWorld);
*/
//MPI_Reduce(papi_values,accumulated_counters,hw_counters+4,
// MPI_LONG,MPI_SUM,0,MPI_COMM_WORLD);
shmem_long_sum_to_all(accumulated_counters, papi_values, hw_counters+4,
comm.pestart, comm.logPE_stride, comm.size, pWrk_i, pSync2);
if(world_rank==0)
{
for(int i=0; i<hw_counters; i++)
{
std::cout<<"Accumulated: "<<(papi_event_name[i])<<" = "<<(accumulated_counters[i])<<"\n";
}
std::cout<<"PAPI accumulated real cycles : "<<(accumulated_counters[hw_counters])<<"\n";
std::cout<<"PAPI accumulated user cycles : "<<(accumulated_counters[hw_counters+2])<<"\n";
double gflops_papi = ((double)accumulated_counters[1])/
(1000.0*(double)papi_values[hw_counters+1]);
double gflops_hw_double = ((double)accumulated_counters[2])/
(1000.0*(double)papi_values[hw_counters+1]);
double gflops_hw_single = ((double)accumulated_counters[3])/
(1000.0*(double)papi_values[hw_counters+1]);
double gips = ((double)accumulated_counters[0])/(1000.0*(double)papi_values[hw_counters+1]);
std::cout<<"PAPI_FP_OPS real GFLOP/s : "<<(gflops_papi)<<"\n";
std::cout<<"PAPI hw double real GFLOP/s : "<<(gflops_hw_double)<<"\n";
std::cout<<"PAPI hw single real GFLOP/s : "<<(gflops_hw_single)<<"\n";
std::cout<<"PAPI real GINST/s : "<<(gips)<<"\n";
}
#endif
//MPI_Finalize();
return 0;
}
int
main (int argc, char **argv)
{
int i;
int nextpe;
int me, npes;
int success1, success2, success3, success4, success5, success6, success7,
success8;
short src1[N];
int src2[N];
long src3[N];
long double src4[N];
long long src5[N];
double src6[N];
float src7[N];
char *src8;
short src9;
int src10;
long src11;
double src12;
float src13;
short *dest1;
int *dest2;
long *dest3;
long double *dest4;
long long *dest5;
double *dest6;
float *dest7;
char *dest8;
short *dest9;
int *dest10;
long *dest11;
double *dest12;
float *dest13;
shmem_init ();
me = shmem_my_pe ();
npes = shmem_n_pes ();
if (npes > 1) {
success1 = 0;
success2 = 0;
success3 = 0;
success4 = 0;
success5 = 0;
success6 = 0;
success7 = 0;
success8 = 0;
src8 = (char *) malloc (N * sizeof (char));
for (i = 0; i < N; i += 1) {
src1[i] = (short) me;
src2[i] = me;
src3[i] = (long) me;
src4[i] = (long double) me;
src5[i] = (long long) me;
src6[i] = (double) me;
src7[i] = (float) me;
src8[i] = (char) me;
}
src9 = (short) me;
src10 = me;
src11 = (long) me;
src12 = (double) me;
src13 = (float) me;
dest1 = (short *) shmem_malloc (N * sizeof (*dest1));
dest2 = (int *) shmem_malloc (N * sizeof (*dest2));
dest3 = (long *) shmem_malloc (N * sizeof (*dest3));
dest4 = (long double *) shmem_malloc (N * sizeof (*dest4));
dest5 = (long long *) shmem_malloc (N * sizeof (*dest5));
dest6 = (double *) shmem_malloc (N * sizeof (*dest6));
dest7 = (float *) shmem_malloc (N * sizeof (*dest7));
dest8 = (char *) shmem_malloc (4 * sizeof (*dest8));
dest9 = (short *) shmem_malloc (sizeof (*dest9));
dest10 = (int *) shmem_malloc (sizeof (*dest10));
dest11 = (long *) shmem_malloc (sizeof (*dest11));
dest12 = (double *) shmem_malloc (sizeof (*dest12));
dest13 = (float *) shmem_malloc (sizeof (*dest13));
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
dest5[i] = -9;
dest6[i] = -9;
dest7[i] = -9.0;
dest8[i] = -9;
}
*dest9 = -9;
*dest10 = -9;
*dest11 = -9;
*dest12 = -9;
*dest13 = -9.0;
nextpe = (me + 1) % npes;
/* Testing shmem_short_put, shmem_int_put, shmem_long_put,
shmem_longdouble_put, shmem_longlong_put, shmem_double_put,
shmem_float_put, shmem_putmem */
shmem_barrier_all ();
shmem_short_put (dest1, src1, N, nextpe);
shmem_int_put (dest2, src2, N, nextpe);
shmem_long_put (dest3, src3, N, nextpe);
shmem_longdouble_put (dest4, src4, N, nextpe);
shmem_longlong_put (dest5, src5, N, nextpe);
shmem_double_put (dest6, src6, N, nextpe);
shmem_float_put (dest7, src7, N, nextpe);
shmem_putmem (dest8, src8, N * sizeof (char), nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
if (dest5[i] != (npes - 1)) {
success5 = 1;
}
if (dest6[i] != (npes - 1)) {
success6 = 1;
}
if (dest7[i] != (npes - 1)) {
success7 = 1;
}
if (dest8[i] != (npes - 1)) {
success8 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_short_put: Passed\n");
else
printf ("Test shmem_short_put: Failed\n");
if (success2 == 0)
printf ("Test shmem_int_put: Passed\n");
else
printf ("Test shmem_int_put: Failed\n");
if (success3 == 0)
printf ("Test shmem_long_put: Passed\n");
else
printf ("Test shmem_long_put: Failed\n");
if (success4 == 0)
printf ("Test shmem_longdouble_put: Passed\n");
else
printf ("Test shmem_longdouble_put: Failed\n");
if (success5 == 0)
printf ("Test shmem_longlong_put: Passed\n");
else
printf ("Test shmem_longlong_put: Failed\n");
if (success6 == 0)
printf ("Test shmem_double_put: Passed\n");
else
printf ("Test shmem_double_put: Failed\n");
if (success7 == 0)
printf ("Test shmem_float_put: Passed\n");
else
printf ("Test shmem_float_put: Failed\n");
if (success8 == 0)
printf ("Test shmem_putmem: Passed\n");
else
printf ("Test shmem_putmem: Failed\n");
}
shmem_barrier_all ();
/* Testing shmem_put32, shmem_put64, shmem_put128 */
if (sizeof (int) == 4) {
for (i = 0; i < N; i += 1) {
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
}
success2 = 0;
success3 = 0;
success4 = 0;
shmem_barrier_all ();
shmem_put32 (dest2, src2, N, nextpe);
shmem_put64 (dest3, src3, N, nextpe);
shmem_put128 (dest4, src4, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
}
if (success2 == 0)
printf ("Test shmem_put32: Passed\n");
else
printf ("Test shmem_put32: Failed\n");
if (success3 == 0)
printf ("Test shmem_put64: Passed\n");
else
printf ("Test shmem_put64: Failed\n");
if (success4 == 0)
printf ("Test shmem_put128: Passed\n");
else
printf ("Test shmem_put128: Failed\n");
}
}
else if (sizeof (int) == 8) {
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
shmem_barrier_all ();
shmem_put32 (dest1, src1, N, nextpe);
shmem_put64 (dest2, src2, N, nextpe);
shmem_put128 (dest3, src3, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_put32: Passed\n");
else
printf ("Test shmem_put32: Failed\n");
if (success2 == 0)
printf ("Test shmem_put64: Passed\n");
else
printf ("Test shmem_put64: Failed\n");
if (success3 == 0)
printf ("Test shmem_put128: Passed\n");
else
printf ("Test shmem_put128: Failed\n");
}
}
/* Testing shmem_iput32, shmem_iput64, shmem_iput128 */
shmem_barrier_all ();
if (sizeof (int) == 4) {
for (i = 0; i < N; i += 1) {
dest2[i] = -9;
dest3[i] = -9;
dest4[i] = -9;
}
success2 = 0;
success3 = 0;
success4 = 0;
shmem_barrier_all ();
shmem_iput32 (dest2, src2, 1, 2, N, nextpe);
shmem_iput64 (dest3, src3, 1, 2, N, nextpe);
shmem_iput128 (dest4, src4, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest4[i] != (npes - 1)) {
success4 = 1;
}
}
if (success2 == 0)
printf ("Test shmem_iput32: Passed\n");
else
printf ("Test shmem_iput32: Failed\n");
if (success3 == 0)
printf ("Test shmem_iput64: Passed\n");
else
printf ("Test shmem_iput64: Failed\n");
if (success4 == 0)
printf ("Test shmem_iput128: Passed\n");
else
printf ("Test shmem_iput128: Failed\n");
}
}
else if (sizeof (int) == 8) {
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
shmem_barrier_all ();
shmem_iput32 (dest1, src1, 1, 2, N, nextpe);
shmem_iput64 (dest2, src2, 1, 2, N, nextpe);
shmem_iput128 (dest3, src3, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_iput32: Passed\n");
else
printf ("Test shmem_iput32: Failed\n");
if (success2 == 0)
printf ("Test shmem_iput64: Passed\n");
else
printf ("Test shmem_iput64: Failed\n");
if (success3 == 0)
printf ("Test shmem_iput128: Passed\n");
else
printf ("Test shmem_iput128: Failed\n");
}
}
/* Testing shmem_short_iput, shmem_int_iput, shmem_long_iput,
shmem_double_iput, shmem_float_iput */
for (i = 0; i < N; i += 1) {
dest1[i] = -9;
dest2[i] = -9;
dest3[i] = -9;
dest6[i] = -9;
dest7[i] = -9;
}
success1 = 0;
success2 = 0;
success3 = 0;
success6 = 0;
success7 = 0;
shmem_barrier_all ();
shmem_short_iput (dest1, src1, 1, 2, N, nextpe);
shmem_int_iput (dest2, src2, 1, 2, N, nextpe);
shmem_long_iput (dest3, src3, 1, 2, N, nextpe);
shmem_double_iput (dest6, src6, 1, 2, N, nextpe);
shmem_float_iput (dest7, src7, 1, 2, N, nextpe);
shmem_barrier_all ();
if (me == 0) {
for (i = 0; i < N / 2; i += 1) {
if (dest1[i] != (npes - 1)) {
success1 = 1;
}
if (dest2[i] != (npes - 1)) {
success2 = 1;
}
if (dest3[i] != (npes - 1)) {
success3 = 1;
}
if (dest6[i] != (npes - 1)) {
success6 = 1;
}
if (dest7[i] != (npes - 1)) {
success7 = 1;
}
}
if (success1 == 0)
printf ("Test shmem_short_iput: Passed\n");
else
printf ("Test shmem_short_iput: Failed\n");
if (success2 == 0)
printf ("Test shmem_int_iput: Passed\n");
else
printf ("Test shmem_int_iput: Failed\n");
if (success3 == 0)
printf ("Test shmem_long_iput: Passed\n");
else
printf ("Test shmem_long_iput: Failed\n");
if (success6 == 0)
printf ("Test shmem_double_iput: Passed\n");
else
printf ("Test shmem_double_iput: Failed\n");
if (success7 == 0)
printf ("Test shmem_float_iput: Passed\n");
else
printf ("Test shmem_float_iput: Failed\n");
}
/* Testing shmem_double_p, shmem_float_p, shmem_int_p, shmem_long_p,
shmem_short_p */
shmem_barrier_all ();
shmem_short_p (dest9, src9, nextpe);
shmem_int_p (dest10, src10, nextpe);
shmem_long_p (dest11, src11, nextpe);
shmem_double_p (dest12, src12, nextpe);
shmem_float_p (dest13, src13, nextpe);
shmem_barrier_all ();
if (me == 0) {
if (*dest9 == (npes - 1))
printf ("Test shmem_short_p: Passed\n");
else
printf ("Test shmem_short_p: Failed\n");
if (*dest10 == (npes - 1))
printf ("Test shmem_int_p: Passed\n");
else
printf ("Test shmem_int_p: Failed\n");
if (*dest11 == (npes - 1))
printf ("Test shmem_long_p: Passed\n");
else
printf ("Test shmem_long_p: Failed\n");
if (*dest12 == (npes - 1))
printf ("Test shmem_double_p: Passed\n");
else
printf ("Test shmem_double_p: Failed\n");
if (*dest13 == (npes - 1))
printf ("Test shmem_float_p: Passed\n");
else
printf ("Test shmem_float_p: Failed\n");
}
shmem_barrier_all ();
shmem_free (dest1);
shmem_free (dest2);
shmem_free (dest3);
shmem_free (dest4);
shmem_free (dest5);
shmem_free (dest6);
shmem_free (dest7);
shmem_free (dest8);
shmem_free (dest9);
shmem_free (dest10);
shmem_free (dest11);
shmem_free (dest12);
shmem_free (dest13);
}
else {
printf ("Number of PEs must be > 1 to test shmem put, test skipped\n");
}
shmem_finalize ();
return 0;
}
int hyperquick(int *A, int N, int npes){
int pivot;
int i;
//the step two of algo.....broadcast the new pivot
//pivot = quicksort(A, 0, n-1);
next_pivot = A[N/2]; //the median
//shmem_barrier_all();
//printf("(%d) N= %d\n",me,N);
shmem_broadcast32(&next_pivot,&next_pivot,1,0,0,0,npes,pSync);
shmem_barrier_all();
/*printf("Process %d the pivot:%d",me, pivot);
shmem_barrier_all(); //just for the sake of clear display...can be removed in the end
printf("\nThe sorted list is of process %d: ",me);
for(i=0;i<N/npes;i++){
printf("%d, ",A[i]);
}
printf("\n");*/
printf("the new pivot of process %d: %d\n",me,next_pivot); // to check the broadcast of new pivots
int check,j; //to check the division of the sorted arrays according to the new pivot.
shmem_barrier_all();
check = uplowPartition(A, next_pivot, N*npes, npes);
shmem_barrier_all();
printf("(%d)",me);
for(int j=0;j<N;j++){
printf("%d, ",A[j]);
}
printf("new partition: %d",check);
shmem_barrier_all();
printf("\n");
if(me < npes/2){
printf("\n");
pe = me +npes/2;
nelems[0] = N - check;
printf (" process %d pe : %d nelems : %d\n",me,pe,nelems[0]);//to test the value
printf("(%d) addr = %d , value = %d , pe = %d\n ",me, &nelems_import[0],nelems[0],pe);//to test the value
shmem_int_p(nelems_import,nelems[0],pe);
shmem_quiet();
shmem_int_put(temp_arr,&A[check],nelems[0],pe);
}
shmem_barrier_all();//check if the entire barrier is needed
if(me >= npes/ 2){
pe = me-npes/2;//check if it is synced
nelems[0]= check;
printf (" process %d pe : %d nelems : %d\n",me,pe,nelems[0]);//to test the value
shmem_int_p(nelems_import,nelems[0],pe);
shmem_quiet();
shmem_int_put(temp_arr,A,nelems[0],pe);
}
shmem_barrier_all();//again sync is required...check it with profiling
//this snippet is to check if the processors have got the high and low lists respectively -------------------
printf("(%d) nelems_import = %d\n",me,nelems_import[0]);//to test the value
printf("(%d) new elements = ",me);
for(i=0;i<nelems_import[0];i++){
printf("%d, ",temp_arr[i]);
}
printf("\n");
//------------------------------------here this checking snippet ends----
//----------------------------------merging of arrays begin-------------------------
if(me < npes/2){
i=0;
for(j=nelems_import[0];j<(nelems_import[0]+check);j++){
temp_arr[j] = A[i];
i++;
}
}
if(me >= npes/2){
i=check;
for(j=nelems_import[0];j<(nelems_import[0]+N-check);j++){
temp_arr[j] = A[i];
i++;
}
}
shmem_barrier_all(); //to test if the arrays are merged properly
int size;
if(me < npes/2){
size = (nelems_import[0]+check);
printf("(%d) merged array:",me);
for(j=0;j<size;j++){
printf("%d, ",temp_arr[j]);
}
printf("\n");
}
if(me >= npes/2){
size = (nelems_import[0]+N-check);
printf("(%d) merged array:",me);
for(j=0;j<size;j++){
printf("%d, ",temp_arr[j]);
}
printf("\n");
}
//-----------------------check of merging finishes--------
//--------------------------------------------------merging finishes------------------------------
//-----------------------sort again-----------------------------------------------
if(me < npes/2){
quicksort(temp_arr,0,(nelems_import[0]+check-1));
}
if(me >= npes/2){
quicksort(temp_arr,0,(nelems_import[0]+N-check-1));
}
//sorting routine checked...once program is done we can remove this part-------------
shmem_barrier_all();//test purpose only
if(me < npes/2){
printf("(%d) sorted list: ",me);
for(i=0;i<size;i++){
printf("%d, ",temp_arr[i]);
A[i] = temp_arr[i];
}
printf("\n");
}
if(me >= npes/2){
printf("(%d) sorted list: ",me);
for(i=0;i<size;i++){
printf("%d, ",temp_arr[i]);
A[i] = temp_arr[i];
}
printf("\n");
}
//-------------------------------------------------------------
//---------------------------------------------------------------------------------
//hyperquick(A,size,npes/2);
}
int main(int argc, char *argv[]){
int i,n,next_pivot, pivot;
long pSync[_SHMEM_BCAST_SYNC_SIZE];
for (i=0; i < SHMEM_BCAST_SYNC_SIZE; i++) {
pSync[i] = _SHMEM_SYNC_VALUE;
}
start_pes(0);
me = shmem_my_pe();
npes = shmem_n_pes();
shmem_barrier_all();
srand (me+time(NULL));
N = atoi(argv[1]);
//int *nelems = (int*) shmalloc(sizeof(int));
//int *nelems_import= (int*) shmalloc(sizeof(int));;
printf("%d: Size = %d with np=%d\n",me,N,npes);
A = (int *)shmalloc((N/npes)*sizeof(int));
temp_arr = (int *)shmalloc((N/npes)*sizeof(int));
if(A==NULL){
printf("\nOut of memory");
return 1;
}
n= N/npes;
i=0;
while(i<N/npes){
A[i] = rand()%(10000-0);
i++;
}
printf("\nprocess %d elements:",me);
for(i=0;i<(N/npes);i++){
printf("%d, ", A[i]);
}
next_pivot = A[0];
//the step two of algo.....broadcast the new pivot
shmem_broadcast32(&next_pivot,A,1,0,0,0,npes,pSync);
shmem_barrier_all();
pivot = quicksort(A, 0, n-1);
printf("Process %d the pivot:%d",me, pivot);
shmem_barrier_all(); //just for the sake of clear display...can be removed in the end
printf("\nThe sorted list is of process %d: ",me);
for(i=0;i<n;i++){
printf("%d, ",A[i]);
}
printf("\n");
printf("the new pivot of process %d: %d\n",me,next_pivot); // to check the broadcast of new pivots
int check,j; //to check the division of the sorted arrays according to the new pivot.
shmem_barrier_all();
check = uplowPartition(next_pivot);
shmem_barrier_all();
printf("(%d)",me);
for(int j=0;j<N/npes;j++){
printf("%d, ",A[j]);
}
printf("new partition: %d",check);
shmem_barrier_all();
if(me < npes/2)
{
i=0;
// printf("Hello from %d", me);
printf("\n");
for(j=check;j<N/npes;j++){
temp_arr[i] = A[j];
i++;
}
i=0;
printf("(%d)",me);
for(j=check;j<N/npes;j++){
printf("%d, ",temp_arr[i]) ;
i++;
}
// printf("\n");
}
shmem_barrier_all();
if(me >= npes/2)
{
// printf("Hello from %d", me);
printf("\n");
for(j=0;j<check;j++){
temp_arr[j] = A[j];
}
printf("(%d)",me);
for(j=0;j<check;j++){
printf("%d, ",temp_arr[j]) ;
}
// printf("\n");
}
shmem_barrier_all();
printf("\n");
if(me < npes/2){
printf("\n");
pe = me +npes/2;
nelems[0] = N/npes - check;
printf (" process %d pe : %d nelems : %d\n",me,pe,nelems[0]);//to test the value
printf("(%d) addr = %d , value = %d , pe = %d\n ",me, &nelems_import[0],nelems[0],pe);//to test the value
shmem_int_p(nelems_import,nelems[0],pe);
shmem_quiet();
shmem_int_put(temp_arr,&A[check],nelems[0],pe);
}
shmem_barrier_all();//check if the entire barrier is needed
if(me >= npes/ 2){
pe = me-npes/2;//check if it is synced
nelems[0]= check;
printf (" process %d pe : %d nelems : %d\n",me,pe,nelems[0]);//to test the value
shmem_int_p(nelems_import,nelems[0],pe);
shmem_quiet();
shmem_int_put(temp_arr,A,nelems[0],pe);
}
shmem_barrier_all();//again sync is required...check it with profiling
//this snippet is to check if the processors have got the high and low lists respectively -------------------
printf("(%d) nelems_import = %d\n",me,nelems_import[0]);//to test the value
printf("(%d) new elements = ",me);
for(i=0;i<nelems_import[0];i++){
printf("%d, ",temp_arr[i]);
}
printf("\n");
//------------------------------------here this checking snippet ends----
//----------------------------------merging of arrays begin-------------------------
if(me < npes/2){
i=0;
for(j=nelems_import[0];j<(nelems_import[0]+check);j++){
temp_arr[j] = A[i];
i++;
}
}
if(me >= npes/2){
i=check;
for(j=nelems_import[0];j<(nelems_import[0]+N/npes-check);j++){
temp_arr[j] = A[i];
i++;
}
}
shmem_barrier_all(); //to test if the arrays are merged properly
int size;
if(me < npes/2){
size = (nelems_import[0]+check);
printf("(%d) merged array:",me);
for(j=0;j<size;j++){
printf("%d, ",temp_arr[j]);
}
printf("\n");
}
if(me >= npes/2){
size = (nelems_import[0]+N/npes-check);
printf("(%d) merged array:",me);
for(j=0;j<size;j++){
printf("%d, ",temp_arr[j]);
}
printf("\n");
}
//-----------------------check of merging finishes--------
//--------------------------------------------------merging finishes------------------------------
//-----------------------sort again-----------------------------------------------
if(me < npes/2){
quicksort(temp_arr,0,(nelems_import[0]+check-1));
}
if(me >= npes/2){
quicksort(temp_arr,0,(nelems_import[0]+N/npes-check-1));
}
//sorting routine checked...once program is done we can remove this part-------------
shmem_barrier_all();//test purpose only
if(me < npes/2){
printf("(%d) sorted list: ",me);
for(i=0;i<size;i++){
printf("%d, ",temp_arr[i]);
}
printf("\n");
}
if(me >= npes/2){
printf("(%d) sorted list: ",me);
for(i=0;i<size;i++){
printf("%d, ",temp_arr[i]);
}
printf("\n");
}
//-------------------------------------------------------------
//---------------------------------------------------------------------------------
shfree(temp_arr);
shfree(A);
shmem_finalize();
}
int
main(int argc, char **argv)
{
int me, npes;
struct timeval now;
long t_start, t_end;
start_pes(0);
me = _my_pe();
npes = _num_pes();
if (npes < 4) {
if (me==0)
fprintf(stderr,"ERR: test requires 4 or more PEs\n");
return 1;
}
shmem_barrier_all();
gettimeofday(&now, NULL);
t_start = (now.tv_sec * 1000000.0) + now.tv_usec;
switch (me) {
case 0:
while (pe_escape) {
double pi, pi2, pi3;
int j;
for (j=1; j <= 5000; j++) {
pi = (22.0 / 7.0) + (double) j;
pi2 = pi * (double) j;
pi3 = (pi2 * pi) / 1.2;
}
mb();
}
gettimeofday(&now, NULL);
t_end = ((now.tv_sec * 1000000.0) + now.tv_usec) - t_start;
break;
case 1:
shmem_int_inc(&A, 0);
gettimeofday(&now, NULL);
t_end = ((now.tv_sec * 1000000.0) + now.tv_usec) - t_start;
break;
case 2:
while (1 != shmem_int_g(&A, 0)) { ; }
shmem_int_inc(&A, 0);
gettimeofday(&now, NULL);
t_end = ((now.tv_sec * 1000000.0) + now.tv_usec) - t_start;
break;
case 3:
while (2 != shmem_int_g(&A, 0)) { ; }
shmem_int_p((int*) &pe_escape, 0, 0); // release PE0.
if (npes > 4) {
int i;
for(i=4; i < npes; i++)
shmem_int_p((int*)&pe_escape, 0, i); // release PE0.
}
gettimeofday(&now, NULL);
t_end = ((now.tv_sec * 1000000.0) + now.tv_usec) - t_start;
break;
default:
/* spin until released, A will never == 99, generate PE-0 traffic */
while (99 != shmem_int_g(&A, 0) && pe_escape) {
mb();
}
gettimeofday(&now, NULL);
t_end = ((now.tv_sec * 1000000.0) + now.tv_usec) - t_start;
break;
}
if (me < 4)
fprintf(stderr,"[%d] elapsed usecs %ld A %d\n",me,t_end,A);
shmem_barrier_all();
return 0;
}
