filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
ENCCS/intermediate-mpi/content/code/day-4/02_threading-multiple/solution/threading-multiple.c | #pragma omp parallel for | 100 | cal computation. OpenMP will distribute each
* iteration to a different thread. */
<LOOP-START>for (int k = 0; k != 2; k = k + 1)
{
compute_row(local_work[k], working_data_set, next_working_data_set);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
ENCCS/intermediate-mpi/content/code/day-4/02_threading-multiple/solution/threading-multiple.c | #pragma omp parallel for | 100 | * iteration to a different thread. */
int non_local_work[] = {1, 4};
<LOOP-START>for (int k = 0; k != 2; k = k + 1)
{
compute_row(non_local_work[k], working_data_set, next_working_data_set);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | r(size_t i=0; i < particleVec.size(); i++)
{
double densityVal = 0;
<LOOP-START>for(size_t j = 0; j < particleVec[i].neighbours.size(); j++)
{
if(i == particleVec[i].neighbours[j])continue;
const Helper::Point3D diffParticleNeighbour = particleVec[i].position - particleVec[particleVec[i].neighbours[j]].position;
if(Config::SupportRadius - diffParticleNeighbour.calcNorm() > DBL_EPSILON)
{
densityVal += particleVec[particleVec[i].neighbours[j]].mass * PolyKernel(diffParticleNeighbour);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | }
}
void IISPHForces::compute_gravity_force(ParticleVec& particleVec)
{
<LOOP-START>for(auto& particle: particleVec)
{
particle.fGravity = Config::GravitationalAcceleration * particle.mass;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | }
}
void IISPHForces::compute_advection_forces(ParticleVec& particleVec)
{
<LOOP-START>for(auto& particle: particleVec)
{
particle.fAdvection = particle.fGravity;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | }
}
void IISPHForces::compute_predicted_velocity(ParticleVec& particleVec)
{
<LOOP-START>for(auto& particle: particleVec)
{
particle.predicted_velocity = particle.velocity + Config::timestep*particle.fAdvection/particle.mass;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | cle.mass;
}
}
void IISPHForces::compute_DII(ParticleVec& particleVec)
{
<LOOP-START>for(size_t i=0; i < particleVec.size(); i++)
{
Helper::Point3D finalDII = Helper::Point3D(0,0,0);
#pragma omp parallel for
for(size_t j=0; j< particleVec[i].neighbours.size(); j++)
{
if(i == particleVec[i].neighbours[j])continue;
const Helper::Point3D diffParticleNeighbour = particleVec[i].position - particleVec[particleVec[i].neighbours[j]].position;
if(Config::SupportRadius - diffParticleNeighbour.calcNorm() > DBL_EPSILON && diffParticleNeighbour.calcNorm()!=0)
{
finalDII += -1 * Config::timestep * Config::timestep * particleVec[particleVec[i].neighbours[j]].mass * PolyKernelGradient(diffParticleNeighbour)/(particleVec[i].density*particleVec[i].density);
}
}
if(std::isnan(finalDII.x) || std::isnan(finalDII.y) || std::isnan(finalDII.z)) std::cout << "computeDII" << i << std::endl;
particleVec[i].dii = finalDII;
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | c.size(); i++)
{
Helper::Point3D finalDII = Helper::Point3D(0,0,0);
<LOOP-START>for(size_t j=0; j< particleVec[i].neighbours.size(); j++)
{
if(i == particleVec[i].neighbours[j])continue;
const Helper::Point3D diffParticleNeighbour = particleVec[i].position - particleVec[particleVec[i].neighbours[j]].position;
if(Config::SupportRadius - diffParticleNeighbour.calcNorm() > DBL_EPSILON && diffParticleNeighbour.calcNorm()!=0)
{
finalDII += -1 * Config::timestep * Config::timestep * particleVec[particleVec[i].neighbours[j]].mass * PolyKernelGradient(diffParticleNeighbour)/(particleVec[i].density*particleVec[i].density);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | Point3D diffParticleNeighbour = pV[i].position - pV[pV[i].neighbours[j]].position;
<LOOP-START>if(Config::SupportRadius - diffParticleNeighbour.calcNorm() > DBL_EPSILON && diffParticleNeighbour.calcNorm()!=0)
{
pV[i].predicted_density += Config::timestep* pV[pV[i].neighbours[j]].mass * (pV[i].predicted_velocity - pV[pV[i].neighbours[j]].predicted_velocity).dot(PolyKernelGradient(diffParticleNeighbour));
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | Point3D diffParticleNeighbour = pV[i].position - pV[pV[i].neighbours[j]].position;
<LOOP-START>if(Config::SupportRadius - diffParticleNeighbour.calcNorm() > DBL_EPSILON && diffParticleNeighbour.calcNorm()!=0)
{
Helper::Point3D dji = -1 * Config::timestep * Config::timestep *( pV[pV[i].neighbours[j]].mass/pow(pV[pV[i].neighbours[j]].density,2)) * PolyKernelGradient(-1 * diffParticleNeighbour);
aiiSUM += pV[pV[i].neighbours[j]].mass *(pV[i].dii - dji).dot(PolyKernelGradient(diffParticleNeighbour));
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | cleVec& particleVec, int i)
{
Helper::Point3D sumDIJ = Helper::Point3D(0,0,0);
<LOOP-START>for(size_t j=0; j< particleVec[i].neighbours.size(); j++)
{
if(i == particleVec[i].neighbours[j])continue;
particleVec[particleVec[i].neighbours[j]].prev_iterate_pressure = particleVec[particleVec[i].neighbours[j]].curr_iterate_pressure;
const Helper::Point3D diffParticleNeighbour = particleVec[i].position - particleVec[particleVec[i].neighbours[j]].position;
if(!diffParticleNeighbour.calcNorm())continue;
sumDIJ += -1 * particleVec[particleVec[i].neighbours[j]].mass * particleVec[particleVec[i].neighbours[j]].prev_iterate_pressure * (PolyKernelGradient(diffParticleNeighbour))/(pow(particleVec[particleVec[i].neighbours[j]].density,2));
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | ize(); i++)
{
double corr_density=0.0;
<LOOP-START>for(size_t j=0; j< pV[i].neighbours.size(); j++)
{
if(i==pV[i].neighbours[j])continue;
const Helper::Point3D diffParticleNeighbour = pV[pV[i].neighbours[j]].position - pV[i].position;
if(!diffParticleNeighbour.calcNorm())continue;
Helper::Point3D dji = -1 * Config::timestep * Config::timestep * (pV[i].mass/(pV[i].density*pV[i].density))*PolyKernelGradient(diffParticleNeighbour);
corr_density += pV[pV[i].neighbours[j]].mass * (pV[i].sigma_dij - (pV[pV[i].neighbours[j]].dii * pV[pV[i].neighbours[j]].prev_iterate_pressure) - (pV[pV[i].neighbours[j]].sigma_dij - dji*pV[i].pressure)).dot(PolyKernelGradient(-1*diffParticleNeighbour));
}<LOOP-END> <OMP-START>#pragma omp parallel for <OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | ble IISPHForces::ErrorDensity(ParticleVec& particleVec)
{
double avg_density=0;
<LOOP-START>for(size_t i=0; i< particleVec.size(); i++)
{
avg_density += particleVec[i].corrected_density ;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | ce(ParticleVec& pV, int i)
{
Helper::Point3D forceSum = Helper::Point3D(0,0,0);
<LOOP-START>for(size_t j=0; j < pV[i].neighbours.size(); j++)
{
if(i == pV[i].neighbours[j])continue;
const Helper::Point3D diffParticleNeighbour = pV[i].position - pV[pV[i].neighbours[j]].position;
if(!diffParticleNeighbour.calcNorm())continue;
forceSum += pV[pV[i].neighbours[j]].mass * ((pV[i].pressure/pow(pV[i].density,2)) + (pV[pV[i].neighbours[j]].pressure/pow(pV[pV[i].neighbours[j]].density,2))) * PolyKernelGradient(diffParticleNeighbour);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
agam-kashyap/Fluid-Simulation-Rendering/Simulation/src/iisph-forces.cpp | #pragma omp parallel for | 100 | * -1 * pV[i].mass;
}
void IISPHForces::integration(ParticleVec& particleVec)
{
<LOOP-START>for(size_t i=0; i < particleVec.size(); i++)
{
if(std::isnan(particleVec[i].velocity.x) || std::isnan(particleVec[i].velocity.y) || std::isnan(particleVec[i].velocity.z))
{
particleVec[i].predicted_velocity = Helper::Point3D(1,1,1);
}
particleVec[i].velocity = particleVec[i].predicted_velocity + Config::timestep * compute_pressure_force(particleVec, i)/particleVec[i].mass ;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/libhermit/usr/benchmarks/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> |
hermit-os/libhermit/usr/benchmarks/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> |
hermit-os/libhermit/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/libhermit/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/libhermit/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/libhermit/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/libhermit/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | #ifdef TUNED
/* stubs for "tuned" versions of the kernels */
void tuned_STREAM_Copy()
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j];
}
void tuned_STREAM_Scale(STREAM_TYPE scalar)
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/libhermit/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | AY_SIZE; j++)
c[j] = a[j];
}
void tuned_STREAM_Scale(STREAM_TYPE scalar)
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}
void tuned_STREAM_Add()
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/libhermit/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | r (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}
void tuned_STREAM_Add()
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
}
void tuned_STREAM_Triad(STREAM_TYPE scalar)
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/libhermit/usr/openmpbench/syncbench.c | #pragma omp parallel for | 100 | Y
static int n = 1;
XRayAnnotate("n = %i", n);
n++;
#endif
for (j = 0; j < innerreps; j++) {
<LOOP-START>for (i = 0; i < nthreads; i++) {
delay(delaylength);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/libhermit/usr/openmpbench/syncbench.c | #pragma omp parallel for ordered schedule (static,1) | 100 | ck);
delay(delaylength);
omp_unset_lock(&lock);
}
}
}
void testorder() {
int j;
<LOOP-START>for (j = 0; j < (int)innerreps; j++) {
#pragma omp ordered
delay(delaylength);
}<LOOP-END> <OMP-START>#pragma omp parallel for ordered schedule (static,1)<OMP-END> |
hermit-os/hermit-playground/usr/benchmarks/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> |
hermit-os/hermit-playground/usr/benchmarks/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> |
hermit-os/hermit-playground/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/hermit-playground/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/hermit-playground/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/hermit-playground/usr/benchmarks/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];
}
/* --- 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> |
hermit-os/hermit-playground/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | #ifdef TUNED
/* stubs for "tuned" versions of the kernels */
void tuned_STREAM_Copy()
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j];
}
void tuned_STREAM_Scale(STREAM_TYPE scalar)
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/hermit-playground/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | AY_SIZE; j++)
c[j] = a[j];
}
void tuned_STREAM_Scale(STREAM_TYPE scalar)
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}
void tuned_STREAM_Add()
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/hermit-playground/usr/benchmarks/stream.c | #pragma omp parallel for | 100 | r (j=0; j<STREAM_ARRAY_SIZE; j++)
b[j] = scalar*c[j];
}
void tuned_STREAM_Add()
{
ssize_t j;
<LOOP-START>for (j=0; j<STREAM_ARRAY_SIZE; j++)
c[j] = a[j]+b[j];
}
void tuned_STREAM_Triad(STREAM_TYPE scalar)
{
ssize_t j;
#pragma omp parallel for
for (j=0; j<STREAM_ARRAY_SIZE; j++)
a[j] = b[j]+scalar*c[j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/hermit-playground/usr/openmpbench/syncbench.c | #pragma omp parallel for | 100 | Y
static int n = 1;
XRayAnnotate("n = %i", n);
n++;
#endif
for (j = 0; j < innerreps; j++) {
<LOOP-START>for (i = 0; i < nthreads; i++) {
delay(delaylength);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
hermit-os/hermit-playground/usr/openmpbench/syncbench.c | #pragma omp parallel for ordered schedule (static,1) | 100 | ck);
delay(delaylength);
omp_unset_lock(&lock);
}
}
}
void testorder() {
int j;
<LOOP-START>for (j = 0; j < (int)innerreps; j++) {
#pragma omp ordered
delay(delaylength);
}<LOOP-END> <OMP-START>#pragma omp parallel for ordered schedule (static,1)<OMP-END> |
RIKEN-SysSoft/mckernel/test/uti/CT30.c | #pragma omp parallel for | 100 | "Error: pthread_create: %s\n", strerror(errno));
exit(1);
}
}
pthread_barrier_wait(&bar);
<LOOP-START>for (i = 0; i < omp_get_num_threads(); i++) {
printf("[INFO] thread_num=%d,tid=%d\n", i, syscall(SYS_gettid));
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
RIKEN-SysSoft/mckernel/test/uti/mpi/011.c | #pragma omp parallel for | 100 | memset(recvv[i], 0, szentry);
}
printf("after memset\n");
print_cpu_last_executed_on("main");
<LOOP-START>for (i = 0; i < omp_get_num_threads(); i++) {
printf("thread_num=%d,tid=%d\n", i, syscall(SYS_gettid));
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/oshmpi/tests/stream_omp.c | #pragma omp parallel for num_threads(NTHREADS) | 100 | r (j = 0; j < STREAM_ARRAY_SIZE; j += blocksize)
{
if (next_p == count_p)
{
#ifdef _OPENMP
<LOOP-START>#ifdef __INTEL_COMPILER
#pragma vector aligned
#pragma ivdep
for (i = j; i < (j + blocksize); i++)
{
a[i] = 1.0;
b[i] = 2.0;
c[i] = 0.0;
a[i] = 2.0E0 * a[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NTHREADS)<OMP-END> |
jeffhammond/oshmpi/tests/stream_omp.c | #pragma omp parallel for num_threads(NTHREADS) | 100 | (j = 0; j < STREAM_ARRAY_SIZE; j += blocksize)
{
if (next_p == count_p)
{
#ifdef _OPENMP
<LOOP-START>#ifdef __INTEL_COMPILER
#pragma vector aligned
#pragma ivdep
for (i = j; i < (j + blocksize); i++)
{
c[i] = a[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NTHREADS)<OMP-END> |
jeffhammond/oshmpi/tests/stream_omp.c | #pragma omp parallel for num_threads(NTHREADS) | 100 | r (j = 0; j < STREAM_ARRAY_SIZE; j += blocksize)
{
if (next_p == count_p)
{
#ifdef _OPENMP
<LOOP-START>#ifdef __INTEL_COMPILER
#pragma vector aligned
#pragma ivdep
for (i = j; i < (j + blocksize); i++)
{
b[i] = scalar * c[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NTHREADS)<OMP-END> |
jeffhammond/oshmpi/tests/stream_omp.c | #pragma omp parallel for num_threads(NTHREADS) | 100 | r (j = 0; j < STREAM_ARRAY_SIZE; j += blocksize)
{
if (next_p == count_p)
{
#ifdef _OPENMP
<LOOP-START>#ifdef __INTEL_COMPILER
#pragma vector aligned
#pragma ivdep
for (i = j; i < (j + blocksize); i++)
{
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NTHREADS)<OMP-END> |
jeffhammond/oshmpi/tests/stream_omp.c | #pragma omp parallel for num_threads(NTHREADS) | 100 | r (j = 0; j < STREAM_ARRAY_SIZE; j += blocksize)
{
if (next_p == count_p)
{
#ifdef _OPENMP
<LOOP-START>#ifdef __INTEL_COMPILER
#pragma vector aligned
#pragma ivdep
for (i = j; i < (j + blocksize); i++)
{
a[i] = b[i] + scalar * c[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(NTHREADS)<OMP-END> |
jeffhammond/HPCInfo/simd/simd-memtest/util.c | #pragma omp parallel for reduction(+:errors) | 100 | re_doubles(size_t n, const double * RESTRICT x, const double * RESTRICT y)
{
size_t errors = 0;
<LOOP-START>for (size_t i=0; i<n; i++) {
if (x[i] != y[i]) errors++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:errors)<OMP-END> |
jeffhammond/HPCInfo/simd/simd-memtest/util.c | #pragma omp parallel for reduction(+:errors) | 100 | ize_t n, const double * RESTRICT x, const double * RESTRICT y, int stride)
{
size_t errors = 0;
<LOOP-START>for (size_t i=0; i<n; i+=stride) {
if (x[i] != y[i]) errors++;
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:errors)<OMP-END> |
jeffhammond/HPCInfo/simd/simd-memtest/util.c | #pragma omp parallel for reduction(+:errors) | 100 | st double * RESTRICT x, const double * RESTRICT y, int stride, double val)
{
size_t errors = 0;
<LOOP-START>for (size_t i=0; i<n; i+=stride) {
/* check the part that is copied */
if (y[i] != x[i]) errors++;
/* between the strides, elements should not change */
for (int s=1; s<stride && i+s<n; s++) {
if (y[i+s] != val) errors++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:errors)<OMP-END> |
jeffhammond/HPCInfo/simd/simd-memtest/util.c | #pragma omp parallel for | 100 | errors++;
}
}
return errors;
}
void init_doubles(size_t n, double * RESTRICT x)
{
<LOOP-START>for (size_t i=0; i<n; i++) {
x[i] = (double)i;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/simd/simd-memtest/util.c | #pragma omp parallel for | 100 |
x[i] = (double)i;
}
}
void set_doubles(size_t n, double value, double * RESTRICT x)
{
<LOOP-START>for (size_t i=0; i<n; i++) {
x[i] = value;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 | eof(double) );
B = safemalloc( N * sizeof(double) );
int k = 0;
#ifdef OMP
<LOOP-START>for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
A[i*n+j] = (double)(k++);
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = 0.0;
/* reference - memcpy */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
memcpy( B , A , N );
t1 = getticks();
d0[n] = (t1-t0)/REPEAT;
/* reference - direct copy */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = A[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 | for ( int j=0 ; j<n ; j++ )
A[i*n+j] = (double)(k++);
#ifdef OMP
<LOOP-START>for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = 0.0;
/* reference - memcpy */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
memcpy( B , A , N );
t1 = getticks();
d0[n] = (t1-t0)/REPEAT;
/* reference - direct copy */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = A[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 |
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
<LOOP-START>for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = A[i*n+j];
}
t1 = getticks();
d1[n] = (t1-t0)/REPEAT;
/* basic w/ stride-1 stores */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = A[j*n+i];
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 |
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
<LOOP-START>for ( int i=0 ; i<n ; i++ )
for ( int j=0 ; j<n ; j++ )
B[i*n+j] = A[j*n+i];
}
t1 = getticks();
d2[n] = (t1-t0)/REPEAT;
/* verify */
for ( int j=0 ; j<n ; j++ )
for ( int i=0 ; i<n ; i++ )
assert( B[i*n+j] == A[j*n+i] );
/* basic w/ stride-1 loads */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
for ( int j=0 ; j<n ; j++ )
for ( int i=0 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 |
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ )
{
#ifdef OMP
<LOOP-START>for ( int j=0 ; j<n ; j++ )
for ( int i=0 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}
t1 = getticks();
d3[n] = (t1-t0)/REPEAT;
/* verify */
for ( int j=0 ; j<n ; j++ )
for ( int i=0 ; i<n ; i++ )
assert( B[i*n+j] == A[j*n+i] );
/* pragma unroll 4x4 + s1 loads */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ ) {
#ifdef OMP
#pragma omp parallel for if(n>OMP_MIN_SIZE)
//#pragma unroll(4)
#pragma unroll_and_jam
for ( int j=0 ; j<n ; j++ )
//#pragma unroll(4)
#pragma unroll_and_jam
for ( int i=0 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/tuning/transpose/transpose.c | #pragma omp parallel for if(n>OMP_MIN_SIZE) | 100 | s1 loads */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ ) {
#ifdef OMP
<LOOP-START>//#pragma unroll(4)
#pragma unroll_and_jam
for ( int j=0 ; j<n ; j++ )
//#pragma unroll(4)
#pragma unroll_and_jam
for ( int i=0 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}
t1 = getticks();
d4[n] = (t1-t0)/REPEAT;
/* verify */
for ( int j=0 ; j<n ; j++ )
for ( int i=0 ; i<n ; i++ )
assert( B[i*n+j] == A[j*n+i] );
/* manual unroll 4x4 + s1 loads */
t0 = getticks();
for ( int t=0 ; t<REPEAT ; t++ ) {
#ifdef OMP
#pragma omp parallel if(n>OMP_MIN_SIZE)
{
int n4 = n-(n%4); /* divisible-by-4 part */
#ifdef OMP
#pragma omp for private(i,j,n4)
for ( int j=0 ; j<n4 ; j+=4 ) {
for ( int i=0 ; i<n4 ; i+=4 ) {
B[(i )*n+j ] = A[(j )*n+i ];
B[(i )*n+j+1] = A[(j+1)*n+i ];
B[(i )*n+j+2] = A[(j+2)*n+i ];
B[(i )*n+j+3] = A[(j+3)*n+i ];
B[(i+1)*n+j ] = A[(j )*n+i+1];
B[(i+1)*n+j+1] = A[(j+1)*n+i+1];
B[(i+1)*n+j+2] = A[(j+2)*n+i+1];
B[(i+1)*n+j+3] = A[(j+3)*n+i+1];
B[(i+2)*n+j ] = A[(j )*n+i+2];
B[(i+2)*n+j+1] = A[(j+1)*n+i+2];
B[(i+2)*n+j+2] = A[(j+2)*n+i+2];
B[(i+2)*n+j+3] = A[(j+3)*n+i+2];
B[(i+3)*n+j ] = A[(j )*n+i+3];
B[(i+3)*n+j+1] = A[(j+1)*n+i+3];
B[(i+3)*n+j+2] = A[(j+2)*n+i+3];
B[(i+3)*n+j+3] = A[(j+3)*n+i+3];
}
for ( int i=n4 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}
for ( int j=n4 ; j<n ; j++ )
{
for ( int i=0 ; i<n4 ; i+=4 )
{
B[(i )*n+j] = A[j*n+i ];
B[(i+1)*n+j] = A[j*n+i+1];
B[(i+2)*n+j] = A[j*n+i+2];
B[(i+3)*n+j] = A[j*n+i+3];
}
for ( int i=n4 ; i<n ; i++ )
B[i*n+j] = A[j*n+i];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for if(n>OMP_MIN_SIZE)<OMP-END> |
jeffhammond/HPCInfo/openmp/distribute.c | #pragma omp parallel for | 100 | */
int main(int argc, char* argv[])
{
#ifdef DISTRIBUTE
#pragma omp distribute parallel for
#else
<LOOP-START>for (int i=0; i<100; i++) {
printf("tid=%d\n", omp_get_thread_num());
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/matrix.c | #pragma omp parallel for | 100 | A!=NULL);
assert(B!=NULL);
assert(C!=NULL);
double t0, t1;
#pragma omp parallel
{
<LOOP-START>for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
A[i*n+j] = 1.0/(i+j+1);
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
B[i*n+j] = 1.0/(i+j+1);
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] = 0.0;
t0 = omp_get_wtime();
#pragma omp parallel for
for (int k=0; k<n; k++)
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] += A[i*n+k] * B[k*n+j];
t1 = omp_get_wtime();
}
double x = 0.0;
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
{
//printf("C(%d,%d) = %lf \n", i, j, C[i*n+j]);
x += C[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/matrix.c | #pragma omp parallel for | 100 | for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
A[i*n+j] = 1.0/(i+j+1);
<LOOP-START>for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
B[i*n+j] = 1.0/(i+j+1);
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] = 0.0;
t0 = omp_get_wtime();
#pragma omp parallel for
for (int k=0; k<n; k++)
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] += A[i*n+k] * B[k*n+j];
t1 = omp_get_wtime();
}
double x = 0.0;
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
{
//printf("C(%d,%d) = %lf \n", i, j, C[i*n+j]);
x += C[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/matrix.c | #pragma omp parallel for | 100 | for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
B[i*n+j] = 1.0/(i+j+1);
<LOOP-START>for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] = 0.0;
t0 = omp_get_wtime();
#pragma omp parallel for
for (int k=0; k<n; k++)
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] += A[i*n+k] * B[k*n+j];
t1 = omp_get_wtime();
}
double x = 0.0;
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
{
//printf("C(%d,%d) = %lf \n", i, j, C[i*n+j]);
x += C[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/matrix.c | #pragma omp parallel for | 100 | <n; i++)
for (int j=0; j<n; j++)
C[i*n+j] = 0.0;
t0 = omp_get_wtime();
<LOOP-START>for (int k=0; k<n; k++)
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
C[i*n+j] += A[i*n+k] * B[k*n+j];
t1 = omp_get_wtime();
}
double x = 0.0;
#pragma omp parallel for
for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
{
//printf("C(%d,%d) = %lf \n", i, j, C[i*n+j]);
x += C[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/matrix.c | #pragma omp parallel for | 100 | C[i*n+j] += A[i*n+k] * B[k*n+j];
t1 = omp_get_wtime();
}
double x = 0.0;
<LOOP-START>for (int i=0; i<n; i++)
for (int j=0; j<n; j++)
{
//printf("C(%d,%d) = %lf \n", i, j, C[i*n+j]);
x += C[i*n+j];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/stl.cc | #pragma omp parallel for | 100 | uble> A(1000);
#if 0
#pragma omp workshare
std::iota(A.begin(), A.end(), 0.0);
#endif
<LOOP-START>std::for_each( std::begin(A), std::end(A), [&] (double x) { std::cout << x; }<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_4.c | #pragma omp parallel for simd | 100 | STRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
<LOOP-START>#elif defined(_OPENMP)
#warning No OpenMP simd support!
#pragma omp parallel for
#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_4.c | #pragma omp parallel for | 100 | )
#pragma omp parallel for simd
#elif defined(_OPENMP)
#warning No OpenMP simd support!
<LOOP-START>#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_4.c | #pragma omp parallel for simd | 100 | a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
<LOOP-START>#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd3(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#ifdef __cilk
_Cilk_for(int i = 0; i < n; i++)
#else
#warning No Cilk support. Using sequential for loop.
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_4.c | #pragma omp parallel for | 100 | rom:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
<LOOP-START>for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd3(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#ifdef __cilk
_Cilk_for(int i = 0; i < n; i++)
#else
#warning No Cilk support. Using sequential for loop.
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_2.c | #pragma omp parallel for simd | 100 | STRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
<LOOP-START>#elif defined(_OPENMP)
#warning No OpenMP simd support!
#pragma omp parallel for
#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_2.c | #pragma omp parallel for | 100 | )
#pragma omp parallel for simd
#elif defined(_OPENMP)
#warning No OpenMP simd support!
<LOOP-START>#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_2.c | #pragma omp parallel for simd | 100 | a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
<LOOP-START>#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
int main(int argc, char * argv[])
{
int n = (argc > 1 ) ? atoi(argv[1]) : 1000;
float * x = calloc(n,sizeof(float)); assert(x !=NULL);
float * y = calloc(n,sizeof(float)); assert(y !=NULL);
float * z0 = calloc(n,sizeof(float)); assert(z0!=NULL);
float * z1 = calloc(n,sizeof(float)); assert(z1!=NULL);
float * z2 = calloc(n,sizeof(float)); assert(z2!=NULL);
#if 0 && defined(_OPENMP) && (_OPENMP >= 201307)
int nthrd = omp_get_max_threads();
int ndevs = omp_get_num_devices();
printf("OpenMP threads = %d devices = %d\n", nthrd, ndevs);
for (int i=0; i<n; i++) {
x[i] = (float)i;
}
for (int i=0; i<n; i++) {
y[i] = (float)i;
}
for (int iter=0; iter<10; iter++) {
double t0 = omp_get_wtime();
vadd0(n,x,y,z0);
double t1 = omp_get_wtime();
vadd1(n,x,y,z1);
double t2 = omp_get_wtime();
vadd2(n,x,y,z2);
double t3 = omp_get_wtime();
printf("%20s time = %lf \n", "for", t1-t0);
printf("%20s time = %lf (error=%lf) \n", "OpenMP for", t2-t1, vdiff(n,z0,z1));
printf("%20s time = %lf (error=%lf) \n", "OpenMP offload for", t3-t2, vdiff(n,z0,z2));
/* prevent compiler from optimizing away anything */
double junk = t0+t1+t2+t3;
for (int i=0; i<n; i++) {
junk += z0[i] + z1[i] + z2[i];
}
printf("junk=%lf\n", junk);
}
free(z2);
free(z1);
free(z0);
free(y);
free(x);
printf("Success\n");
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_2.c | #pragma omp parallel for | 100 | rom:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
<LOOP-START>for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
int main(int argc, char * argv[])
{
int n = (argc > 1 ) ? atoi(argv[1]) : 1000;
float * x = calloc(n,sizeof(float)); assert(x !=NULL);
float * y = calloc(n,sizeof(float)); assert(y !=NULL);
float * z0 = calloc(n,sizeof(float)); assert(z0!=NULL);
float * z1 = calloc(n,sizeof(float)); assert(z1!=NULL);
float * z2 = calloc(n,sizeof(float)); assert(z2!=NULL);
#if 0 && defined(_OPENMP) && (_OPENMP >= 201307)
int nthrd = omp_get_max_threads();
int ndevs = omp_get_num_devices();
printf("OpenMP threads = %d devices = %d\n", nthrd, ndevs);
for (int i=0; i<n; i++) {
x[i] = (float)i;
}
for (int i=0; i<n; i++) {
y[i] = (float)i;
}
for (int iter=0; iter<10; iter++) {
double t0 = omp_get_wtime();
vadd0(n,x,y,z0);
double t1 = omp_get_wtime();
vadd1(n,x,y,z1);
double t2 = omp_get_wtime();
vadd2(n,x,y,z2);
double t3 = omp_get_wtime();
printf("%20s time = %lf \n", "for", t1-t0);
printf("%20s time = %lf (error=%lf) \n", "OpenMP for", t2-t1, vdiff(n,z0,z1));
printf("%20s time = %lf (error=%lf) \n", "OpenMP offload for", t3-t2, vdiff(n,z0,z2));
/* prevent compiler from optimizing away anything */
double junk = t0+t1+t2+t3;
for (int i=0; i<n; i++) {
junk += z0[i] + z1[i] + z2[i];
}
printf("junk=%lf\n", junk);
}
free(z2);
free(z1);
free(z0);
free(y);
free(x);
printf("Success\n");
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_memory_model.c | #pragma omp parallel for | 100 | #pragma omp parallel
#pragma omp master
{
#pragma omp task
{
<LOOP-START>for (int i=0; i<100000; i++) {
#pragma omp atomic update
x++;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_memory_model.c | #pragma omp parallel for | 100 | ragma omp task
{
#pragma omp target map(tofrom:x)
{
<LOOP-START>for (int i=0; i<100000; i++) {
#pragma omp atomic update
x++;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_syscall.c | #pragma omp parallel for | 100 | sched.h>
#ifdef _OPENMP
#include <omp.h>
#endif
#if 1
void foo(void)
{
#pragma omp target
<LOOP-START>for (int i=0; i<1; i++)
sched_yield();
}
#if 0
void foo(void)
{
#pragma omp target
#pragma omp parallel for
for (int i=0; i<1; i++)
printf("Bob W is great.\n");
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_syscall.c | #pragma omp parallel for | 100 | (int i=0; i<1; i++)
sched_yield();
}
#endif
#if 0
void foo(void)
{
#pragma omp target
<LOOP-START>for (int i=0; i<1; i++)
printf("Bob W is great.\n");
}
#if 0
void foo(void)
{
#pragma omp target
#pragma omp parallel for
for (int i=0; i<1; i++)
puts("Rolf R is great\n");
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_syscall.c | #pragma omp parallel for | 100 | ; i++)
printf("Bob W is great.\n");
}
#endif
#if 0
void foo(void)
{
#pragma omp target
<LOOP-START>for (int i=0; i<1; i++)
puts("Rolf R is great\n");
}
int main(int argc, char * argv[])
{
foo();
printf("Success\n");
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd.c | #pragma omp parallel for simd | 100 | STRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
<LOOP-START>#elif defined(_OPENMP)
#warning No OpenMP simd support!
#pragma omp parallel for
#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
# if defined(__INTEL_COMPILER) && defined(__INTEL_OFFLOAD)
#pragma omp parallel for simd
# else
#pragma omp teams distribute parallel for simd
# endif
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd.c | #pragma omp parallel for | 100 | )
#pragma omp parallel for simd
#elif defined(_OPENMP)
#warning No OpenMP simd support!
<LOOP-START>#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
# if defined(__INTEL_COMPILER) && defined(__INTEL_OFFLOAD)
#pragma omp parallel for simd
# else
#pragma omp teams distribute parallel for simd
# endif
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd.c | #pragma omp parallel for simd | 100 | to:n,a[0:n],b[0:n]) map(from:c[0:n])
# if defined(__INTEL_COMPILER) && defined(__INTEL_OFFLOAD)
<LOOP-START># else
#pragma omp teams distribute parallel for simd
# endif
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd3(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#ifdef __cilk
_Cilk_for(int i = 0; i < n; i++)
#else
#warning No Cilk support. Using sequential for loop.
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd.c | #pragma omp parallel for | 100 | mp teams distribute parallel for simd
# endif
#else
#warning No OpenMP target/simd support!
<LOOP-START>for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd3(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#ifdef __cilk
_Cilk_for(int i = 0; i < n; i++)
#else
#warning No Cilk support. Using sequential for loop.
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_1.c | #pragma omp parallel for simd | 100 | STRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
<LOOP-START>#elif defined(_OPENMP)
#warning No OpenMP simd support!
#pragma omp parallel for
#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_1.c | #pragma omp parallel for | 100 | )
#pragma omp parallel for simd
#elif defined(_OPENMP)
#warning No OpenMP simd support!
<LOOP-START>#else
#warning No OpenMP support!
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
void vadd2(int n, float * RESTRICT a, float * RESTRICT b, float * RESTRICT c)
{
#if defined(_OPENMP) && (_OPENMP >= 201307)
//#pragma omp target teams distribute map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_1.c | #pragma omp parallel for simd | 100 | a[0:n],b[0:n]) map(from:c[0:n])
#pragma omp target map(to:n,a[0:n],b[0:n]) map(from:c[0:n])
<LOOP-START>#else
#warning No OpenMP target/simd support!
#pragma omp parallel for
for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
int main(int argc, char * argv[])
{
int n = (argc > 1 ) ? atoi(argv[1]) : 1000;
float * x = calloc(n,sizeof(float)); assert(x !=NULL);
float * y = calloc(n,sizeof(float)); assert(y !=NULL);
float * z0 = calloc(n,sizeof(float)); assert(z0!=NULL);
float * z1 = calloc(n,sizeof(float)); assert(z1!=NULL);
float * z2 = calloc(n,sizeof(float)); assert(z2!=NULL);
for (int i=0; i<n; i++) {
y[i] = x[i] = (float)i;
}
for (int iter=0; iter<10; iter++) {
double t0 = omp_get_wtime();
vadd0(n,x,y,z0);
double t1 = omp_get_wtime();
vadd1(n,x,y,z1);
double t2 = omp_get_wtime();
vadd2(n,x,y,z2);
double t3 = omp_get_wtime();
printf("%20s time = %lf \n", "for", t1-t0);
printf("%20s time = %lf (error=%lf) \n", "OpenMP for", t2-t1, vdiff(n,z0,z1));
printf("%20s time = %lf (error=%lf) \n", "OpenMP offload for", t3-t2, vdiff(n,z0,z2));
/* prevent compiler from optimizing away anything */
double junk = t0+t1+t2+t3;
for (int i=0; i<n; i++) {
junk += z0[i] + z1[i] + z2[i];
}
printf("junk=%lf\n", junk);
}
free(z2);
free(z1);
free(z0);
free(y);
free(x);
printf("Success\n");
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for simd<OMP-END> |
jeffhammond/HPCInfo/openmp/offload/test_vadd_1.c | #pragma omp parallel for | 100 | rom:c[0:n])
#pragma omp parallel for simd
#else
#warning No OpenMP target/simd support!
<LOOP-START>for(int i = 0; i < n; i++)
c[i] = a[i] + b[i];
}
int main(int argc, char * argv[])
{
int n = (argc > 1 ) ? atoi(argv[1]) : 1000;
float * x = calloc(n,sizeof(float)); assert(x !=NULL);
float * y = calloc(n,sizeof(float)); assert(y !=NULL);
float * z0 = calloc(n,sizeof(float)); assert(z0!=NULL);
float * z1 = calloc(n,sizeof(float)); assert(z1!=NULL);
float * z2 = calloc(n,sizeof(float)); assert(z2!=NULL);
for (int i=0; i<n; i++) {
y[i] = x[i] = (float)i;
}
for (int iter=0; iter<10; iter++) {
double t0 = omp_get_wtime();
vadd0(n,x,y,z0);
double t1 = omp_get_wtime();
vadd1(n,x,y,z1);
double t2 = omp_get_wtime();
vadd2(n,x,y,z2);
double t3 = omp_get_wtime();
printf("%20s time = %lf \n", "for", t1-t0);
printf("%20s time = %lf (error=%lf) \n", "OpenMP for", t2-t1, vdiff(n,z0,z1));
printf("%20s time = %lf (error=%lf) \n", "OpenMP offload for", t3-t2, vdiff(n,z0,z2));
/* prevent compiler from optimizing away anything */
double junk = t0+t1+t2+t3;
for (int i=0; i<n; i++) {
junk += z0[i] + z1[i] + z2[i];
}
printf("junk=%lf\n", junk);
}
free(z2);
free(z1);
free(z0);
free(y);
free(x);
printf("Success\n");
return 0;
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
jeffhammond/HPCInfo/atomics/gpu/basic.cc | #pragma omp parallel for | 100 | ble> rd{d};
#endif
#define ALSO_NO 1
int main(void)
{
const int n{10000};
#ifdef _OPENMP
<LOOP-START>#else
#pragma acc parallel loop
for (int i=0; i<n; ++i) {
ai++;
af.fetch_add(1.0f);
ad.fetch_add(1.0);
ri++;
rf.fetch_add(1.0f);
rd.fetch_add(1.0);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
AndreiCNitu/HPC/lattice-boltzmann/openMP/lbm.c | #pragma omp parallel for reduction(+:tot_u), reduction(+:tot_cells) | 100 | ; /* accumulated magnitudes of velocity for each cell */
/* loop over the cells in the grid */
<LOOP-START>for (int jj = 0; jj < params.ny; jj++) {
__assume_aligned(cells->speed_0, 64);
__assume_aligned(cells->speed_1, 64);
__assume_aligned(cells->speed_2, 64);
__assume_aligned(cells->speed_3, 64);
__assume_aligned(cells->speed_4, 64);
__assume_aligned(cells->speed_5, 64);
__assume_aligned(cells->speed_6, 64);
__assume_aligned(cells->speed_7, 64);
__assume_aligned(cells->speed_8, 64);
__assume_aligned(tmp_cells->speed_0, 64);
__assume_aligned(tmp_cells->speed_1, 64);
__assume_aligned(tmp_cells->speed_2, 64);
__assume_aligned(tmp_cells->speed_3, 64);
__assume_aligned(tmp_cells->speed_4, 64);
__assume_aligned(tmp_cells->speed_5, 64);
__assume_aligned(tmp_cells->speed_6, 64);
__assume_aligned(tmp_cells->speed_7, 64);
__assume_aligned(tmp_cells->speed_8, 64);
#pragma omp simd
for (int ii = 0; ii < params.nx; ii++) {
// PROPAGATION STEP:
/* determine indices of axis-direction neighbours
** respecting periodic boundary conditions (wrap around) */
const int y_n = (jj + 1) % params.ny;
const int x_e = (ii + 1) % params.nx;
const int y_s = (jj == 0) ? (jj + params.ny - 1) : (jj - 1);
const int x_w = (ii == 0) ? (ii + params.nx - 1) : (ii - 1);
/* propagate densities from neighbouring cells, following
** appropriate directions of travel and writing into
** scratch space grid */
const float s0 = cells->speed_0[ii + jj*params.nx]; /* central cell, no movement */
const float s1 = cells->speed_1[x_w + jj*params.nx]; /* east */
const float s2 = cells->speed_2[ii + y_s*params.nx]; /* north */
const float s3 = cells->speed_3[x_e + jj*params.nx]; /* west */
const float s4 = cells->speed_4[ii + y_n*params.nx]; /* south */
const float s5 = cells->speed_5[x_w + y_s*params.nx]; /* north-east */
const float s6 = cells->speed_6[x_e + y_s*params.nx]; /* north-west */
const float s7 = cells->speed_7[x_e + y_n*params.nx]; /* south-west */
const float s8 = cells->speed_8[x_w + y_n*params.nx]; /* south-east */
// COLLISION STEP:
/* compute local density total */
const float local_density = s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8;
/* compute x velocity component */
const float u_x = (s1 + s5 + s8 - (s3 + s6 + s7)) / local_density;
/* compute y velocity component */
const float u_y = (s2 + s5 + s6 - (s4 + s7 + s8)) / local_density;
/* velocity squared */
const float u_sq = u_x * u_x + u_y * u_y;
/* directional velocity components */
float u[NSPEEDS];
u[1] = u_x; /* east */
u[2] = u_y; /* north */
u[3] = - u_x; /* west */
u[4] = - u_y; /* south */
u[5] = u_x + u_y; /* north-east */
u[6] = - u_x + u_y; /* north-west */
u[7] = - u_x - u_y; /* south-west */
u[8] = u_x - u_y; /* south-east */
/* equilibrium densities */
float d_equ[NSPEEDS];
/* zero velocity density: weight w0 */
d_equ[0] = w0 * local_density
* (1.f - u_sq / (2.f * c_sq));
/* axis speeds: weight w1 */
d_equ[1] = w1 * local_density * (1.f + u[1] / c_sq
+ (u[1] * u[1]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[2] = w1 * local_density * (1.f + u[2] / c_sq
+ (u[2] * u[2]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[3] = w1 * local_density * (1.f + u[3] / c_sq
+ (u[3] * u[3]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[4] = w1 * local_density * (1.f + u[4] / c_sq
+ (u[4] * u[4]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
/* diagonal speeds: weight w2 */
d_equ[5] = w2 * local_density * (1.f + u[5] / c_sq
+ (u[5] * u[5]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[6] = w2 * local_density * (1.f + u[6] / c_sq
+ (u[6] * u[6]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[7] = w2 * local_density * (1.f + u[7] / c_sq
+ (u[7] * u[7]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
d_equ[8] = w2 * local_density * (1.f + u[8] / c_sq
+ (u[8] * u[8]) / (2.f * c_sq * c_sq)
- u_sq / (2.f * c_sq));
/* relaxation step */
const float t0 = (obstacles[jj*params.nx + ii] != 0) ? s0 : (s0 + params.omega * (d_equ[0] - s0));
const float t1 = (obstacles[jj*params.nx + ii] != 0) ? s3 : (s1 + params.omega * (d_equ[1] - s1));
const float t2 = (obstacles[jj*params.nx + ii] != 0) ? s4 : (s2 + params.omega * (d_equ[2] - s2));
const float t3 = (obstacles[jj*params.nx + ii] != 0) ? s1 : (s3 + params.omega * (d_equ[3] - s3));
const float t4 = (obstacles[jj*params.nx + ii] != 0) ? s2 : (s4 + params.omega * (d_equ[4] - s4));
const float t5 = (obstacles[jj*params.nx + ii] != 0) ? s7 : (s5 + params.omega * (d_equ[5] - s5));
const float t6 = (obstacles[jj*params.nx + ii] != 0) ? s8 : (s6 + params.omega * (d_equ[6] - s6));
const float t7 = (obstacles[jj*params.nx + ii] != 0) ? s5 : (s7 + params.omega * (d_equ[7] - s7));
const float t8 = (obstacles[jj*params.nx + ii] != 0) ? s6 : (s8 + params.omega * (d_equ[8] - s8));
// AVERAGE VELOCITIES STEP:
/* local density total */
const float local_density_v = t0 + t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8;
/* x-component of velocity */
const float u_x_v = (t1 + t5 + t8 - (t3 + t6 + t7)) / local_density_v;
/* compute y velocity component */
const float u_y_v = (t2 + t5 + t6 - (t4 + t7 + t8)) / local_density_v;
/* accumulate the norm of x- and y- velocity components */
tot_u += (obstacles[jj*params.nx + ii] != 0) ? 0 : sqrtf((u_x_v * u_x_v) + (u_y_v * u_y_v));
/* increase counter of inspected cells */
tot_cells += (obstacles[jj*params.nx + ii] != 0) ? 0 : 1;
tmp_cells->speed_0[ii + jj*params.nx] = t0;
tmp_cells->speed_1[ii + jj*params.nx] = t1;
tmp_cells->speed_2[ii + jj*params.nx] = t2;
tmp_cells->speed_3[ii + jj*params.nx] = t3;
tmp_cells->speed_4[ii + jj*params.nx] = t4;
tmp_cells->speed_5[ii + jj*params.nx] = t5;
tmp_cells->speed_6[ii + jj*params.nx] = t6;
tmp_cells->speed_7[ii + jj*params.nx] = t7;
tmp_cells->speed_8[ii + jj*params.nx] = t8;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:tot_u), reduction(+:tot_cells)<OMP-END> |
AndreiCNitu/HPC/lattice-boltzmann/openMP/lbm.c | #pragma omp parallel for | 100 | * 4.f / 9.f;
float w1 = params->density / 9.f;
float w2 = params->density / 36.f;
<LOOP-START>for (int jj = 0; jj < params->ny; jj++) {
for (int ii = 0; ii < params->nx; ii++) {
/* centre */
(*cells_ptr)->speed_0[ii + jj*params->nx] = w0;
/* axis directions */
(*cells_ptr)->speed_1[ii + jj*params->nx] = w1;
(*cells_ptr)->speed_2[ii + jj*params->nx] = w1;
(*cells_ptr)->speed_3[ii + jj*params->nx] = w1;
(*cells_ptr)->speed_4[ii + jj*params->nx] = w1;
/* diagonals */
(*cells_ptr)->speed_5[ii + jj*params->nx] = w2;
(*cells_ptr)->speed_6[ii + jj*params->nx] = w2;
(*cells_ptr)->speed_7[ii + jj*params->nx] = w2;
(*cells_ptr)->speed_8[ii + jj*params->nx] = w2;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
AndreiCNitu/HPC/lattice-boltzmann/openMP/lbm.c | #pragma omp parallel for | 100 | peed_8[ii + jj*params->nx] = w2;
}
}
/* first set all cells in obstacle array to zero */
<LOOP-START>for (int jj = 0; jj < params->ny; jj++) {
for (int ii = 0; ii < params->nx; ii++) {
(*obstacles_ptr)[ii + jj*params->nx] = 0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
Dainerx/parallel-distributed-computing-C/applying_functions.c | #pragma omp parallel for | 100 | ();
//start parallel
//printf("thread number %d\n",omp_get_thread_num());
<LOOP-START>for(i=0; i<n; i++)
{
//tt[i] = f(tt[i]); //O(1)
tt[i] = f1(tt[i]); //the speed up is much higher with f1 since log and cos computations are polynomial; see function.
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
Dainerx/parallel-distributed-computing-C/PI_estimation.c | #pragma omp parallel for num_threads(nb_threads) private(xi) reduction(+:sum) | 100 | {
long int i;
double pi_value = 0.0;
double sum = 0.0;
double xi, h = (b - a) / N;
<LOOP-START>for (i = 0; i < N; i++) {
xi = a + h*i;
sum += f(xi);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nb_threads) private(xi) reduction(+:sum) <OMP-END> |
Dainerx/parallel-distributed-computing-C/sum_of_array.c | #pragma omp parallel for reduction(+:sum) | 100 | d_parallel);
sum = 0;
//start parallel with reduction
start_parallel = omp_get_wtime();
<LOOP-START>for (i = 0; i < n; i++) {
//see what index each thread is working on
//printf("thread %d -> %d\n", omp_get_thread_num(), i);
sum += tt[i];
}<LOOP-END> <OMP-START>#pragma omp parallel for reduction(+:sum)<OMP-END> |
Dainerx/parallel-distributed-computing-C/matrix_addition.c | #pragma omp parallel for collapse(2) | 100 | s of n obviously the speedup will remarkably increase.
double start_parallel = omp_get_wtime();
<LOOP-START>for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
//see which thread handling entry (i,j)
//printf("thread %d working on (%d,%d)\n", omp_get_thread_num(), i, j);
c[i][j] = a[i][j] + b[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for collapse(2)<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/solver.c | #pragma omp parallel for schedule(guided) collapse(2) private(j, k, t, sum) shared(mat_A, mat_B, mat_C) | 100 | t, sum;
omp_set_dynamic(0);
omp_set_num_threads(num_threads);
start = omp_get_wtime();
<LOOP-START>for (i = 0; i < lines_a; i++)
{
for (j = 0; j < columns_b; j++)
{
sum = 0;
for (k = 0; k < columns_a; k++)
{
t = (mat_A[i][k] * mat_B[k][j]);
sum += t;
}
mat_C[i][j] = sum;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided) collapse(2) private(j, k, t, sum) shared(mat_A, mat_B, mat_C)<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/solver.c | #pragma omp parallel for | 100 | nt));
struct FlatArraysCouple flat_array_couple = {a, b};
omp_set_num_threads(num_threads);
<LOOP-START>for (int i = 0; i < lines_a; i++)
{
for (int j = 0; j < columns_a; j++)
{
a[i * columns_a + j] = matrixA[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/solver.c | #pragma omp parallel for | 100 | 0; j < columns_a; j++)
{
a[i * columns_a + j] = matrixA[i][j];
}
}
<LOOP-START>for (int i = 0; i < lines_b; i++)
{
for (int j = 0; j < columns_b; j++)
{
b[j * lines_b + i] = matrixB[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/mpi_parallelized_scatter_gather.c | #pragma omp parallel for schedule(guided) private(j) shared(a) | 100 | rtMat_parralel(int **matrixA, int **matrixB, int *a, int *b)
{
int i, j;
#pragma omp parallel
{
<LOOP-START>for (i = 0; i < ci.lines_a; i++)
{
for (j = 0; j < ci.columns_a; j++)
{
a[i * ci.columns_a + j] = matrixA[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided) private(j) shared(a)<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/mpi_parallelized_scatter_gather.c | #pragma omp parallel for schedule(guided) private(j) shared(b) | 100 | = 0; j < ci.columns_a; j++)
{
a[i * ci.columns_a + j] = matrixA[i][j];
}
}
<LOOP-START>for (i = 0; i < ci.lines_b; i++)
{
for (j = 0; j < ci.columns_b; j++)
{
b[j * ci.lines_b + i] = matrixB[i][j];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided) private(j) shared(b)<OMP-END> |
Dainerx/parallel-distributed-computing-C/MultMat/mpi_send_recv.c | #pragma omp parallel for schedule(guided) private(i, j) shared(actual_C, mat_A, mat_B) | 100 | , MPI_INT, root, TAG_MASTER, MPI_COMM_WORLD, &status);
// Every worker's compute its part of matC.
<LOOP-START>for (k = 0; k < ci.columns_b; k++)
for (i = 0; i < rows; i++)
{
actual_C[i][k] = 0.0;
for (j = 0; j < ci.columns_a; j++)
{
actual_C[i][k] = actual_C[i][k] + mat_A[i][j] * mat_B[j][k];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(guided) private(i, j) shared(actual_C, mat_A, mat_B)<OMP-END> |
xxyux/Distributed-SpMV/DistSpMV_Reordered.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_Reordered.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_Reordered.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> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.