Commit 02bdbd74 authored by Uwe Schulzweida's avatar Uwe Schulzweida
Browse files

CheckVector: update.

parent e958bc53
Pipeline #4591 passed with stages
in 17 minutes and 15 seconds
......@@ -136,7 +136,7 @@ void read_coordinates(int gridID, Varray<double> &xvals, Varray<double> &yvals)
}
static
void read_xbounds_reg2d(int gridID, Varray<double> &xbounds2d)
void read_xbounds_reg2d(int gridID, std::vector<double> &xbounds2d)
{
const auto nlon = gridInqXsize(gridID);
xbounds2d.resize(nlon * 2);
......@@ -147,7 +147,7 @@ void read_xbounds_reg2d(int gridID, Varray<double> &xbounds2d)
}
else
{
Varray<double> xvals(nlon);
std::vector<double> xvals(nlon);
gridInqXvals(gridID, xvals.data());
grid_gen_bounds(nlon, xvals, xbounds2d);
}
......@@ -170,7 +170,7 @@ void read_xbounds_reg2d(int gridID, Varray<double> &xbounds2d)
}
static
void read_ybounds_reg2d(int gridID, Varray<double> &ybounds2d)
void read_ybounds_reg2d(int gridID, std::vector<double> &ybounds2d)
{
const auto nlat = gridInqYsize(gridID);
ybounds2d.resize(nlat * 2);
......@@ -181,7 +181,7 @@ void read_ybounds_reg2d(int gridID, Varray<double> &ybounds2d)
}
else
{
Varray<double> yvals(nlat);
std::vector<double> yvals(nlat);
gridInqYvals(gridID, yvals.data());
grid_gen_bounds(nlat, yvals, ybounds2d);
grid_check_lat_borders(2 * nlat, ybounds2d.data());
......@@ -212,7 +212,7 @@ double calc_maxdist(size_t i, size_t nv, double plon, double plat, const Varray<
}
static
double calc_maxdist_rec2d(size_t i, size_t nlon, double plon, double plat, const Varray<double> &xbounds, const Varray<double> &ybounds)
double calc_maxdist_rec2d(size_t i, size_t nlon, double plon, double plat, const std::vector<double> &xbounds, const std::vector<double> &ybounds)
{
double p1[3], p2[3];
gcLLtoXYZ(plon, plat, p1);
......@@ -380,7 +380,7 @@ size_t find_points(std::vector<char> &vmask, size_t cell_no, size_t ncorner, siz
static
size_t find_points_rec2d(std::vector<char> &vmask, size_t i, size_t nlon2, size_t nadds, Varray<size_t> &adds, const Varray<double> &xvals1,
const Varray<double> &yvals1, const Varray<double> &xbounds2d, const Varray<double> &ybounds2d)
const Varray<double> &yvals1, const std::vector<double> &xbounds2d, const std::vector<double> &ybounds2d)
{
const auto iy = i / nlon2;
const auto ix = i - iy * nlon2;
......@@ -442,7 +442,7 @@ Varray2D<size_t> gen_mapdata(int gridID1, int gridID2)
int gridID2x = -1;
Varray<double> xbounds, ybounds;
Varray<double> xbounds2d, ybounds2d;
std::vector<double> xbounds2d, ybounds2d;
size_t nv = 4;
if (grid2_is_reg2d)
{
......
......@@ -919,7 +919,7 @@ window_box(const Field &field1, Field &field2, const long lat1, const long lat2,
template <typename T>
static void
window_cell(const int nwpv, const std::vector<T> &array1, std::vector<T> &array2, const long gridsize2,
window_cell(const int nwpv, const Varray<T> &array1, Varray<T> &array2, const long gridsize2,
const std::vector<long> &cellidx)
{
if (nwpv == 2)
......
......@@ -60,7 +60,7 @@ smooth(int gridID, double missval, const Varray<double> &array1, Varray<double>
auto numNeighbors = spoint.maxpoints;
if (numNeighbors > gridsize) numNeighbors = gridsize;
std::vector<uint8_t> mask(gridsize);
Varray<uint8_t> mask(gridsize);
for (size_t i = 0; i < gridsize; ++i) mask[i] = !DBL_IS_EQUAL(array1[i], missval);
auto gridtype = gridInqType(gridID);
......
......@@ -280,8 +280,8 @@ Vertintap(void *process)
if (useHeightLevel)
{
Varray<double> phlev(nplev);
height2pressure(&phlev[0], plev.data(), nplev);
std::vector<double> phlev(nplev);
height2pressure(phlev.data(), plev.data(), nplev);
if (Options::cdoVerbose)
for (int i = 0; i < nplev; ++i) cdoPrint("level = %d height = %g pressure = %g", i + 1, plev[i], phlev[i]);
......
......@@ -251,8 +251,8 @@ Vertintml(void *process)
if (useHeightLevel)
{
Varray<double> phlev(nplev);
height2pressure(&phlev[0], plev.data(), nplev);
std::vector<double> phlev(nplev);
height2pressure(phlev.data(), plev.data(), nplev);
if (Options::cdoVerbose)
for (int i = 0; i < nplev; ++i) cdoPrint("level=%d height=%g pressure=%g", i + 1, plev[i], phlev[i]);
......
......@@ -23,7 +23,7 @@
#include <cfloat>
#include "compare.h"
//#define CHECK_UNUSED_VECTOR 1
// #define CHECK_UNUSED_VECTOR 1
#ifdef CHECK_UNUSED_VECTOR
template <typename T>
......@@ -43,6 +43,8 @@ CheckVector
T * begin() noexcept { return &ptr[0]; }
T * end() noexcept { return &ptr[0] + 1; }
const T * begin() const noexcept { return &ptr[0]; }
const T * end() const noexcept { return &ptr[0] + 1; }
bool empty() const { return true; }
size_t size() const { return m_count; }
......@@ -51,6 +53,10 @@ CheckVector
void resize(size_t count) { m_count = count; }
void resize(size_t count, const T& value) { m_count = count; ptr[0] = value; }
void reserve(size_t new_cap) { (void) new_cap; }
void push_back(const T& value) { ptr[0] = value; }
T * data() noexcept { return ptr; }
const T* data() const noexcept { return ptr; }
......
......@@ -53,7 +53,7 @@ fld_weights(int gridID, size_t ngp)
int getLayerThickness(bool useweights, bool genbounds, int index, int zaxisID, int nlev, double *thickness, double *weights);
void
vert_weights(int zaxisID, size_t nlev, std::vector<double> &weights)
vert_weights(int zaxisID, size_t nlev, Varray<double> &weights)
{
weights.resize(nlev);
std::vector<double> thickness(nlev);
......
......@@ -22,6 +22,6 @@
#include "field.h"
void fld_field_init(Field &field, size_t nmiss, double missval, size_t ngp, double *array, double *w);
void vert_weights(int zaxisID, size_t nlev, std::vector<double> &weights);
void vert_weights(int zaxisID, size_t nlev, Varray<double> &weights);
#endif
......@@ -21,16 +21,16 @@
#include "field.h"
#include "vertical_interp.h"
void genind(std::vector<int> &vert_index, Varray<double> &plev, Field3D &full_level, size_t gridsize, bool lreverse = false);
void genind(std::vector<int> &vert_index, std::vector<double> &plev, Field3D &full_level, size_t gridsize, bool lreverse = false);
void genindmiss(std::vector<int> &vert_index, Varray<double> &plev, size_t gridsize, Field &level0, std::vector<size_t> &pnmiss, bool lreverse = false);
void genindmiss(std::vector<int> &vert_index, std::vector<double> &plev, size_t gridsize, Field &level0, std::vector<size_t> &pnmiss, bool lreverse = false);
void vertical_interp_T(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, Field &sgeopot, std::vector<int> &vert_index, Varray<double> &plev, size_t gridsize);
void vertical_interp_T(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, Field &sgeopot, std::vector<int> &vert_index, std::vector<double> &plev, size_t gridsize);
void vertical_interp_Z(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, Field3D &temp, Field &sgeopot, std::vector<int> &vert_index, Varray<double> &plev, size_t gridsize);
void vertical_interp_Z(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, Field3D &temp, Field &sgeopot, std::vector<int> &vert_index, std::vector<double> &plev, size_t gridsize);
void vertical_interp_X(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, std::vector<int> &vert_index, Varray<double> &plev, size_t gridsize);
void vertical_interp_X(size_t nlevels, Field3D &full_level, Field3D &half_level, Field3D &field1, Field3D &field2, std::vector<int> &vert_index, std::vector<double> &plev, size_t gridsize);
void vertical_interp_X(size_t nlevels, Field3D &levels, Field3D &field1, Field3D &field2, std::vector<int> &vert_index, Varray<double> &plev, size_t gridsize);
void vertical_interp_X(size_t nlevels, Field3D &levels, Field3D &field1, Field3D &field2, std::vector<int> &vert_index, std::vector<double> &plev, size_t gridsize);
#endif
......@@ -59,7 +59,7 @@ input_ival(FILE *gfp, int &ival)
}
size_t
input_darray(FILE *gfp, size_t n_values, Varray<double> &array)
input_darray(FILE *gfp, size_t n_values, std::vector<double> &array)
{
if (n_values <= 0) return 0;
......
......@@ -10,6 +10,7 @@
#include <cmath>
#include <vector>
#include "array.h"
#include "interpol.h"
class knnWeightsType
......@@ -174,7 +175,7 @@ public:
}
size_t
computeWeights(const std::vector<int> &grid_mask)
computeWeights(const Varray<int> &grid_mask)
{
// Compute weights based on inverse distance if mask is false, eliminate those points
......@@ -195,7 +196,7 @@ public:
}
size_t
computeWeights(const std::vector<uint8_t> &grid_mask, const double searchRadius, const double weight0, const double weightR)
computeWeights(const Varray<uint8_t> &grid_mask, const double searchRadius, const double weight0, const double weightR)
{
// Compute weights based on inverse distance if mask is false, eliminate those points
......@@ -226,7 +227,7 @@ public:
template <typename T>
double
arrayWeightsSum(const std::vector<T> &array) const
arrayWeightsSum(const Varray<T> &array) const
{
double result = 0.0;
for (size_t n = 0; n < m_numNeighbors; ++n) result += array[m_addr[n]] * m_dist[n];
......
......@@ -83,7 +83,7 @@ struct RemapGrid
size_t dims[2]; // size of grid dimension
int nvgp; // size of vgpm
std::vector<int> vgpm; // flag which cells are valid
Varray<int> vgpm; // flag which cells are valid
Varray<int> mask; // flag which cells participate
Varray<double> reg2d_center_lon; // reg2d lon/lat coordinates for
......@@ -96,17 +96,17 @@ struct RemapGrid
Varray<double> cell_corner_lon; // lon/lat coordinates for
Varray<double> cell_corner_lat; // each grid corner in radians
Varray<double> cell_area; // total area of each grid cell
Varray<double> cell_frac; // fractional area of grid cells participating in remapping
Varray<double> cell_area; // total area of each grid cell
Varray<double> cell_frac; // fractional area of grid cells participating in remapping
};
struct GridSearchBins
{
unsigned nbins; // num of bins for restricted search
size_t ncells; // total number of grid cells (cell_bound_box)
std::vector<size_t> bin_addr; // min,max adds for grid cells in this lat bin
std::vector<float> bin_lats; // min,max latitude for each search bin
std::vector<float> cell_bound_box; // lon/lat bounding box for use
unsigned nbins; // num of bins for restricted search
size_t ncells; // total number of grid cells (cell_bound_box)
Varray<size_t> bin_addr; // min,max adds for grid cells in this lat bin
Varray<float> bin_lats; // min,max latitude for each search bin
Varray<float> cell_bound_box; // lon/lat bounding box for use
};
struct RemapSearch
......@@ -166,7 +166,7 @@ void remapConserv(NormOpt normOpt, RemapSearch &rsearch, const double *src_array
void remapStat(int remapOrder, RemapGrid &src_grid, RemapGrid &tgt_grid, RemapVars &rv, const Varray<double> &array1,
const Varray<double> &array2, double missval);
void remapGradients(RemapGrid &grid, const std::vector<uint8_t> &mask, const double *array, RemapGradients &gradients);
void remapGradients(RemapGrid &grid, const Varray<uint8_t> &mask, const double *array, RemapGradients &gradients);
void remapGradients(RemapGrid &grid, const double *array, RemapGradients &gradients);
void sort_add(size_t num_links, size_t num_wts, size_t *add1, size_t *add2, double *weights);
......
......@@ -50,7 +50,7 @@ bicubicSetWeights(double iw, double jw, double (&wgts)[4][4])
}
template <typename T>
int num_src_points(const std::vector<T> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
int num_src_points(const Varray<T> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
static void
renormalizeWeights(const double (&src_lats)[4], double (&wgts)[4][4])
......@@ -218,7 +218,7 @@ remapBicubic(RemapSearch &rsearch, const double *restrict src_array, double *res
auto tgt_grid_size = tgt_grid->size;
auto src_grid_size = src_grid->size;
std::vector<uint8_t> src_grid_mask(src_grid_size);
Varray<uint8_t> src_grid_mask(src_grid_size);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) shared(src_grid_size, src_array, src_grid_mask, missval)
#endif
......
......@@ -105,7 +105,7 @@ bilinearSetWeights(double iw, double jw, double (&wgts)[4])
template <typename T>
int
num_src_points(const std::vector<T> &mask, const size_t (&src_add)[4], double (&src_lats)[4])
num_src_points(const Varray<T> &mask, const size_t (&src_add)[4], double (&src_lats)[4])
{
int icount = 0;
......@@ -121,8 +121,8 @@ num_src_points(const std::vector<T> &mask, const size_t (&src_add)[4], double (&
}
// Explicit instantiation
template int num_src_points(const std::vector<uint8_t> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
template int num_src_points(const std::vector<int> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
template int num_src_points(const Varray<uint8_t> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
template int num_src_points(const Varray<int> &mask, const size_t (&src_add)[4], double (&src_lats)[4]);
static void
renormalizeWeights(const double (&src_lats)[4], double (&wgts)[4])
......@@ -270,7 +270,7 @@ remapBilinear(RemapSearch &rsearch, const double *restrict src_array, double *re
auto tgt_grid_size = tgt_grid->size;
auto src_grid_size = src_grid->size;
std::vector<uint8_t> src_grid_mask(src_grid_size);
Varray<uint8_t> src_grid_mask(src_grid_size);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) shared(src_grid_size, src_array, src_grid_mask, missval)
#endif
......
......@@ -35,10 +35,10 @@ struct search_t
enum yac_edge_type *src_edge_type;
size_t srch_corners;
size_t max_srch_cells;
std::vector<double> partial_areas;
std::vector<double> partial_weights;
std::vector<grid_cell> src_grid_cells;
std::vector<grid_cell> overlap_buffer;
Varray<double> partial_areas;
Varray<double> partial_weights;
Varray<grid_cell> src_grid_cells;
Varray<grid_cell> overlap_buffer;
};
static void
......@@ -404,7 +404,7 @@ setCellCoordinatesYac(RemapGridType remapGridType, const size_t cellAddr, const
static void
setCoordinatesYac(const size_t numCells, RemapGridType remapGridType, const std::vector<size_t> &cellIndices,
const size_t numCellCorners, RemapGrid *remap_grid, std::vector<grid_cell> &yac_grid_cell)
const size_t numCellCorners, RemapGrid *remap_grid, Varray<grid_cell> &yac_grid_cell)
{
for (size_t n = 0; n < numCells; ++n)
setCellCoordinatesYac(remapGridType, cellIndices[n], numCellCorners, remap_grid, yac_grid_cell[n]);
......@@ -440,7 +440,7 @@ greatCircleTypeInit(std::vector<enum yac_edge_type> &great_circle_type, size_t s
}
static void
scaleCellFrac(size_t numCells, std::vector<double> &cellFrac, const std::vector<double> &cellArea)
scaleCellFrac(size_t numCells, Varray<double> &cellFrac, const Varray<double> &cellArea)
{
for (size_t i = 0; i < numCells; ++i)
if (IS_NOT_EQUAL(cellArea[i], 0)) cellFrac[i] /= cellArea[i];
......@@ -466,7 +466,7 @@ yacGridCellFree(const grid_cell &cell)
}
static void
vec_add_weights(std::vector<double> &vec, size_t num_weights, const std::vector<double> &weights, const std::vector<size_t> &srch_add)
vec_add_weights(Varray<double> &vec, size_t num_weights, const Varray<double> &weights, const std::vector<size_t> &srch_add)
{
for (size_t i = 0; i < num_weights; ++i)
{
......@@ -480,7 +480,7 @@ vec_add_weights(std::vector<double> &vec, size_t num_weights, const std::vector<
}
static size_t
remove_invalid_areas(size_t num_srch_cells, std::vector<double> &partial_areas, std::vector<size_t> &srch_add)
remove_invalid_areas(size_t num_srch_cells, Varray<double> &partial_areas, std::vector<size_t> &srch_add)
{
size_t n = 0;
for (size_t i = 0; i < num_srch_cells; ++i)
......@@ -497,7 +497,7 @@ remove_invalid_areas(size_t num_srch_cells, std::vector<double> &partial_areas,
}
static size_t
remove_invalid_weights(size_t grid_size, size_t num_weights, std::vector<double> &partial_weights, std::vector<size_t> &srch_add)
remove_invalid_weights(size_t grid_size, size_t num_weights, Varray<double> &partial_weights, std::vector<size_t> &srch_add)
{
size_t n = 0;
for (size_t i = 0; i < num_weights; ++i)
......@@ -515,7 +515,7 @@ remove_invalid_weights(size_t grid_size, size_t num_weights, std::vector<double>
}
static size_t
remove_unmask_weights(const std::vector<int> &grid_mask, size_t num_weights, std::vector<double> &partial_weights, std::vector<size_t> &srch_add)
remove_unmask_weights(const Varray<int> &grid_mask, size_t num_weights, Varray<double> &partial_weights, std::vector<size_t> &srch_add)
{
size_t n = 0;
for (size_t i = 0; i < num_weights; ++i)
......@@ -758,7 +758,7 @@ remapConservWeights(RemapSearch &rsearch, RemapVars &rv)
} // remapConservWeights
static double
conservRemap(const double *restrict src_array, size_t num_weights, const std::vector<double> &wgts, const std::vector<size_t> &src_add)
conservRemap(const double *restrict src_array, size_t num_weights, const Varray<double> &wgts, const std::vector<size_t> &src_add)
{
double tgt_point = 0.;
for (size_t i = 0; i < num_weights; ++i) tgt_point += src_array[src_add[i]] * wgts[i];
......@@ -787,7 +787,7 @@ remapConserv(NormOpt normOpt, RemapSearch &rsearch, const double *restrict src_a
auto src_grid_size = src_grid->size;
auto tgt_grid_size = tgt_grid->size;
std::vector<int> src_grid_mask(src_grid_size);
Varray<int> src_grid_mask(src_grid_size);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) shared(src_grid_size, src_array, src_grid_mask, missval)
#endif
......
......@@ -112,7 +112,7 @@ remapDistwgt(size_t numNeighbors, RemapSearch &rsearch, const double *restrict s
auto tgt_grid_size = tgt_grid->size;
auto src_grid_size = src_grid->size;
std::vector<int> src_grid_mask(src_grid_size);
Varray<int> src_grid_mask(src_grid_size);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) shared(src_grid_size, src_array, src_grid_mask, missval)
#endif
......@@ -188,9 +188,9 @@ intgriddis(Field &field1, Field &field2, size_t numNeighbors)
auto src_grid_size = remap.src_grid.size;
auto tgt_grid_size = remap.tgt_grid.size;
std::vector<int> src_mask(src_grid_size);
Varray<int> src_mask(src_grid_size);
for (size_t i = 0; i < src_grid_size; ++i) src_mask[i] = !DBL_IS_EQUAL(src_array[i], src_missval);
std::vector<int> tgt_mask(tgt_grid_size, 1);
Varray<int> tgt_mask(tgt_grid_size, 1);
std::vector<knnWeightsType> knnWeights;
for (int i = 0; i < Threading::ompNumThreads; ++i) knnWeights.push_back(knnWeightsType(numNeighbors));
......
......@@ -201,7 +201,7 @@ remap(double *restrict dst_array, double missval, size_t dst_size, const RemapVa
}
static size_t
get_max_add(size_t num_links, size_t size, const std::vector<size_t> &add)
get_max_add(size_t num_links, size_t size, const Varray<size_t> &add)
{
std::vector<size_t> isum(size, 0);
......@@ -215,7 +215,7 @@ get_max_add(size_t num_links, size_t size, const std::vector<size_t> &add)
}
static size_t
binary_search_int(const std::vector<size_t> &array, size_t len, size_t value)
binary_search_int(const Varray<size_t> &array, size_t len, size_t value)
{
int64_t low = 0, high = len - 1;
......
......@@ -63,9 +63,9 @@ struct RemapVars
size_t num_wts; // num of weights used in remapping
size_t resize_increment; // default amount to increase array size
std::vector<size_t> src_cell_add; // source grid address for each link
std::vector<size_t> tgt_cell_add; // target grid address for each link
std::vector<double> wts; // map weights for each link [max_links*num_wts]
Varray<size_t> src_cell_add; // source grid address for each link
Varray<size_t> tgt_cell_add; // target grid address for each link
Varray<double> wts; // map weights for each link [max_links*num_wts]
remaplink_t links;
};
......
......@@ -302,7 +302,7 @@ grid_check_lat_borders_rad(size_t n, Varray<double> &ybounds)
}
static void
convert_bounds_reg2d(size_t n, const std::vector<double> &boundsIn, std::vector<double> &boundsOut)
convert_bounds_reg2d(size_t n, const Varray<double> &boundsIn, Varray<double> &boundsOut)
{
auto lrev = (boundsIn[0] > boundsIn[2 * n - 1]);
if (boundsIn[0] > boundsIn[1]) lrev = !lrev;
......@@ -354,7 +354,7 @@ remap_define_reg2d(int gridID, RemapGrid &grid)
if (gridInqXbounds(gridID, nullptr))
{
std::vector<double> xbounds(2 * nx);
Varray<double> xbounds(2 * nx);
gridInqXbounds(gridID, xbounds.data());
convert_bounds_reg2d(nx, xbounds, grid.reg2d_corner_lon);
cdo_grid_to_radian(gridID, CDI_XAXIS, nx + 1, grid.reg2d_corner_lon.data(), "grid reg2d corner lon");
......@@ -366,7 +366,7 @@ remap_define_reg2d(int gridID, RemapGrid &grid)
if (gridInqYbounds(gridID, nullptr))
{
std::vector<double> ybounds(2 * ny);
Varray<double> ybounds(2 * ny);
gridInqYbounds(gridID, ybounds.data());
convert_bounds_reg2d(ny, ybounds, grid.reg2d_corner_lat);
cdo_grid_to_radian(gridID, CDI_YAXIS, ny + 1, grid.reg2d_corner_lat.data(), "grid reg2d corner lat");
......@@ -850,7 +850,7 @@ remapStat(int remapOrder, RemapGrid &src_grid, RemapGrid &tgt_grid, RemapVars &r
/*****************************************************************************/
void
remapGradients(RemapGrid &grid, const std::vector<uint8_t> &mask, const double *restrict array, RemapGradients &gradients)
remapGradients(RemapGrid &grid, const Varray<uint8_t> &mask, const double *restrict array, RemapGradients &gradients)
{
if (grid.rank != 2) cdoAbort("Internal problem (remapGradients), grid rank = %d!", grid.rank);
......@@ -1017,7 +1017,7 @@ void
remapGradients(RemapGrid &grid, const double *restrict array, RemapGradients &gradients)
{
auto grid_size = grid.size;
std::vector<uint8_t> mask(grid_size);
Varray<uint8_t> mask(grid_size);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) shared(grid_size, grid, mask)
#endif
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment