filename stringlengths 19 182 | omp_pragma_line stringlengths 24 416 | context_chars int64 100 100 | text stringlengths 152 177k |
|---|---|---|---|
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,k,index) | 100 | ATA) {
x_inc=1;
y_inc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
<LOOP-START>for (k=y_min-depth;k<=y_max+y_inc+depth;k++) {
#pragma ivdep
for (j=1;j<=depth;j++) {
index=buffer_offset + j+(k+depth-1)*depth;
left_snd_buffer[FTNREF1D(index,1)]=field[FTNREF2D(x_min+x_inc-1+j,k,x_max+4+x_inc,x_min-2,y_min-2)];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,k,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,k,index) | 100 | ATA) {
x_inc=1;
y_inc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
<LOOP-START>for (k=y_min-depth;k<=y_max+y_inc+depth;k++) {
#pragma ivdep
for (j=1;j<=depth;j++) {
index=buffer_offset + j+(k+depth-1)*depth;
field[FTNREF2D(x_min-j,k,x_max+4+x_inc,x_min-2,y_min-2)]=left_rcv_buffer[FTNREF1D(index,1)];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,k,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,k,index) | 100 | ATA) {
x_inc=1;
y_inc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
<LOOP-START>for (k=y_min-depth;k<=y_max+y_inc+depth;k++) {
#pragma ivdep
for (j=1;j<=depth;j++) {
index=buffer_offset + j+(k+depth-1)*depth;
right_snd_buffer[FTNREF1D(index,1)]=field[FTNREF2D(x_max+1-j,k,x_max+4+x_inc,x_min-2,y_min-2)];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,k,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,k,index) | 100 | ATA) {
x_inc=1;
y_inc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
<LOOP-START>for (k=y_min-depth;k<=y_max+y_inc+depth;k++) {
#pragma ivdep
for (j=1;j<=depth;j++) {
index=buffer_offset + j+(k+depth-1)*depth;
field[FTNREF2D(x_max+x_inc+j,k,x_max+4+x_inc,x_min-2,y_min-2)]=right_rcv_buffer[FTNREF1D(index,1)];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,k,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,index) | 100 | nc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
for (k=1;k<=depth;k++) {
<LOOP-START>for (j=x_min-depth;j<=x_max+x_inc+depth;j++) {
index= buffer_offset + k+(j+depth-1)*depth;
top_snd_buffer[FTNREF1D(index,1)]=field[FTNREF2D(j,y_max+1-k,x_max+4+x_inc,x_min-2,y_min-2)];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,index) | 100 | nc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
for (k=1;k<=depth;k++) {
<LOOP-START>for (j=x_min-depth;j<=x_max+x_inc+depth;j++) {
index= buffer_offset + k+(j+depth-1)*depth;
bottom_snd_buffer[FTNREF1D(index,1)]=field[FTNREF2D(j,y_min+y_inc-1+k,x_max+4+x_inc,x_min-2,y_min-2)];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,index) | 100 | nc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
for (k=1;k<=depth;k++) {
<LOOP-START>for (j=x_min-depth;j<=x_max+x_inc+depth;j++) {
index= buffer_offset + k+(j+depth-1)*depth;
field[FTNREF2D(j,y_min-k,x_max+4+x_inc,x_min-2,y_min-2)]=bottom_rcv_buffer[FTNREF1D(index,1)];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,index)<OMP-END> |
HPCL/benchmarks/miniapps/CloverLeaf_OpenMP/pack_kernel_c.c | #pragma omp parallel for private(j,index) | 100 | nc=0;
}
if(field_type==Y_FACE_DATA) {
x_inc=0;
y_inc=1;
}
for (k=1;k<=depth;k++) {
<LOOP-START>for (j=x_min-depth;j<=x_max+x_inc+depth;j++) {
index= buffer_offset + k+(j+depth-1)*depth;
field[FTNREF2D(j,y_max+y_inc+k,x_max+4+x_inc,x_min-2,y_min-2)]=top_rcv_buffer[FTNREF1D(index,1)];
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j,index)<OMP-END> |
HPCL/benchmarks/miniapps/xsbench/openmp-threading/GridInit.c | #pragma omp parallel for | 100 | d * sizeof(int);
double du = 1.0 / in.hash_bins;
// For each energy level in the hash table
<LOOP-START>for( long e = 0; e < in.hash_bins; e++ )
{
double energy = e * du;
// We need to determine the bounding energy levels for all isotopes
for( long i = 0; i < in.n_isotopes; i++ )
{
SD.index_grid[e * in.n_isotopes + i] = grid_search_nuclide( in.n_gridpoints, energy, SD.nuclide_grid + i * in.n_gridpoints, 0, in.n_gridpoints-1);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
HPCL/benchmarks/miniapps/xsbench/openmp-threading/Simulation.c | #pragma omp parallel for schedule(dynamic, 100) | 100 | als and Energies
////////////////////////////////////////////////////////////////////////////////
<LOOP-START>for( int i = 0; i < in.lookups; i++ )
{
// Set the initial seed value
uint64_t seed = STARTING_SEED;
// Forward seed to lookup index (we need 2 samples per lookup)
seed = fast_forward_LCG(seed, 2*i);
// Randomly pick an energy and material for the particle
double p_energy = LCG_random_double(&seed);
int mat = pick_mat(&seed);
SD.p_energy_samples[i] = p_energy;
SD.mat_samples[i] = mat;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 100)<OMP-END> |
HPCL/benchmarks/miniapps/xsbench/openmp-threading/Simulation.c | #pragma omp parallel for schedule(dynamic, 100) | 100 | als and Energies
////////////////////////////////////////////////////////////////////////////////
<LOOP-START>for( int i = 0; i < in.lookups; i++ )
{
// Set the initial seed value
uint64_t seed = STARTING_SEED;
// Forward seed to lookup index (we need 2 samples per lookup)
seed = fast_forward_LCG(seed, 2*i);
// Randomly pick an energy and material for the particle
double p_energy = LCG_random_double(&seed);
int mat = pick_mat(&seed);
SD.p_energy_samples[i] = p_energy;
SD.mat_samples[i] = mat;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 100)<OMP-END> |
flame/blis/kernels/bgq/1/bli_axpyv_bgq_int.c | #pragma omp parallel for | 100 | r4double xv, yv, zv;
vector4double alphav = vec_lds( 0 * sizeof(double), (double*)alpha );
<LOOP-START>for ( dim_t i = 0; i < n_run; i++ )
{
xv = vec_lda( 0 * sizeof(double), &x[i*4] );
yv = vec_lda( 0 * sizeof(double), &y[i*4] );
zv = vec_madd( alphav, xv, yv );
vec_sta( zv, 0 * sizeof(double), &y[i*4] );
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
nowke/hpc_lab/11_black_white_image/black_white_static.c | #pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(static) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = gdImageRed(img, color);
green = gdImageGreen(img, color);
blue = gdImageBlue(img, color);
tmp = (red + green + blue) / 3;
red = green = blue = tmp;
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(static)<OMP-END> |
nowke/hpc_lab/11_black_white_image/black_white.c | #pragma omp parallel for private(y, color, red, green, blue, tmp) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = gdImageRed(img, color);
green = gdImageGreen(img, color);
blue = gdImageBlue(img, color);
tmp = (red + green + blue) / 3;
red = green = blue = tmp;
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue, tmp)<OMP-END> |
nowke/hpc_lab/11_black_white_image/black_white_dynamic.c | #pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(dynamic) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = gdImageRed(img, color);
green = gdImageGreen(img, color);
blue = gdImageBlue(img, color);
tmp = (red + green + blue) / 3;
red = green = blue = tmp;
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(dynamic)<OMP-END> |
nowke/hpc_lab/11_black_white_image/black_white_guided.c | #pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(guided) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = gdImageRed(img, color);
green = gdImageGreen(img, color);
blue = gdImageBlue(img, color);
tmp = (red + green + blue) / 3;
red = green = blue = tmp;
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue, tmp) schedule(guided)<OMP-END> |
nowke/hpc_lab/1_pi_calculation/pi_calculation.c | #pragma omp parallel for private(x) reduction(+:sum) | 100 | ulate_pi() {
double sum = 0.0;
double step = 1.0 / intervals;
double x;
int i;
<LOOP-START>for (i=1; i < intervals; i++) {
x = step * (i+0.5); // We take 0.5 as we are taking middle point of rectangular area
sum += 4.0 / (1.0 + x * x);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(x) reduction(+:sum)<OMP-END> |
nowke/hpc_lab/5_negative_image/negative_critical.c | #pragma omp parallel for private(y, color, red, green, blue) num_threads(num_threads) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
#pragma omp critical
{
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = 255 - gdImageRed(img, color);
green = 255 - gdImageGreen(img, color);
blue = 255 - gdImageBlue(img, color);
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue) num_threads(num_threads)<OMP-END> |
nowke/hpc_lab/5_negative_image/negative.c | #pragma omp parallel for private(y, color, red, green, blue) num_threads(num_threads) | 100 | int width = gdImageSX(img);
int height = gdImageSY(img);
double t1 = omp_get_wtime();
<LOOP-START>for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
color = x + 0;
color = gdImageGetPixel(img, x, y);
red = 255 - gdImageRed(img, color);
green = 255 - gdImageGreen(img, color);
blue = 255 - gdImageBlue(img, color);
color = gdImageColorAllocate(img, red, green, blue);
gdImageSetPixel(img, x, y, color);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(y, color, red, green, blue) num_threads(num_threads)<OMP-END> |
nowke/hpc_lab/7_points_clustering/points_clustering.cpp | #pragma omp parallel for num_threads(num_threads) | 100 | point
cluster_count[i] = 1;
points[i][1] = i;
}
}
void cluster_points() {
<LOOP-START>for (long i=0; i<num_points; i++) {
double min_dist = 1000, cur_dist = -1;
int cluster_index = -1;
for (int j=0; j<K; j++) {
cur_dist = fabs((double)points[i][0] - cluster_mean[j]);
if (cur_dist < min_dist) {
min_dist = cur_dist;
cluster_index = j;
}
}
points[i][1] = cluster_index;
#pragma omp critical
{
// Calculate Cluster mean
cluster_mean[cluster_index] = ((cluster_mean[cluster_index] * cluster_count[cluster_index]) + points[i][0]) /
( cluster_count[cluster_index] + 1);
cluster_count[cluster_index]++;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(num_threads)<OMP-END> |
nowke/hpc_lab/2_matrix/matrix.c | #pragma omp parallel for private(j, k) | 100 | B[i][j] = rand() % 10;
}
}
}
void multiply_matrix() {
int i, j, k;
<LOOP-START>for (i=0; i < matrix_size; i++) {
for (j=0; j < matrix_size; j++) {
C[i][j] = 0;
for (k=0; k < matrix_size; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(j, k)<OMP-END> |
nowke/hpc_lab/6_multitasking/multitask.cpp | #pragma omp parallel for private(a) num_threads(num_threads) | 100 | e answer!
*/
double* sine_table(int num) {
double* sines = new double[num];
double a;
<LOOP-START>for (int i=0; i<num; i++) {
sines[i] = 0.0;
for (int j=0; j <= i; j++) {
a = j * PI / (num - 1);
sines[i] += sin(a);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(a) num_threads(num_threads)<OMP-END> |
nowke/hpc_lab/9_points_classification/points_classification.cpp | #pragma omp parallel for num_threads(num_threads) | 100 | int dx = x2-x1, dy = y2-y1;
return (double)sqrt(dx*dx + dy*dy);
}
void classify_points() {
<LOOP-START>for (long i=0; i<num_points; i++) {
double min_dist = 1000, cur_dist = 1;
int cluster_index = -1;
for (int j=0; j<K; j++) {
cur_dist = get_distance(
points[i][0], points[i][1],
cluster[j][0], cluster[j][1]
);
if (cur_dist < min_dist) {
min_dist = cur_dist;
cluster_index = j;
}
}
cluster_count[cluster_index]++;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(num_threads)<OMP-END> |
abhi4578/Parallelization-of-PSO/omp_parallel.c | #pragma omp parallel for private(a,b) reduction(min:gBestFitness) | 100 | int)nDimensions];
double gBestFitness = DBL_MAX;
int min;
//particle initialization
<LOOP-START>for (i=0; i<distributed_particles; i++) {
for (j=0; j<(int)nDimensions; j++)
{
a = x_min + (x_max - x_min) * gsl_rng_uniform(r);
b = x_min + (x_max - x_min) * gsl_rng_uniform(r);
positions[i][j] = a;
pBestPositions[i][j] = a;
velocities[i][j] = (a-b) / 2.;
}
pBestFitness[i] = ackley(positions[i],(int)nDimensions);
if (pBestFitness[i] < gBestFitness) {
gBestFitness = pBestFitness[i];
memmove((void *)gBestPosition, (void *)&positions[i], sizeof(double) * nDimensions);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(a,b) reduction(min:gBestFitness)<OMP-END> |
abhi4578/Parallelization-of-PSO/mpiomp.c | #pragma omp parallel for | 100 | ain(int argc, char *argv[]) {
int i,j;
double nParticles;
//Argument handling START
<LOOP-START>for(i=1; i < argc-1; i++) {
if (strcmp(argv[i], "-D") == 0)
nDimensions = strtol(argv[i+1],NULL,10);
else if (strcmp(argv[i], "-m") == 0)
nParticles = strtol(argv[i+1],NULL,10);
else if (strcmp(argv[i], "-V") == 0)
mVelocity = strtol(argv[i+1],NULL,10);
else if (strcmp(argv[i], "-i") == 0)
nIterations = strtol(argv[i+1],NULL,10);
else if (strcmp(argv[i], "-s") == 0)
seed = strtol(argv[i+1],NULL,10);
}<LOOP-END> <OMP-START>#pragma omp parallel for<OMP-END> |
abhi4578/Parallelization-of-PSO/mpiomp.c | #pragma omp parallel for private(a,b) reduction(min:gBestFitness) | 100 | int)nDimensions];
double gBestFitness = DBL_MAX;
int min;
//particle initialization
<LOOP-START>for (i=0; i<distributed_particles; i++) {
// #pragma omp parallel for private(a,b)
for (j=0; j<(int)nDimensions; j++) {
a = x_min + (x_max - x_min) * gsl_rng_uniform(r);
b = x_min + (x_max - x_min) * gsl_rng_uniform(r);
positions[i][j] = a;
pBestPositions[i][j] = a;
velocities[i][j] = (a-b) / 2.;
}
pBestFitness[i] = ackley(positions[i],(int)nDimensions);
if (pBestFitness[i] < gBestFitness) {
memmove((void *)gBestPosition, (void *)&positions[i], sizeof(double) * nDimensions);
gBestFitness = pBestFitness[i];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(a,b) reduction(min:gBestFitness)<OMP-END> |
abhi4578/Parallelization-of-PSO/mpiomp.c | #pragma omp parallel for private(a,b) | 100 | private(a,b) reduction(min:gBestFitness)
for (i=0; i<distributed_particles; i++) {
// <LOOP-START>for (j=0; j<(int)nDimensions; j++) {
a = x_min + (x_max - x_min) * gsl_rng_uniform(r);
b = x_min + (x_max - x_min) * gsl_rng_uniform(r);
positions[i][j] = a;
pBestPositions[i][j] = a;
velocities[i][j] = (a-b) / 2.;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(a,b)<OMP-END> |
abhi4578/Parallelization-of-PSO/omp.c | #pragma omp parallel for private(a,b) reduction(min:gBestFitness) | 100 | int)nDimensions];
double gBestFitness = DBL_MAX;
int min;
//particle initialization
<LOOP-START>for (i=0; i<distributed_particles; i++) {
for (j=0; j<(int)nDimensions; j++)
{
a = x_min + (x_max - x_min) * gsl_rng_uniform(r);
b = x_min + (x_max - x_min) * gsl_rng_uniform(r);
positions[i][j] = a;
pBestPositions[i][j] = a;
velocities[i][j] = (a-b) / 2.;
}
pBestFitness[i] = ackley(positions[i],(int)nDimensions);
if (pBestFitness[i] < gBestFitness) {
gBestFitness = pBestFitness[i];
memmove((void *)gBestPosition, (void *)&positions[i], sizeof(double) * nDimensions);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for private(a,b) reduction(min:gBestFitness)<OMP-END> |
ecrc/stars-h/src/control/problem.c | #pragma omp parallel for private(dest, src, i, j) | 100 | esize *= A->shape[i];
if(A->order == 'C')
{
lda = A->shape[A->ndim-1];
//<LOOP-START>for(i = 0; i < nrows; i++)
for(j = 0; j < ncols; j++)
{
dest = j*(size_t)ld+i;
src = irow[i]*lda+icol[j];
memcpy(result+dest*esize, A->data+src*esize, esize);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(dest, src, i, j)<OMP-END> |
ecrc/stars-h/src/control/problem.c | #pragma omp parallel for private(dest, src, i, j) | 100 | A->data+src*esize, esize);
}
}
else
{
lda = A->shape[0];
//<LOOP-START>for(i = 0; i < nrows; i++)
for(j = 0; j < ncols; j++)
{
dest = j*(size_t)ld+i;
src = icol[j]*lda+irow[i];
memcpy(result+dest*esize, A->data+src*esize, esize);
}<LOOP-END> <OMP-START>#pragma omp parallel for private(dest, src, i, j)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | s_far;
char symm = F->symm;
int info = 0;
// Simple cycle over all far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_far; bi++)
{
if(info != 0)
continue;
// Get indexes and sizes of block row and column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Rank of a block
int rank = M->far_rank[bi];
// Temporary array for more precise dnrm2
double *D, D_norm[ncols];
size_t D_size = (size_t)nrows*(size_t)ncols;
STARSH_PMALLOC(D, D_size, info);
// Get actual elements of a block
kernel(nrows, ncols, R->pivot+R->start[i], C->pivot+C->start[j],
RD, CD, D, nrows);
// Get Frobenius norm of a block
for(size_t k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*nrows, 1);
double tmpnorm = cblas_dnrm2(ncols, D_norm, 1);
far_block_norm[bi] = tmpnorm;
// Get difference of initial and approximated block
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans, nrows, ncols,
rank, -1., U[bi]->data, nrows, V[bi]->data, ncols, 1.,
D, nrows);
// Compute Frobenius norm of the latter
for(size_t k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*nrows, 1);
free(D);
double tmpdiff = cblas_dnrm2(ncols, D_norm, 1);
far_block_diff[bi] = tmpdiff;
if(i != j && symm == 'S')
{
// Multiply by square root of 2 in symmetric case
// (work on 1 block instead of 2 blocks)
far_block_norm[bi] *= sqrt2;
far_block_diff[bi] *= sqrt2;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | // not Error code)
if(M->onfly == 0)
// Simple cycle over all near-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_near; bi++)
{
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Compute norm of a block
double *D = M->near_D[bi]->data, D_norm[ncols];
for(size_t k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*nrows, 1);
near_block_norm[bi] = cblas_dnrm2(ncols, D_norm, 1);
if(i != j && symm == 'S')
// Multiply by square root of 2 in symmetric case
near_block_norm[bi] *= sqrt2;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | ck_norm[bi] *= sqrt2;
}
else
// Simple cycle over all near-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_near; bi++)
{
if(info != 0)
continue;
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
double *D, D_norm[ncols];
// Allocate temporary array and fill it with elements of a block
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
kernel(nrows, ncols, R->pivot+R->start[i], C->pivot+C->start[j],
RD, CD, D, nrows);
// Compute norm of a block
for(size_t k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*nrows, 1);
// Free temporary buffer
free(D);
near_block_norm[bi] = cblas_dnrm2(ncols, D_norm, 1);
if(i != j && symm == 'S')
// Multiply by square root of 2 ub symmetric case
near_block_norm[bi] *= sqrt2;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | axrank = 100;
int maxnb = nrows/F->nbrows;
// Setting B = beta*B
if(beta == 0.)
<LOOP-START>for(int i = 0; i < nrows; i++)
for(int j = 0; j < nrhs; j++)
B[j*ldb+i] = 0.;
else
#pragma omp parallel for schedule(static)
for(int i = 0; i < nrows; i++)
for(int j = 0; j < nrhs; j++)
B[j*ldb+i] *= beta;
double *temp_D, *temp_B;
int num_threads;
#pragma omp parallel
#pragma omp master
num_threads = omp_get_num_threads();
if(M->onfly == 0)
{
STARSH_MALLOC(temp_D, num_threads*nrhs*maxrank);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | s; i++)
for(int j = 0; j < nrhs; j++)
B[j*ldb+i] = 0.;
else
<LOOP-START>for(int i = 0; i < nrows; i++)
for(int j = 0; j < nrhs; j++)
B[j*ldb+i] *= beta;
double *temp_D, *temp_B;
int num_threads;
#pragma omp parallel
#pragma omp master
num_threads = omp_get_num_threads();
if(M->onfly == 0)
{
STARSH_MALLOC(temp_D, num_threads*nrhs*maxrank);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | [j] = 0.;
}
int ldout = nrows;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(bi = 0; bi < nblocks_far; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[bi];
// Get pointers to data buffers
double *U = M->far_U[bi]->data, *V = M->far_V[bi]->data;
int info = 0;
double *D = temp_D+omp_get_thread_num()*nrhs*maxrank;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
// Multiply low-rank matrix in U*V^T format by a dense matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Multiply low-rank matrix in V*U^T format by a dense matrix
// U and V are simply swapped in case of symmetric block
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
nrows, 1.0, U, nrows, A+R->start[i], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, ncols,
nrhs, rank, alpha, V, ncols, D, rank, 1.0,
out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | );
}
}
if(M->onfly == 1)
// Simple cycle over all near-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_near; bi++)
{
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
int info = 0;
double *D = temp_D+omp_get_thread_num()*maxnb*maxnb;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
// Fill temporary buffer with elements of corresponding block
kernel(nrows, ncols, R->pivot+R->start[i],
C->pivot+C->start[j], RD, CD, D, nrows);
// Multiply 2 dense matrices
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Repeat in case of symmetric matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, ncols,
nrhs, nrows, alpha, D, nrows, A+R->start[i], lda,
1.0, out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | ldout);
}
}
else
// Simple cycle over all near-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_near; bi++)
{
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Get pointers to data buffers
double *D = M->near_D[bi]->data;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
// Multiply 2 dense matrices
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Repeat in case of symmetric matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, ncols,
nrhs, nrows, alpha, D, nrows, A+R->start[i], lda,
1.0, out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dsdd.c | #pragma omp parallel for schedule(dynamic,1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(bi = 0; bi < nblocks_far; bi++)
{
int info;
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int mn = nrows > ncols ? ncols : nrows;
// Get size of temporary arrays
int lmn = mn, lwork = (4*lmn+8+nrows+ncols)*lmn, liwork = 8*lmn;
double *D, *work;
int *iwork;
size_t D_size = (size_t)nrows*(size_t)ncols;
// Allocate temporary arrays
STARSH_PMALLOC(D, D_size, info);
STARSH_PMALLOC(work, lwork, info);
STARSH_PMALLOC(iwork, liwork, info);
// Compute elements of a block
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
starsh_dense_dlrsdd(nrows, ncols, D, nrows, far_U[bi]->data, nrows,
far_V[bi]->data, ncols, far_rank+bi, maxrank, tol, work, lwork,
iwork);
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dsdd.c | #pragma omp parallel for schedule(static) | 100 | ar, 2*new_nblocks_near);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dsdd.c | #pragma omp parallel for schedule(static) | 100 | bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dsdd.c | #pragma omp parallel for schedule(dynamic,1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(bi = 0; bi < new_nblocks_near; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
array_from_buffer(near_D+bi, 2, shape, 'd', 'F', D);
offset_D += near_D[bi]->size;
}
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/drsdd.c | #pragma omp parallel for schedule(dynamic,1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(bi = 0; bi < nblocks_far; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
if(nrows != ncols && BAD_TILE == 0)
{
#pragma omp critical
BAD_TILE = 1;
STARSH_WARNING("This was only tested on square tiles, error of "
"approximation may be much higher, than demanded");
}
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
int lwork = ncols, lwork_sdd = (4*mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+nrows+mn2+1);
int liwork = 8*mn2;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
STARSH_PMALLOC(iwork, liwork, info);
STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
double time1 = omp_get_wtime();
starsh_dense_dlrrsdd(nrows, ncols, D, nrows, far_U[bi]->data, nrows,
far_V[bi]->data, ncols, far_rank+bi, maxrank, oversample, tol,
work, lwork, iwork);
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/drsdd.c | #pragma omp parallel for schedule(static) | 100 | ar, 2*new_nblocks_near);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/drsdd.c | #pragma omp parallel for schedule(static) | 100 | bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/drsdd.c | #pragma omp parallel for schedule(dynamic,1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
//<LOOP-START>for(bi = 0; bi < new_nblocks_near; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
array_from_buffer(near_D+bi, 2, shape, 'd', 'F', D);
offset_D += near_D[bi]->size;
}
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
double time1 = omp_get_wtime();
#pragma omp critical
kernel_time += time1-time0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dqp3.c | #pragma omp parallel for schedule(dynamic,1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(bi = 0; bi < nblocks_far; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
int lwork = 3*ncols+1, lwork_sdd = (4*(size_t)mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+mn2+1)+mn;
int liwork = ncols, liwork_sdd = 8*mn2;
if(liwork_sdd > liwork)
liwork = liwork_sdd;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
STARSH_PMALLOC(iwork, liwork, info);
STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
starsh_dense_dlrqp3(nrows, ncols, D, nrows, far_U[bi]->data, nrows,
far_V[bi]->data, ncols, far_rank+bi, maxrank, oversample, tol,
work, lwork, iwork);
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dqp3.c | #pragma omp parallel for schedule(static) | 100 | ar, 2*new_nblocks_near);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dqp3.c | #pragma omp parallel for schedule(static) | 100 | bi++)
block_near[bi] = F->block_near[bi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/openmp/blrm/dqp3.c | #pragma omp parallel for schedule(dynamic,1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(bi = 0; bi < new_nblocks_near; bi++)
{
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
array_from_buffer(near_D+bi, 2, shape, 'd', 'F', D);
offset_D += near_D[bi]->size;
}
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic,1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | far_local;
char symm = F->symm;
int info;
// Simple cycle over all far-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes and sizes of block row and column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Rank of a block
int rank = M->far_rank[lbi];
// Temporary array for more precise dnrm2
double *D, D_norm[ncols];
size_t D_size = (size_t)nrows*(size_t)ncols;
STARSH_PMALLOC(D, D_size, info);
// Get actual elements of a block
kernel(nrows, ncols, R->pivot+R->start[i], C->pivot+C->start[j],
RD, CD, D, nrows);
// Get Frobenius norm of a block
for(STARSH_int k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*(size_t)nrows, 1);
double tmpnorm = cblas_dnrm2(ncols, D_norm, 1);
far_block_norm[lbi] = tmpnorm;
// Get difference of initial and approximated block
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans, nrows, ncols,
rank, -1., U[lbi]->data, nrows, V[lbi]->data, ncols, 1.,
D, nrows);
// Compute Frobenius norm of the latter
for(STARSH_int k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*(size_t)nrows, 1);
free(D);
double tmpdiff = cblas_dnrm2(ncols, D_norm, 1);
far_block_diff[lbi] = tmpdiff;
if(i != j && symm == 'S')
{
// Multiply by square root of 2 in symmetric case
// (work on 1 block instead of 2 blocks)
far_block_norm[lbi] *= sqrt2;
far_block_diff[lbi] *= sqrt2;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | 2;
}
}
if(M->onfly == 0)
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Compute norm of a block
double *D = M->near_D[lbi]->data, D_norm[ncols];
for(STARSH_int k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*(size_t)nrows, 1);
near_block_norm[lbi] = cblas_dnrm2(ncols, D_norm, 1);
if(i != j && symm == 'S')
// Multiply by square root of 2 in symmetric case
near_block_norm[lbi] *= sqrt2;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dfe.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | k_norm[lbi] *= sqrt2;
}
else
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
double *D, D_norm[ncols];
// Allocate temporary array and fill it with elements of a block
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
kernel(nrows, ncols, R->pivot+R->start[i], C->pivot+C->start[j],
RD, CD, D, nrows);
// Compute norm of a block
for(STARSH_int k = 0; k < ncols; k++)
D_norm[k] = cblas_dnrm2(nrows, D+k*(size_t)nrows, 1);
// Free temporary buffer
free(D);
near_block_norm[lbi] = cblas_dnrm2(ncols, D_norm, 1);
if(i != j && symm == 'S')
// Multiply by square root of 2 ub symmetric case
near_block_norm[lbi] *= sqrt2;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | nrhs*(size_t)nrows; j++)
out[j] = 0.;
}
if(beta != 0. && mpi_rank == 0)
<LOOP-START>for(STARSH_int i = 0; i < nrows; i++)
for(STARSH_int j = 0; j < nrhs; j++)
temp_B[j*ldb+i] = beta*B[j*ldb+i];
int ldout = nrows;
// Simple cycle over all far-field admissible blocks
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[lbi];
if(rank == 0)
continue;
// Get pointers to data buffers
double *U = M->far_U[lbi]->data, *V = M->far_V[lbi]->data;
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*nrhs*maxrank;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Multiply low-rank matrix in U*V^T format by a dense matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Multiply low-rank matrix in V*U^T format by a dense matrix
// U and V are simply swapped in case of symmetric block
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
nrows, 1.0, U, nrows, A+R->start[i], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, ncols,
nrhs, rank, alpha, V, ncols, D, rank, 1.0,
out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | eta*B[j*ldb+i];
int ldout = nrows;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[lbi];
if(rank == 0)
continue;
// Get pointers to data buffers
double *U = M->far_U[lbi]->data, *V = M->far_V[lbi]->data;
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*nrhs*maxrank;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Multiply low-rank matrix in U*V^T format by a dense matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Multiply low-rank matrix in V*U^T format by a dense matrix
// U and V are simply swapped in case of symmetric block
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
nrows, 1.0, U, nrows, A+R->start[i], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, ncols,
nrhs, rank, alpha, V, ncols, D, rank, 1.0,
out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | );
}
}
if(M->onfly == 1)
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*maxnb*maxnb;
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Fill temporary buffer with elements of corresponding block
kernel(nrows, ncols, R->pivot+R->start[i],
C->pivot+C->start[j], RD, CD, D, nrows);
// Multiply 2 dense matrices
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Repeat in case of symmetric matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, ncols,
nrhs, nrows, alpha, D, nrows, A+R->start[i], lda,
1.0, out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | ldout);
}
}
else
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Get pointers to data buffers
double *D = M->near_D[lbi]->data;
#ifdef OPENMP
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
#else
double *out = temp_B;
// Multiply 2 dense matrices
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
out+R->start[i], ldout);
if(i != j && symm == 'S')
{
// Repeat in case of symmetric matrix
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, ncols,
nrhs, nrows, alpha, D, nrows, A+R->start[i], lda,
1.0, out+C->start[j], ldout);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | ;
}
}
// Reduce result to temp_B, corresponding to master openmp thread
<LOOP-START>for(int i = 0; i < ldout; i++)
for(int j = 0; j < nrhs; j++)
for(int k = 1; k < num_threads; k++)
temp_B[j*(size_t)ldout+i] +=
temp_B[(k*(size_t)nrhs+j)*ldout+i];
// Since I keep result only on root node, following code is commented
//for(int i = 0; i < nrhs; i++)
// MPI_Allreduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM,
// MPI_COMM_WORLD);
for(int i = 0; i < nrhs; i++)
MPI_Reduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
free(temp_B);
free(temp_D);
return STARSH_SUCCESS;
}
int starsh_blrm__dmml_mpi_tlr(STARSH_blrm *matrix, int nrhs, double alpha,
double *A, int lda, double beta, double *B, int ldb)
//! Multiply blr-matrix by dense matrix on MPI nodes.
/*! Performs `C=alpha*A*B+beta*C` with @ref STARSH_blrm `A` and dense matrices
* `B` and `C`. All the integer types are int, since they are used in BLAS
* calls. Block-wise low-rank matrix `A` is in TLR format.
*
* @param[in] matrix: Pointer to @ref STARSH_blrm object.
* @param[in] nrhs: Number of right hand sides.
* @param[in] alpha: Scalar mutliplier.
* @param[in] A: Dense matrix, right havd side.
* @param[in] lda: Leading dimension of `A`.
* @param[in] beta: Scalar multiplier.
* @param[in] B: Resulting dense matrix.
* @param[in] ldb: Leading dimension of B.
* @return Error code @ref STARSH_ERRNO.
* @ingroup blrm
* */
{
STARSH_blrm *M = matrix;
STARSH_blrf *F = M->format;
STARSH_problem *P = F->problem;
STARSH_kernel *kernel = P->kernel;
STARSH_int nrows = P->shape[0];
STARSH_int ncols = P->shape[P->ndim-1];
// Shorcuts to information about clusters
STARSH_cluster *R = F->row_cluster;
STARSH_cluster *C = F->col_cluster;
void *RD = R->data, *CD = C->data;
// Number of far-field and near-field blocks
STARSH_int nblocks_far_local = F->nblocks_far_local;
STARSH_int nblocks_near_local = F->nblocks_near_local;
STARSH_int lbi;
char symm = F->symm;
int maxrank = 0;
for(lbi = 0; lbi < nblocks_far_local; lbi++)
if(maxrank < M->far_rank[lbi])
maxrank = M->far_rank[lbi];
STARSH_int maxnb = nrows/F->nbrows;
int mpi_rank, mpi_size;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
int grid_nx = sqrt(mpi_size), grid_ny = grid_nx, grid_x, grid_y;
if(grid_nx*grid_ny != mpi_size)
STARSH_ERROR("MPI SIZE MUST BE SQUARE OF INTEGER!");
grid_ny = mpi_size / grid_nx;
grid_x = mpi_rank / grid_nx;
grid_y = mpi_rank % grid_nx;
MPI_Group mpi_leadingx_group, mpi_leadingy_group, mpi_world_group;
MPI_Comm mpi_splitx, mpi_splity, mpi_leadingx, mpi_leadingy;
MPI_Comm_group(MPI_COMM_WORLD, &mpi_world_group);
int group_rank[grid_nx];
for(int i = 0; i < grid_ny; i++)
group_rank[i] = i;
MPI_Group_incl(mpi_world_group, grid_ny, group_rank, &mpi_leadingy_group);
MPI_Comm_create_group(MPI_COMM_WORLD, mpi_leadingy_group, 0,
&mpi_leadingy);
for(int i = 0; i < grid_nx; i++)
group_rank[i] = i*grid_ny;
MPI_Group_incl(mpi_world_group, grid_nx, group_rank, &mpi_leadingx_group);
MPI_Comm_create_group(MPI_COMM_WORLD, mpi_leadingx_group, 0,
&mpi_leadingx);
MPI_Comm_split(MPI_COMM_WORLD, grid_x, mpi_rank, &mpi_splitx);
MPI_Comm_split(MPI_COMM_WORLD, grid_y, mpi_rank, &mpi_splity);
int mpi_leadingx_rank=-1, mpi_leadingx_size=-1;
int mpi_leadingy_rank=-1, mpi_leadingy_size=-1;
int mpi_splitx_rank, mpi_splitx_size;
int mpi_splity_rank, mpi_splity_size;
if(mpi_leadingx != MPI_COMM_NULL)
{
MPI_Comm_rank(mpi_leadingx, &mpi_leadingx_rank);
MPI_Comm_size(mpi_leadingx, &mpi_leadingx_size);
}
if(mpi_leadingy != MPI_COMM_NULL)
{
MPI_Comm_rank(mpi_leadingy, &mpi_leadingy_rank);
MPI_Comm_size(mpi_leadingy, &mpi_leadingy_size);
}
MPI_Comm_rank(mpi_splitx, &mpi_splitx_rank);
MPI_Comm_size(mpi_splitx, &mpi_splitx_size);
MPI_Comm_rank(mpi_splity, &mpi_splity_rank);
MPI_Comm_size(mpi_splity, &mpi_splity_size);
/*
STARSH_WARNING("MPI: GLOBAL=%d/%d LEADX=%d/%d LEADY=%d/%d SPLITX=%d/%d "
"SPLITY=%d/%d", mpi_rank, mpi_size, mpi_leadingx_rank,
mpi_leadingx_size, mpi_leadingy_rank, mpi_leadingy_size,
mpi_splitx_rank, mpi_splitx_size, mpi_splity_rank,
mpi_splity_size);
*/
int grid_block_size = maxnb*grid_nx;
int ld_temp_A = (F->nbcols+grid_nx-1-grid_x)/grid_nx*maxnb;
double *temp_A;
STARSH_MALLOC(temp_A, nrhs*(size_t)ld_temp_A);
if(mpi_leadingx != MPI_COMM_NULL)
{
for(STARSH_int i = 0; i < F->nbcols/grid_nx; i++)
{
double *src = A+i*grid_block_size;
double *recv = temp_A+i*maxnb;
for(int j = 0; j < nrhs; j++)
{
MPI_Scatter(src+j*(size_t)lda, maxnb, MPI_DOUBLE,
recv+j*(size_t)ld_temp_A, maxnb, MPI_DOUBLE, 0,
mpi_leadingx);
}
}
STARSH_int i = F->nbcols/grid_nx;
int remain = F->nbcols-i*grid_nx;
if(remain > 0)
{
double *src = A+i*(size_t)grid_block_size;
double *recv = temp_A+i*(size_t)maxnb;
if(mpi_rank == 0)
{
int sendcounts[grid_nx], displs[grid_nx];
for(int j = 0; j < remain; j++)
sendcounts[j] = maxnb;
for(int j = remain; j < grid_nx; j++)
sendcounts[j] = 0;
displs[0] = 0;
for(int j = 1; j < grid_nx; j++)
displs[j] = displs[j-1]+sendcounts[j-1];
for(int j = 0; j < nrhs; j++)
MPI_Scatterv(src+j*(size_t)lda, sendcounts, displs,
MPI_DOUBLE, recv+j*(size_t)ld_temp_A, maxnb,
MPI_DOUBLE, 0, mpi_leadingx);
}
else
{
int recvcount = 0;
if(grid_x < remain)
recvcount = maxnb;
for(int j = 0; j < nrhs; j++)
MPI_Scatterv(NULL, NULL, NULL, MPI_DOUBLE,
recv+j*(size_t)ld_temp_A, recvcount, MPI_DOUBLE, 0,
mpi_leadingx);
}
}
}
MPI_Bcast(temp_A, nrhs*(size_t)ld_temp_A, MPI_DOUBLE, 0, mpi_splitx);
//if(mpi_rank == 0)
// STARSH_WARNING("DATA DISTRIBUTED!");
//for(int i = 0; i < nrhs; i++)
// MPI_Bcast(A+i*lda, ncols, MPI_DOUBLE, 0, MPI_COMM_WORLD);
double *temp_D, *temp_B;
int num_threads;
#ifdef OPENMP
#pragma omp parallel
#pragma omp master
num_threads = omp_get_num_threads();
#else
num_threads = 1;
if(M->onfly == 0)
{
STARSH_MALLOC(temp_D, num_threads*nrhs*maxrank);
}
else
{
STARSH_MALLOC(temp_D, num_threads*maxnb*maxnb);
}
int ldout = (F->nbrows+grid_ny-1-grid_y)/grid_ny*maxnb;
//STARSH_WARNING("MPI=%d ldA=%d ldB=%d", mpi_rank, ld_temp_A, ldout);
STARSH_MALLOC(temp_B, num_threads*(size_t)nrhs*(size_t)ldout);
// Setting temp_B=beta*B for master thread of root node and B=0 otherwise
#pragma omp parallel
{
#ifdef OPENMP
double *out = temp_B+omp_get_thread_num()*nrhs*ldout;
#else
double *out = temp_B;
for(size_t j = 0; j < nrhs*(size_t)ldout; j++)
out[j] = 0.;
}
if(beta != 0. && mpi_leadingy != MPI_COMM_NULL)
{
for(STARSH_int i = 0; i < F->nbrows/grid_ny; i++)
{
double *src = B+i*maxnb*grid_ny;
double *recv = temp_B+i*maxnb;
for(int j = 0; j < nrhs; j++)
MPI_Scatter(src+j*(size_t)ldb, maxnb, MPI_DOUBLE,
recv+j*(size_t)ldout, maxnb, MPI_DOUBLE, 0,
mpi_leadingy);
}
#pragma omp parallel for schedule(static)
for(int i = 0; i < ldout; i++)
for(int j = 0; j < nrhs; j++)
temp_B[j*(size_t)ldb+i] *= beta;
}
//if(mpi_rank == 0)
// STARSH_WARNING("MORE DATA DISTRIBUTED");
// Simple cycle over all far-field admissible blocks
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[lbi];
if(rank == 0)
continue;
// Get pointers to data buffers
double *U = M->far_U[lbi]->data, *V = M->far_V[lbi]->data;
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*(size_t)nrhs*(size_t)maxrank;
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*(size_t)ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Multiply low-rank matrix in U*V^T format by a dense matrix
//cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
// ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, temp_A+(j/grid_nx)*maxnb, ld_temp_A, 0.0,
D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+i/grid_ny*maxnb,
ldout);
}
//STARSH_WARNING("NODE %d DONE WITH FAR", mpi_rank);
if(M->onfly == 1)
// Simple cycle over all near-field blocks
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*(size_t)maxnb*
(size_t)maxnb;
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*
(size_t)ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Fill temporary buffer with elements of corresponding block
kernel(nrows, ncols, R->pivot+R->start[i],
C->pivot+C->start[j], RD, CD, D, nrows);
// Multiply 2 dense matrices
//cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
// nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
// out+R->start[i], ldout);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows,
temp_A+(j/grid_nx)*(size_t)maxnb, ld_temp_A, 1.0,
out+i/grid_ny*(size_t)maxnb, ldout);
}
else
// Simple cycle over all near-field blocks
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Get pointers to data buffers
double *D = M->near_D[lbi]->data;
#ifdef OPENMP
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*
(size_t)ldout;
#else
double *out = temp_B;
// Multiply 2 dense matrices
//cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
// nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
// out+R->start[i], ldout);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows,
temp_A+(j/grid_nx)*(size_t)maxnb, ld_temp_A, 1.0,
out+i/grid_ny*(size_t)maxnb, ldout);
}
// Reduce result to temp_B, corresponding to master openmp thread
#pragma omp parallel for schedule(static)
for(int i = 0; i < ldout; i++)
for(int j = 0; j < nrhs; j++)
for(int k = 1; k < num_threads; k++)
temp_B[j*(size_t)ldout+i] +=
temp_B[(k*(size_t)nrhs+j)*ldout+i];
//STARSH_WARNING("NODE %d DONE WITH OMP REDUCTION", mpi_rank);
MPI_Barrier(MPI_COMM_WORLD);
// Since I keep result only on root node, following code is commented
//for(int i = 0; i < nrhs; i++)
// MPI_Allreduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM,
// MPI_COMM_WORLD);
//for(int i = 0; i < nrhs; i++)
// MPI_Reduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM, 0,
// MPI_COMM_WORLD);
double *final_B = NULL;
if(mpi_leadingy != MPI_COMM_NULL)
{
STARSH_MALLOC(final_B, nrhs*(size_t)ldout);
#pragma omp parallel for schedule(static)
for(size_t i = 0; i < nrhs*(size_t)ldout; i++)
final_B[i] = 0.0;
}
MPI_Reduce(temp_B, final_B, nrhs*(size_t)ldout, MPI_DOUBLE, MPI_SUM, 0,
mpi_splity);
//STARSH_WARNING("REDUCE(%d): %f", mpi_rank, temp_B[0]);
//if(mpi_splity_rank == 0)
// STARSH_WARNING("RESULT(%d): %f", mpi_rank, final_B[0]);
if(mpi_leadingy != MPI_COMM_NULL)
{
for(STARSH_int i = 0; i < F->nbrows/grid_ny; i++)
{
double *src = final_B+i*(size_t)maxnb;
double *recv = B+i*(size_t)maxnb*(size_t)grid_ny;
for(int j = 0; j < nrhs; j++)
MPI_Gather(src+j*(size_t)ldout, maxnb, MPI_DOUBLE,
recv+j*(size_t)ldb, maxnb, MPI_DOUBLE, 0,
mpi_leadingy);
}
STARSH_int i = F->nbrows/grid_ny;
int remain = F->nbrows-i*grid_ny;
if(remain > 0)
{
double *src = final_B+i*(size_t)maxnb;
double *recv = B+i*(size_t)maxnb*(size_t)grid_ny;
if(mpi_rank == 0)
{
int recvcounts[grid_ny], displs[grid_ny];
for(int j = 0; j < remain; j++)
recvcounts[j] = maxnb;
for(int j = remain; j < grid_ny; j++)
recvcounts[j] = 0;
displs[0] = 0;
for(int j = 1; j < grid_ny; j++)
displs[j] = displs[j-1]+recvcounts[j-1];
for(int j = 0; j < nrhs; j++)
MPI_Gatherv(src+j*(size_t)ldout, maxnb, MPI_DOUBLE,
recv+j*(size_t)ldb, recvcounts, displs, MPI_DOUBLE,
0, mpi_leadingy);
}
else
{
int sendcount = 0;
if(grid_y < remain)
sendcount = maxnb;
for(int j = 0; j < nrhs; j++)
MPI_Gatherv(src+j*(size_t)ldout, sendcount, MPI_DOUBLE,
NULL, NULL, NULL, MPI_DOUBLE, 0, mpi_leadingy);
}
}
MPI_Comm_free(&mpi_leadingy);
free(final_B);
}
if(mpi_leadingx != MPI_COMM_NULL)
MPI_Comm_free(&mpi_leadingx);
MPI_Comm_free(&mpi_splitx);
MPI_Comm_free(&mpi_splity);
free(temp_A);
free(temp_B);
free(temp_D);
return STARSH_SUCCESS;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | ecv+j*(size_t)ldout, maxnb, MPI_DOUBLE, 0,
mpi_leadingy);
}
<LOOP-START>for(int i = 0; i < ldout; i++)
for(int j = 0; j < nrhs; j++)
temp_B[j*(size_t)ldb+i] *= beta;
}
//if(mpi_rank == 0)
// STARSH_WARNING("MORE DATA DISTRIBUTED");
// Simple cycle over all far-field admissible blocks
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[lbi];
if(rank == 0)
continue;
// Get pointers to data buffers
double *U = M->far_U[lbi]->data, *V = M->far_V[lbi]->data;
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*(size_t)nrhs*(size_t)maxrank;
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*(size_t)ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Multiply low-rank matrix in U*V^T format by a dense matrix
//cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
// ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, temp_A+(j/grid_nx)*maxnb, ld_temp_A, 0.0,
D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+i/grid_ny*maxnb,
ldout);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | ARSH_WARNING("MORE DATA DISTRIBUTED");
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = F->block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = F->block_far[2*bi];
STARSH_int j = F->block_far[2*bi+1];
// Get sizes and rank
int nrows = R->size[i];
int ncols = C->size[j];
int rank = M->far_rank[lbi];
if(rank == 0)
continue;
// Get pointers to data buffers
double *U = M->far_U[lbi]->data, *V = M->far_V[lbi]->data;
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*(size_t)nrhs*(size_t)maxrank;
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*(size_t)ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Multiply low-rank matrix in U*V^T format by a dense matrix
//cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
// ncols, 1.0, V, ncols, A+C->start[j], lda, 0.0, D, rank);
cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, rank, nrhs,
ncols, 1.0, V, ncols, temp_A+(j/grid_nx)*maxnb, ld_temp_A, 0.0,
D, rank);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows, nrhs,
rank, alpha, U, nrows, D, rank, 1.0, out+i/grid_ny*maxnb,
ldout);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | H FAR", mpi_rank);
if(M->onfly == 1)
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
int info = 0;
#ifdef OPENMP
double *D = temp_D+omp_get_thread_num()*(size_t)maxnb*
(size_t)maxnb;
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*
(size_t)ldout;
#else
double *D = temp_D;
double *out = temp_B;
// Fill temporary buffer with elements of corresponding block
kernel(nrows, ncols, R->pivot+R->start[i],
C->pivot+C->start[j], RD, CD, D, nrows);
// Multiply 2 dense matrices
//cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
// nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
// out+R->start[i], ldout);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows,
temp_A+(j/grid_nx)*(size_t)maxnb, ld_temp_A, 1.0,
out+i/grid_ny*(size_t)maxnb, ldout);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | size_t)maxnb, ldout);
}
else
// Simple cycle over all near-field blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
{
STARSH_int bi = F->block_near_local[lbi];
// Get indexes and sizes of corresponding block row and column
STARSH_int i = F->block_near[2*bi];
STARSH_int j = F->block_near[2*bi+1];
int nrows = R->size[i];
int ncols = C->size[j];
// Get pointers to data buffers
double *D = M->near_D[lbi]->data;
#ifdef OPENMP
double *out = temp_B+omp_get_thread_num()*(size_t)nrhs*
(size_t)ldout;
#else
double *out = temp_B;
// Multiply 2 dense matrices
//cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
// nrhs, ncols, alpha, D, nrows, A+C->start[j], lda, 1.0,
// out+R->start[i], ldout);
cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, nrows,
nrhs, ncols, alpha, D, nrows,
temp_A+(j/grid_nx)*(size_t)maxnb, ld_temp_A, 1.0,
out+i/grid_ny*(size_t)maxnb, ldout);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | )maxnb, ldout);
}
// Reduce result to temp_B, corresponding to master openmp thread
<LOOP-START>for(int i = 0; i < ldout; i++)
for(int j = 0; j < nrhs; j++)
for(int k = 1; k < num_threads; k++)
temp_B[j*(size_t)ldout+i] +=
temp_B[(k*(size_t)nrhs+j)*ldout+i];
//STARSH_WARNING("NODE %d DONE WITH OMP REDUCTION", mpi_rank);
MPI_Barrier(MPI_COMM_WORLD);
// Since I keep result only on root node, following code is commented
//for(int i = 0; i < nrhs; i++)
// MPI_Allreduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM,
// MPI_COMM_WORLD);
//for(int i = 0; i < nrhs; i++)
// MPI_Reduce(temp_B+i*ldout, B+i*ldb, ldout, MPI_DOUBLE, MPI_SUM, 0,
// MPI_COMM_WORLD);
double *final_B = NULL;
if(mpi_leadingy != MPI_COMM_NULL)
{
STARSH_MALLOC(final_B, nrhs*(size_t)ldout);
#pragma omp parallel for schedule(static)
for(size_t i = 0; i < nrhs*(size_t)ldout; i++)
final_B[i] = 0.0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dmml.c | #pragma omp parallel for schedule(static) | 100 | if(mpi_leadingy != MPI_COMM_NULL)
{
STARSH_MALLOC(final_B, nrhs*(size_t)ldout);
<LOOP-START>for(size_t i = 0; i < nrhs*(size_t)ldout; i++)
final_B[i] = 0.0;
}
MPI_Reduce(temp_B, final_B, nrhs*(size_t)ldout, MPI_DOUBLE, MPI_SUM, 0,
mpi_splity);
//STARSH_WARNING("REDUCE(%d): %f", mpi_rank, temp_B[0]);
//if(mpi_splity_rank == 0)
// STARSH_WARNING("RESULT(%d): %f", mpi_rank, final_B[0]);
if(mpi_leadingy != MPI_COMM_NULL)
{
for(STARSH_int i = 0; i < F->nbrows/grid_ny; i++)
{
double *src = final_B+i*(size_t)maxnb;
double *recv = B+i*(size_t)maxnb*(size_t)grid_ny;
for(int j = 0; j < nrhs; j++)
MPI_Gather(src+j*(size_t)ldout, maxnb, MPI_DOUBLE,
recv+j*(size_t)ldb, maxnb, MPI_DOUBLE, 0,
mpi_leadingy);
}
STARSH_int i = F->nbrows/grid_ny;
int remain = F->nbrows-i*grid_ny;
if(remain > 0)
{
double *src = final_B+i*(size_t)maxnb;
double *recv = B+i*(size_t)maxnb*(size_t)grid_ny;
if(mpi_rank == 0)
{
int recvcounts[grid_ny], displs[grid_ny];
for(int j = 0; j < remain; j++)
recvcounts[j] = maxnb;
for(int j = remain; j < grid_ny; j++)
recvcounts[j] = 0;
displs[0] = 0;
for(int j = 1; j < grid_ny; j++)
displs[j] = displs[j-1]+recvcounts[j-1];
for(int j = 0; j < nrhs; j++)
MPI_Gatherv(src+j*(size_t)ldout, maxnb, MPI_DOUBLE,
recv+j*(size_t)ldb, recvcounts, displs, MPI_DOUBLE,
0, mpi_leadingy);
}
else
{
int sendcount = 0;
if(grid_y < remain)
sendcount = maxnb;
for(int j = 0; j < nrhs; j++)
MPI_Gatherv(src+j*(size_t)ldout, sendcount, MPI_DOUBLE,
NULL, NULL, NULL, MPI_DOUBLE, 0, mpi_leadingy);
}
}
MPI_Comm_free(&mpi_leadingy);
free(final_B);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(static) | 100 | r-field admissible blocks
// Since this is fake low-rank approximation, every tile is dense
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
far_rank[lbi] = -1;
/*
#pragma omp parallel for schedule(dynamic, 1)
for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
size_t bi = block_far_local[lbi];
// Get indexes of corresponding block row and block column
int i = block_far[2*bi];
int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
if(nrows != ncols && BAD_TILE == 0)
{
#pragma omp critical
BAD_TILE = 1;
STARSH_WARNING("This was only tested on square tiles, error of "
"approximation may be much higher, than demanded");
}
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
size_t lwork = ncols, lwork_sdd = (4*mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+nrows+mn2+1);
size_t liwork = 8*mn2;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
//STARSH_PMALLOC(iwork, liwork, info);
//STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D);
double time1 = omp_get_wtime();
starsh_kernel_dna(nrows, ncols, D, far_U[lbi]->data,
far_V[lbi]->data, far_rank+lbi, maxrank, oversample, tol, work,
lwork, iwork);
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
//free(work);
//free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | ule(static)
for(lbi = 0; lbi < nblocks_far_local; lbi++)
far_rank[lbi] = -1;
/*
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
size_t bi = block_far_local[lbi];
// Get indexes of corresponding block row and block column
int i = block_far[2*bi];
int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
if(nrows != ncols && BAD_TILE == 0)
{
#pragma omp critical
BAD_TILE = 1;
STARSH_WARNING("This was only tested on square tiles, error of "
"approximation may be much higher, than demanded");
}
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
size_t lwork = ncols, lwork_sdd = (4*mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+nrows+mn2+1);
size_t liwork = 8*mn2;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
//STARSH_PMALLOC(iwork, liwork, info);
//STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D);
double time1 = omp_get_wtime();
starsh_kernel_dna(nrows, ncols, D, far_U[lbi]->data,
far_V[lbi]->data, far_rank+lbi, maxrank, oversample, tol, work,
lwork, iwork);
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
//free(work);
//free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(static) | 100 | new_nblocks_near_local);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
#pragma omp parallel for schedule(static)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(static) | 100 | for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(static) | 100 | block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dna.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(lbi = 0; lbi < new_nblocks_near_local; lbi++)
{
STARSH_int bi = block_near_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
offset_D += nrows*ncols;
//array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
//offset_D += near_D[lbi]->size;
}
array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
#pragma omp critical
kernel_time += time1-time0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dsdd.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int mn = nrows < ncols ? nrows : ncols;
// Get size of temporary arrays
int lmn = mn, lwork = (4*lmn+8+nrows+ncols)*lmn, liwork = 8*lmn;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
STARSH_PMALLOC(iwork, liwork, info);
STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
starsh_dense_dlrsdd(nrows, ncols, D, nrows, far_U[lbi]->data, nrows,
far_V[lbi]->data, ncols, far_rank+lbi, maxrank, tol, work,
lwork, iwork);
#ifdef OPENMP
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dsdd.c | #pragma omp parallel for schedule(static) | 100 | new_nblocks_near_local);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
#pragma omp parallel for schedule(static)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dsdd.c | #pragma omp parallel for schedule(static) | 100 | for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dsdd.c | #pragma omp parallel for schedule(static) | 100 | block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dsdd.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(lbi = 0; lbi < new_nblocks_near_local; lbi++)
{
STARSH_int bi = block_near_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
offset_D += nrows*ncols;
//array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
//offset_D += near_D[lbi]->size;
}
array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
#pragma omp critical
kernel_time += time1-time0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/drsdd.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
int lwork = ncols, lwork_sdd = (4*mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+nrows+mn2+1);
int liwork = 8*mn2;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
STARSH_PMALLOC(iwork, liwork, info);
STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
starsh_dense_dlrrsdd(nrows, ncols, D, nrows, far_U[lbi]->data, nrows,
far_V[lbi]->data, ncols, far_rank+lbi, maxrank, oversample,
tol, work, lwork, iwork);
#ifdef OPENMP
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/drsdd.c | #pragma omp parallel for schedule(static) | 100 | new_nblocks_near_local);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
#pragma omp parallel for schedule(static)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/drsdd.c | #pragma omp parallel for schedule(static) | 100 | for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/drsdd.c | #pragma omp parallel for schedule(static) | 100 | block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/drsdd.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(lbi = 0; lbi < new_nblocks_near_local; lbi++)
{
STARSH_int bi = block_near_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
offset_D += nrows*ncols;
//array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
//offset_D += near_D[lbi]->size;
}
array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
#pragma omp critical
kernel_time += time1-time0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dqp3.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | }
// Work variables
int info;
// Simple cycle over all far-field admissible blocks
<LOOP-START>for(lbi = 0; lbi < nblocks_far_local; lbi++)
{
STARSH_int bi = block_far_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_far[2*bi];
STARSH_int j = block_far[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int mn = nrows < ncols ? nrows : ncols;
int mn2 = maxrank+oversample;
if(mn2 > mn)
mn2 = mn;
// Get size of temporary arrays
int lwork = 3*ncols+1, lwork_sdd = (4*(size_t)mn2+7)*mn2;
if(lwork_sdd > lwork)
lwork = lwork_sdd;
lwork += (size_t)mn2*(2*ncols+mn2+1)+mn;
int liwork = ncols, liwork_sdd = 8*mn2;
if(liwork_sdd > liwork)
liwork = liwork_sdd;
double *D, *work;
int *iwork;
int info;
// Allocate temporary arrays
STARSH_PMALLOC(D, (size_t)nrows*(size_t)ncols, info);
STARSH_PMALLOC(iwork, liwork, info);
STARSH_PMALLOC(work, lwork, info);
// Compute elements of a block
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i], CC->pivot+CC->start[j],
RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
starsh_dense_dlrqp3(nrows, ncols, D, nrows, far_U[lbi]->data, nrows,
far_V[lbi]->data, ncols, far_rank+lbi, maxrank, oversample,
tol, work, lwork, iwork);
#ifdef OPENMP
double time2 = omp_get_wtime();
#pragma omp critical
{
drsdd_time += time2-time1;
kernel_time += time1-time0;
}
// Free temporary arrays
free(D);
free(work);
free(iwork);
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dqp3.c | #pragma omp parallel for schedule(static) | 100 | new_nblocks_near_local);
// At first get all near-field blocks, assumed to be dense
<LOOP-START>for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
#pragma omp parallel for schedule(static)
for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dqp3.c | #pragma omp parallel for schedule(static) | 100 | for(bi = 0; bi < 2*nblocks_near; bi++)
block_near[bi] = F->block_near[bi];
<LOOP-START>for(lbi = 0; lbi < nblocks_near_local; lbi++)
block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
#pragma omp parallel for schedule(static)
for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dqp3.c | #pragma omp parallel for schedule(static) | 100 | block_near_local[lbi] = F->block_near_local[lbi];
// Add false far-field blocks
<LOOP-START>for(bi = 0; bi < nblocks_false_far; bi++)
{
STARSH_int bj = false_far[bi];
block_near[2*(bi+nblocks_near)] = F->block_far[2*bj];
block_near[2*(bi+nblocks_near)+1] = F->block_far[2*bj+1];
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(static)<OMP-END> |
ecrc/stars-h/src/backends/mpi/blrm/dqp3.c | #pragma omp parallel for schedule(dynamic, 1) | 100 | STARSH_MALLOC(alloc_D, size_D);
// For each near-field block compute its elements
<LOOP-START>for(lbi = 0; lbi < new_nblocks_near_local; lbi++)
{
STARSH_int bi = block_near_local[lbi];
// Get indexes of corresponding block row and block column
STARSH_int i = block_near[2*bi];
STARSH_int j = block_near[2*bi+1];
// Get corresponding sizes and minimum of them
int nrows = RC->size[i];
int ncols = CC->size[j];
int shape[2] = {nrows, ncols};
double *D;
#pragma omp critical
{
D = alloc_D+offset_D;
offset_D += nrows*ncols;
//array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
//offset_D += near_D[lbi]->size;
}
array_from_buffer(near_D+lbi, 2, shape, 'd', 'F', D);
#ifdef OPENMP
double time0 = omp_get_wtime();
kernel(nrows, ncols, RC->pivot+RC->start[i],
CC->pivot+CC->start[j], RD, CD, D, nrows);
#ifdef OPENMP
double time1 = omp_get_wtime();
#pragma omp critical
kernel_time += time1-time0;
}<LOOP-END> <OMP-START>#pragma omp parallel for schedule(dynamic, 1)<OMP-END> |
PanosAntoniadis/pps-ntua/Lab1/ex2/parallel/OpenMP/fws_parfor.c | #pragma omp parallel for private(i, j) shared(A, k, N) | 100 | alloc(N*sizeof(int));
graph_init_random(A,-1,N,128*N);
gettimeofday(&t1,0);
for(k=0;k<N;k++)
<LOOP-START>for(i=0; i<N; i++)
for(j=0; j<N; j++)
A[i][j]=min(A[i][j], A[i][k] + A[k][j]);
gettimeofday(&t2,0);
time=(double)((t2.tv_sec-t1.tv_sec)*1000000+t2.tv_usec-t1.tv_usec)/1000000;
printf("FW,%d,%.4f\n", N, time);
/*
for(i=0; i<N; i++)
for(j=0; j<N; j++) fprintf(stdout,"%d\n", A[i][j]);
*/
return 0;
}
inline int min(int a, int b)
{
if(a<=b)return a;
else return b;
}<LOOP-END> <OMP-START>#pragma omp parallel for private(i, j) shared(A, k, N)<OMP-END> |
PanosAntoniadis/pps-ntua/Lab1/ex1/parallel/GoL_p.c | #pragma omp parallel for shared(N, previous, current) private(i, j, nbrs) | 100 | r ( t = 0 ; t < T ; t++ ) {
/* Use OpenMP parallel for in order to parallelize i and j loops */
<LOOP-START>for ( i = 1 ; i < N-1 ; i++ )
for ( j = 1 ; j < N-1 ; j++ ) {
nbrs = previous[i+1][j+1] + previous[i+1][j] + previous[i+1][j-1] \
+ previous[i][j-1] + previous[i][j+1] \
+ previous[i-1][j-1] + previous[i-1][j] + previous[i-1][j+1];
if ( nbrs == 3 || ( previous[i][j]+nbrs ==3 ) )
current[i][j]=1;
else
current[i][j]=0;
}<LOOP-END> <OMP-START>#pragma omp parallel for shared(N, previous, current) private(i, j, nbrs)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | gcount(ngp);
if(Rf_isNull(gs)) {
for(int i = 0; i != l; ++i) ++gcount[g[i]];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
// if(gcount[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gcount[i] > 0) {
gmap[i] = std::vector<double> (gcount[i]);
gcount[i] = 0;
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<double> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | L);
for(int i = 0; i != l; ++i) if(nisnan(x[i])) gmap[g[i]][gcount[g[i]]++] = x[i];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
if(gcount[i] != 0) {
int n = gcount[i], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
out[i-1] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | }
} else {
gmap[g[i]][gcount[g[i]]++] = x[i];
}
}
<LOOP-START>for(int i = 0; i < ng; ++i) {
if(isnan2(out[i]) || gcount[i+1] == 0) continue;
int n = gcount[i+1], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i+1].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
out[i] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | eads > col) nthreads = col;
NumericVector out = no_init_vector(col);
if(narm) {
<LOOP-START>for(int j = 0; j < col; ++j) {
NumericMatrix::ConstColumn colj = x( _ , j);
NumericVector column = no_init_vector(l); // without multithreading this could be taken out of the loop, see previous version of the code.
double *begin = column.begin(), *pend = std::remove_copy_if(colj.begin(), colj.end(), begin, isnan2);
int sz = pend - begin, nth = lower ? (sz-1)*Q : sz*Q;
if(sz == 0) {
out[j] = colj[0];
} else {
std::nth_element(begin, begin+nth, pend);
out[j] = (tiesmean && sz%2 == 0) ? (column[nth] + *(std::min_element(begin+nth+1, pend)))*0.5 : column[nth];
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | } else {
int nth = lower ? (l-1)*Q : l*Q;
bool tm = tiesmean && l%2 == 0;
<LOOP-START>for(int j = 0; j < col; ++j) {
{
NumericMatrix::ConstColumn colj = x( _ , j);
for(int i = 0; i != l; ++i) {
if(isnan2(colj[i])) {
out[j] = colj[i];
goto endloop;
}
}
NumericVector column = Rf_duplicate(wrap(colj)); // best ?
std::nth_element(column.begin(), column.begin()+nth, column.end());
out[j] = tm ? (column[nth] + *(std::min_element(column.begin()+nth+1, column.end())))*0.5 : column[nth];
}
endloop:;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | gcount(ngp);
if(Rf_isNull(gs)) {
for(int i = 0; i != l; ++i) ++gcount[g[i]];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
// if(gcount[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gcount[i] > 0) gmap[i] = std::vector<double> (gcount[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | IntegerVector gsv = gs;
if(ng != gsv.size()) stop("ng must match length(gs)");
<LOOP-START>for(int i = 0; i < ng; ++i) {
// if(gsv[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gsv[i] > 0) gmap[i+1] = std::vector<double> (gsv[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | for(int i = 0; i != l; ++i) if(nisnan(column[i])) gmap[g[i]][gcount[g[i]]++] = column[i];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
if(gcount[i] != 0) {
int n = gcount[i], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
nthj[i-1] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | } else {
gmap[g[i]][gcount[g[i]]++] = column[i];
}
}
<LOOP-START>for(int i = 0; i < ng; ++i) {
if(isnan2(nthj[i]) || gcount[i+1] == 0) continue;
int n = gcount[i+1], nth = lower ? (n-1)*Q : n*Q;
auto begin = gmap[i+1].begin(), mid = begin + nth, end = begin + n;
std::nth_element(begin, mid, end);
nthj[i] = (tiesmean && n%2 == 0) ? (*(mid) + *(std::min_element(mid+1, end)))*0.5 : *(mid);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | lement(begin+nth+1, pend)))*0.5 : column[nth];
}
}
} else {
<LOOP-START>for(int j = 0; j < l; ++j) out[j] = median_narm(x[j], lower, tiesmean, Q);
}
} else {
#pragma omp parallel for num_threads(nthreads)
for(int j = 0; j < l; ++j) out[j] = median_keepna(x[j], lower, tiesmean, Q);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | j = 0; j < l; ++j) out[j] = median_narm(x[j], lower, tiesmean, Q);
}
} else {
<LOOP-START>for(int j = 0; j < l; ++j) out[j] = median_keepna(x[j], lower, tiesmean, Q);
}
if(drop) {
Rf_setAttrib(out, R_NamesSymbol, Rf_getAttrib(x, R_NamesSymbol));
return out;
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
SebKrantz/collapse/misc/legacy/sorted out 1.8.9 - 1.9.0/fnth_fmedian.cpp | #pragma omp parallel for num_threads(nthreads) | 100 | count(ngp);
if(Rf_isNull(gs)) {
for(int i = 0; i != lx1; ++i) ++gcount[g[i]];
<LOOP-START>for(int i = 1; i < ngp; ++i) {
// if(gcount[i] == 0) stop("Group size of 0 encountered. This is probably because of unused factor levels. Use fdroplevels(f) to drop them.");
if(gcount[i] > 0) gmap[i] = std::vector<double> (gcount[i]);
}<LOOP-END> <OMP-START>#pragma omp parallel for num_threads(nthreads)<OMP-END> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.