text
stringclasses 10
values | label
stringclasses 2
values | index
int64 0
9
|
|---|---|---|
int main()
{
int i;
int j;
int numeros[6];
int seeds[6];
srand((int) time(0));
for (j = 0; j < 6; ++j)
seeds[j] = rand();
omp_set_nested(1);
#pragma omp parallel num_threads(2)
{
#pragma omp sections
{
#pragma omp section
{
#pragma omp critical
{
#pragma omp parallel shared(i) num_threads(4)
{
printf("Thread %d de %d\n", omp_get_thread_num(), omp_get_num_threads());
#pragma omp atomic
i++;
}
}
}
#pragma omp section
{
#pragma omp parallel shared(numeros, seeds) num_threads(6)
{
int seed = seeds[omp_get_thread_num()];
numeros[omp_get_thread_num()] = rand_r(&seed) % 10000;
#pragma omp barrier
#pragma omp master
{
printf("\nIteraciones: %d\n", omp_get_num_threads());
int sum = 0;
for (j = 0; j < 6; ++j)
sum += numeros[j];
printf("Suma: %d\n", sum);
printf("Promedio: %f\n", (sum + 0.0) / 6);
}
}
}
}
}
return 0;
}
| no_bug | 0 |
double my_trap(int a, int b, int n)
{
double h = (b - a) / ((double) n);
my_approx = (f(a) + f(b)) / 2;
int i;
#pragma omp parallel for
for (i = 1; i < n; i++)
{
printf("%d \n", omp_get_thread_num());
#pragma omp critical
my_approx += f(a + (i * h));
}
return h * my_approx;
}
| no_bug | 1 |
int numthreads;
float ***image;
int cshape[13][4] = {{64, 3, 3, 3}, {64, 64, 3, 3}, {128, 64, 3, 3}, {128, 128, 3, 3}, {256, 128, 3, 3}, {256, 256, 3, 3}, {256, 256, 3, 3}, {512, 256, 3, 3}, {512, 512, 3, 3}, {512, 512, 3, 3}, {512, 512, 3, 3}, {512, 512, 3, 3}, {512, 512, 3, 3}};
float *****wc;
float **bc;
int dshape[3][2] = {{25088, 4096}, {4096, 4096}, {4096, 1000}};
float ***wd;
float **bd;
int mem_block_shape[3] = {512, 224, 224};
float ***mem_block1;
float ***mem_block2;
int mem_block_dense_shape = {(512 * 7) * 7};
float *mem_block1_dense;
float *mem_block2_dense;
void get_VGG16_predict(int only_convolution)
{
int i;
int j;
int level;
int cur_size;
reset_mem_block(mem_block1);
reset_mem_block(mem_block2);
reset_mem_block_dense(mem_block1_dense);
reset_mem_block_dense(mem_block2_dense);
level = 0;
cur_size = 224;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(image[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
level = 1;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
maxpooling(mem_block2[i], cur_size);
}
cur_size /= 2;
level = 2;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
level = 3;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
maxpooling(mem_block2[i], cur_size);
}
cur_size /= 2;
level = 4;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
level = 5;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
level = 6;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
maxpooling(mem_block1[i], cur_size);
}
cur_size /= 2;
level = 7;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
level = 8;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
level = 9;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
maxpooling(mem_block2[i], cur_size);
}
cur_size /= 2;
level = 10;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
level = 11;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block1[j], wc[level][i][j], mem_block2[i], cur_size);
}
add_bias_and_relu(mem_block2[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block1);
level = 12;
#pragma omp parallel for private(j) schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
for (j = 0; j < cshape[level][1]; j++)
{
convolution_3_x_3(mem_block2[j], wc[level][i][j], mem_block1[i], cur_size);
}
add_bias_and_relu(mem_block1[i], bc[level][i], cur_size);
}
reset_mem_block(mem_block2);
#pragma omp parallel for schedule(dynamic,1) num_threads(numthreads)
for (i = 0; i < cshape[level][0]; i++)
{
maxpooling(mem_block1[i], cur_size);
}
cur_size /= 2;
flatten(mem_block1, mem_block1_dense, cshape[level][0], cur_size, cur_size);
if (only_convolution == 1)
{
return;
}
level = 0;
dense(mem_block1_dense, wd[level], mem_block2_dense, dshape[level][0], dshape[level][1]);
add_bias_and_relu_flatten(mem_block2_dense, bd[level], dshape[level][1], 1);
reset_mem_block_dense(mem_block1_dense);
level = 1;
dense(mem_block2_dense, wd[level], mem_block1_dense, dshape[level][0], dshape[level][1]);
add_bias_and_relu_flatten(mem_block1_dense, bd[level], dshape[level][1], 1);
reset_mem_block_dense(mem_block2_dense);
level = 2;
dense(mem_block1_dense, wd[level], mem_block2_dense, dshape[level][0], dshape[level][1]);
add_bias_and_relu_flatten(mem_block2_dense, bd[level], dshape[level][1], 1);
softmax(mem_block2_dense, dshape[level][1]);
return;
}
| no_bug | 2 |
void sweep_task(int nx, int ny, double dx, double dy, double *f_, int itold, int itnew, double *u_, double *unew_, int block_size)
{
int i;
int it;
int j;
double (*f)[nx][ny] = (double (*)[nx][ny]) f_;
double (*u)[nx][ny] = (double (*)[nx][ny]) u_;
double (*unew)[nx][ny] = (double (*)[nx][ny]) unew_;
#pragma omp parallel shared (f, u, unew) firstprivate(nx, ny, dx, dy, itold, itnew)
#pragma omp single
{
for (it = itold + 1; it <= itnew; it++)
{
for (i = 0; i < nx; i++)
{
#pragma omp task firstprivate(i, ny) shared(u, unew)
for (j = 0; j < ny; j++)
{
(*u)[i][j] = (*unew)[i][j];
}
}
#pragma omp taskwait
for (i = 0; i < nx; i++)
{
#pragma omp task firstprivate(i, dx, dy, nx, ny) shared(u, unew, f)
for (j = 0; j < ny; j++)
{
if ((((i == 0) || (j == 0)) || (i == (nx - 1))) || (j == (ny - 1)))
{
(*unew)[i][j] = (*f)[i][j];
}
else
{
(*unew)[i][j] = 0.25 * (((((*u)[i - 1][j] + (*u)[i][j + 1]) + (*u)[i][j - 1]) + (*u)[i + 1][j]) + (((*f)[i][j] * dx) * dy));
}
}
}
#pragma omp taskwait
}
}
}
| bug | 3 |
#include <stdio.h>
#include <omp.h>
// Function containing OpenMP code
void runOpenMP() {
{
#pragma omp for
for (int i = 0; i < 90; i++) {
for (int j = 0; j < 99; j++) {
printf("data augmentation");
}
}
}
}
int main()
{
int i1;
int i2;
int i;
int j;
int k;
int *A;
int *B;
int *C;
int temp;
int id;
int start;
int stop;
int sum = 0;
A = (int *) malloc((6 * 6) * (sizeof(int)));
B = (int *) malloc((6 * 6) * (sizeof(int)));
C = (int *) malloc((6 * 6) * (sizeof(int)));
printf("Ma tran A:\n");
for (i = 0; i < 6; i++)
for (j = 0; j < 6; j++)
if (i == j)
*((A + (i * 6)) + j) = 1;
else
*((A + (i * 6)) + j) = 0;
for (i = 0; i < 6; i++)
{
for (j = 0; j < 6; j++)
printf("%d", *((A + (i * 6)) + j));
printf("\n");
}
printf("\n");
printf("Ma tran B:\n");
for (i = 0; i < 6; i++)
for (j = 0; j < 6; j++)
*((B + (i * 6)) + j) = (i * 6) + j;
for (i = 0; i < 6; i++)
{
for (j = 0; j < 6; j++)
printf("%d", *((B + (i * 6)) + j));
printf("\n");
}
omp_set_num_threads(9);
#pragma omp parallel
{
id = omp_get_thread_num();
i1 = (6 / 4) * id;
i2 = (6 / 4) * (id + 1);
for (i = 0; i < 6; i++)
{
for (j = i1; j < i2; j++)
{
for (k = 0; k < 6; k++)
sum += (*((A + (i * 6)) + k)) * (*((B + (k * 6)) + j));
*((C + (i * 6)) + j) = sum;
sum = 0;
}
}
}
printf("\n");
printf("Ma tran C:\n");
for (i = 0; i < 6; i++)
{
for (j = 0; j < 6; j++)
printf("%d\t", *((C + (i * 6)) + j));
printf("\n");
}
return 0;
}
| bug | 4 |
double calcula_integral2(double a, double b, int n)
{
double x;
double h;
double s = 0;
double result;
int i;
struct timespec t;
t.tv_sec = 0;
t.tv_nsec = 1000;
h = (b - a) / n;
#pragma omp parallel for reduction(+:s)
for (i = 0; i < n; i++)
{
x = a + (h * (i + 0.5));
s += f(x);
}
result = h * s;
return result;
}
| bug | 5 |
int sim_readout(const int arrx, double pix_cur[arrx], double pix_read[arrx], const double cte_frac_col[arrx], const int levels[NUM_LEV], const double dpde_l[NUM_LEV], const double chg_leak_lt[MAX_TAIL_LEN * NUM_LEV], const double chg_open_lt[MAX_TAIL_LEN * NUM_LEV]);
int sim_readout_nit(const int arrx, double pix_cur[arrx], double pix_read[arrx], const int shft_nit, const double cte_frac_col[arrx], const int levels[NUM_LEV], const double dpde_l[NUM_LEV], const double chg_leak_lt[MAX_TAIL_LEN * NUM_LEV], const double chg_open_lt[MAX_TAIL_LEN * NUM_LEV]);
int FixYCte(const int arrx, const int arry, const double sig_cte[arrx * arry], double sig_cor[arrx * arry], const int sim_nit, const int shft_nit, const double too_low, double cte_frac[arrx * arry], const int levels[NUM_LEV], const double dpde_l[NUM_LEV], const double chg_leak_lt[MAX_TAIL_LEN * NUM_LEV], const double chg_open_lt[MAX_TAIL_LEN * NUM_LEV], int onecpu)
{
extern int status;
int i;
int i2;
int j;
int n;
double pix_obs[arrx];
double pix_cur[arrx];
double pix_read[arrx];
double cte_frac_col[arrx];
double new_cte_frac;
double ncf_top;
double ncf_bot;
short int high_found;
int high_location;
short int redo_col = 0;
int num_redo;
if (onecpu == 1)
{
trlmessage("Using single-CPU processing for YCTE correction.\n");
for (j = 0; j < arry; j++)
{
for (i = 0; i < arrx; i++)
{
pix_obs[i] = sig_cte[(i * arry) + j];
pix_cur[i] = pix_obs[i];
pix_read[i] = 0.0;
cte_frac_col[i] = cte_frac[(i * arry) + j];
}
num_redo = 0;
do
{
for (n = 0; n < sim_nit; n++)
{
status = sim_readout_nit(arrx, pix_cur, pix_read, shft_nit, cte_frac_col, levels, dpde_l, chg_leak_lt, chg_open_lt);
if (status == 0)
{
for (i = 0; i < arrx; i++)
{
pix_cur[i] += pix_obs[i] - pix_read[i];
}
}
}
if (status == 0)
{
redo_col = 0;
for (i = 2; i < (arrx - 2); i++)
{
if ((((pix_cur[i] - pix_obs[i]) < too_low) && (pix_cur[i] < too_low)) && (!redo_col))
{
high_found = 0;
for (i2 = i - 1; i2 > 0; i2--)
{
if ((pix_cur[i2] - pix_obs[i2 - 1]) < 0)
{
high_found = 1;
high_location = i2 - 1;
break;
}
}
if (high_found == 0)
{
continue;
}
else
{
redo_col = 1;
}
ncf_top = fmax(pix_obs[i], 0.0);
ncf_bot = ncf_top - pix_cur[i];
if (ncf_top == 0)
{
new_cte_frac = 0.0;
}
else
if (ncf_bot == 0)
{
new_cte_frac = 0.0;
}
else
{
new_cte_frac = ncf_top / ncf_bot;
}
for (i2 = high_location; i2 <= i; i2++)
{
cte_frac_col[i2] *= new_cte_frac;
if (cte_frac_col[i2] < 0)
{
cte_frac_col[i2] = 0.0;
}
}
if ((i + 1) < arrx)
{
cte_frac_col[i + 1] *= 1.0 - (0.8 * (1.0 - new_cte_frac));
}
if ((i + 2) < arrx)
{
cte_frac_col[i + 2] *= 1.0 - (0.6 * (1.0 - new_cte_frac));
}
if ((i + 3) < arrx)
{
cte_frac_col[i + 3] *= 1.0 - (0.4 * (1.0 - new_cte_frac));
}
if ((i + 4) < arrx)
{
cte_frac_col[i + 4] *= 1.0 - (0.2 * (1.0 - new_cte_frac));
}
if (redo_col)
{
break;
}
}
}
num_redo++;
}
}
while (redo_col && (num_redo < 10));
if (status == 0)
{
for (i = 0; i < arrx; i++)
{
sig_cor[(i * arry) + j] = pix_cur[i];
cte_frac[(i * arry) + j] = cte_frac_col[i];
}
}
}
}
else
{
trlmessage("Parallel processing for YCTE correction not used... OpenMP missing.\n");
#pragma omp parallel for schedule(dynamic) private(i,j,n,status,cte_frac_col,new_cte_frac,ncf_top,ncf_bot, high_found,high_location,redo_col,num_redo,pix_obs,pix_cur,pix_read) shared(sig_cte,sig_cor,cte_frac)
for (j = 0; j < arry; j++)
{
for (i = 0; i < arrx; i++)
{
pix_obs[i] = sig_cte[(i * arry) + j];
pix_cur[i] = pix_obs[i];
pix_read[i] = 0.0;
cte_frac_col[i] = cte_frac[(i * arry) + j];
}
num_redo = 0;
do
{
for (n = 0; n < sim_nit; n++)
{
status = sim_readout_nit(arrx, pix_cur, pix_read, shft_nit, cte_frac_col, levels, dpde_l, chg_leak_lt, chg_open_lt);
if (status == 0)
{
for (i = 0; i < arrx; i++)
{
pix_cur[i] += pix_obs[i] - pix_read[i];
}
}
}
if (status == 0)
{
redo_col = 0;
for (i = 2; i < (arrx - 2); i++)
{
if ((((pix_cur[i] - pix_obs[i]) < too_low) && (pix_cur[i] < too_low)) && (!redo_col))
{
high_found = 0;
for (i2 = i - 1; i2 > 0; i2--)
{
if ((pix_cur[i2] - pix_obs[i2 - 1]) < 0)
{
high_found = 1;
high_location = i2 - 1;
break;
}
}
if (high_found == 0)
{
continue;
}
else
{
redo_col = 1;
}
ncf_top = fmax(pix_obs[i], 0.0);
ncf_bot = ncf_top - pix_cur[i];
if (ncf_top == 0)
{
new_cte_frac = 0.0;
}
else
if (ncf_bot == 0)
{
new_cte_frac = 0.0;
}
else
{
new_cte_frac = ncf_top / ncf_bot;
}
for (i2 = high_location; i2 <= i; i2++)
{
cte_frac_col[i2] *= new_cte_frac;
if (cte_frac_col[i2] < 0)
{
cte_frac_col[i2] = 0.0;
}
}
if ((i + 1) < arrx)
{
cte_frac_col[i + 1] *= 1.0 - (0.8 * (1.0 - new_cte_frac));
}
if ((i + 2) < arrx)
{
cte_frac_col[i + 2] *= 1.0 - (0.6 * (1.0 - new_cte_frac));
}
if ((i + 3) < arrx)
{
cte_frac_col[i + 3] *= 1.0 - (0.4 * (1.0 - new_cte_frac));
}
if ((i + 4) < arrx)
{
cte_frac_col[i + 4] *= 1.0 - (0.2 * (1.0 - new_cte_frac));
}
if (redo_col)
{
break;
}
}
}
num_redo++;
}
}
while (redo_col && (num_redo < 10));
if (status == 0)
{
for (i = 0; i < arrx; i++)
{
sig_cor[(i * arry) + j] = pix_cur[i];
cte_frac[(i * arry) + j] = cte_frac_col[i];
}
}
}
}
return status;
}
| no_bug | 6 |
double a[729][729];
double b[729][729];
double c[729];
int jmax[729];
void init1(void);
void init2(void);
void loop1(void);
void loop2(void);
void valid1(void);
void valid2(void);
void loop1(void)
{
int i;
int j;
#pragma omp parallel for default(none) private(i,j) shared(a,b) schedule(guided, 4)
for (i = 0; i < 729; i++)
{
for (j = 729 - 1; j > i; j--)
{
a[i][j] += cos(b[i][j]);
}
}
}
| no_bug | 7 |
double hwFunc(double x, double y);
double Partial_Derivative_X(double x, double y);
double Partial_Derivative_X(double x, double y);
void Form_Gradient();
void Form_Actual();
double gradientX[100][100];
double gradientY[100][100];
double xycoord[100];
double actual[100][100];
void Form_Gradient()
{
int i;
int j;
int k;
i = 0;
j = 0;
k = 0;
double cxy;
double xGrad;
double yGrad;
double small_i;
double small_j;
int target_thread_num = 4;
omp_set_num_threads(target_thread_num);
unsigned long times[target_thread_num];
double max_value = 0.0;
double magnitude = 0.0;
cxy = -2.0;
double step = (2.0 - (-2.0)) / 100;
for (k = 0; k < 100; k++)
{
xycoord[k] = cxy;
cxy = cxy + step;
}
double gX[100][100];
double gY[100][100];
#pragma omp parallel for shared(gX,gY), private(i,j)
for (i = 0; i < 100; i++)
{
for (j = 0; j < 100; j++)
{
xGrad = Partial_Derivative_X(xycoord[i], xycoord[j]);
gX[i][j] = xGrad;
yGrad = Partial_Derivative_Y(xycoord[i], xycoord[j]);
gY[i][j] = yGrad;
magnitude = sqrt(pow(xGrad, 2) + pow(yGrad, 2));
printf("GradX: %f GradY: %f Magnitude: %f\n", xGrad, yGrad, magnitude);
#pragma omp flush(max_value)
if (magnitude > max_value)
{
#pragma omp critical
{
if (magnitude > max_value)
max_value = magnitude;
}
}
}
}
printf("Maximum Vector Magnitude is: %f\n", max_value);
for (i = 0; i < 100; i++)
{
for (j = 0; j < 100; j++)
{
gradientX[i][j] = gX[i][j];
gradientY[i][j] = gY[i][j];
}
}
}
| no_bug | 8 |
#include <stdio.h>
#include <omp.h>
void runOpenMP() {
int a; // You can change the value of 'a' as needed
// Parallel region with private clause
#pragma omp parallel private num_threads(4)
{
int tid = omp_get_thread_num(); // Get the thread ID
if (tid == 0) {
// Thread 0 loop
#pragma omp for
for (int i = 0; i < 10; i++) {
if (a == 100) {
printf("Thread 0: data augmentation");
} else {
printf("Thread 0: Good luck");
}
}
} else if (tid == 1) {
// Thread 1 loop
#pragma omp for
for (int i = 0; i < 10; i++) {
// Replace this condition with your desired condition
if (a == 200) {
printf("Thread 1: data augmentation");
} else {
printf("Thread 1: Good luck");
}
}
} else if (tid == 2) {
// Thread 2 loop
#pragma omp for
for (int i = 0; i < 10; i++) {
// Replace this condition with your desired condition
if (a == 300) {
printf("Thread 2: data augmentation");
} else {
printf("Thread 2: Good luck");
}
}
} else if (tid == 3) {
// Thread 3 loop
#pragma omp for
for (int i = 0; i < 10; i++) {
// Replace this condition with your desired condition
if (a == 400) {
printf("Thread 3: data augmentation");
} else {
printf("Thread 3: Good luck");
}
}
}
}
}
int main()
{
int thds;
int i;
int errors = 0;
thds = omp_get_max_threads();
if (thds == 1)
{
printf("should be run this program on multi thread.\n");
exit(0);
}
omp_set_dynamic(0);
#pragma omp parallel sections
{
#pragma omp section
{
if (omp_in_parallel() == 0)
{
#pragma omp critical
errors += 1;
}
}
#pragma omp section
{
if (omp_in_parallel() == 0)
{
#pragma omp critical
errors += 1;
}
}
}
for (i = 1; i <= thds; i++)
{
omp_set_num_threads(i);
#pragma omp parallel sections
{
#pragma omp section
{
if (omp_in_parallel() == 0)
{
#pragma omp critical
errors += 1;
}
}
#pragma omp section
{
if (omp_in_parallel() == 0)
{
#pragma omp critical
errors += 1;
}
}
}
}
if (errors == 0)
{
printf("omp_in_parallel 004 : SUCCESS\n");
return 0;
}
else
{
printf("omp_in_parallel 004 : FAILED\n");
return 1;
}
}
| no_bug | 9 |
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 5