filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | ads+1) * sizeof(int));
int stridennz = ceil((double)sub_local_mtx.nnznum/(double)nthreads);
<LOOP-START>for (int tid = 0; tid <= nthreads; tid++)
{
int boundary = tid * stridennz;
boundary = boundary > sub_local_mtx.nnznum ? sub_local_mtx.nnznum : boundary;
csrSplitter[tid] = binary_search_right_boundary_kernel(sub_local_mtx.rowptr, boundary, sub_local_mtx.rownum + 1) - 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | MPI_Barrier(MPI_COMM_WORLD);
if(id==0) gettimeofday(&t1,NULL);
// Compute local spmv
// <LOOP-START>// for (int i = 0; i < sub_local_mtx.rownum; i++)
// {
// local_y[i]=0;
// for (int j = sub_local_mtx.rowptr[i]; j < sub_local_mtx.rowptr[i + 1]; j++)
// {
// local_y[i] += sub_local_mtx.val[j] * x[sub_local_mtx.colidx[j]];
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | al_y[i] += sub_local_mtx.val[j] * x[sub_local_mtx.colidx[j]];
// }
// }
<LOOP-START>for (int tid = 0; tid < nthreads; tid++)
{
for (int u = csrSplitter[tid]; u < csrSplitter[tid+1]; u++)
{
local_y[u] = 0;
for (int h = sub_local_mtx.rowptr[u]; h < sub_local_mtx.rowptr[u+1]; h++)
{
local_y[u] += sub_local_mtx.val[h] * x[sub_local_mtx.colidx[h]];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | ur_time;
}
}
stridennz = ceil((double)sub_remote_mtx.nnznum/(double)nthreads);
<LOOP-START>for (int tid = 0; tid <= nthreads; tid++)
{
int boundary = tid * stridennz;
boundary = boundary > sub_remote_mtx.nnznum ? sub_remote_mtx.nnznum : boundary;
csrSplitter[tid] = binary_search_right_boundary_kernel(sub_remote_mtx.rowptr, boundary, sub_remote_mtx.rownum + 1) - 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | dary, sub_remote_mtx.rownum + 1) - 1;
}
for (int iter = 0; iter < NTIMES; iter++)
{
// <LOOP-START>// for (int i = 0; i < sub_remote_mtx.rownum; i++) {
// remote_y[i]=0;
// for (int j = sub_remote_mtx.rowptr[i]; j < sub_remote_mtx.rowptr[i + 1]; j++)
// remote_y[i] += sub_remote_mtx.val[j] * x[sub_remote_mtx.colidx[j]];
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Balanced.c | #pragma omp parallel for | 100 | // }
MPI_Barrier(MPI_COMM_WORLD);
if(id==0) gettimeofday(&t1,NULL);
<LOOP-START>for (int tid = 0; tid < nthreads; tid++)
{
for (int u = csrSplitter[tid]; u < csrSplitter[tid+1]; u++)
{
remote_y[u] = 0;
for (int h = sub_remote_mtx.rowptr[u]; h < sub_remote_mtx.rowptr[u+1]; h++)
{
remote_y[u] += sub_remote_mtx.val[h] * x[sub_remote_mtx.colidx[h]];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV.c | #pragma omp parallel for | 100 | threads+1) * sizeof(int));
int stridennz = ceil((double)submatrix.nnznum/(double)nthreads);
<LOOP-START>for (int tid = 0; tid <= nthreads; tid++)
{
int boundary = tid * stridennz;
boundary = boundary > submatrix.nnznum ? submatrix.nnznum : boundary;
csrSplitter[tid] = binary_search_right_boundary_kernel(submatrix.rowptr, boundary, submatrix.rownum + 1) - 1;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV.c | #pragma omp parallel for | 100 | q++)
{
MPI_Barrier(MPI_COMM_WORLD);
if(id==0) gettimeofday(&t1, NULL);
<LOOP-START>for (int tid = 0; tid < nthreads; tid++)
{
for (int u = csrSplitter[tid]; u < csrSplitter[tid+1]; u++)
{
y[u] = 0;
for (int h = submatrix.rowptr[u]; h < submatrix.rowptr[u+1]; h++)
{
y[u] += submatrix.val[h] * x[submatrix.colidx[h]];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV.c | #pragma omp parallel for | 100 | usec - t1.tv_usec) / 1000.0);
}
// for (int q = 0; q < NTIMES; q++)
// {
// <LOOP-START>// for (int i=0;i<submatrix.rownum;i++)
// {
// y[i] = 0;
// for (int u = submatrix.rowptr[i];u<submatrix.rowptr[i+1]; u++)
// {
// y[i] += submatrix.val[u] * x[submatrix.colidx[u]];
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
slcs-jsc/jurassic/src/jurassic.c | #pragma omp parallel for default(none) shared(ctl,tbl,id,nu,f,n,dnu) | 100 | 1; i < n; i++)
dnu = MIN(dnu, nu[i] - nu[i - 1]);
/* Compute source function table... */
<LOOP-START>for (int it = 0; it < TBLNS; it++) {
/* Set temperature... */
tbl->st[it] = LIN(0.0, TMIN, TBLNS - 1.0, TMAX, (double) it);
/* Integrate Planck function... */
double fsum = tbl->sr[it][id] = 0;
for (double fnu = nu[0]; fnu <= nu[n - 1]; fnu += dnu) {
int i = locate_irr(nu, n, fnu);
double ff = LIN(nu[i], f[i], nu[i + 1], f[i + 1], fnu);
fsum += ff;
tbl->sr[it][id] += ff * planck(tbl->st[it], fnu);
}
tbl->sr[it][id] /= fsum;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(ctl,tbl,id,nu,f,n,dnu)<OMP-END> |
slcs-jsc/jurassic/src/jurassic.c | #pragma omp parallel for default(none) shared(ctl,atm,obs,k,x0,yy0,n,m,iqa) private(x1, yy1, atm1, obs1) | 100 | nitialize kernel matrix... */
gsl_matrix_set_zero(k);
/* Loop over state vector elements... */
<LOOP-START>for (size_t j = 0; j < n; j++) {
/* Allocate... */
x1 = gsl_vector_alloc(n);
yy1 = gsl_vector_alloc(m);
ALLOC(atm1, atm_t, 1);
ALLOC(obs1, obs_t, 1);
/* Set perturbation size... */
double h;
if (iqa[j] == IDXP)
h = MAX(fabs(0.01 * gsl_vector_get(x0, j)), 1e-7);
else if (iqa[j] == IDXT)
h = 1.0;
else if (iqa[j] >= IDXQ(0) && iqa[j] < IDXQ(ctl->ng))
h = MAX(fabs(0.01 * gsl_vector_get(x0, j)), 1e-15);
else if (iqa[j] >= IDXK(0) && iqa[j] < IDXK(ctl->nw))
h = 1e-4;
else if (iqa[j] == IDXCLZ || iqa[j] == IDXCLDZ)
h = 1.0;
else if (iqa[j] >= IDXCLK(0) && iqa[j] < IDXCLK(ctl->ncl))
h = 1e-4;
else if (iqa[j] == IDXSFZ)
h = 0.1;
else if (iqa[j] == IDXSFP)
h = 10.0;
else if (iqa[j] == IDXSFT)
h = 1.0;
else if (iqa[j] >= IDXSFEPS(0) && iqa[j] < IDXSFEPS(ctl->nsf))
h = 1e-2;
else
ERRMSG("Cannot set perturbation size!");
/* Disturb state vector element... */
gsl_vector_memcpy(x1, x0);
gsl_vector_set(x1, j, gsl_vector_get(x1, j) + h);
copy_atm(ctl, atm1, atm, 0);
copy_obs(ctl, obs1, obs, 0);
x2atm(ctl, x1, atm1);
/* Compute radiance for disturbed atmospheric data... */
formod(ctl, atm1, obs1);
/* Compose measurement vector for disturbed radiance data... */
obs2y(ctl, obs1, yy1, NULL, NULL);
/* Compute derivatives... */
for (size_t i = 0; i < m; i++)
gsl_matrix_set(k, i, j,
(gsl_vector_get(yy1, i) - gsl_vector_get(yy0, i)) / h);
/* Free... */
gsl_vector_free(x1);
gsl_vector_free(yy1);
free(atm1);
free(obs1);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(none) shared(ctl,atm,obs,k,x0,yy0,n,m,iqa) private(x1, yy1, atm1, obs1)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ead binary data... */
cms_sol_t *sol = cms_read_sol(cms_ptr, inout);
/* Evaluate... */
<LOOP-START>for (size_t ix = 0; ix < nx; ix++)
for (size_t iy = 0; iy < ny; iy++) {
double val, x[] = { lon[ix], lat[iy] };
cms_eval(cms_ptr, sol, x, &val);
array[ARRAY_3D(ix, iy, ny, ip, np)] = (float) val;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | inout);
FREAD(sarray, unsigned short,
nxy * nz,
inout);
/* Convert to float... */
<LOOP-START>for (size_t ixy = 0; ixy < nxy; ixy++)
for (size_t iz = 0; iz < nz; iz++)
array[ixy * nz + iz]
= (float) (sarray[ixy * nz + iz] * scl[iz] + off[iz]);
}
/* Compress array and output compressed stream... */
else {
/* Write info... */
LOG(2, "Write 3-D variable: %s (pack, RATIO= %g %%)",
varname, 100. * sizeof(unsigned short) / sizeof(float));
/* Get range... */
for (size_t iz = 0; iz < nz; iz++) {
min[iz] = array[iz];
max[iz] = array[iz];
}
for (size_t ixy = 1; ixy < nxy; ixy++)
for (size_t iz = 0; iz < nz; iz++) {
if (array[ixy * nz + iz] < min[iz])
min[iz] = array[ixy * nz + iz];
if (array[ixy * nz + iz] > max[iz])
max[iz] = array[ixy * nz + iz];
}
/* Get offset and scaling factor... */
for (size_t iz = 0; iz < nz; iz++) {
scl[iz] = (max[iz] - min[iz]) / 65533.;
off[iz] = min[iz];
}
/* Convert to short... */
#pragma omp parallel for default(shared)
for (size_t ixy = 0; ixy < nxy; ixy++)
for (size_t iz = 0; iz < nz; iz++)
if (scl[iz] != 0)
sarray[ixy * nz + iz] = (unsigned short)
((array[ixy * nz + iz] - off[iz]) / scl[iz] + .5);
else
sarray[ixy * nz + iz] = 0;
/* Write data... */
FWRITE(&scl, double,
nz,
inout);
FWRITE(&off, double,
nz,
inout);
FWRITE(sarray, unsigned short,
nxy * nz,
inout);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | l[iz] = (max[iz] - min[iz]) / 65533.;
off[iz] = min[iz];
}
/* Convert to short... */
<LOOP-START>for (size_t ixy = 0; ixy < nxy; ixy++)
for (size_t iz = 0; iz < nz; iz++)
if (scl[iz] != 0)
sarray[ixy * nz + iz] = (unsigned short)
((array[ixy * nz + iz] - off[iz]) / scl[iz] + .5);
else
sarray[ixy * nz + iz] = 0;
/* Write data... */
FWRITE(&scl, double,
nz,
inout);
FWRITE(&off, double,
nz,
inout);
FWRITE(sarray, unsigned short,
nxy * nz,
inout);
}
/* Free... */
free(sarray);
}
/*****************************************************************************/
#ifdef ZFP
void compress_zfp(
char *varname,
float *array,
int nx,
int ny,
int nz,
int precision,
double tolerance,
int decompress,
FILE * inout) {
zfp_type type; /* array scalar type */
zfp_field *field; /* array meta data */
zfp_stream *zfp; /* compressed stream */
void *buffer; /* storage for compressed stream */
size_t bufsize; /* byte size of compressed buffer */
bitstream *stream; /* bit stream to write to or read from */
size_t zfpsize; /* byte size of compressed stream */
/* Allocate meta data for the 3D array a[nz][ny][nx]... */
type = zfp_type_float;
field = zfp_field_3d(array, type, (uint) nx, (uint) ny, (uint) nz);
/* Allocate meta data for a compressed stream... */
zfp = zfp_stream_open(NULL);
/* Set compression mode... */
int actual_prec = 0;
double actual_tol = 0;
if (precision > 0)
actual_prec = (int) zfp_stream_set_precision(zfp, (uint) precision);
else if (tolerance > 0)
actual_tol = zfp_stream_set_accuracy(zfp, tolerance);
else
ERRMSG("Set precision or tolerance!");
/* Allocate buffer for compressed data... */
bufsize = zfp_stream_maximum_size(zfp, field);
buffer = malloc(bufsize);
/* Associate bit stream with allocated buffer... */
stream = stream_open(buffer, bufsize);
zfp_stream_set_bit_stream(zfp, stream);
zfp_stream_rewind(zfp);
/* Read compressed stream and decompress array... */
if (decompress) {
FREAD(&zfpsize, size_t,
1,
inout);
if (fread(buffer, 1, zfpsize, inout) != zfpsize)
ERRMSG("Error while reading zfp data!");
if (!zfp_decompress(zfp, field)) {
ERRMSG("Decompression failed!");
}
LOG(2, "Read 3-D variable: %s "
"(zfp, PREC= %d, TOL= %g, RATIO= %g %%)",
varname, actual_prec, actual_tol,
(100. * (double) zfpsize) / (double) (nx * ny * nz));
}
/* Compress array and output compressed stream... */
else {
zfpsize = zfp_compress(zfp, field);
if (!zfpsize) {
ERRMSG("Compression failed!");
} else {
FWRITE(&zfpsize, size_t,
1,
inout);
if (fwrite(buffer, 1, zfpsize, inout) != zfpsize)
ERRMSG("Error while writing zfp data!");
}
LOG(2, "Write 3-D variable: %s "
"(zfp, PREC= %d, TOL= %g, RATIO= %g %%)",
varname, actual_prec, actual_tol,
(100. * (double) zfpsize) / (double) (nx * ny * nz));
}
/* Free... */
zfp_field_free(field);
zfp_stream_close(zfp);
stream_close(stream);
free(buffer);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) private(ci,cw) | 100 | s,
double *zs) {
INTPOL_INIT;
ctl->met_tropo = met_tropo;
read_met_tropo(ctl, clim, met);
<LOOP-START>for (int ix = 0; ix < nx; ix++)
for (int iy = 0; iy < ny; iy++) {
intpol_met_space_2d(met, met->pt, lons[ix], lats[iy],
&pt[iy * nx + ix], ci, cw, 1);
intpol_met_space_2d(met, met->ps, lons[ix], lats[iy],
&ps[iy * nx + ix], ci, cw, 0);
intpol_met_space_2d(met, met->zs, lons[ix], lats[iy],
&zs[iy * nx + ix], ci, cw, 0);
intpol_met_space_3d(met, met->z, pt[iy * nx + ix], lons[ix],
lats[iy], &zt[iy * nx + ix], ci, cw, 1);
intpol_met_space_3d(met, met->t, pt[iy * nx + ix], lons[ix],
lats[iy], &tt[iy * nx + ix], ci, cw, 0);
intpol_met_space_3d(met, met->h2o, pt[iy * nx + ix], lons[ix],
lats[iy], &qt[iy * nx + ix], ci, cw, 0);
intpol_met_space_3d(met, met->o3, pt[iy * nx + ix], lons[ix],
lats[iy], &o3t[iy * nx + ix], ci, cw, 0);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(ci,cw)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | tm_t * atm) {
/* Initialize pressure consistent with zeta... */
if (ctl->vert_coord_ap == 1) {
<LOOP-START>for (int ip = 0; ip < atm->np; ip++) {
INTPOL_INIT;
intpol_met_4d_coord(met0, met0->zetal, met0->pl, met1, met1->zetal,
met1->pl, atm->time[ip], atm->q[ctl->qnt_zeta][ip],
atm->lon[ip], atm->lat[ip], &atm->p[ip], ci, cw, 1);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | (ctl->chemgrid_lat1 - ctl->chemgrid_lat0) / ctl->chemgrid_ny;
/* Set vertical coordinates... */
<LOOP-START>for (int iz = 0; iz < ctl->chemgrid_nz; iz++) {
z[iz] = ctl->chemgrid_z0 + dz * (iz + 0.5);
press[iz] = P(z[iz]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | double t0 = tt - 0.5 * ctl->dt_mod;
double t1 = tt + 0.5 * ctl->dt_mod;
/* Get indices... */
<LOOP-START>for (int ip = 0; ip < atm->np; ip++) {
ixs[ip] = (int) ((atm->lon[ip] - ctl->chemgrid_lon0) / dlon);
iys[ip] = (int) ((atm->lat[ip] - ctl->chemgrid_lat0) / dlat);
izs[ip] = (int) ((Z(atm->p[ip]) - ctl->chemgrid_z0) / dz);
if (atm->time[ip] < t0 || atm->time[ip] > t1
|| ixs[ip] < 0 || ixs[ip] >= ctl->chemgrid_nx
|| iys[ip] < 0 || iys[ip] >= ctl->chemgrid_ny
|| izs[ip] < 0 || izs[ip] >= ctl->chemgrid_nz)
izs[ip] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | for (int ix = 0; ix < ctl->chemgrid_nx; ix++)
lon[ix] = ctl->chemgrid_lon0 + dlon * (ix + 0.5);
<LOOP-START>for (int iy = 0; iy < ctl->chemgrid_ny; iy++) {
lat[iy] = ctl->chemgrid_lat0 + dlat * (iy + 0.5);
area[iy] = dlat * dlon * SQR(RE * M_PI / 180.)
* cos(lat[iy] * M_PI / 180.);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | zs[ip], ctl->chemgrid_nz)]
+= atm->q[ctl->qnt_m][ip];
/* Assign grid data to air parcels ... */
<LOOP-START>for (int ip = 0; ip < atm->np; ip++)
if (izs[ip] >= 0) {
/* Interpolate temperature... */
double temp;
INTPOL_INIT;
intpol_met_time_3d(met0, met0->t, met1, met1->t, tt, press[izs[ip]],
lon[ixs[ip]], lat[iys[ip]], &temp, ci, cw, 1);
/* Set mass... */
double m = mass[ARRAY_3D(ixs[ip], iys[ip], ctl->chemgrid_ny,
izs[ip], ctl->chemgrid_nz)];
/* Calculate volume mixing ratio... */
atm->q[ctl->qnt_Cx][ip] = MA / ctl->molmass * m
/ (1e9 * RHO(press[izs[ip]], temp) * area[iys[ip]] * dz);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | module_chem_init(
ctl_t * ctl,
clim_t * clim,
met_t * met0,
met_t * met1,
atm_t * atm) {
<LOOP-START>for (int ip = 0; ip < atm->np; ip++) {
/* Set H2O and O3 using meteo data... */
INTPOL_INIT;
if (ctl->qnt_Ch2o >= 0) {
double h2o;
INTPOL_3D(h2o, 1);
SET_ATM(qnt_Ch2o, h2o);
}
if (ctl->qnt_Co3 >= 0) {
double o3;
INTPOL_3D(o3, 1);
SET_ATM(qnt_Co3, o3);
}
/* Set radical species... */
SET_ATM(qnt_Coh, clim_oh(ctl, clim, atm->time[ip],
atm->lon[ip], atm->lat[ip], atm->p[ip]));
SET_ATM(qnt_Cho2, clim_zm(&clim->ho2, atm->time[ip],
atm->lat[ip], atm->p[ip]));
SET_ATM(qnt_Ch2o2, clim_zm(&clim->h2o2, atm->time[ip],
atm->lat[ip], atm->p[ip]));
SET_ATM(qnt_Co1d, clim_zm(&clim->o1d, atm->time[ip],
atm->lat[ip], atm->p[ip]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | acc data present(ctl,clim,atm,ixs,iys,izs)
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (int ip = 0; ip < np; ip++) {
ixs[ip] = (int) ((atm->lon[ip] - ctl->mixing_lon0) / dlon);
iys[ip] = (int) ((atm->lat[ip] - ctl->mixing_lat0) / dlat);
izs[ip] = (int) ((Z(atm->p[ip]) - ctl->mixing_z0) / dz);
if (atm->time[ip] < t0 || atm->time[ip] > t1
|| ixs[ip] < 0 || ixs[ip] >= ctl->mixing_nx
|| iys[ip] < 0 || iys[ip] >= ctl->mixing_ny
|| izs[ip] < 0 || izs[ip] >= ctl->mixing_nz)
izs[ip] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for | 100 | #pragma acc parallel loop independent gang vector
#else
#ifdef __NVCOMPILER
#pragma novector
#endif
<LOOP-START>for (int i = 0; i < ngrid; i++) {
count[i] = 0;
cmean[i] = 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for | 100 | #pragma acc parallel loop independent gang vector
#else
#ifdef __NVCOMPILER
#pragma novector
#endif
<LOOP-START>for (int i = 0; i < ngrid; i++)
if (count[i] > 0)
cmean[i] /= count[i];
/* Calculate interparcel mixing... */
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
#pragma omp parallel for
for (int ip = 0; ip < np; ip++)
if (izs[ip] >= 0) {
/* Set mixing parameter... */
double mixparam = 1.0;
if (ctl->mixing_trop < 1 || ctl->mixing_strat < 1) {
double w =
tropo_weight(clim, atm->time[ip], atm->lat[ip], atm->p[ip]);
mixparam = w * ctl->mixing_trop + (1 - w) * ctl->mixing_strat;
}
/* Adjust quantity... */
atm->q[qnt_idx][ip] +=
(cmean
[ARRAY_3D(ixs[ip], iys[ip], ctl->mixing_ny, izs[ip], ctl->mixing_nz)]
- atm->q[qnt_idx][ip]) * mixparam;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for | 100 | te interparcel mixing... */
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (int ip = 0; ip < np; ip++)
if (izs[ip] >= 0) {
/* Set mixing parameter... */
double mixparam = 1.0;
if (ctl->mixing_trop < 1 || ctl->mixing_strat < 1) {
double w =
tropo_weight(clim, atm->time[ip], atm->lat[ip], atm->p[ip]);
mixparam = w * ctl->mixing_trop + (1 - w) * ctl->mixing_strat;
}
/* Adjust quantity... */
atm->q[qnt_idx][ip] +=
(cmean
[ARRAY_3D(ixs[ip], iys[ip], ctl->mixing_ny, izs[ip], ctl->mixing_nz)]
- atm->q[qnt_idx][ip]) * mixparam;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | erators... */
if (ctl->rng_type == 0) {
/* Uniform distribution... */
if (method == 0) {
<LOOP-START>for (size_t i = 0; i < n; ++i)
rs[i] = gsl_rng_uniform(rng[omp_get_thread_num()]);
}
/* Normal distribution... */
else if (method == 1) {
#pragma omp parallel for default(shared)
for (size_t i = 0; i < n; ++i)
rs[i] = gsl_ran_gaussian_ziggurat(rng[omp_get_thread_num()], 1.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | orm(rng[omp_get_thread_num()]);
}
/* Normal distribution... */
else if (method == 1) {
<LOOP-START>for (size_t i = 0; i < n; ++i)
rs[i] = gsl_ran_gaussian_ziggurat(rng[omp_get_thread_num()], 1.0);
}
/* Update of random numbers on device... */
#ifdef _OPENACC
#pragma acc update device(rs[:n])
}
/* Use Squares random number generator (Widynski, 2022)... */
else if (ctl->rng_type == 1) {
/* Set key (don't change this!)... */
const uint64_t key = 0xc8e4fd154ce32f6d;
/* Uniform distribution... */
#ifdef _OPENACC
#pragma acc data present(rs)
#pragma acc parallel loop independent gang vector
#else
#pragma omp parallel for default(shared)
for (size_t i = 0; i < n + 1; ++i) {
uint64_t r, t, x, y, z;
y = x = (rng_ctr + i) * key;
z = y + key;
x = x * x + y;
x = (x >> 32) | (x << 32);
x = x * x + z;
x = (x >> 32) | (x << 32);
x = x * x + y;
x = (x >> 32) | (x << 32);
t = x = x * x + z;
x = (x >> 32) | (x << 32);
r = t ^ ((x * x + y) >> 32);
rs[i] = (double) r / (double) UINT64_MAX;
}
rng_ctr += n + 1;
/* Normal distribution... */
if (method == 1) {
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
#pragma omp parallel for default(shared)
for (size_t i = 0; i < n; i += 2) {
double r = sqrt(-2.0 * log(rs[i]));
double phi = 2.0 * M_PI * rs[i + 1];
rs[i] = r * cosf((float) phi);
rs[i + 1] = r * sinf((float) phi);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ifdef _OPENACC
#pragma acc data present(rs)
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (size_t i = 0; i < n + 1; ++i) {
uint64_t r, t, x, y, z;
y = x = (rng_ctr + i) * key;
z = y + key;
x = x * x + y;
x = (x >> 32) | (x << 32);
x = x * x + z;
x = (x >> 32) | (x << 32);
x = x * x + y;
x = (x >> 32) | (x << 32);
t = x = x * x + z;
x = (x >> 32) | (x << 32);
r = t ^ ((x * x + y) >> 32);
rs[i] = (double) r / (double) UINT64_MAX;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | . */
if (method == 1) {
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (size_t i = 0; i < n; i += 2) {
double r = sqrt(-2.0 * log(rs[i]));
double phi = 2.0 * M_PI * rs[i + 1];
rs[i] = r * cosf((float) phi);
rs[i + 1] = r * sinf((float) phi);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | f
/* Get box index... */
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (int ip = 0; ip < np; ip++) {
a[ip] =
(double) ((locate_reg(met0->lon, met0->nx, atm->lon[ip]) * met0->ny +
locate_reg(met0->lat, met0->ny, atm->lat[ip]))
* met0->np + locate_irr(met0->p, met0->np, atm->p[ip]));
p[ip] = ip;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | p[0:np])
#pragma acc data present(a,p,help)
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (int ip = 0; ip < np; ip++)
help[ip] = a[p[ip]];
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
#pragma omp parallel for default(shared)
for (int ip = 0; ip < np; ip++)
a[ip] = help[ip];
/* Free... */
#ifdef _OPENACC
#pragma acc exit data delete(help)
free(help);
}
/*****************************************************************************/
void module_timesteps(
ctl_t * ctl,
met_t * met0,
atm_t * atm,
double *dt,
double t) {
/* Set timer... */
SELECT_TIMER("MODULE_TIMESTEPS", "PHYSICS", NVTX_GPU);
const double latmin = gsl_stats_min(met0->lat, 1, (size_t) met0->ny),
latmax = gsl_stats_max(met0->lat, 1, (size_t) met0->ny);
const int local =
(fabs(met0->lon[met0->nx - 1] - met0->lon[0] - 360.0) >= 0.01);
/* Loop over particles... */
PARTICLE_LOOP(0, atm->np, 0, "acc data present(ctl,atm,met0,dt)") {
/* Set time step for each air parcel... */
if ((ctl->direction * (atm->time[ip] - ctl->t_start) >= 0
&& ctl->direction * (atm->time[ip] - ctl->t_stop) <= 0
&& ctl->direction * (atm->time[ip] - t) < 0))
dt[ip] = t - atm->time[ip];
else
dt[ip] = 0.0;
/* Check horizontal boundaries of local meteo data... */
if (local && (atm->lon[ip] <= met0->lon[0]
|| atm->lon[ip] >= met0->lon[met0->nx - 1]
|| atm->lat[ip] <= latmin || atm->lat[ip] >= latmax))
dt[ip] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | +)
help[ip] = a[p[ip]];
#ifdef _OPENACC
#pragma acc parallel loop independent gang vector
#else
<LOOP-START>for (int ip = 0; ip < np; ip++)
a[ip] = help[ip];
/* Free... */
#ifdef _OPENACC
#pragma acc exit data delete(help)
free(help);
}
/*****************************************************************************/
void module_timesteps(
ctl_t * ctl,
met_t * met0,
atm_t * atm,
double *dt,
double t) {
/* Set timer... */
SELECT_TIMER("MODULE_TIMESTEPS", "PHYSICS", NVTX_GPU);
const double latmin = gsl_stats_min(met0->lat, 1, (size_t) met0->ny),
latmax = gsl_stats_max(met0->lat, 1, (size_t) met0->ny);
const int local =
(fabs(met0->lon[met0->nx - 1] - met0->lon[0] - 360.0) >= 0.01);
/* Loop over particles... */
PARTICLE_LOOP(0, atm->np, 0, "acc data present(ctl,atm,met0,dt)") {
/* Set time step for each air parcel... */
if ((ctl->direction * (atm->time[ip] - ctl->t_start) >= 0
&& ctl->direction * (atm->time[ip] - ctl->t_stop) <= 0
&& ctl->direction * (atm->time[ip] - t) < 0))
dt[ip] = t - atm->time[ip];
else
dt[ip] = 0.0;
/* Check horizontal boundaries of local meteo data... */
if (local && (atm->lon[ip] <= met0->lon[0]
|| atm->lon[ip] >= met0->lon[met0->nx - 1]
|| atm->lat[ip] <= latmin || atm->lat[ip] >= latmax))
dt[ip] = 0.0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | ERRMSG("MPTRAC was compiled without cmultiscale compression!");
#endif
}
/* Copy data... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++) {
var[ix][iy][ip] = help[ARRAY_3D(ix, iy, met->ny, ip, met->np)];
if (var[ix][iy][ip] < bound_min)
var[ix][iy][ip] = bound_min;
else if (var[ix][iy][ip] > bound_max)
var[ix][iy][ip] = bound_max;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | ... */
const double pfac = 1.01439, dz0 = RI / MA / G0 * log(pfac);
/* Loop over columns... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Get potential temperature and water vapor at lowest 50 hPa... */
int n = 0;
double h2o = 0, t, theta = 0;
double pbot = MIN(met->ps[ix][iy], met->p[0]);
double ptop = pbot - 50.;
for (int ip = 0; ip < met->np; ip++) {
if (met->p[ip] <= pbot) {
theta += THETA(met->p[ip], met->t[ix][iy][ip]);
h2o += met->h2o[ix][iy][ip];
n++;
}
if (met->p[ip] < ptop && n > 0)
break;
}
theta /= n;
h2o /= n;
/* Cannot compute anything if water vapor is missing... */
met->plcl[ix][iy] = NAN;
met->plfc[ix][iy] = NAN;
met->pel[ix][iy] = NAN;
met->cape[ix][iy] = NAN;
met->cin[ix][iy] = NAN;
if (h2o <= 0)
continue;
/* Find lifted condensation level (LCL)... */
ptop = P(20.);
pbot = met->ps[ix][iy];
do {
met->plcl[ix][iy] = (float) (0.5 * (pbot + ptop));
t = theta / pow(1000. / met->plcl[ix][iy], 0.286);
if (RH(met->plcl[ix][iy], t, h2o) > 100.)
ptop = met->plcl[ix][iy];
else
pbot = met->plcl[ix][iy];
} while (pbot - ptop > 0.1);
/* Calculate CIN up to LCL... */
INTPOL_INIT;
double dcape, dz, h2o_env, t_env;
double p = met->ps[ix][iy];
met->cape[ix][iy] = met->cin[ix][iy] = 0;
do {
dz = dz0 * TVIRT(t, h2o);
p /= pfac;
t = theta / pow(1000. / p, 0.286);
intpol_met_space_3d(met, met->t, p, met->lon[ix], met->lat[iy],
&t_env, ci, cw, 1);
intpol_met_space_3d(met, met->h2o, p, met->lon[ix], met->lat[iy],
&h2o_env, ci, cw, 0);
dcape = 1e3 * G0 * (TVIRT(t, h2o) - TVIRT(t_env, h2o_env)) /
TVIRT(t_env, h2o_env) * dz;
if (dcape < 0)
met->cin[ix][iy] += fabsf((float) dcape);
} while (p > met->plcl[ix][iy]);
/* Calculate level of free convection (LFC), equilibrium level (EL),
and convective available potential energy (CAPE)... */
dcape = 0;
p = met->plcl[ix][iy];
t = theta / pow(1000. / p, 0.286);
ptop = 0.75 * clim_tropo(clim, met->time, met->lat[iy]);
do {
dz = dz0 * TVIRT(t, h2o);
p /= pfac;
t -= lapse_rate(t, h2o) * dz;
double psat = PSAT(t);
h2o = psat / (p - (1. - EPS) * psat);
intpol_met_space_3d(met, met->t, p, met->lon[ix], met->lat[iy],
&t_env, ci, cw, 1);
intpol_met_space_3d(met, met->h2o, p, met->lon[ix], met->lat[iy],
&h2o_env, ci, cw, 0);
double dcape_old = dcape;
dcape = 1e3 * G0 * (TVIRT(t, h2o) - TVIRT(t_env, h2o_env)) /
TVIRT(t_env, h2o_env) * dz;
if (dcape > 0) {
met->cape[ix][iy] += (float) dcape;
if (!isfinite(met->plfc[ix][iy]))
met->plfc[ix][iy] = (float) p;
} else if (dcape_old > 0)
met->pel[ix][iy] = (float) p;
if (dcape < 0 && !isfinite(met->plfc[ix][iy]))
met->cin[ix][iy] += fabsf((float) dcape);
} while (p > ptop);
/* Check results... */
if (!isfinite(met->plfc[ix][iy]))
met->cin[ix][iy] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | T_CLOUD", "METPROC", NVTX_READ);
LOG(2, "Calculate cloud data...");
/* Loop over columns... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Init... */
met->pct[ix][iy] = NAN;
met->pcb[ix][iy] = NAN;
met->cl[ix][iy] = 0;
/* Loop over pressure levels... */
for (int ip = 0; ip < met->np - 1; ip++) {
/* Check pressure... */
if (met->p[ip] > met->ps[ix][iy] || met->p[ip] < P(20.))
continue;
/* Check ice water and liquid water content... */
if (met->iwc[ix][iy][ip] > 0 || met->rwc[ix][iy][ip] > 0
|| met->lwc[ix][iy][ip] > 0 || met->swc[ix][iy][ip] > 0) {
/* Get cloud top pressure ... */
met->pct[ix][iy]
= (float) (0.5 * (met->p[ip] + (float) met->p[ip + 1]));
/* Get cloud bottom pressure ... */
if (!isfinite(met->pcb[ix][iy]))
met->pcb[ix][iy]
= (float) (0.5 * (met->p[ip] + met->p[MAX(ip - 1, 0)]));
}
/* Get cloud water... */
met->cl[ix][iy] += (float)
(0.5 * (met->lwc[ix][iy][ip] + met->lwc[ix][iy][ip + 1]
+ met->rwc[ix][iy][ip] + met->rwc[ix][iy][ip + 1]
+ met->iwc[ix][iy][ip] + met->iwc[ix][iy][ip + 1]
+ met->swc[ix][iy][ip] + met->swc[ix][iy][ip + 1])
* 100. * (met->p[ip] - met->p[ip + 1]) / G0);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | (met->lat[1] - met->lat[0]));
sy = MIN(MAX(1, sy), met->ny / 2);
/* Calculate background... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++) {
for (int iy = 0; iy < met->ny; iy++) {
/* Calculate Cartesian coordinates... */
double x0[3];
geo2cart(0.0, met->lon[ix], met->lat[iy], x0);
/* Calculate box size in longitude... */
int sx =
(int) (3. * DX2DEG(sigma, met->lat[iy]) /
fabs(met->lon[1] - met->lon[0]));
sx = MIN(MAX(1, sx), met->nx / 2);
/* Init... */
float wsum = 0;
for (int ip = 0; ip < met->np; ip++) {
help->t[ix][iy][ip] = 0;
help->u[ix][iy][ip] = 0;
help->v[ix][iy][ip] = 0;
help->w[ix][iy][ip] = 0;
}
/* Loop over neighboring grid points... */
for (int ix2 = ix - sx; ix2 <= ix + sx; ix2++) {
int ix3 = ix2;
if (ix3 < 0)
ix3 += met->nx;
else if (ix3 >= met->nx)
ix3 -= met->nx;
for (int iy2 = MAX(iy - sy, 0);
iy2 <= MIN(iy + sy, met->ny - 1); iy2++) {
/* Calculate Cartesian coordinates... */
double x1[3];
geo2cart(0.0, met->lon[ix3], met->lat[iy2], x1);
/* Calculate weighting factor... */
float w = (float) exp(-DIST2(x0, x1) / tssq);
/* Add data... */
wsum += w;
for (int ip = 0; ip < met->np; ip++) {
help->t[ix][iy][ip] += w * met->t[ix3][iy2][ip];
help->u[ix][iy][ip] += w * met->u[ix3][iy2][ip];
help->v[ix][iy][ip] += w * met->v[ix3][iy2][ip];
help->w[ix][iy][ip] += w * met->w[ix3][iy2][ip];
}
}
}
/* Normalize... */
for (int ip = 0; ip < met->np; ip++) {
help->t[ix][iy][ip] /= wsum;
help->u[ix][iy][ip] /= wsum;
help->v[ix][iy][ip] /= wsum;
help->w[ix][iy][ip] /= wsum;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(3) | 100 | x][iy][ip] /= wsum;
help->w[ix][iy][ip] /= wsum;
}
}
}
/* Subtract background... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++) {
met->t[ix][iy][ip] -= help->t[ix][iy][ip];
met->u[ix][iy][ip] -= help->u[ix][iy][ip];
met->v[ix][iy][ip] -= help->v[ix][iy][ip];
met->w[ix][iy][ip] -= help->w[ix][iy][ip];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(3)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | OLATE", "METPROC", NVTX_READ);
LOG(2, "Extrapolate meteo data...");
/* Loop over columns... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Find lowest valid data point... */
int ip0;
for (ip0 = met->np - 1; ip0 >= 0; ip0--)
if (!isfinite(met->t[ix][iy][ip0])
|| !isfinite(met->u[ix][iy][ip0])
|| !isfinite(met->v[ix][iy][ip0])
|| !isfinite(met->w[ix][iy][ip0]))
break;
/* Extrapolate... */
for (int ip = ip0; ip >= 0; ip--) {
met->t[ix][iy][ip] = met->t[ix][iy][ip + 1];
met->u[ix][iy][ip] = met->u[ix][iy][ip + 1];
met->v[ix][iy][ip] = met->v[ix][iy][ip + 1];
met->w[ix][iy][ip] = met->w[ix][iy][ip + 1];
met->h2o[ix][iy][ip] = met->h2o[ix][iy][ip + 1];
met->o3[ix][iy][ip] = met->o3[ix][iy][ip + 1];
met->lwc[ix][iy][ip] = met->lwc[ix][iy][ip + 1];
met->rwc[ix][iy][ip] = met->rwc[ix][iy][ip + 1];
met->iwc[ix][iy][ip] = met->iwc[ix][iy][ip + 1];
met->swc[ix][iy][ip] = met->swc[ix][iy][ip + 1];
met->cc[ix][iy][ip] = met->cc[ix][iy][ip + 1];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ROC", NVTX_READ);
LOG(2, "Calculate geopotential heights...");
/* Calculate log pressure... */
<LOOP-START>for (int ip = 0; ip < met->np; ip++)
logp[ip] = log(met->p[ip]);
/* Apply hydrostatic equation to calculate geopotential heights... */
#pragma omp parallel for default(shared) collapse(2)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Get surface height and pressure... */
double zs = met->zs[ix][iy];
double lnps = log(met->ps[ix][iy]);
/* Get temperature and water vapor at the surface... */
int ip0 = locate_irr(met->p, met->np, met->ps[ix][iy]);
double ts = LIN(met->p[ip0], met->t[ix][iy][ip0], met->p[ip0 + 1],
met->t[ix][iy][ip0 + 1], met->ps[ix][iy]);
double h2os = LIN(met->p[ip0], met->h2o[ix][iy][ip0], met->p[ip0 + 1],
met->h2o[ix][iy][ip0 + 1], met->ps[ix][iy]);
/* Upper part of profile... */
met->z[ix][iy][ip0 + 1]
= (float) (zs +
ZDIFF(lnps, ts, h2os, logp[ip0 + 1],
met->t[ix][iy][ip0 + 1], met->h2o[ix][iy][ip0 + 1]));
for (int ip = ip0 + 2; ip < met->np; ip++)
met->z[ix][iy][ip]
= (float) (met->z[ix][iy][ip - 1] +
ZDIFF(logp[ip - 1], met->t[ix][iy][ip - 1],
met->h2o[ix][iy][ip - 1], logp[ip],
met->t[ix][iy][ip], met->h2o[ix][iy][ip]));
/* Lower part of profile... */
met->z[ix][iy][ip0]
= (float) (zs +
ZDIFF(lnps, ts, h2os, logp[ip0],
met->t[ix][iy][ip0], met->h2o[ix][iy][ip0]));
for (int ip = ip0 - 1; ip >= 0; ip--)
met->z[ix][iy][ip]
= (float) (met->z[ix][iy][ip + 1] +
ZDIFF(logp[ip + 1], met->t[ix][iy][ip + 1],
met->h2o[ix][iy][ip + 1], logp[ip],
met->t[ix][iy][ip], met->h2o[ix][iy][ip]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | ogp[ip] = log(met->p[ip]);
/* Apply hydrostatic equation to calculate geopotential heights... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Get surface height and pressure... */
double zs = met->zs[ix][iy];
double lnps = log(met->ps[ix][iy]);
/* Get temperature and water vapor at the surface... */
int ip0 = locate_irr(met->p, met->np, met->ps[ix][iy]);
double ts = LIN(met->p[ip0], met->t[ix][iy][ip0], met->p[ip0 + 1],
met->t[ix][iy][ip0 + 1], met->ps[ix][iy]);
double h2os = LIN(met->p[ip0], met->h2o[ix][iy][ip0], met->p[ip0 + 1],
met->h2o[ix][iy][ip0 + 1], met->ps[ix][iy]);
/* Upper part of profile... */
met->z[ix][iy][ip0 + 1]
= (float) (zs +
ZDIFF(lnps, ts, h2os, logp[ip0 + 1],
met->t[ix][iy][ip0 + 1], met->h2o[ix][iy][ip0 + 1]));
for (int ip = ip0 + 2; ip < met->np; ip++)
met->z[ix][iy][ip]
= (float) (met->z[ix][iy][ip - 1] +
ZDIFF(logp[ip - 1], met->t[ix][iy][ip - 1],
met->h2o[ix][iy][ip - 1], logp[ip],
met->t[ix][iy][ip], met->h2o[ix][iy][ip]));
/* Lower part of profile... */
met->z[ix][iy][ip0]
= (float) (zs +
ZDIFF(lnps, ts, h2os, logp[ip0],
met->t[ix][iy][ip0], met->h2o[ix][iy][ip0]));
for (int ip = ip0 - 1; ip >= 0; ip--)
met->z[ix][iy][ip]
= (float) (met->z[ix][iy][ip + 1] +
ZDIFF(logp[ip + 1], met->t[ix][iy][ip + 1],
met->h2o[ix][iy][ip + 1], logp[ip],
met->t[ix][iy][ip], met->h2o[ix][iy][ip]));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | 6;
dy = 4;
}
}
/* Calculate weights for smoothing... */
float ws[dx + 1][dy + 1];
<LOOP-START>for (int ix = 0; ix <= dx; ix++)
for (int iy = 0; iy < dy; iy++)
ws[ix][iy] = (1.0f - (float) ix / (float) dx)
* (1.0f - (float) iy / (float) dy);
/* Copy data... */
#pragma omp parallel for default(shared) collapse(3)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++)
help[ip][ix][iy] = met->z[ix][iy][ip];
/* Horizontal smoothing... */
#pragma omp parallel for default(shared) collapse(3)
for (int ip = 0; ip < met->np; ip++)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
float res = 0, wsum = 0;
int iy0 = MAX(iy - dy + 1, 0);
int iy1 = MIN(iy + dy - 1, met->ny - 1);
for (int ix2 = ix - dx + 1; ix2 <= ix + dx - 1; ++ix2) {
int ix3 = ix2;
if (ix3 < 0)
ix3 += met->nx;
else if (ix3 >= met->nx)
ix3 -= met->nx;
for (int iy2 = iy0; iy2 <= iy1; ++iy2)
if (isfinite(help[ip][ix3][iy2])) {
float w = ws[abs(ix - ix2)][abs(iy - iy2)];
res += w * help[ip][ix3][iy2];
wsum += w;
}
}
if (wsum > 0)
met->z[ix][iy][ip] = res / wsum;
else
met->z[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(3) | 100 | ][iy] = (1.0f - (float) ix / (float) dx)
* (1.0f - (float) iy / (float) dy);
/* Copy data... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++)
help[ip][ix][iy] = met->z[ix][iy][ip];
/* Horizontal smoothing... */
#pragma omp parallel for default(shared) collapse(3)
for (int ip = 0; ip < met->np; ip++)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
float res = 0, wsum = 0;
int iy0 = MAX(iy - dy + 1, 0);
int iy1 = MIN(iy + dy - 1, met->ny - 1);
for (int ix2 = ix - dx + 1; ix2 <= ix + dx - 1; ++ix2) {
int ix3 = ix2;
if (ix3 < 0)
ix3 += met->nx;
else if (ix3 >= met->nx)
ix3 -= met->nx;
for (int iy2 = iy0; iy2 <= iy1; ++iy2)
if (isfinite(help[ip][ix3][iy2])) {
float w = ws[abs(ix - ix2)][abs(iy - iy2)];
res += w * help[ip][ix3][iy2];
wsum += w;
}
}
if (wsum > 0)
met->z[ix][iy][ip] = res / wsum;
else
met->z[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(3)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(3) | 100 | p = 0; ip < met->np; ip++)
help[ip][ix][iy] = met->z[ix][iy][ip];
/* Horizontal smoothing... */
<LOOP-START>for (int ip = 0; ip < met->np; ip++)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
float res = 0, wsum = 0;
int iy0 = MAX(iy - dy + 1, 0);
int iy1 = MIN(iy + dy - 1, met->ny - 1);
for (int ix2 = ix - dx + 1; ix2 <= ix + dx - 1; ++ix2) {
int ix3 = ix2;
if (ix3 < 0)
ix3 += met->nx;
else if (ix3 >= met->nx)
ix3 -= met->nx;
for (int iy2 = iy0; iy2 <= iy1; ++iy2)
if (isfinite(help[ip][ix3][iy2])) {
float w = ws[abs(ix - ix2)][abs(iy - iy2)];
res += w * help[ip][ix3][iy2];
wsum += w;
}
}
if (wsum > 0)
met->z[ix][iy][ip] = res / wsum;
else
met->z[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(3)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | , "rh", "RH", NULL, NULL, ctl, met, met->h2o, 0.01f))
WARN("Cannot read relative humidity!");
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++) {
double pw = met->h2o[ix][iy][ip] * PSAT(met->t[ix][iy][ip]);
met->h2o[ix][iy][ip] =
(float) (pw / (met->p[ip] - (1.0 - EPS) * pw));
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) private(aux,p) collapse(2) | 100 | ;
LOG(2, "Interpolate meteo data to pressure levels: %s", varname);
/* Loop over columns... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Copy pressure profile... */
for (int ip = 0; ip < met->np; ip++)
p[ip] = met->pl[ix][iy][ip];
/* Interpolate... */
for (int ip = 0; ip < ctl->met_np; ip++) {
double pt = ctl->met_p[ip];
if ((pt > p[0] && p[0] > p[1]) || (pt < p[0] && p[0] < p[1]))
pt = p[0];
else if ((pt > p[met->np - 1] && p[1] > p[0])
|| (pt < p[met->np - 1] && p[1] < p[0]))
pt = p[met->np - 1];
int ip2 = locate_irr(p, met->np, pt);
aux[ip] = LIN(p[ip2], var[ix][iy][ip2],
p[ip2 + 1], var[ix][iy][ip2 + 1], pt);
}
/* Copy data... */
for (int ip = 0; ip < ctl->met_np; ip++)
var[ix][iy][ip] = (float) aux[ip];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(aux,p) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | , NVTX_READ);
LOG(2, "Make zeta profiles monotone...");
/* Create monotone zeta profiles... */
<LOOP-START>for (int i = 0; i < met->nx; i++)
for (int j = 0; j < met->ny; j++) {
int k = 1;
while (k < met->npl) { /* Check if there is an inversion at level k... */
if ((met->zetal[i][j][k - 1] >= met->zetal[i][j][k])) {
/* Find the upper level k+l over the inversion... */
int l = 0;
do {
l++;
}
while ((met->zetal[i][j][k - 1] >=
met->zetal[i][j][k + l]) & (k + l < met->npl));
/* Interpolate linear between the top and bottom
of the inversion... */
float s =
(float) (met->zetal[i][j][k + l] - met->zetal[i][j][k - 1])
/ (float) (met->hybrid[k + l] - met->hybrid[k - 1]);
for (int m = k; m < k + l; m++) {
float d = (float) (met->hybrid[m] - met->hybrid[k - 1]);
met->zetal[i][j][m] = s * d + met->zetal[i][j][k - 1];
}
/* Search for more inversions above the last inversion ... */
k = k + l;
} else {
k++;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | . */
k = k + l;
} else {
k++;
}
}
}
/* Create monotone pressure profiles... */
<LOOP-START>for (int i = 0; i < met->nx; i++)
for (int j = 0; j < met->ny; j++) {
int k = 1;
while (k < met->npl) { /* Check if there is an inversion at level k... */
if ((met->pl[i][j][k - 1] <= met->pl[i][j][k])) {
/* Find the upper level k+l over the inversion... */
int l = 0;
do {
l++;
}
while ((met->pl[i][j][k - 1] <= met->pl[i][j][k + l]) & (k + l <
met->npl));
/* Interpolate linear between the top and bottom
of the inversion... */
float s = (float) (met->pl[i][j][k + l] - met->pl[i][j][k - 1])
/ (float) (met->hybrid[k + l] - met->hybrid[k - 1]);
for (int m = k; m < k + l; m++) {
float d = (float) (met->hybrid[m] - met->hybrid[k - 1]);
met->pl[i][j][m] = s * d + met->pl[i][j][k - 1];
}
/* Search for more inversions above the last inversion ... */
k = k + l;
} else {
k++;
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 | SG("Meteo data layout not implemented for packed netCDF files!");
/* Copy and check data... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
if (init)
dest[ix][iy] = 0;
short aux = help[ARRAY_2D(iy, ix, met->nx)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux * scalfac + offset) < 1e14f)
dest[ix][iy] += scl * (aux * scalfac + offset);
else
dest[ix][iy] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 | ... */
if (ctl->met_convention == 0) {
/* Copy and check data (ordering: lat, lon)... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
if (init)
dest[ix][iy] = 0;
float aux = help[ARRAY_2D(iy, ix, met->nx)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux) < 1e14f)
dest[ix][iy] += scl * aux;
else
dest[ix][iy] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 |
dest[ix][iy] = NAN;
}
} else {
/* Copy and check data (ordering: lon, lat)... */
<LOOP-START>for (int iy = 0; iy < met->ny; iy++)
for (int ix = 0; ix < met->nx; ix++) {
if (init)
dest[ix][iy] = 0;
float aux = help[ARRAY_2D(ix, iy, met->ny)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux) < 1e14f)
dest[ix][iy] += scl * aux;
else
dest[ix][iy] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 | SG("Meteo data layout not implemented for packed netCDF files!");
/* Copy and check data... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++) {
short aux = help[ARRAY_3D(ip, iy, met->ny, ix, met->nx)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux * scalfac + offset) < 1e14f)
dest[ix][iy][ip] = scl * (aux * scalfac + offset);
else
dest[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 | /
if (ctl->met_convention == 0) {
/* Copy and check data (ordering: lev, lat, lon)... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++) {
float aux = help[ARRAY_3D(ip, iy, met->ny, ix, met->nx)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux) < 1e14f)
dest[ix][iy][ip] = scl * aux;
else
dest[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) num_threads(12) | 100 | ix][iy][ip] = NAN;
}
} else {
/* Copy and check data (ordering: lon, lat, lev)... */
<LOOP-START>for (int ip = 0; ip < met->np; ip++)
for (int iy = 0; iy < met->ny; iy++)
for (int ix = 0; ix < met->nx; ix++) {
float aux = help[ARRAY_3D(ix, iy, met->ny, ip, met->np)];
if ((fillval == 0 || aux != fillval)
&& (missval == 0 || aux != missval)
&& fabsf(aux) < 1e14f)
dest[ix][iy][ip] = scl * aux;
else
dest[ix][iy][ip] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) num_threads(12)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | 012)... */
const double rib_crit = 0.25, dz = 0.05, umin = 5.0;
/* Loop over grid points... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Set bottom level of PBL... */
double pbl_bot = met->ps[ix][iy] + DZ2DP(dz, met->ps[ix][iy]);
/* Find lowest level near the bottom... */
int ip;
for (ip = 1; ip < met->np; ip++)
if (met->p[ip] < pbl_bot)
break;
/* Get near surface data... */
double zs = LIN(met->p[ip - 1], met->z[ix][iy][ip - 1],
met->p[ip], met->z[ix][iy][ip], pbl_bot);
double ts = LIN(met->p[ip - 1], met->t[ix][iy][ip - 1],
met->p[ip], met->t[ix][iy][ip], pbl_bot);
double us = LIN(met->p[ip - 1], met->u[ix][iy][ip - 1],
met->p[ip], met->u[ix][iy][ip], pbl_bot);
double vs = LIN(met->p[ip - 1], met->v[ix][iy][ip - 1],
met->p[ip], met->v[ix][iy][ip], pbl_bot);
double h2os = LIN(met->p[ip - 1], met->h2o[ix][iy][ip - 1],
met->p[ip], met->h2o[ix][iy][ip], pbl_bot);
double tvs = THETAVIRT(pbl_bot, ts, h2os);
/* Init... */
double rib_old = 0;
/* Loop over levels... */
for (; ip < met->np; ip++) {
/* Get squared horizontal wind speed... */
double vh2
= SQR(met->u[ix][iy][ip] - us) + SQR(met->v[ix][iy][ip] - vs);
vh2 = MAX(vh2, SQR(umin));
/* Calculate bulk Richardson number... */
double rib = G0 * 1e3 * (met->z[ix][iy][ip] - zs) / tvs
* (THETAVIRT(met->p[ip], met->t[ix][iy][ip],
met->h2o[ix][iy][ip]) - tvs) / vh2;
/* Check for critical value... */
if (rib >= rib_crit) {
met->pbl[ix][iy] = (float) (LIN(rib_old, met->p[ip - 1],
rib, met->p[ip], rib_crit));
if (met->pbl[ix][iy] > pbl_bot)
met->pbl[ix][iy] = (float) pbl_bot;
break;
}
/* Save Richardson number... */
rib_old = rib;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ->lon[met->nx - 2] + met->lon[1] - met->lon[0];
/* Loop over latitudes and pressure levels... */
<LOOP-START>for (int iy = 0; iy < met->ny; iy++) {
met->ps[met->nx - 1][iy] = met->ps[0][iy];
met->zs[met->nx - 1][iy] = met->zs[0][iy];
met->ts[met->nx - 1][iy] = met->ts[0][iy];
met->us[met->nx - 1][iy] = met->us[0][iy];
met->vs[met->nx - 1][iy] = met->vs[0][iy];
met->lsm[met->nx - 1][iy] = met->lsm[0][iy];
met->sst[met->nx - 1][iy] = met->sst[0][iy];
for (int ip = 0; ip < met->np; ip++) {
met->t[met->nx - 1][iy][ip] = met->t[0][iy][ip];
met->u[met->nx - 1][iy][ip] = met->u[0][iy][ip];
met->v[met->nx - 1][iy][ip] = met->v[0][iy][ip];
met->w[met->nx - 1][iy][ip] = met->w[0][iy][ip];
met->h2o[met->nx - 1][iy][ip] = met->h2o[0][iy][ip];
met->o3[met->nx - 1][iy][ip] = met->o3[0][iy][ip];
met->lwc[met->nx - 1][iy][ip] = met->lwc[0][iy][ip];
met->rwc[met->nx - 1][iy][ip] = met->rwc[0][iy][ip];
met->iwc[met->nx - 1][iy][ip] = met->iwc[0][iy][ip];
met->swc[met->nx - 1][iy][ip] = met->swc[0][iy][ip];
met->cc[met->nx - 1][iy][ip] = met->cc[0][iy][ip];
}
for (int ip = 0; ip < met->npl; ip++) {
met->ul[met->nx - 1][iy][ip] = met->ul[0][iy][ip];
met->vl[met->nx - 1][iy][ip] = met->vl[0][iy][ip];
met->wl[met->nx - 1][iy][ip] = met->wl[0][iy][ip];
met->pl[met->nx - 1][iy][ip] = met->pl[0][iy][ip];
met->zetal[met->nx - 1][iy][ip] = met->zetal[0][iy][ip];
met->zeta_dotl[met->nx - 1][iy][ip] = met->zeta_dotl[0][iy][ip];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | 0)
sign = -1;
/* Look-up table of cosinus and sinus... */
double clon[EX], slon[EX];
<LOOP-START>for (int ix = 0; ix < met->nx; ix++) {
clon[ix] = cos(sign * met->lon[ix] / 180. * M_PI);
slon[ix] = sin(sign * met->lon[ix] / 180. * M_PI);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | _PI);
slon[ix] = sin(sign * met->lon[ix] / 180. * M_PI);
}
/* Loop over levels... */
<LOOP-START>for (int ip = 0; ip < met->np; ip++) {
/* Transform 89 degree u and v winds into Cartesian coordinates and take the mean... */
double vel89x = 0, vel89y = 0;
for (int ix = 0; ix < met->nx; ix++) {
vel89x +=
(met->u[ix][i89][ip] * clon[ix] -
met->v[ix][i89][ip] * slon[ix]) / met->nx;
vel89y +=
(met->u[ix][i89][ip] * slon[ix] +
met->v[ix][i89][ip] * clon[ix]) / met->nx;
}
/* Replace 90 degree winds by 89 degree mean... */
for (int ix = 0; ix < met->nx; ix++) {
met->u[ix][i90][ip]
= (float) (vel89x * clon[ix] + vel89y * slon[ix]);
met->v[ix][i90][ip]
= (float) (-vel89x * slon[ix] + vel89y * clon[ix]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ET_PV", "METPROC", NVTX_READ);
LOG(2, "Calculate potential vorticity...");
/* Set powers... */
<LOOP-START>for (int ip = 0; ip < met->np; ip++)
pows[ip] = pow(1000. / met->p[ip], 0.286);
/* Loop over grid points... */
#pragma omp parallel for default(shared)
for (int ix = 0; ix < met->nx; ix++) {
/* Set indices... */
int ix0 = MAX(ix - 1, 0);
int ix1 = MIN(ix + 1, met->nx - 1);
/* Loop over grid points... */
for (int iy = 0; iy < met->ny; iy++) {
/* Set indices... */
int iy0 = MAX(iy - 1, 0);
int iy1 = MIN(iy + 1, met->ny - 1);
/* Set auxiliary variables... */
double latr = 0.5 * (met->lat[iy1] + met->lat[iy0]);
double dx = 1000. * DEG2DX(met->lon[ix1] - met->lon[ix0], latr);
double dy = 1000. * DEG2DY(met->lat[iy1] - met->lat[iy0]);
double c0 = cos(met->lat[iy0] / 180. * M_PI);
double c1 = cos(met->lat[iy1] / 180. * M_PI);
double cr = cos(latr / 180. * M_PI);
double vort = 2 * 7.2921e-5 * sin(latr * M_PI / 180.);
/* Loop over grid points... */
for (int ip = 0; ip < met->np; ip++) {
/* Get gradients in longitude... */
double dtdx
= (met->t[ix1][iy][ip] - met->t[ix0][iy][ip]) * pows[ip] / dx;
double dvdx = (met->v[ix1][iy][ip] - met->v[ix0][iy][ip]) / dx;
/* Get gradients in latitude... */
double dtdy
= (met->t[ix][iy1][ip] - met->t[ix][iy0][ip]) * pows[ip] / dy;
double dudy
= (met->u[ix][iy1][ip] * c1 - met->u[ix][iy0][ip] * c0) / dy;
/* Set indices... */
int ip0 = MAX(ip - 1, 0);
int ip1 = MIN(ip + 1, met->np - 1);
/* Get gradients in pressure... */
double dtdp, dudp, dvdp;
double dp0 = 100. * (met->p[ip] - met->p[ip0]);
double dp1 = 100. * (met->p[ip1] - met->p[ip]);
if (ip != ip0 && ip != ip1) {
double denom = dp0 * dp1 * (dp0 + dp1);
dtdp = (dp0 * dp0 * met->t[ix][iy][ip1] * pows[ip1]
- dp1 * dp1 * met->t[ix][iy][ip0] * pows[ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->t[ix][iy][ip] * pows[ip])
/ denom;
dudp = (dp0 * dp0 * met->u[ix][iy][ip1]
- dp1 * dp1 * met->u[ix][iy][ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->u[ix][iy][ip])
/ denom;
dvdp = (dp0 * dp0 * met->v[ix][iy][ip1]
- dp1 * dp1 * met->v[ix][iy][ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->v[ix][iy][ip])
/ denom;
} else {
double denom = dp0 + dp1;
dtdp =
(met->t[ix][iy][ip1] * pows[ip1] -
met->t[ix][iy][ip0] * pows[ip0]) / denom;
dudp = (met->u[ix][iy][ip1] - met->u[ix][iy][ip0]) / denom;
dvdp = (met->v[ix][iy][ip1] - met->v[ix][iy][ip0]) / denom;
}
/* Calculate PV... */
met->pv[ix][iy][ip] = (float)
(1e6 * G0 *
(-dtdp * (dvdx - dudy / cr + vort) + dvdp * dtdx - dudp * dtdy));
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | p < met->np; ip++)
pows[ip] = pow(1000. / met->p[ip], 0.286);
/* Loop over grid points... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++) {
/* Set indices... */
int ix0 = MAX(ix - 1, 0);
int ix1 = MIN(ix + 1, met->nx - 1);
/* Loop over grid points... */
for (int iy = 0; iy < met->ny; iy++) {
/* Set indices... */
int iy0 = MAX(iy - 1, 0);
int iy1 = MIN(iy + 1, met->ny - 1);
/* Set auxiliary variables... */
double latr = 0.5 * (met->lat[iy1] + met->lat[iy0]);
double dx = 1000. * DEG2DX(met->lon[ix1] - met->lon[ix0], latr);
double dy = 1000. * DEG2DY(met->lat[iy1] - met->lat[iy0]);
double c0 = cos(met->lat[iy0] / 180. * M_PI);
double c1 = cos(met->lat[iy1] / 180. * M_PI);
double cr = cos(latr / 180. * M_PI);
double vort = 2 * 7.2921e-5 * sin(latr * M_PI / 180.);
/* Loop over grid points... */
for (int ip = 0; ip < met->np; ip++) {
/* Get gradients in longitude... */
double dtdx
= (met->t[ix1][iy][ip] - met->t[ix0][iy][ip]) * pows[ip] / dx;
double dvdx = (met->v[ix1][iy][ip] - met->v[ix0][iy][ip]) / dx;
/* Get gradients in latitude... */
double dtdy
= (met->t[ix][iy1][ip] - met->t[ix][iy0][ip]) * pows[ip] / dy;
double dudy
= (met->u[ix][iy1][ip] * c1 - met->u[ix][iy0][ip] * c0) / dy;
/* Set indices... */
int ip0 = MAX(ip - 1, 0);
int ip1 = MIN(ip + 1, met->np - 1);
/* Get gradients in pressure... */
double dtdp, dudp, dvdp;
double dp0 = 100. * (met->p[ip] - met->p[ip0]);
double dp1 = 100. * (met->p[ip1] - met->p[ip]);
if (ip != ip0 && ip != ip1) {
double denom = dp0 * dp1 * (dp0 + dp1);
dtdp = (dp0 * dp0 * met->t[ix][iy][ip1] * pows[ip1]
- dp1 * dp1 * met->t[ix][iy][ip0] * pows[ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->t[ix][iy][ip] * pows[ip])
/ denom;
dudp = (dp0 * dp0 * met->u[ix][iy][ip1]
- dp1 * dp1 * met->u[ix][iy][ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->u[ix][iy][ip])
/ denom;
dvdp = (dp0 * dp0 * met->v[ix][iy][ip1]
- dp1 * dp1 * met->v[ix][iy][ip0]
+ (dp1 * dp1 - dp0 * dp0) * met->v[ix][iy][ip])
/ denom;
} else {
double denom = dp0 + dp1;
dtdp =
(met->t[ix][iy][ip1] * pows[ip1] -
met->t[ix][iy][ip0] * pows[ip0]) / denom;
dudp = (met->u[ix][iy][ip1] - met->u[ix][iy][ip0]) / denom;
dvdp = (met->v[ix][iy][ip1] - met->v[ix][iy][ip0]) / denom;
}
/* Calculate PV... */
met->pv[ix][iy][ip] = (float)
(1e6 * G0 *
(-dtdp * (dvdx - dudy / cr + vort) + dvdp * dtdx - dudp * dtdy));
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | udy / cr + vort) + dvdp * dtdx - dudp * dtdy));
}
}
}
/* Fix for polar regions... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int ip = 0; ip < met->np; ip++) {
met->pv[ix][0][ip]
= met->pv[ix][1][ip]
= met->pv[ix][2][ip];
met->pv[ix][met->ny - 1][ip]
= met->pv[ix][met->ny - 2][ip]
= met->pv[ix][met->ny - 3][ip];
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | , "METPROC", NVTX_READ);
LOG(2, "Calculate total column ozone...");
/* Loop over columns... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Integrate... */
double cd = 0;
for (int ip = 1; ip < met->np; ip++)
if (met->p[ip - 1] <= met->ps[ix][iy]) {
double vmr = 0.5 * (met->o3[ix][iy][ip - 1] + met->o3[ix][iy][ip]);
double dp = met->p[ip - 1] - met->p[ip];
cd += vmr * MO3 / MA * dp * 1e2 / G0;
}
/* Convert to Dobson units... */
met->o3c[ix][iy] = (float) (cd / 2.1415e-5);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | C", NVTX_READ);
LOG(2, "Calculate tropopause...");
/* Get altitude and pressure profiles... */
<LOOP-START>for (int iz = 0; iz < met->np; iz++)
z[iz] = Z(met->p[iz]);
#pragma omp parallel for default(shared)
for (int iz = 0; iz <= 190; iz++) {
z2[iz] = 4.5 + 0.1 * iz;
p2[iz] = P(z2[iz]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | omp parallel for default(shared)
for (int iz = 0; iz < met->np; iz++)
z[iz] = Z(met->p[iz]);
<LOOP-START>for (int iz = 0; iz <= 190; iz++) {
z2[iz] = 4.5 + 0.1 * iz;
p2[iz] = P(z2[iz]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | iz;
p2[iz] = P(z2[iz]);
}
/* Do not calculate tropopause... */
if (ctl->met_tropo == 0)
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
met->pt[ix][iy] = NAN;
/* Use tropopause climatology... */
else if (ctl->met_tropo == 1) {
#pragma omp parallel for default(shared) collapse(2)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
met->pt[ix][iy] = (float) clim_tropo(clim, met->time, met->lat[iy]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | +)
met->pt[ix][iy] = NAN;
/* Use tropopause climatology... */
else if (ctl->met_tropo == 1) {
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
met->pt[ix][iy] = (float) clim_tropo(clim, met->time, met->lat[iy]);
}
/* Use cold point... */
else if (ctl->met_tropo == 2) {
/* Loop over grid points... */
#pragma omp parallel for default(shared) private(t,t2) collapse(2)
for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Interpolate temperature profile... */
for (int iz = 0; iz < met->np; iz++)
t[iz] = met->t[ix][iy][iz];
spline(z, t, met->np, z2, t2, 171, ctl->met_tropo_spline);
/* Find minimum... */
int iz = (int) gsl_stats_min_index(t2, 1, 171);
if (iz > 0 && iz < 170)
met->pt[ix][iy] = (float) p2[iz];
else
met->pt[ix][iy] = NAN;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) private(t,t2) collapse(2) | 100 | }
/* Use cold point... */
else if (ctl->met_tropo == 2) {
/* Loop over grid points... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Interpolate temperature profile... */
for (int iz = 0; iz < met->np; iz++)
t[iz] = met->t[ix][iy][iz];
spline(z, t, met->np, z2, t2, 171, ctl->met_tropo_spline);
/* Find minimum... */
int iz = (int) gsl_stats_min_index(t2, 1, 171);
if (iz > 0 && iz < 170)
met->pt[ix][iy] = (float) p2[iz];
else
met->pt[ix][iy] = NAN;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(t,t2) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) private(t,t2) collapse(2) | 100 | ... */
else if (ctl->met_tropo == 3 || ctl->met_tropo == 4) {
/* Loop over grid points... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Interpolate temperature profile... */
int iz;
for (iz = 0; iz < met->np; iz++)
t[iz] = met->t[ix][iy][iz];
spline(z, t, met->np, z2, t2, 191, ctl->met_tropo_spline);
/* Find 1st tropopause... */
met->pt[ix][iy] = NAN;
for (iz = 0; iz <= 170; iz++) {
int found = 1;
for (int iz2 = iz + 1; iz2 <= iz + 20; iz2++)
if (LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]) > 2.0) {
found = 0;
break;
}
if (found) {
if (iz > 0 && iz < 170)
met->pt[ix][iy] = (float) p2[iz];
break;
}
}
/* Find 2nd tropopause... */
if (ctl->met_tropo == 4) {
met->pt[ix][iy] = NAN;
for (; iz <= 170; iz++) {
int found = 1;
for (int iz2 = iz + 1; iz2 <= iz + 10; iz2++)
if (LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]) < 3.0) {
found = 0;
break;
}
if (found)
break;
}
for (; iz <= 170; iz++) {
int found = 1;
for (int iz2 = iz + 1; iz2 <= iz + 20; iz2++)
if (LAPSE(p2[iz], t2[iz], p2[iz2], t2[iz2]) > 2.0) {
found = 0;
break;
}
if (found) {
if (iz > 0 && iz < 170)
met->pt[ix][iy] = (float) p2[iz];
break;
}
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(t,t2) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) private(pv,pv2,th,th2) collapse(2) | 100 | se dynamical tropopause... */
else if (ctl->met_tropo == 5) {
/* Loop over grid points... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
/* Interpolate potential vorticity profile... */
for (int iz = 0; iz < met->np; iz++)
pv[iz] = met->pv[ix][iy][iz];
spline(z, pv, met->np, z2, pv2, 171, ctl->met_tropo_spline);
/* Interpolate potential temperature profile... */
for (int iz = 0; iz < met->np; iz++)
th[iz] = THETA(met->p[iz], met->t[ix][iy][iz]);
spline(z, th, met->np, z2, th2, 171, ctl->met_tropo_spline);
/* Find dynamical tropopause... */
met->pt[ix][iy] = NAN;
for (int iz = 0; iz <= 170; iz++)
if (fabs(pv2[iz]) >= ctl->met_tropo_pv
|| th2[iz] >= ctl->met_tropo_theta) {
if (iz > 0 && iz < 170)
met->pt[ix][iy] = (float) p2[iz];
break;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) private(pv,pv2,th,th2) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | calculate tropopause!");
/* Interpolate temperature, geopotential height, and water vapor... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++) {
double h2ot, tt, zt;
INTPOL_INIT;
intpol_met_space_3d(met, met->t, met->pt[ix][iy], met->lon[ix],
met->lat[iy], &tt, ci, cw, 1);
intpol_met_space_3d(met, met->z, met->pt[ix][iy], met->lon[ix],
met->lat[iy], &zt, ci, cw, 0);
intpol_met_space_3d(met, met->h2o, met->pt[ix][iy], met->lon[ix],
met->lat[iy], &h2ot, ci, cw, 0);
met->tt[ix][iy] = (float) tt;
met->zt[ix][iy] = (float) zt;
met->h2ot[ix][iy] = (float) h2ot;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ouble dlat = (ctl->grid_lat1 - ctl->grid_lat0) / ctl->grid_ny;
/* Set vertical coordinates... */
<LOOP-START>for (int iz = 0; iz < ctl->grid_nz; iz++) {
z[iz] = ctl->grid_z0 + dz * (iz + 0.5);
press[iz] = P(z[iz]);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | .. */
for (int ix = 0; ix < ctl->grid_nx; ix++)
lon[ix] = ctl->grid_lon0 + dlon * (ix + 0.5);
<LOOP-START>for (int iy = 0; iy < ctl->grid_ny; iy++) {
lat[iy] = ctl->grid_lat0 + dlat * (iy + 0.5);
area[iy] = dlat * dlon * SQR(RE * M_PI / 180.)
* cos(lat[iy] * M_PI / 180.);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | e t0 = t - 0.5 * ctl->dt_mod;
double t1 = t + 0.5 * ctl->dt_mod;
/* Get grid box indices... */
<LOOP-START>for (int ip = 0; ip < atm->np; ip++) {
ixs[ip] = (int) ((atm->lon[ip] - ctl->grid_lon0) / dlon);
iys[ip] = (int) ((atm->lat[ip] - ctl->grid_lat0) / dlat);
izs[ip] = (int) ((Z(atm->p[ip]) - ctl->grid_z0) / dz);
if (atm->time[ip] < t0 || atm->time[ip] > t1
|| ixs[ip] < 0 || ixs[ip] >= ctl->grid_nx
|| iys[ip] < 0 || iys[ip] >= ctl->grid_ny
|| izs[ip] < 0 || izs[ip] >= ctl->grid_nz)
izs[ip] = -1;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) | 100 | ernel * atm->q[iq][ip]);
}
}
/* Calculate column density and volume mixing ratio... */
<LOOP-START>for (int ix = 0; ix < ctl->grid_nx; ix++)
for (int iy = 0; iy < ctl->grid_ny; iy++)
for (int iz = 0; iz < ctl->grid_nz; iz++) {
/* Get grid index... */
int idx = ARRAY_3D(ix, iy, ctl->grid_ny, iz, ctl->grid_nz);
/* Calculate column density... */
cd[idx] = NAN;
if (ctl->qnt_m >= 0)
cd[idx] = mean[ctl->qnt_m][idx] / (1e6 * area[iy]);
/* Calculate volume mixing ratio (implicit)... */
vmr_impl[idx] = NAN;
if (ctl->qnt_m >= 0 && ctl->molmass > 0 && met0 != NULL
&& met1 != NULL) {
vmr_impl[idx] = 0;
if (mean[ctl->qnt_m][idx] > 0) {
/* Get temperature... */
double temp;
INTPOL_INIT;
intpol_met_time_3d(met0, met0->t, met1, met1->t, t, press[iz],
lon[ix], lat[iy], &temp, ci, cw, 1);
/* Calculate volume mixing ratio... */
vmr_impl[idx] = MA / ctl->molmass * mean[ctl->qnt_m][idx]
/ (RHO(press[iz], temp) * 1e6 * area[iy] * 1e3 * dz);
}
}
/* Calculate mean... */
if (np[idx] > 0)
for (int iq = 0; iq < ctl->nq; iq++) {
mean[iq][idx] /= np[idx];
double var = sigma[iq][idx] / np[idx] - SQR(mean[iq][idx]);
sigma[iq][idx] = (var > 0 ? sqrt(var) : 0);
} else
for (int iq = 0; iq < ctl->nq; iq++) {
mean[iq][idx] = NAN;
sigma[iq][idx] = NAN;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) collapse(2) | 100 | ) {
float *help;
/* Allocate... */
ALLOC(help, float,
EX * EY * EP);
/* Copy data... */
<LOOP-START>for (int ix = 0; ix < met->nx; ix++)
for (int iy = 0; iy < met->ny; iy++)
for (int ip = 0; ip < met->np; ip++)
help[ARRAY_3D(ix, iy, met->ny, ip, met->np)] = var[ix][iy][ip];
/* Write uncompressed data... */
if (ctl->met_type == 1) {
LOG(2, "Write 3-D variable: %s (uncompressed)", varname);
FWRITE(help, float,
(size_t) (met->nx * met->ny * met->np),
out);
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) collapse(2)<OMP-END> |
slcs-jsc/mptrac/src/mptrac.c | #pragma omp parallel for default(shared) reduction(+:mass,np) | 100 | le_dz);
/* Init... */
double mass = 0;
int np = 0;
/* Loop over air parcels... */
<LOOP-START>for (int ip = 0; ip < atm->np; ip++) {
/* Check time... */
if (atm->time[ip] < t0 || atm->time[ip] > t1)
continue;
/* Check latitude... */
if (fabs(rlat[i] - atm->lat[ip]) > dlat)
continue;
/* Check horizontal distance... */
double x1[3];
geo2cart(0, atm->lon[ip], atm->lat[ip], x1);
if (DIST2(x0, x1) > rmax2)
continue;
/* Check pressure... */
if (ctl->sample_dz > 0)
if (atm->p[ip] > pbot || atm->p[ip] < ptop)
continue;
/* Add mass... */
if (ctl->qnt_m >= 0)
mass +=
kernel_weight(kz, kw, nk, atm->p[ip]) * atm->q[ctl->qnt_m][ip];
np++;
}<LOOP-END> <OMP-START>#pragma omp parallel for default(shared) reduction(+:mass,np)<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_tag_mt.cc | #pragma omp parallel for | 100 | nd_data[i] = 0xdeadbeefdeadbeef + 10 * i;
recv_data[i] = 0;
}
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
ucs_status_t status;
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT) {
worker_index = i;
}
send_b(&(send_data[i]), sizeof(send_data[i]), DATATYPE, 0x111337+i,
NULL, i);
short_progress_loop(worker_index); /* Receive messages as unexpected */
status = recv_b(&(recv_data[i]), sizeof(recv_data[i]), DATATYPE, 0x1337+i,
0xffff, &(info[i]), NULL, i);
ASSERT_UCS_OK(status);
EXPECT_EQ(sizeof(send_data[i]), info[i].length);
EXPECT_EQ((ucp_tag_t)(0x111337+i), info[i].sender_tag);
EXPECT_EQ(send_data[i], recv_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | > rkey;
rkey.resize(num_threads);
/* test parallel rkey unpack */
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT) {
worker_index = i;
}
ucs_status_t status = ucp_ep_rkey_unpack(sender().ep(worker_index),
rkey_buffer, &rkey[i]);
ASSERT_UCS_OK(status);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | _data[i] = 0xdeadbeefdeadbeef + 10 * i;
target_data[i] = 0;
}
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT) {
worker_index = i;
}
void* req = ucp_put_nb(sender().ep(worker_index), &orig_data[i],
sizeof(uint64_t), (uintptr_t)((uint64_t*)memheap + i),
rkey[i], send_cb);
request_wait(req, {}, worker_index);
flush_worker(sender(), worker_index);
EXPECT_EQ(orig_data[i], target_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | _data[i] = 0xdeadbeefdeadbeef + 10 * i;
target_data[i] = 0;
}
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
ucs_status_t status;
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT)
worker_index = i;
status = ucp_put_nbi(sender().ep(worker_index), &orig_data[i], sizeof(uint64_t),
(uintptr_t)((uint64_t*)memheap + i), rkey[i]);
ASSERT_UCS_OK_OR_INPROGRESS(status);
flush_worker(sender(), worker_index);
EXPECT_EQ(orig_data[i], target_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | _data[i] = 0;
target_data[i] = 0xdeadbeefdeadbeef + 10 * i;
}
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT) {
worker_index = i;
}
void *req = ucp_get_nb(sender().ep(worker_index), &orig_data[i],
sizeof(uint64_t), (uintptr_t)((uint64_t*)memheap + i),
rkey[i], send_cb);
request_wait(req, {}, worker_index);
flush_worker(sender(), worker_index);
EXPECT_EQ(orig_data[i], target_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | _data[i] = 0;
target_data[i] = 0xdeadbeefdeadbeef + 10 * i;
}
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
ucs_status_t status;
int worker_index = 0;
if (get_variant_thread_type() == MULTI_THREAD_CONTEXT) {
worker_index = i;
}
status = ucp_get_nbi(sender().ep(worker_index), &orig_data[i], sizeof(uint64_t),
(uintptr_t)((uint64_t *)memheap + i), rkey[i]);
ASSERT_UCS_OK_OR_INPROGRESS(status);
flush_worker(sender(), worker_index);
EXPECT_EQ(orig_data[i], target_data[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
openucx/ucx/test/gtest/ucp/test_ucp_rma_mt.cc | #pragma omp parallel for | 100 | er_index);
EXPECT_EQ(orig_data[i], target_data[i]);
}
#endif
#if _OPENMP && ENABLE_MT
<LOOP-START>for (int i = 0; i < num_threads; i++) {
ucp_rkey_destroy(rkey[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | rintf ("Number of Threads counted = %i\n",k);
#endif
/* Get initial value for system clock. */
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++) {
a[j] = 1.0;
b[j] = 2.0;
c[j] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | rity appears to be "
"less than one microsecond.\n");
quantum = 1;
}
t = mysecond();
<LOOP-START>for (j = 0; j < STREAM_ARRAY_SIZE; j++)
a[j] = 2.0E0 * a[j];
t = 1.0E6 * (mysecond() - t);
printf("Each test below will take on the order"
" of %d microseconds.\n", (int) t );
printf(" (= %d clock ticks)\n", (int) (t/quantum) );
printf("Increase the size of the arrays if this shows that\n");
printf("you are not getting at least 20 clock ticks per test.\n");
printf(HLINE);
printf("WARNING -- The above is only a rough guideline.\n");
printf("For best results, please be sure you know the\n");
printf("precision of your system timer.\n");
printf(HLINE);
/* --- MAIN LOOP --- repeat test cases NTIMES times --- */
scalar = 3.0;
for (k=0; k<NTIMES; k++)
{
times[0][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Copy();
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j];
times[0][k] = mysecond() - times[0][k];
times[1][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Scale(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
times[1][k] = mysecond() - times[1][k];
times[2][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Add();
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
times[2][k] = mysecond() - times[2][k];
times[3][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Triad(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
times[3][k] = mysecond() - times[3][k];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | (k=0; k<NTIMES; k++)
{
times[0][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Copy();
#else
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j];
times[0][k] = mysecond() - times[0][k];
times[1][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Scale(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
times[1][k] = mysecond() - times[1][k];
times[2][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Add();
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
times[2][k] = mysecond() - times[2][k];
times[3][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Triad(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
times[3][k] = mysecond() - times[3][k];
}
#ifdef USE_LIKWID
LIKWID_MARKER_CLOSE;
/* --- SUMMARY --- */
for (k=1; k<NTIMES; k++) /* note -- skip first iteration */
{
for (j=0; j<4; j++)
{
avgtime[j] = avgtime[j] + times[j][k];
mintime[j] = MIN(mintime[j], times[j][k]);
maxtime[j] = MAX(maxtime[j], times[j][k]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | - times[0][k];
times[1][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Scale(scalar);
#else
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
times[1][k] = mysecond() - times[1][k];
times[2][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Add();
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
times[2][k] = mysecond() - times[2][k];
times[3][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Triad(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
times[3][k] = mysecond() - times[3][k];
}
#ifdef USE_LIKWID
LIKWID_MARKER_CLOSE;
/* --- SUMMARY --- */
for (k=1; k<NTIMES; k++) /* note -- skip first iteration */
{
for (j=0; j<4; j++)
{
avgtime[j] = avgtime[j] + times[j][k];
mintime[j] = MIN(mintime[j], times[j][k]);
maxtime[j] = MAX(maxtime[j], times[j][k]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | second() - times[1][k];
times[2][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Add();
#else
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
times[2][k] = mysecond() - times[2][k];
times[3][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Triad(scalar);
#else
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
times[3][k] = mysecond() - times[3][k];
}
#ifdef USE_LIKWID
LIKWID_MARKER_CLOSE;
/* --- SUMMARY --- */
for (k=1; k<NTIMES; k++) /* note -- skip first iteration */
{
for (j=0; j<4; j++)
{
avgtime[j] = avgtime[j] + times[j][k];
mintime[j] = MIN(mintime[j], times[j][k]);
maxtime[j] = MAX(maxtime[j], times[j][k]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/STREAM/stream.c | #pragma omp parallel for | 100 | - times[2][k];
times[3][k] = mysecond();
#ifdef TUNED
tuned_STREAM_Triad(scalar);
#else
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
times[3][k] = mysecond() - times[3][k];
}
#ifdef USE_LIKWID
LIKWID_MARKER_CLOSE;
/* --- SUMMARY --- */
for (k=1; k<NTIMES; k++) /* note -- skip first iteration */
{
for (j=0; j<4; j++)
{
avgtime[j] = avgtime[j] + times[j][k];
mintime[j] = MIN(mintime[j], times[j][k]);
maxtime[j] = MAX(maxtime[j], times[j][k]);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/linear_algebra.c | #pragma omp parallel for | 100 | anspose of mat_a
void transpose_matrix(double** mat_a, int rows_a, int cols_a, double** mat_c) {
<LOOP-START>for (int i = 0; i < rows_a; i++) {
for (int j = 0; j < cols_a; j++) {
mat_c[j][i] = mat_a[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/linear_algebra_separate.c | #pragma omp parallel for | 100 | e of mat_a
// void transpose_matrix(double** mat_a, int rows_a, int cols_a, double** mat_c) {
// <LOOP-START>// for (int i = 0; i < rows_a; i++) {
// for (int j = 0; j < cols_a; j++) {
// mat_c[j][i] = mat_a[i][j];
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for private(i,j,k) | 100 | *));
for (i=0; i<rows_a; i++) V[i] = (double*)aligned_alloc(256,cols_b*sizeof(double)+GAP);
// <LOOP-START>// for (i=0; i<size; i++) {
// for (j=0; j<size; j++) {
// A[i][j] = (double)rand()/(double)(RAND_MAX);
// B[i][j] = (double)rand()/(double)(RAND_MAX);
// C[i][j] = 0.0;
// V[i][j] = 0.0;
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for private(i,j,k) | 100 | ] = (double)rand()/(double)(RAND_MAX);
// C[i][j] = 0.0;
// V[i][j] = 0.0;
// }
// }
<LOOP-START>for (i=0; i<rows_a; i++)
for (j=0; j<cols_a; j++)
A[i][j] = (double)rand()/(double)(RAND_MAX);
#pragma omp parallel for private(i,j,k)
for (i=0; i<cols_a; i++)
for (j=0; j<cols_b; j++)
B[i][j] = (double)rand()/(double)(RAND_MAX);
#pragma omp parallel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
C[i][j] = 0.0;
#pragma omp parallel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
V[i][j] = 0.0;
transpose_matrix(B, cols_a, cols_b, B_T);
//fill validation matrix based on naive implementation
if (validate) {
printf("producing validation matrix...\n"); fflush(stdout);
// multiply_matrix_vp(A, size, size, B_T, size, V);
multiply_matrix_vp(A, rows_a, cols_a, B_T, cols_b, V);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for private(i,j,k) | 100 | (i=0; i<rows_a; i++)
for (j=0; j<cols_a; j++)
A[i][j] = (double)rand()/(double)(RAND_MAX);
<LOOP-START>for (i=0; i<cols_a; i++)
for (j=0; j<cols_b; j++)
B[i][j] = (double)rand()/(double)(RAND_MAX);
#pragma omp parallel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
C[i][j] = 0.0;
#pragma omp parallel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
V[i][j] = 0.0;
transpose_matrix(B, cols_a, cols_b, B_T);
//fill validation matrix based on naive implementation
if (validate) {
printf("producing validation matrix...\n"); fflush(stdout);
// multiply_matrix_vp(A, size, size, B_T, size, V);
multiply_matrix_vp(A, rows_a, cols_a, B_T, cols_b, V);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for private(i,j,k) | 100 | (i=0; i<cols_a; i++)
for (j=0; j<cols_b; j++)
B[i][j] = (double)rand()/(double)(RAND_MAX);
<LOOP-START>for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
C[i][j] = 0.0;
#pragma omp parallel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
V[i][j] = 0.0;
transpose_matrix(B, cols_a, cols_b, B_T);
//fill validation matrix based on naive implementation
if (validate) {
printf("producing validation matrix...\n"); fflush(stdout);
// multiply_matrix_vp(A, size, size, B_T, size, V);
multiply_matrix_vp(A, rows_a, cols_a, B_T, cols_b, V);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for private(i,j,k) | 100 | llel for private(i,j,k)
for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
C[i][j] = 0.0;
<LOOP-START>for (i=0; i<rows_a; i++)
for (j=0; j<cols_b; j++)
V[i][j] = 0.0;
transpose_matrix(B, cols_a, cols_b, B_T);
//fill validation matrix based on naive implementation
if (validate) {
printf("producing validation matrix...\n"); fflush(stdout);
// multiply_matrix_vp(A, size, size, B_T, size, V);
multiply_matrix_vp(A, rows_a, cols_a, B_T, cols_b, V);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for | 100 | = omp_get_wtime();
if (validate) {
printf("Checking result...\n"); fflush(stdout);
// <LOOP-START>// #pragma omp parallel for reduction(+:ee) private(i,j)
// for (i=0; i<size; i++) {
// for (j=0; j<size; j++) {
// ee += (C[i][j] - V[i][j])*(C[i][j] - V[i][j]);
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/test_linear_algebra.c | #pragma omp parallel for reduction(+:ee) private(i,j) | 100 | date) {
printf("Checking result...\n"); fflush(stdout);
// #pragma omp parallel for
// <LOOP-START>// for (i=0; i<size; i++) {
// for (j=0; j<size; j++) {
// ee += (C[i][j] - V[i][j])*(C[i][j] - V[i][j]);
// }
// }<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:ee) private(i,j)<OMP-END> |
HPCL/benchmarks/kernels/mm_blocks/matrix_mul_validated.c | #pragma omp parallel for private(i,j,k) | 100 | double** mat_b, int cols_b,
double** mat_c) {
int i, j, k;
<LOOP-START>for (i = 0; i < rows_a; i++) {
for (j = 0; j < cols_b; j++) {
mat_c[i][j] = 0;
for (k = 0; k < cols_a; k++) {
mat_c[i][j] += mat_a[i][k] * mat_b[j][k];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i,j,k)<OMP-END> |
HPCL/benchmarks/kernels/shingles/fp_crunch/fp_utils.c | #pragma omp parallel for | 100 | it_arrays(fa, fb, fc);
// #pragma unroll(DATA_SIZE)
for( long t = 0; t < n_trials; t++ ){
<LOOP-START>for (int i = 0; i < DATA_SIZE; i++) {
fa[i] += fc[i] * fb[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/kernels/shingles/fp_crunch/fp_utils.c | #pragma omp parallel for shared(fa) reduction(+:norm) | 100 | nt i = 0; i < DATA_SIZE; i++) {
fa[i] += fc[i] * fb[i];
}
}
// norm for validation
<LOOP-START>for (int i = 0; i < DATA_SIZE; i++) {
norm += fa[i] * fa[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(fa) reduction(+:norm)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.