int main ()
{
//Get num proc
int num_proc = get_proc_id();
_printdecp("num proc=", num_proc);
_printdecp("size image x=",IMAGE_X);
_printdecp("size image y=",IMAGE_Y);
if(num_proc==1)
{
//Send result to output memory
outm_write_burst (MyImage, IMAGE_X, IMAGE_Y);
outm_write_file ();
}
//End
return(0);
}
void parallel_initialize(size_t nthreads)
{
envmanager_.initialize(nthreads);
std::cout << "Initialized process " << get_proc_id()
<< " of " << get_nproc() << "\n";
}
// B C S
//##############################################################################
//
// Apply boundary conditions.
//
void bcs( lattice_ptr lattice)
{
int i, j, k, n, n1, a, id;
int ni, nj, nk;
int subs;
double *ftemp, *f, *f1, *feq, *feq1, *rhoo, temp[Q];
double v, rho_in, rho_out, rho1;
double c0;
double D;
double c2;
#if RHO0_TEST
//------------------------------------------------------------------[ TEST ]----
double *rho0;
//------------------------------------------------------------------[ TEST ]----
#endif /* RHO0_TEST */
double u_x, u_y, u_z, usq,udotx;
double u_in[2][2],
u_out[2][2],
u,
rho,
hua;
double c;
ni = lattice->param.LX;
nj = lattice->param.LY;
nk = lattice->param.LZ;
id = get_proc_id(lattice);
// for( subs=0; subs<(NUM_FLUID_COMPONENTS)-(INAMURO_SIGMA_COMPONENT); subs++)
for( subs=0; subs<NUM_FLUID_COMPONENTS; subs++)
{
// P R E S S U R E T O P I N F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// pressure top inflow
// -- Pressure boundary on top side using inflow pressure condition.
if( (id ==(get_num_procs(lattice)-1))
&& !lattice->param.GZL
&& lattice->param.pressure_t_in[subs] )
{
k = nk-1;
switch(NUM_FLUID_COMPONENTS)
{
case 1:
{ rho_in = lattice->param.rho_in; break;}
case 2:
{
if(subs==0) { rho_in = lattice->param.rho_in;}
if(subs==1) { rho_in = lattice->param.rho_A[subs];}
break;
}
}
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
ftemp = lattice->pdf[subs][n].ftemp;
// Top, Inflow
if( lattice->param.incompressible)
{
u_z = -rho_in
+ ( ftemp[ C]
+ ftemp[ N] + ftemp[ S] + ftemp[ E] + ftemp[ W]
+ 2.*( ftemp[T ]
+ ftemp[TW] + ftemp[TE] + ftemp[TS] + ftemp[TN]));
c = u_z;
}
else // compressible
{
u_z = -1.
+ ( ftemp[C]
+ ftemp[N ] + ftemp[S ] + ftemp[ E] + ftemp[ W]
+ ftemp[NE] + ftemp[NW] + ftemp[SE] + ftemp[SW]
+ 2.*( ftemp[T ]
+ ftemp[TW] + ftemp[TE] + ftemp[TS] + ftemp[TN]))
/ rho_in;
c = u_z*rho_in;
}
//rev_Huang
ftemp[B ] = ftemp[T ] - (1./3.)*c;
ftemp[BW] = ftemp[TE] - (1./6.)*c
+ 0.5*(-ftemp[ W] - ftemp[NW] - ftemp[SW]
+ ftemp[ E] + ftemp[NE] + ftemp[SE]);
ftemp[BE] = ftemp[TW] - (1./6.)*c
- 0.5*(-ftemp[ W] - ftemp[NW] - ftemp[SW]
+ ftemp[ E] + ftemp[NE] + ftemp[SE]);
ftemp[BS] = ftemp[TN] - (1./6.)*c
+ 0.5*( ftemp[N ] + ftemp[NW] + ftemp[NE]
- ftemp[S ] - ftemp[SW] - ftemp[SE]);
ftemp[BN] = ftemp[TS] - (1./6.)*c
- 0.5*( ftemp[N ] + ftemp[NW] + ftemp[NE]
- ftemp[S ] - ftemp[SW] - ftemp[SE]);
#if 1 // Confirm density
rho = ftemp[ C]
+ ftemp[ E] + ftemp[ W]
+ ftemp[ N] + ftemp[ S]
+ ftemp[ T] + ftemp[ B]
+ ftemp[NE] + ftemp[NW] + ftemp[SE] + ftemp[SW]
+ ftemp[TN] + ftemp[TS] + ftemp[BN] + ftemp[BS]
+ ftemp[TE] + ftemp[TW] + ftemp[BE] + ftemp[BW];
if( rho_in - rho > 1e-6)
{
printf("%s %d >> ERROR: pressure_top_in FAIL! "
"rho_in = %f, rho = %f\n",__FILE__,__LINE__, rho_in, rho);
}
#endif
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.pressure_t_in[subs] ) */
//********************************************************************************
// P R E S S U R E B O T T O M O U T F L O W B C (peter's attempt?)
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// pressure bottom outflow
// -- Pressure boundary on bottom side using outflow pressure condition.
if((id ==0) && !lattice->param.GZL && lattice->param.pressure_b_out[subs] )
{
k = 0;
switch(NUM_FLUID_COMPONENTS)
{
case 1:
{ rho_out = lattice->param.rho_out; break; }
case 2:
{
if(subs==0) { rho_out = lattice->param.rho_out;}
if(subs==1) { rho_out = lattice->param.rho_A[subs];}
break;
}
}
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
ftemp = lattice->pdf[subs][n].ftemp;
// Bottom, rho_out
if( lattice->param.incompressible)
{
u_z = rho_out
- ( ftemp[C]
+ ftemp[N] + ftemp[S] + ftemp[E] + ftemp[W]
+ 2.*( ftemp[B]
+ ftemp[BW] + ftemp[BE] + ftemp[BS] + ftemp[BN]));
c = u_z;
}
else // compressible
{
u_z = 1.
- ( ftemp[C]
+ ftemp[N ] + ftemp[S ] + ftemp[ E] + ftemp[ W]
+ ftemp[NW] + ftemp[NE] + ftemp[SW] + ftemp[SE]
+ 2.*( ftemp[B ]
+ ftemp[BW] + ftemp[BE] + ftemp[BS] + ftemp[BN]))
/ rho_out;
c = u_z*rho_out;
}
ftemp[T ] = ftemp[B ] + (1./3.)*c;
ftemp[TW] = ftemp[BE] + (1./6.)*c
+ 0.5*(-ftemp[ W] - ftemp[NW] - ftemp[SW]
+ ftemp[ E] + ftemp[NE] + ftemp[SE]);
ftemp[TE] = ftemp[BW] + (1./6.)*c
- 0.5*(-ftemp[ W] - ftemp[NW] - ftemp[SW]
+ ftemp[ E] + ftemp[NE] + ftemp[SE]);
ftemp[TS] = ftemp[BN] + (1./6.)*c
+ 0.5*( ftemp[N ] + ftemp[NW] + ftemp[NE]
- ftemp[S ] - ftemp[SW] - ftemp[SE]);
ftemp[TN] = ftemp[BS] + (1./6.)*c
- 0.5*( ftemp[N ] + ftemp[NW] + ftemp[NE]
- ftemp[S ] - ftemp[SW] - ftemp[SE]);
#if 1 // Confirm density
rho = ftemp[ C]
+ ftemp[ E] + ftemp[ W]
+ ftemp[ N] + ftemp[ S]
+ ftemp[ T] + ftemp[ B]
+ ftemp[NE] + ftemp[NW] + ftemp[SE] + ftemp[SW]
+ ftemp[TN] + ftemp[TS] + ftemp[BN] + ftemp[BS]
+ ftemp[TE] + ftemp[TW] + ftemp[BE] + ftemp[BW];
if( rho_out - rho > 1e-6)
{
printf("%s %d >> ERROR: pressure_bottom_out FAIL! "
"rho_out = %f, rho = %f\n",__FILE__,__LINE__, rho_out, rho);
}
#endif
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.pressure_b_out[subs] ) */
//********************************************************************************
// V E L O C I T Y T O P I N F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// velocity top inflow
// -- Velocity boundary on top side using inflow velocity condition.
if( id == get_num_procs( lattice) - 1 && !lattice->param.GZL &&
lattice->param.velocity_t_in[subs])
{
//printf("%s %d >> BOOM!",__FILE__,__LINE__);
if(subs==0) u = lattice->param.uz_in; //lattice->param.uz_in; Non-wetting
if(subs==1) u = lattice->param.uz_in; //lattice->param.uz_in;
k = nk-1;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
ftemp = lattice->pdf[subs][n].ftemp;
if( !lattice->solids[subs][n].is_solid)
{
rho = ( ftemp[C ]
+ ftemp[W ] + ftemp[E ] + ftemp[N ] + ftemp[S ]
+ ftemp[NW] + ftemp[NE] + ftemp[SW] + ftemp[SE]
+ 2.*( ftemp[T ]
+ ftemp[TW] + ftemp[TE] + ftemp[TS] + ftemp[TN])
)
/ ( 1. + u);
c = rho*u;
ftemp[B ] = ftemp[T ] - (1./3.)*c;
ftemp[BW] = ftemp[TE] - (1./6.)*c + 0.5* (-ftemp[W ]- ftemp[NW]- ftemp[SW]
+ ftemp[E] +ftemp[NE] + ftemp[SE]);
ftemp[BE] = ftemp[TW] - (1./6.)*c - 0.5* (-ftemp[W ]- ftemp[NW]- ftemp[SW]
+ ftemp[E] +ftemp[NE] + ftemp[SE]);
ftemp[BS] = ftemp[TN] - (1./6.)*c + 0.5* (ftemp[N ] + ftemp[NW] + ftemp[NE]
-ftemp[S ] -ftemp[SW] - ftemp[SE]);
ftemp[BN] = ftemp[TS] - (1./6.)*c - 0.5* (ftemp[N ] + ftemp[NW] + ftemp[NE]
-ftemp[S ] -ftemp[SW] - ftemp[SE]);
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_t_in[subs]) */
// V E L O C I T Y B O T T O M O U T F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// velocity bottom inflow
// -- Velocity boundary on bottom side using outflow velocity condition.
if( id == 0 && !lattice->param.GZL && lattice->param.velocity_b_out[subs])
{
//printf("%s %d >> BOOM!",__FILE__,__LINE__);
if(subs==0) u = lattice->param.uz_out; //lattice->param.uz_out; Non-wetting
if(subs==1) u = lattice->param.uz_out; //lattice->param.uz_out;
k = 0;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
ftemp = lattice->pdf[subs][n].ftemp;
if( !lattice->solids[subs][n].is_solid)
{
rho = ( ftemp[C ]
+ ftemp[W ] + ftemp[E ] + ftemp[N ] + ftemp[S ]
+ ftemp[NW] + ftemp[NE] + ftemp[SW] + ftemp[SE]
+ 2.*( ftemp[B ]
+ ftemp[BW] + ftemp[BE] + ftemp[BS] + ftemp[BN])
)
/ ( 1. - u);
c = rho*u;
ftemp[T ] = ftemp[B ] + (1./3.)*c;
ftemp[TW] = ftemp[BE] + (1./6.)*c + 0.5* (-ftemp[W ]- ftemp[NW]- ftemp[SW]
+ ftemp[E] +ftemp[NE] + ftemp[SE]);
ftemp[TE] = ftemp[BW] + (1./6.)*c - 0.5* (-ftemp[W ]- ftemp[NW]- ftemp[SW]
+ ftemp[E] +ftemp[NE] + ftemp[SE]);
ftemp[TS] = ftemp[BN] + (1./6.)*c + 0.5* (ftemp[N ] + ftemp[NW] + ftemp[NE]
-ftemp[S ] -ftemp[SW] - ftemp[SE]);
ftemp[TN] = ftemp[BS] + (1./6.)*c - 0.5* (ftemp[N ] + ftemp[NW] + ftemp[NE]
-ftemp[S ] -ftemp[SW] - ftemp[SE]);
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_b_in[subs]) */
//********************************************************************************
// GZL P R E S S U R E // V E L O C I T Y T O P I N F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// -- Velocity boundary on top side using inflow velocity condition.
#if PARALLEL
id = get_proc_id(lattice);
#else
id = get_num_procs(lattice)-1;
#endif
if( (id ==get_num_procs(lattice)-1) && lattice->param.GZL && lattice->param.PressureBC)//lattice->param.velocity_t_in[subs])
{
printf("%s %d >> BOOM!",__FILE__,__LINE__);
k = nk-1;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
f = lattice->pdf[subs][n].f;
#if STORE_UEQ
// u_x = &lattice->ueq[n].u[0] = 0.02;
// lattice->ueq[n].u[1] = 0.;
// lattice->ueq[n].u[2] = 0.;
#else /* !( STORE_UEQ) */
// lattice->macro_vars[subs][n].u[0] = 0.02 ;
// lattice->macro_vars[subs][n].u[1] = 0. ;
// lattice->macro_vars[subs][n].u[2] = 0. ;
#endif /* STORE_UEQ */
n1 = XYZ2N( i, j, k-1, ni, nj);
f1 = lattice->pdf[subs][n1].f;
feq1 = lattice->pdf[subs][n1].feq;
// rhoo = &( lattice->macro_vars[subs][n].rho);
switch(NUM_FLUID_COMPONENTS)
{case 1:
{
rho = /*lattice->macro_vars[subs][n1].rho;*/lattice->param.rho_in;
u_x = 0.;//lattice->macro_vars[subs][n1].u[0] ;
u_y = 0.;//lattice->macro_vars[subs][n1].u[1] ;
u_z = lattice->macro_vars[subs][n1].u[2] ;
lattice->macro_vars[subs][n].u[2] = u_z;
break;
}
case 2:
{
#if STORE_UEQ
if(subs==0)
{
rho =lattice->param.rho_in;// 8+ 0.001*(double)lattice->time;// ; subs= 0 Non-wetting
if( lattice->time >1000) {rho = lattice->param.rho_in;}
}
if(subs==1) rho = 0.000 ; //lattice->param.uz_in; subs= 1 Wetting
// rho = lattice->param.rho_A[subs];
u_x = 0.;// lattice->ueq[n1].u[0] ;
u_y = 0.;// lattice->ueq[n1].u[1] ;
u_z = lattice->ueq[n1].u[2] ;
lattice->macro_vars[subs][n].u[2] = u_z;
lattice->ueq[n].u[2] = u_z;
#endif
break;
}
}
lattice->macro_vars[subs][n].rho = rho;
lattice->macro_vars[subs][n].u[0] = u_x;
lattice->macro_vars[subs][n].u[1] = u_y;
if( !lattice->solids[subs][n].is_solid)
{
compute_a_feq( feq, rho, u_x, u_y, u_z );
for (a= 0; a<Q; a++)
{
temp[a] = f1[a] - feq1[a];
f[a]=feq[a]+ temp[a];
}
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_GZL) */
//GZL P R E S S U R E // V E L O C I T Y B O T T O M O U T F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// velocity bottom inflow
// -- Velocity boundary on bottom side using inflow velocity condition.
#if PARALLEL
id = get_proc_id(lattice);
#else
id = 0;
#endif
if( (id ==0) && lattice->param.GZL && lattice->param.PressureBC)//lattice->param.velocity_b_in[subs])
{
printf("%s %d >> BOOM!",__FILE__,__LINE__);
k = 0;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
f = lattice->pdf[subs][n].f;
n1 = XYZ2N( i, j, k+1, ni, nj);
f1 = lattice->pdf[subs][n1].f;
feq1 = lattice->pdf[subs][n1].feq;
switch(NUM_FLUID_COMPONENTS)
{case 1:
{
rho = /*lattice->macro_vars[subs][n1].rho;*/lattice->param.rho_out;
u_x = 0.;//lattice->macro_vars[subs][n1].u[0] ;
u_y = 0.;//lattice->macro_vars[subs][n1].u[1] ;
u_z = lattice->macro_vars[subs][n1].u[2] ;
lattice->macro_vars[subs][n].u[2] = u_z;
break;
}
case 2:
{
#if STORE_UEQ
if(subs==0) rho = 0.000;
if(subs==1)
{
rho =lattice->param.rho_out; //8.0- 0.001*(double)lattice->time;//
if( lattice->time >6000) {rho = lattice->param.rho_out;}
}
// rho = lattice->param.rho_B[subs];
u_x = 0.;//lattice->ueq[n1].u[0] ;
u_y = 0.;//lattice->ueq[n1].u[1] ;
u_z = lattice->ueq[n1].u[2] ;
lattice->macro_vars[subs][n].u[2] = u_z;
lattice->ueq[n].u[2] = u_z;
#endif
break;
}
}
lattice->macro_vars[subs][n].rho = rho;
lattice->macro_vars[subs][n].u[0] = u_x;
lattice->macro_vars[subs][n].u[1] = u_y;
if( !lattice->solids[subs][n].is_solid)
{
compute_a_feq( feq, rho, u_x, u_y, u_z );
for (a= 0; a<Q; a++)
{
temp[a] =f1[a] - feq1[a];
f[a] = feq[a]+ temp[a];
}
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_GZL) */
//PAN V E L O C I T Y T O P I N F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// -- Velocity boundary on top side using inflow velocity condition.
if( lattice->param.GZL && (!lattice->param.PressureBC))//lattice->param.velocity_t_in[subs])
{
printf("%s %d >> BOOM!",__FILE__,__LINE__);
k = nk-1;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
f = lattice->pdf[subs][n].f;
// feq = lattice->pdf[subs][n].feq;
n1 = XYZ2N( i, j, k-1, ni, nj);
f1 = lattice->pdf[subs][n1].f;
feq1 = lattice->pdf[subs][n1].feq;
rhoo = &( lattice->macro_vars[subs][n].rho);
switch(NUM_FLUID_COMPONENTS)
{case 1:
{
rho = /*lattice->macro_vars[subs][n1].rho;*/lattice->param.rho_in;
u_x = 0.;//lattice->macro_vars[subs][n1].u[0] ;
u_y = 0.;//lattice->macro_vars[subs][n1].u[1] ;
u_z = -0.0;//lattice->macro_vars[subs][n1].u[2] ;
break;
}
case 2:
{
#if STORE_UEQ
rho = lattice->param.rho_A[subs];
u_x = 0.;// lattice->ueq[n1].u[0] ;
u_y = 0.;// lattice->ueq[n1].u[1] ;
u_z = 0.;// lattice->ueq[n1].u[2] ;
#endif
break;
}
}
lattice->macro_vars[subs][n].rho = rho;
lattice->macro_vars[subs][n].u[0] = u_x;
lattice->macro_vars[subs][n].u[1] = u_y;
lattice->macro_vars[subs][n].u[2] = u_z;
if( !lattice->solids[subs][n].is_solid)
{
compute_a_feq( feq, rho, u_x, u_y, u_z );
for (a= 0; a<Q; a++)
{f[a] = feq[a];}//+(f1[a] - feq1[a]);
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_GZL) */
//PAN V E L O C I T Y B O T T O M I N F L O W B C
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// velocity bottom inflow
// -- Velocity boundary on bottom side using inflow velocity condition.
if( lattice->param.GZL && (!lattice->param.PressureBC))//lattice->param.velocity_b_in[subs])
{
printf("%s %d >> BOOM!",__FILE__,__LINE__);
k = 0;
for( j=0; j<nj; j++)
{
for( i=0; i<ni; i++)
{
n = XYZ2N( i, j, k, ni, nj);
f = lattice->pdf[subs][n].f;
// feq = lattice->pdf[subs][n].feq;
n1 = XYZ2N( i, j, k+1, ni, nj);
f1 = lattice->pdf[subs][n1].f;
feq1 = lattice->pdf[subs][n1].feq;
switch(NUM_FLUID_COMPONENTS)
{case 1:
{
rho = /*lattice->macro_vars[subs][n1].rho;*/lattice->param.rho_out;
u_x = 0.;//lattice->macro_vars[subs][n1].u[0] ;
u_y = 0.;//lattice->macro_vars[subs][n1].u[1] ;
u_z = -0.0;//lattice->macro_vars[subs][n1].u[2] ;
break;
}
case 2:
{
#if STORE_UEQ
rho = lattice->param.rho_B[subs];
u_x = 0.;//lattice->ueq[n1].u[0] ;
u_y = 0.;//lattice->ueq[n1].u[1] ;
u_z = 0.;//lattice->ueq[n1].u[2] ;
#endif
break;
}
}
lattice->macro_vars[subs][n].rho = rho;
lattice->macro_vars[subs][n].u[0] = u_x;
lattice->macro_vars[subs][n].u[1] = u_y;
lattice->macro_vars[subs][n].u[2] = u_z;
if( !lattice->solids[subs][n].is_solid)
{
compute_a_feq( feq, rho, u_x, u_y, u_z );
if(subs==1)
compute_a_feq( feq1, 2.0- 0.0003*(double)lattice->time, u_x, u_y, u_z );
for (a= 0; a<Q; a++)
{
f[a] = feq[a];
}// +(f1[a] - feq1[a]);
} /* if( !is_solid) */
} /* for( i=0; i<ni; i++) */
} /* for( j=0; j<nj; j++) */
} /* if( lattice->param.velocity_GZL) */
} /* for( subs=0; subs<(NUM_FLUID_COMPONENTS)-(INAMURO_SIGMA_COMPONENT); subs++) */
}
int test_waitpid()
{
test_Data;
void* proc;
void* proc2;
int ret;
int status=-1;
test_Title("WAITPID");
test_Next("waitpid");
proc = create_process(doafunc, "A", "rw", fids);
if (proc)
start_process(proc);
else
perror("Failed to start process A: ");
// test return values of calls to waitpid with different options and pid's
if (proc)
{
// test with option WNOHANG and a correct pid on an active process
ret = wait_for_process_id(proc,get_proc_id(proc),WNOHANG,&status);
test(ret==0);
// test with an invalid pid
ret = wait_for_process_id(proc,99,0,&status);
test(errno==ECHILD&&ret==-1);
// test with invalid options
ret = wait_for_process_id(proc,99,17,&status);
test(errno==EINVAL&&ret==-1);
ret = wait_for_process_id(proc,99,18,&status);
test(errno==EINVAL&&ret==-1);
// process is still active keep waiting until it dies
do
{
ret = wait_for_process_id(proc,get_proc_id(proc),WNOHANG,&status);
}
while(!WIFEXITED(status)&&ret==0);
test(ret==get_proc_id(proc));
printf("child exited, status=%d\n", WEXITSTATUS(status));
}
// create another process and test waitpid with pid -1 and options 0
// this is the same as calling wait
proc2 = create_process(doafunc, "B", "rw", fids);
if (proc2)
start_process(proc2);
else
perror("Failed to start process B: ");
if (proc2)
{
//wait for proc2 to finish
do
{
ret = wait_for_process_id(proc2,-1,0,&status);
}
while (!WIFEXITED(status));
test(ret==get_proc_id(proc2));
printf("child exited, status=%d\n", WEXITSTATUS(status));
}
fflush(stdout);
fclose(stdout);
test_Close();
return 0;
}
void main()
{
int my_id = get_proc_id()-1;
int num_cores = get_proc_num();
short int i, iter, j, k;
int lb, ub, chunk;
//number of rows each core has to multiply
chunk = SIZE / num_cores;
//lower bound
lb = my_id * chunk;
//upper bound
ub = lb + chunk;
#ifdef CHECKSUM
//pr("lb", lb, PR_STRING | PR_DEC | PR_NEWL);
//pr("ub", ub, PR_STRING | PR_DEC | PR_NEWL);
//for (i = 0; i < SIZE; i++) {
//for (k = 0; k < SIZE; k++)
//pr("", A[i][k], PR_DEC);
//pr("", 0, PR_NEWL);
//}
//pr("", 0, PR_NEWL);
//for (i = 0; i < SIZE; i++) {
//for (k = 0; k < SIZE; k++)
//pr("", B[i][k], PR_DEC);
//pr("", 0, PR_NEWL);
//}
#endif
/********************* Benchmark Execution *********************/
start_metric();
for (iter = 0; iter < N_ITERS; iter++) {
for (i = lb; i < ub; i++) {
for (k = 0; k < SIZE; k++) {
C[i][k] = 0;
for (j = 0; j < SIZE; j++)
C[i][k] += A[i][j] * B[j][k];
}
}
}
stop_metric();
/********************* Benchmark Execution *********************/
#ifdef CHECKSUM
if(my_id == 0) {
//pr("", 0, PR_NEWL);
//for (i = 0; i < SIZE; i++) {
//for (k = 0; k < SIZE; k++)
//pr("", C[i][k], PR_DEC);
//pr("", 0, PR_NEWL);
//}
pr("computing CHECKSUM...", 0x0, PR_CPU_ID | PR_STRING | PR_NEWL);
int chk = 0;
for (k = 0; k < SIZE; k++)
for (j = 0; j < SIZE; j++)
chk += C[k][j];
if(chk == CHKSM) {
pr("CHECKSUM OK!", 0x0, PR_CPU_ID | PR_STRING | PR_NEWL);
} else {
pr("CHECKSUM IS WRONG! computed ", chk, PR_CPU_ID | PR_STRING | PR_DEC);
pr(" expected ", CHKSM, PR_STRING | PR_DEC | PR_NEWL);
}
}
#endif
}
int main()
{
_printstrn("--------------------------------------");
_printstrn("Configuration");
_printstrn("--------------------------------------");
_printdecn("WIDTH ", WIDTH);
_printdecn("HEIGHT ", HEIGHT);
_printdecn("ROWS_EACH_COMPUTATION_PIPE ", ROWS_EACH_COMPUTATION_PIPE);
_printdecn("ROWS_EACH_COMPUTATION_OUT_PIPE ", ROWS_EACH_COMPUTATION_OUT_PIPE);
_printstrn("--------------------------------------");
/*--- Pipe Support Data allocation*/
unsigned int nr_bands_pipe = HEIGHT / ROWS_EACH_COMPUTATION_PIPE;
unsigned int band_size_1ch = WIDTH*ROWS_EACH_COMPUTATION_PIPE*sizeof(IMG_DATATYPE);
unsigned int band_size_3ch = WIDTH*ROWS_EACH_COMPUTATION_PIPE*3*sizeof(IMG_DATATYPE);
unsigned int band_word_size_3ch = band_size_3ch / 4;
int pipe_buffID = 0;
/* Pipe Buffers for each stage */
IMG_DATATYPE *csc_in[2];
csc_in[0] = (IMG_DATATYPE *) SHMALLOC(band_size_3ch); //3ch each pixel
csc_in[1] = (IMG_DATATYPE *) SHMALLOC(band_size_3ch); //3ch each pixel
IMG_DATATYPE *cvT_in[2];
cvT_in[0] = (IMG_DATATYPE *) SHMALLOC(band_size_3ch); //3ch each pixel
cvT_in[1] = (IMG_DATATYPE *) SHMALLOC(band_size_3ch); //3ch each pixel
IMG_DATATYPE *cvM_in[2];
cvM_in[0] = (IMG_DATATYPE *) SHMALLOC(band_size_1ch); //1ch each pixel
cvM_in[1] = (IMG_DATATYPE *) SHMALLOC(band_size_1ch); //1ch each pixel
unsigned int moments[2][3] = {{0,0,0},{0,0,0}};
/*--- Out-Pipe Support Data allocation*/
unsigned int nr_bands_out = HEIGHT / ROWS_EACH_COMPUTATION_OUT_PIPE;
unsigned int band_out_size_3ch = WIDTH*ROWS_EACH_COMPUTATION_OUT_PIPE*3*sizeof(IMG_DATATYPE);
unsigned int band_out_word_size_3ch = band_out_size_3ch / 4;
/* Out-pipe Buffers */
IMG_DATATYPE *curr_frame[2];
curr_frame[0] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
curr_frame[1] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
IMG_DATATYPE *track_in[2];
track_in[0] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
track_in[1] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
IMG_DATATYPE *cvAdd_out[2];
cvAdd_out[0] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
cvAdd_out[1] = (IMG_DATATYPE *) SHMALLOC(band_out_size_3ch); //3ch each pixel
#ifdef APP_VERBOSE
_printstrn("--------------------------------------");
_printstrn("Buffers");
_printstrn("--------------------------------------");
_printhexp("csc_in[0] @", csc_in[0]);
_printhexp("csc_in[1] @", csc_in[1]);
_printhexp("cvT_in[0] @", cvT_in[0]);
_printhexp("cvT_in[1] @", cvT_in[1]);
_printhexp("cvM_in[0] @", cvM_in[0]);
_printhexp("cvM_in[1] @", cvM_in[1]);
_printhexp("curr_frame[0] @", curr_frame[0]);
_printhexp("curr_frame[1] @", curr_frame[1]);
_printhexp("track_in[0] @", track_in[0]);
_printhexp("track_in[1] @", track_in[1]);
_printhexp("cvAdd_out[0] @", cvAdd_out[0]);
_printhexp("cvAdd_out[1] @", cvAdd_out[1]);
_printstrn("--------------------------------------");
#endif
unsigned int caching = 0;
for(caching = 0; caching < 2; ++caching)
{
/*--- COMPUTE INPUT FRAMES --- */
#pragma omp parallel num_threads(4) firstprivate(pipe_buffID)
{
int tile_id = 0;
int proc_id = get_proc_id()-1;
int i = 0;
for(i = 0; i < NR_FRAMES; ++i)
{
/*NOTE if library supports multiple ws here you can use sections nowait */
#ifdef SINGLE_WS
#pragma omp master
#else
#pragma omp single nowait
#endif
{
_printdecp("[ColorTracking] Start computation of frame nr ", i);
//_tstamp();
}
/*NOTE if library supports multiple ws here you can use sections nowait */
#ifdef SINGLE_WS
#pragma omp sections
#else
#pragma omp sections nowait
#endif
{
/*--- DMA+CSC SECTION ---*/
#pragma omp section
{
// #ifdef APP_DEBUG
_printdecp("[CSC] operated by proc ", proc_id);
//_tstamp();
// #endif
/* DMA Events */
unsigned char pipe_job_id_read[2];
/*Current Frame*/
IMG_DATATYPE *current_frame_in = in_frame[i];
/*First DMA INLOAD */
pipe_job_id_read[pipe_buffID] = dma_prog(proc_id, /*tile_id,*/ (unsigned int) current_frame_in, (unsigned int) csc_in[pipe_buffID], band_word_size_3ch, 1, 0, 0, 1);
#pragma omp parallel num_threads(4) firstprivate(pipe_buffID)
{
unsigned int ii = 0;
for(ii = 0; ii < nr_bands_pipe; ++ii)
{
if (pipe_buffID == 0)
pipe_buffID = 1;
else
pipe_buffID = 0;
/* --------- DMA Stage --------- */
/*NOTE This in MPARM MUST be managed via master-barrier.
Single is possible to use due DMA policy.
Who program dma must be the same processor who collect dma_wait.
*/
#pragma omp master
{
/*prog next buff*/
if ((ii+1) < nr_bands_pipe)
pipe_job_id_read[pipe_buffID] = dma_prog(proc_id, /*tile_id,*/ (unsigned int) ¤t_frame_in[(ii+1)*band_size_3ch], (unsigned int) csc_in[pipe_buffID], band_word_size_3ch, 1, 0, 0, 1);
#ifdef DMA_WAIT_TIME
//_tstamp();
#endif
//Wait for DMA end
dma_wait(/*tile_id,*/ pipe_job_id_read[!pipe_buffID]);
#ifdef DMA_WAIT_TIME
//_tstamp();
#endif
}
#pragma omp barrier
/* --------- CSC Computation --------- */
#ifdef APP_VERBOSE
_printdecp("[CSC] WORKING BAND NR ", ii);
#endif
__CSC(csc_in[!pipe_buffID], cvT_in[!pipe_buffID], band_size_3ch);
#ifdef APP_VERBOSE
_printstrp("[CSC] WORKING...DONE");
#endif
/* --------- Synch to CVT --------- */
/*NOTE if library supports multiple ws here you can use single nowait */
#ifdef SINGLE_WS
#pragma omp master
#else
#pragma omp single nowait
#endif
{
#ifdef APP_VERBOSE
_printdecp("[CSC] WAITING FOR CVT @ ",!pipe_buffID);
#endif
while(!READY_FLAG_CVT[!pipe_buffID]);
READY_FLAG_CVT[!pipe_buffID] = 0;
#ifdef APP_VERBOSE
_printdecp("[CSC] RELEASE CVT @ ",!pipe_buffID);
#endif
RELEASE_FLAG_CVT[!pipe_buffID] = 1;
}
}
}//end inner parallel
// #ifdef APP_VERBOSE
_printdecp("[CSC] end computation of frame nr ", i);
// #endif
}//end section DMA+CSC
/*--- cvThreshold SECTION ---*/
#pragma omp section
{
// #ifdef APP_DEBUG
_printdecp("[CVT] operated by proc ", proc_id);
//_tstamp();
// #endif
#pragma omp parallel num_threads(4) firstprivate(pipe_buffID)
{
unsigned int ii = 0;
for(ii = 0; ii < nr_bands_pipe; ++ii)
{
/* --------- Buffer Swap --------- */
if (pipe_buffID == 0)
pipe_buffID = 1;
else
pipe_buffID = 0;
#pragma omp single
{
/* --------- Synch from CSC --------- */
READY_FLAG_CVT[!pipe_buffID] = 1;
#ifdef APP_VERBOSE
_printdecp("[CVT] WAITING FOR RELEASE @ ",!pipe_buffID);
#endif
while(!RELEASE_FLAG_CVT[!pipe_buffID]);
#ifdef APP_VERBOSE
_printdecp("[CVT] RELEASED @ ",!pipe_buffID);
#endif
RELEASE_FLAG_CVT[!pipe_buffID] = 0;
}
/* --------- cvThreshold computation --------- */
#ifdef APP_VERBOSE
_printdecp("[CVT] WORKING BAND NR ", ii);
#endif
__cvThreshold(cvT_in[!pipe_buffID], cvM_in[!pipe_buffID], band_size_1ch);
#ifdef APP_VERBOSE
_printstrp("[CVT] WORKING...DONE");
#endif
/* --------- Synch to CVM --------- */
/*NOTE if library supports multiple ws here you can use single nowait */
#ifdef SINGLE_WS
#pragma omp master
#else
#pragma omp single nowait
#endif
{
#ifdef APP_VERBOSE
_printdecp("[CVT] WAITING FOR CVM @ ",!pipe_buffID);
#endif
while(!READY_FLAG_CVM[!pipe_buffID]);
READY_FLAG_CVM[!pipe_buffID] = 0;
#ifdef APP_VERBOSE
_printdecp("[CVT] RELEASE CVM @ ",!pipe_buffID);
#endif
RELEASE_FLAG_CVM[!pipe_buffID] = 1;
}
}
}//end inner parallel
// #ifdef APP_VERBOSE
_printdecp("[CVT] end computation of frame nr ", i);
// #endif
}//end section Threshold
/*--- cvMoments SECTION ---*/
#pragma omp section
{
unsigned int frameBuffID = i & 0x1;
// #ifdef APP_DEBUG
_printdecp("[CVM] operated by proc ", proc_id);
//_tstamp();
// #endif
#pragma omp parallel num_threads(4) firstprivate(pipe_buffID)
{
unsigned int ii = 0;
for(ii = 0; ii < nr_bands_pipe; ++ii)
{
/* --------- Buffer Swap --------- */
if (pipe_buffID == 0)
pipe_buffID = 1;
else
pipe_buffID = 0;
#pragma omp single
{
/* --------- Synch from CVT --------- */
READY_FLAG_CVM[!pipe_buffID] = 1;
#ifdef APP_VERBOSE
_printdecp("[CVM] WAITING FOR RELEASE @ ",!pipe_buffID);
#endif
while(!RELEASE_FLAG_CVM[!pipe_buffID]);
#ifdef APP_VERBOSE
_printdecp("[CVM] RELEASED @ ",!pipe_buffID);
#endif
RELEASE_FLAG_CVM[!pipe_buffID] = 0;
}
/* --------- cvMoments computation --------- */
#ifdef APP_VERBOSE
_printdecp("[CVM] WORKING BAND NR", ii);
#endif
__cvMoments(cvM_in[!pipe_buffID], moments[frameBuffID], ii*ROWS_EACH_COMPUTATION_PIPE, WIDTH, band_size_1ch);
#ifdef APP_VERBOSE
_printstrp("[CVM] WORKING...DONE");
#endif
}
}//end inner parallel
/* --------- Synch to CVA --------- */
//_tstamp();
_printdecp("[CVM] end computation of frame nr ", i);
#ifdef APP_VERBOSE
_printdecp("[CVM] WAITING FOR CVA @ ",frameBuffID);
#endif
while(!READY_FLAG_CVA[frameBuffID]);
READY_FLAG_CVA[frameBuffID] = 0;
#ifdef APP_VERBOSE
_printdecp("[CVM] RELEASE CVA @ ",frameBuffID);
#endif
RELEASE_FLAG_CVA[frameBuffID] = 1;
}//end section Moments
/*--- cvAdd SECTION ---*/
#pragma omp section
{
// #ifdef APP_DEBUG
_printdecp("[CVA] operated by proc ", proc_id);
//_tstamp();
// #endif
/* DMA Events */
unsigned char out_job_id_read[4];
unsigned char out_job_id_write[2];
int out_buffID = 0;
/*Current Frame*/
IMG_DATATYPE *current_frame_in = in_frame[i];
IMG_DATATYPE *current_frame_out = out_frame[i];
unsigned int frameBuffID = i & 0x1;
/* --------- Synch from CVM --------- */
#ifdef APP_VERBOSE
_printdecp("[CVA] WAITING FOR RELEASE @ ",frameBuffID);
#endif
READY_FLAG_CVA[frameBuffID] = 1;
while(!RELEASE_FLAG_CVA[frameBuffID]);
#ifdef APP_VERBOSE
_printdecp("[CVA] RELEASED @ ",frameBuffID);
#endif
RELEASE_FLAG_CVA[frameBuffID] = 0;
/*First DMA INLOAD */
out_job_id_read[out_buffID] = dma_prog(proc_id, /*tile_id,*/ (unsigned int) current_frame_in, (unsigned int)curr_frame[out_buffID], band_out_word_size_3ch, 1, 0, 0, 1);
out_job_id_read[out_buffID+2] = dma_prog(proc_id, /*tile_id,*/ (unsigned int) track_frame, (unsigned int)track_in[out_buffID], band_out_word_size_3ch, 1, 0, 0, 1);
/* --------- cvLine --------- */
/*compute current center of gravity*/
double moment10 = moments[frameBuffID][2];
double moment01 = moments[frameBuffID][1];
double area = moments[frameBuffID][0];
double posX = moment10/area;
double posY = moment01/area;
// #ifdef APP_DEBUG
_printdecp("[CVA] area:" , moments[frameBuffID][0]);
_printdecp("[CVA] moment01:" , moments[frameBuffID][1]);
_printdecp("[CVA] moment10:" , moments[frameBuffID][2]);
_printdecp("[CVA] posX:" , posX); //NOTE TO CHECK RESULTS-> MUST BE ALWAYS 238
_printdecp("[CVA] posY:" , posY); //NOTE TO CHECK RESULTS-> MUST BE ALWAYS 62
// #endif
moments[frameBuffID][0] = moments[frameBuffID][1] = moments[frameBuffID][2] = 0;
#pragma omp parallel num_threads(4) firstprivate(out_buffID)
{
unsigned int ii;
for(ii = 0; ii < nr_bands_out; ++ii )
{
if (out_buffID == 0)
out_buffID = 1;
else
out_buffID = 0;
/* --------- DMA Stage --------- */
/*NOTE This in MPARM MUST be managed via master-barrier.
Single is possible to use due DMA policy.
Who program dma must be the same processor who collect dma_wait.
*/
#pragma omp master
{
if ((ii+1) < nr_bands_out)
{
out_job_id_read[out_buffID] = dma_prog(proc_id, /*tile_id,*/ (unsigned int)¤t_frame_in[(ii+1)*band_out_size_3ch], (unsigned int)curr_frame[out_buffID], band_out_word_size_3ch, 1, 0, 0, 1);
out_job_id_read[out_buffID+2] = dma_prog(proc_id, /*tile_id,*/ (unsigned int)&track_frame[(ii+1)*band_out_size_3ch], (unsigned int)track_in[out_buffID], band_out_word_size_3ch, 1, 0, 0, 1);
}
#ifdef DMA_WAIT_TIME
//_tstamp();
#endif
//Wait for DMA end
dma_wait(/*tile_id,*/ out_job_id_read[!out_buffID]);
dma_wait(/*tile_id,*/ out_job_id_read[(!out_buffID) + 2]);
#ifdef DMA_WAIT_TIME
//_tstamp();
#endif
}
#pragma omp barrier
/*NOTE:MISSING --------- cvLine stage --------- */
//__cvLine(track_in, posX, posY);
/* --------- cvAdd stage --------- */
#ifdef APP_VERBOSE
_printdecp("[CVA] WORKING BAND NR ", ii);
#endif
__cvAdd(curr_frame[!out_buffID], track_in[!out_buffID], cvAdd_out[!out_buffID], band_out_size_3ch);
#ifdef APP_VERBOSE
_printstrp("[CVA] WORKING...DONE");
#endif
/*DMA writeback on L3*/
/*NOTE if library supports multiple ws here you can use single nowait */
#ifdef SINGLE_WS
#pragma omp master
#else
#pragma omp single nowait
#endif
{
out_job_id_write[!out_buffID] = dma_prog(proc_id, /*tile_id,*/ (unsigned int) ¤t_frame_out[ii*band_out_size_3ch], (unsigned int)cvAdd_out[!out_buffID], band_out_word_size_3ch, 0, 1, 0, 1);
}
}//end bands for
}//end inner parallel
//_tstamp();
_printdecp("[CVA] end computation of frame nr ", i);
}//end section DMA+cvAdd
}//end sections
#pragma omp master
{
//_tstamp();
_printdecp("[ColorTracking] end computation of frame nr", i);
}
}//for frame
}//parallel
}//caching
return 0;
}
/*******************************************************************************
* PROCESS AUTO RESTART
*******************************************************************************/
int auto_restart_the_process(int idx)
{
int pid, ret;
char pname[LSIZE_256];
struct stat statbuf;
/***************************************************************************
* CHECK INDEX RANGE
***************************************************************************/
if( (idx < 0) || (idx >= dCurrBlockCnt))
return -1;
/***************************************************************************
* ALREADY RUNNING, REMOVE PROCESS INFORATION
***************************************************************************/
if( (pid = get_proc_id(STR_TSW_COM[idx])) > 0)
{
fidb->mpsw[idx] = NORMAL;
fidb->mpswinfo[idx].pid = pid;
fidb->mpswinfo[idx].when = time(NULL);
return pid;
}
if( (ret = dGetBlockBIN(STR_TSW_COM[idx], pname, LSIZE_256)) < 0)
{
log_print(LOGN_CRI, "F=%s:%s.%d: ERROR IN dGetBlockBIN(STR_TSW_COM[%d][%s]) ret[%d]", __FILE__, __FUNCTION__, __LINE__,
idx, STR_TSW_COM[idx], ret);
}
if(stat(pname, &statbuf) < 0)
return -2;
signal(SIGCHLD, SIG_IGN);
pid = fork();
log_print(LOGN_DEBUG, "[AUTO RESTART] [NEW PID] [%d]", pid);
/* fork에서 실패하면 종료한다 */
if(pid == -1)
{
log_print(LOGN_CRI, "F=%s:%s.%d: FAILED IN fork(pname[%s]) errno[%d-%s]", __FILE__, __FUNCTION__, __LINE__,
pname, errno, strerror(errno));
return -3;
}
else if(pid == 0)
{
/* CHILD PROCESS 에서는 해당 프로그램을 수행을 시도하고 */
freopen("/dev/null", "w", stdout);
if( (ret = execl(pname, STR_TSW_COM[idx], (char*)NULL)) == -1)
{
log_print(LOGN_CRI, "F=%s:%s.%d: FAILED IN execl(pname[%s]) errno[%d-%s]", __FILE__, __FUNCTION__, __LINE__,
pname, errno, strerror(errno));
exit(-4);
}
exit(0);
}
else
{
/* PARENT PROCESS에서는 단순히 CHILD PROCESS의 PID를 RETURN */
#ifdef DEBUG
log_print(LOGN_DEBUG, "%s START WITH %d", STR_TSW_COM[idx], pid);
#endif
fidb->mpswinfo[idx].pid = pid;
fidb->mpswinfo[idx].when = time(NULL);
return pid;
}
}
