int
main() {/* create ctest0_64.nc */
int stat; /* return status */
int ncid; /* netCDF id */
/* dimension ids */
int Dr_dim;
int D1_dim;
int D2_dim;
int D3_dim;
int dim_MINUS_name_MINUS_dashes_dim;
int dim_PERIOD_name_PERIOD_dots_dim;
int dim_PLUS_name_PLUS_plusses_dim;
int dim_ATSIGN_name_ATSIGN_ats_dim;
/* dimension lengths */
size_t Dr_len = NC_UNLIMITED;
size_t D1_len = 1;
size_t D2_len = 2;
size_t D3_len = 3;
size_t dim_MINUS_name_MINUS_dashes_len = 4;
size_t dim_PERIOD_name_PERIOD_dots_len = 5;
size_t dim_PLUS_name_PLUS_plusses_len = 6;
size_t dim_ATSIGN_name_ATSIGN_ats_len = 7;
/* variable ids */
int c_id;
int b_id;
int s_id;
int i_id;
int f_id;
int d_id;
int cr_id;
int br_id;
int sr_id;
int ir_id;
int fr_id;
int dr_id;
int c1_id;
int b1_id;
int s1_id;
int i1_id;
int f1_id;
int d1_id;
int c2_id;
int b2_id;
int s2_id;
int i2_id;
int f2_id;
int d2_id;
int c3_id;
int b3_id;
int s3_id;
int i3_id;
int f3_id;
int d3_id;
int cr1_id;
int br2_id;
int sr3_id;
int f11_id;
int d12_id;
int c13_id;
int s21_id;
int i22_id;
int f23_id;
int c31_id;
int b32_id;
int s33_id;
int sr11_id;
int ir12_id;
int fr13_id;
int cr21_id;
int br22_id;
int sr23_id;
int fr31_id;
int dr32_id;
int cr33_id;
int c111_id;
int b112_id;
int s113_id;
int f121_id;
int d122_id;
int c123_id;
int s131_id;
int i132_id;
int f133_id;
int f211_id;
int d212_id;
int c213_id;
int s221_id;
int i222_id;
int f223_id;
int c231_id;
int b232_id;
int s233_id;
int s311_id;
int i312_id;
int f313_id;
int var_MINUS_name_MINUS_dashes_id;
int var_PERIOD_name_PERIOD_dots_id;
int var_PLUS_name_PLUS_plusses_id;
int var_ATSIGN_name_ATSIGN_ats_id;
/* rank (number of dimensions) for each variable */
# define RANK_c 0
# define RANK_b 0
# define RANK_s 0
# define RANK_i 0
# define RANK_f 0
# define RANK_d 0
# define RANK_cr 1
# define RANK_br 1
# define RANK_sr 1
# define RANK_ir 1
# define RANK_fr 1
# define RANK_dr 1
# define RANK_c1 1
# define RANK_b1 1
# define RANK_s1 1
# define RANK_i1 1
# define RANK_f1 1
# define RANK_d1 1
# define RANK_c2 1
# define RANK_b2 1
# define RANK_s2 1
# define RANK_i2 1
# define RANK_f2 1
# define RANK_d2 1
# define RANK_c3 1
# define RANK_b3 1
# define RANK_s3 1
# define RANK_i3 1
# define RANK_f3 1
# define RANK_d3 1
# define RANK_cr1 2
# define RANK_br2 2
# define RANK_sr3 2
# define RANK_f11 2
# define RANK_d12 2
# define RANK_c13 2
# define RANK_s21 2
# define RANK_i22 2
# define RANK_f23 2
# define RANK_c31 2
# define RANK_b32 2
# define RANK_s33 2
# define RANK_sr11 3
# define RANK_ir12 3
# define RANK_fr13 3
# define RANK_cr21 3
# define RANK_br22 3
# define RANK_sr23 3
# define RANK_fr31 3
# define RANK_dr32 3
# define RANK_cr33 3
# define RANK_c111 3
# define RANK_b112 3
# define RANK_s113 3
# define RANK_f121 3
# define RANK_d122 3
# define RANK_c123 3
# define RANK_s131 3
# define RANK_i132 3
# define RANK_f133 3
# define RANK_f211 3
# define RANK_d212 3
# define RANK_c213 3
# define RANK_s221 3
# define RANK_i222 3
# define RANK_f223 3
# define RANK_c231 3
# define RANK_b232 3
# define RANK_s233 3
# define RANK_s311 3
# define RANK_i312 3
# define RANK_f313 3
# define RANK_var_MINUS_name_MINUS_dashes 0
# define RANK_var_PERIOD_name_PERIOD_dots 0
# define RANK_var_PLUS_name_PLUS_plusses 0
# define RANK_var_ATSIGN_name_ATSIGN_ats 0
/* variable shapes */
int cr_dims[RANK_cr];
int br_dims[RANK_br];
int sr_dims[RANK_sr];
int ir_dims[RANK_ir];
int fr_dims[RANK_fr];
int dr_dims[RANK_dr];
int c1_dims[RANK_c1];
int b1_dims[RANK_b1];
int s1_dims[RANK_s1];
int i1_dims[RANK_i1];
int f1_dims[RANK_f1];
int d1_dims[RANK_d1];
int c2_dims[RANK_c2];
int b2_dims[RANK_b2];
int s2_dims[RANK_s2];
int i2_dims[RANK_i2];
int f2_dims[RANK_f2];
int d2_dims[RANK_d2];
int c3_dims[RANK_c3];
int b3_dims[RANK_b3];
int s3_dims[RANK_s3];
int i3_dims[RANK_i3];
int f3_dims[RANK_f3];
int d3_dims[RANK_d3];
int cr1_dims[RANK_cr1];
int br2_dims[RANK_br2];
int sr3_dims[RANK_sr3];
int f11_dims[RANK_f11];
int d12_dims[RANK_d12];
int c13_dims[RANK_c13];
int s21_dims[RANK_s21];
int i22_dims[RANK_i22];
int f23_dims[RANK_f23];
int c31_dims[RANK_c31];
int b32_dims[RANK_b32];
int s33_dims[RANK_s33];
int sr11_dims[RANK_sr11];
int ir12_dims[RANK_ir12];
int fr13_dims[RANK_fr13];
int cr21_dims[RANK_cr21];
int br22_dims[RANK_br22];
int sr23_dims[RANK_sr23];
int fr31_dims[RANK_fr31];
int dr32_dims[RANK_dr32];
int cr33_dims[RANK_cr33];
int c111_dims[RANK_c111];
int b112_dims[RANK_b112];
int s113_dims[RANK_s113];
int f121_dims[RANK_f121];
int d122_dims[RANK_d122];
int c123_dims[RANK_c123];
int s131_dims[RANK_s131];
int i132_dims[RANK_i132];
int f133_dims[RANK_f133];
int f211_dims[RANK_f211];
int d212_dims[RANK_d212];
int c213_dims[RANK_c213];
int s221_dims[RANK_s221];
int i222_dims[RANK_i222];
int f223_dims[RANK_f223];
int c231_dims[RANK_c231];
int b232_dims[RANK_b232];
int s233_dims[RANK_s233];
int s311_dims[RANK_s311];
int i312_dims[RANK_i312];
int f313_dims[RANK_f313];
/* enter define mode */
stat = nc_create("ctest0_64.nc", NC_CLOBBER|NC_64BIT_OFFSET, &ncid);
check_err(stat,__LINE__,__FILE__);
/* define dimensions */
stat = nc_def_dim(ncid, "Dr", Dr_len, &Dr_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "D1", D1_len, &D1_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "D2", D2_len, &D2_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "D3", D3_len, &D3_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "dim-name-dashes", dim_MINUS_name_MINUS_dashes_len, &dim_MINUS_name_MINUS_dashes_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "dim.name.dots", dim_PERIOD_name_PERIOD_dots_len, &dim_PERIOD_name_PERIOD_dots_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "dim+name+plusses", dim_PLUS_name_PLUS_plusses_len, &dim_PLUS_name_PLUS_plusses_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "dim@name@ats", dim_ATSIGN_name_ATSIGN_ats_len, &dim_ATSIGN_name_ATSIGN_ats_dim);
check_err(stat,__LINE__,__FILE__);
/* define variables */
stat = nc_def_var(ncid, "c", NC_CHAR, RANK_c, 0, &c_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "b", NC_BYTE, RANK_b, 0, &b_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "s", NC_SHORT, RANK_s, 0, &s_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "i", NC_INT, RANK_i, 0, &i_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "f", NC_FLOAT, RANK_f, 0, &f_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "d", NC_DOUBLE, RANK_d, 0, &d_id);
check_err(stat,__LINE__,__FILE__);
cr_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "cr", NC_CHAR, RANK_cr, cr_dims, &cr_id);
check_err(stat,__LINE__,__FILE__);
br_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "br", NC_BYTE, RANK_br, br_dims, &br_id);
check_err(stat,__LINE__,__FILE__);
sr_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "sr", NC_SHORT, RANK_sr, sr_dims, &sr_id);
check_err(stat,__LINE__,__FILE__);
ir_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "ir", NC_INT, RANK_ir, ir_dims, &ir_id);
check_err(stat,__LINE__,__FILE__);
fr_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "fr", NC_FLOAT, RANK_fr, fr_dims, &fr_id);
check_err(stat,__LINE__,__FILE__);
dr_dims[0] = Dr_dim;
stat = nc_def_var(ncid, "dr", NC_DOUBLE, RANK_dr, dr_dims, &dr_id);
check_err(stat,__LINE__,__FILE__);
c1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "c1", NC_CHAR, RANK_c1, c1_dims, &c1_id);
check_err(stat,__LINE__,__FILE__);
b1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "b1", NC_BYTE, RANK_b1, b1_dims, &b1_id);
check_err(stat,__LINE__,__FILE__);
s1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "s1", NC_SHORT, RANK_s1, s1_dims, &s1_id);
check_err(stat,__LINE__,__FILE__);
i1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "i1", NC_INT, RANK_i1, i1_dims, &i1_id);
check_err(stat,__LINE__,__FILE__);
f1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "f1", NC_FLOAT, RANK_f1, f1_dims, &f1_id);
check_err(stat,__LINE__,__FILE__);
d1_dims[0] = D1_dim;
stat = nc_def_var(ncid, "d1", NC_DOUBLE, RANK_d1, d1_dims, &d1_id);
check_err(stat,__LINE__,__FILE__);
c2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "c2", NC_CHAR, RANK_c2, c2_dims, &c2_id);
check_err(stat,__LINE__,__FILE__);
b2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "b2", NC_BYTE, RANK_b2, b2_dims, &b2_id);
check_err(stat,__LINE__,__FILE__);
s2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "s2", NC_SHORT, RANK_s2, s2_dims, &s2_id);
check_err(stat,__LINE__,__FILE__);
i2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "i2", NC_INT, RANK_i2, i2_dims, &i2_id);
check_err(stat,__LINE__,__FILE__);
f2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "f2", NC_FLOAT, RANK_f2, f2_dims, &f2_id);
check_err(stat,__LINE__,__FILE__);
d2_dims[0] = D2_dim;
stat = nc_def_var(ncid, "d2", NC_DOUBLE, RANK_d2, d2_dims, &d2_id);
check_err(stat,__LINE__,__FILE__);
c3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "c3", NC_CHAR, RANK_c3, c3_dims, &c3_id);
check_err(stat,__LINE__,__FILE__);
b3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "b3", NC_BYTE, RANK_b3, b3_dims, &b3_id);
check_err(stat,__LINE__,__FILE__);
s3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "s3", NC_SHORT, RANK_s3, s3_dims, &s3_id);
check_err(stat,__LINE__,__FILE__);
i3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "i3", NC_INT, RANK_i3, i3_dims, &i3_id);
check_err(stat,__LINE__,__FILE__);
f3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "f3", NC_FLOAT, RANK_f3, f3_dims, &f3_id);
check_err(stat,__LINE__,__FILE__);
d3_dims[0] = D3_dim;
stat = nc_def_var(ncid, "d3", NC_DOUBLE, RANK_d3, d3_dims, &d3_id);
check_err(stat,__LINE__,__FILE__);
cr1_dims[0] = Dr_dim;
cr1_dims[1] = D1_dim;
stat = nc_def_var(ncid, "cr1", NC_CHAR, RANK_cr1, cr1_dims, &cr1_id);
check_err(stat,__LINE__,__FILE__);
br2_dims[0] = Dr_dim;
br2_dims[1] = D2_dim;
stat = nc_def_var(ncid, "br2", NC_BYTE, RANK_br2, br2_dims, &br2_id);
check_err(stat,__LINE__,__FILE__);
sr3_dims[0] = Dr_dim;
sr3_dims[1] = D3_dim;
stat = nc_def_var(ncid, "sr3", NC_SHORT, RANK_sr3, sr3_dims, &sr3_id);
check_err(stat,__LINE__,__FILE__);
f11_dims[0] = D1_dim;
f11_dims[1] = D1_dim;
stat = nc_def_var(ncid, "f11", NC_FLOAT, RANK_f11, f11_dims, &f11_id);
check_err(stat,__LINE__,__FILE__);
d12_dims[0] = D1_dim;
d12_dims[1] = D2_dim;
stat = nc_def_var(ncid, "d12", NC_DOUBLE, RANK_d12, d12_dims, &d12_id);
check_err(stat,__LINE__,__FILE__);
c13_dims[0] = D1_dim;
c13_dims[1] = D3_dim;
stat = nc_def_var(ncid, "c13", NC_CHAR, RANK_c13, c13_dims, &c13_id);
check_err(stat,__LINE__,__FILE__);
s21_dims[0] = D2_dim;
s21_dims[1] = D1_dim;
stat = nc_def_var(ncid, "s21", NC_SHORT, RANK_s21, s21_dims, &s21_id);
check_err(stat,__LINE__,__FILE__);
i22_dims[0] = D2_dim;
i22_dims[1] = D2_dim;
stat = nc_def_var(ncid, "i22", NC_INT, RANK_i22, i22_dims, &i22_id);
check_err(stat,__LINE__,__FILE__);
f23_dims[0] = D2_dim;
f23_dims[1] = D3_dim;
stat = nc_def_var(ncid, "f23", NC_FLOAT, RANK_f23, f23_dims, &f23_id);
check_err(stat,__LINE__,__FILE__);
c31_dims[0] = D3_dim;
c31_dims[1] = D1_dim;
stat = nc_def_var(ncid, "c31", NC_CHAR, RANK_c31, c31_dims, &c31_id);
check_err(stat,__LINE__,__FILE__);
b32_dims[0] = D3_dim;
b32_dims[1] = D2_dim;
stat = nc_def_var(ncid, "b32", NC_BYTE, RANK_b32, b32_dims, &b32_id);
check_err(stat,__LINE__,__FILE__);
s33_dims[0] = D3_dim;
s33_dims[1] = D3_dim;
stat = nc_def_var(ncid, "s33", NC_SHORT, RANK_s33, s33_dims, &s33_id);
check_err(stat,__LINE__,__FILE__);
sr11_dims[0] = Dr_dim;
sr11_dims[1] = D1_dim;
sr11_dims[2] = D1_dim;
stat = nc_def_var(ncid, "sr11", NC_SHORT, RANK_sr11, sr11_dims, &sr11_id);
check_err(stat,__LINE__,__FILE__);
ir12_dims[0] = Dr_dim;
ir12_dims[1] = D1_dim;
ir12_dims[2] = D2_dim;
stat = nc_def_var(ncid, "ir12", NC_INT, RANK_ir12, ir12_dims, &ir12_id);
check_err(stat,__LINE__,__FILE__);
fr13_dims[0] = Dr_dim;
fr13_dims[1] = D1_dim;
fr13_dims[2] = D3_dim;
stat = nc_def_var(ncid, "fr13", NC_FLOAT, RANK_fr13, fr13_dims, &fr13_id);
check_err(stat,__LINE__,__FILE__);
cr21_dims[0] = Dr_dim;
cr21_dims[1] = D2_dim;
cr21_dims[2] = D1_dim;
stat = nc_def_var(ncid, "cr21", NC_CHAR, RANK_cr21, cr21_dims, &cr21_id);
check_err(stat,__LINE__,__FILE__);
br22_dims[0] = Dr_dim;
br22_dims[1] = D2_dim;
br22_dims[2] = D2_dim;
stat = nc_def_var(ncid, "br22", NC_BYTE, RANK_br22, br22_dims, &br22_id);
check_err(stat,__LINE__,__FILE__);
sr23_dims[0] = Dr_dim;
sr23_dims[1] = D2_dim;
sr23_dims[2] = D3_dim;
stat = nc_def_var(ncid, "sr23", NC_SHORT, RANK_sr23, sr23_dims, &sr23_id);
check_err(stat,__LINE__,__FILE__);
fr31_dims[0] = Dr_dim;
fr31_dims[1] = D3_dim;
fr31_dims[2] = D1_dim;
stat = nc_def_var(ncid, "fr31", NC_FLOAT, RANK_fr31, fr31_dims, &fr31_id);
check_err(stat,__LINE__,__FILE__);
dr32_dims[0] = Dr_dim;
dr32_dims[1] = D3_dim;
dr32_dims[2] = D2_dim;
stat = nc_def_var(ncid, "dr32", NC_DOUBLE, RANK_dr32, dr32_dims, &dr32_id);
check_err(stat,__LINE__,__FILE__);
cr33_dims[0] = Dr_dim;
cr33_dims[1] = D3_dim;
cr33_dims[2] = D3_dim;
stat = nc_def_var(ncid, "cr33", NC_CHAR, RANK_cr33, cr33_dims, &cr33_id);
check_err(stat,__LINE__,__FILE__);
c111_dims[0] = D1_dim;
c111_dims[1] = D1_dim;
c111_dims[2] = D1_dim;
stat = nc_def_var(ncid, "c111", NC_CHAR, RANK_c111, c111_dims, &c111_id);
check_err(stat,__LINE__,__FILE__);
b112_dims[0] = D1_dim;
b112_dims[1] = D1_dim;
b112_dims[2] = D2_dim;
stat = nc_def_var(ncid, "b112", NC_BYTE, RANK_b112, b112_dims, &b112_id);
check_err(stat,__LINE__,__FILE__);
s113_dims[0] = D1_dim;
s113_dims[1] = D1_dim;
s113_dims[2] = D3_dim;
stat = nc_def_var(ncid, "s113", NC_SHORT, RANK_s113, s113_dims, &s113_id);
check_err(stat,__LINE__,__FILE__);
f121_dims[0] = D1_dim;
f121_dims[1] = D2_dim;
f121_dims[2] = D1_dim;
stat = nc_def_var(ncid, "f121", NC_FLOAT, RANK_f121, f121_dims, &f121_id);
check_err(stat,__LINE__,__FILE__);
d122_dims[0] = D1_dim;
d122_dims[1] = D2_dim;
d122_dims[2] = D2_dim;
stat = nc_def_var(ncid, "d122", NC_DOUBLE, RANK_d122, d122_dims, &d122_id);
check_err(stat,__LINE__,__FILE__);
c123_dims[0] = D1_dim;
c123_dims[1] = D2_dim;
c123_dims[2] = D3_dim;
stat = nc_def_var(ncid, "c123", NC_CHAR, RANK_c123, c123_dims, &c123_id);
check_err(stat,__LINE__,__FILE__);
s131_dims[0] = D1_dim;
s131_dims[1] = D3_dim;
s131_dims[2] = D1_dim;
stat = nc_def_var(ncid, "s131", NC_SHORT, RANK_s131, s131_dims, &s131_id);
check_err(stat,__LINE__,__FILE__);
i132_dims[0] = D1_dim;
i132_dims[1] = D3_dim;
i132_dims[2] = D2_dim;
stat = nc_def_var(ncid, "i132", NC_INT, RANK_i132, i132_dims, &i132_id);
check_err(stat,__LINE__,__FILE__);
f133_dims[0] = D1_dim;
f133_dims[1] = D3_dim;
f133_dims[2] = D3_dim;
stat = nc_def_var(ncid, "f133", NC_FLOAT, RANK_f133, f133_dims, &f133_id);
check_err(stat,__LINE__,__FILE__);
f211_dims[0] = D2_dim;
f211_dims[1] = D1_dim;
f211_dims[2] = D1_dim;
stat = nc_def_var(ncid, "f211", NC_FLOAT, RANK_f211, f211_dims, &f211_id);
check_err(stat,__LINE__,__FILE__);
d212_dims[0] = D2_dim;
d212_dims[1] = D1_dim;
d212_dims[2] = D2_dim;
stat = nc_def_var(ncid, "d212", NC_DOUBLE, RANK_d212, d212_dims, &d212_id);
check_err(stat,__LINE__,__FILE__);
c213_dims[0] = D2_dim;
c213_dims[1] = D1_dim;
c213_dims[2] = D3_dim;
stat = nc_def_var(ncid, "c213", NC_CHAR, RANK_c213, c213_dims, &c213_id);
check_err(stat,__LINE__,__FILE__);
s221_dims[0] = D2_dim;
s221_dims[1] = D2_dim;
s221_dims[2] = D1_dim;
stat = nc_def_var(ncid, "s221", NC_SHORT, RANK_s221, s221_dims, &s221_id);
check_err(stat,__LINE__,__FILE__);
i222_dims[0] = D2_dim;
i222_dims[1] = D2_dim;
i222_dims[2] = D2_dim;
stat = nc_def_var(ncid, "i222", NC_INT, RANK_i222, i222_dims, &i222_id);
check_err(stat,__LINE__,__FILE__);
f223_dims[0] = D2_dim;
f223_dims[1] = D2_dim;
f223_dims[2] = D3_dim;
stat = nc_def_var(ncid, "f223", NC_FLOAT, RANK_f223, f223_dims, &f223_id);
check_err(stat,__LINE__,__FILE__);
c231_dims[0] = D2_dim;
c231_dims[1] = D3_dim;
c231_dims[2] = D1_dim;
stat = nc_def_var(ncid, "c231", NC_CHAR, RANK_c231, c231_dims, &c231_id);
check_err(stat,__LINE__,__FILE__);
b232_dims[0] = D2_dim;
b232_dims[1] = D3_dim;
b232_dims[2] = D2_dim;
stat = nc_def_var(ncid, "b232", NC_BYTE, RANK_b232, b232_dims, &b232_id);
check_err(stat,__LINE__,__FILE__);
s233_dims[0] = D2_dim;
s233_dims[1] = D3_dim;
s233_dims[2] = D3_dim;
stat = nc_def_var(ncid, "s233", NC_SHORT, RANK_s233, s233_dims, &s233_id);
check_err(stat,__LINE__,__FILE__);
s311_dims[0] = D3_dim;
s311_dims[1] = D1_dim;
s311_dims[2] = D1_dim;
stat = nc_def_var(ncid, "s311", NC_SHORT, RANK_s311, s311_dims, &s311_id);
check_err(stat,__LINE__,__FILE__);
i312_dims[0] = D3_dim;
i312_dims[1] = D1_dim;
i312_dims[2] = D2_dim;
stat = nc_def_var(ncid, "i312", NC_INT, RANK_i312, i312_dims, &i312_id);
check_err(stat,__LINE__,__FILE__);
f313_dims[0] = D3_dim;
f313_dims[1] = D1_dim;
f313_dims[2] = D3_dim;
stat = nc_def_var(ncid, "f313", NC_FLOAT, RANK_f313, f313_dims, &f313_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "var-name-dashes", NC_DOUBLE, RANK_var_MINUS_name_MINUS_dashes, 0, &var_MINUS_name_MINUS_dashes_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "var.name.dots", NC_DOUBLE, RANK_var_PERIOD_name_PERIOD_dots, 0, &var_PERIOD_name_PERIOD_dots_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "var+name+plusses", NC_DOUBLE, RANK_var_PLUS_name_PLUS_plusses, 0, &var_PLUS_name_PLUS_plusses_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "var@name@ats", NC_DOUBLE, RANK_var_ATSIGN_name_ATSIGN_ats, 0, &var_ATSIGN_name_ATSIGN_ats_id);
check_err(stat,__LINE__,__FILE__);
/* assign global attributes */
{ /* Gc */
stat = nc_put_att_text(ncid, NC_GLOBAL, "Gc", 0, "");
check_err(stat,__LINE__,__FILE__);
}
{ /* Gb */
static const signed char Gb_att[2] = {-128, 127} ;
stat = nc_put_att_schar(ncid, NC_GLOBAL, "Gb", NC_BYTE, 2, Gb_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gs */
static const short Gs_att[3] = {-32768, 0, 32767} ;
stat = nc_put_att_short(ncid, NC_GLOBAL, "Gs", NC_SHORT, 3, Gs_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gi */
static const int Gi_att[3] = {-2147483647, 0, 2147483647} ;
stat = nc_put_att_int(ncid, NC_GLOBAL, "Gi", NC_INT, 3, Gi_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gf */
static const float Gf_att[3] = {-9.9999996e+35, 0, 9.9999996e+35} ;
stat = nc_put_att_float(ncid, NC_GLOBAL, "Gf", NC_FLOAT, 3, Gf_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gd */
static const double Gd_att[3] = {-1e+308, 0, 1e+308} ;
stat = nc_put_att_double(ncid, NC_GLOBAL, "Gd", NC_DOUBLE, 3, Gd_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gatt-name-dashes */
static const int Gatt_MINUS_name_MINUS_dashes_att[1] = {-1} ;
stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt-name-dashes", NC_INT, 1, Gatt_MINUS_name_MINUS_dashes_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gatt.name.dots */
static const int Gatt_PERIOD_name_PERIOD_dots_att[1] = {-2} ;
stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt.name.dots", NC_INT, 1, Gatt_PERIOD_name_PERIOD_dots_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gatt+name+plusses */
static const int Gatt_PLUS_name_PLUS_plusses_att[1] = {-3} ;
stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt+name+plusses", NC_INT, 1, Gatt_PLUS_name_PLUS_plusses_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Gatt@name@ats */
static const int Gatt_ATSIGN_name_ATSIGN_ats_att[1] = {-4} ;
stat = nc_put_att_int(ncid, NC_GLOBAL, "Gatt@name@ats", NC_INT, 1, Gatt_ATSIGN_name_ATSIGN_ats_att);
check_err(stat,__LINE__,__FILE__);
}
/* assign per-variable attributes */
{ /* att-name-dashes */
static const int c_att_MINUS_name_MINUS_dashes_att[1] = {4} ;
stat = nc_put_att_int(ncid, c_id, "att-name-dashes", NC_INT, 1, c_att_MINUS_name_MINUS_dashes_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* att.name.dots */
static const int c_att_PERIOD_name_PERIOD_dots_att[1] = {5} ;
stat = nc_put_att_int(ncid, c_id, "att.name.dots", NC_INT, 1, c_att_PERIOD_name_PERIOD_dots_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* att+name+plusses */
static const int c_att_PLUS_name_PLUS_plusses_att[1] = {6} ;
stat = nc_put_att_int(ncid, c_id, "att+name+plusses", NC_INT, 1, c_att_PLUS_name_PLUS_plusses_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* att@name@ats */
static const int c_att_ATSIGN_name_ATSIGN_ats_att[1] = {7} ;
stat = nc_put_att_int(ncid, c_id, "att@name@ats", NC_INT, 1, c_att_ATSIGN_name_ATSIGN_ats_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* c */
stat = nc_put_att_text(ncid, b_id, "c", 0, "");
check_err(stat,__LINE__,__FILE__);
}
{ /* b */
static const signed char s_b_att[4] = {0, 127, -128, -1} ;
stat = nc_put_att_schar(ncid, s_id, "b", NC_BYTE, 4, s_b_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* s */
static const short s_s_att[3] = {-32768, 0, 32767} ;
stat = nc_put_att_short(ncid, s_id, "s", NC_SHORT, 3, s_s_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* i */
static const int i_i_att[3] = {-2147483647, 0, 2147483647} ;
stat = nc_put_att_int(ncid, i_id, "i", NC_INT, 3, i_i_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* f */
static const float i_f_att[3] = {-9.9999996e+35, 0, 9.9999996e+35} ;
stat = nc_put_att_float(ncid, i_id, "f", NC_FLOAT, 3, i_f_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* d */
static const double i_d_att[3] = {-1e+308, 0, 1e+308} ;
stat = nc_put_att_double(ncid, i_id, "d", NC_DOUBLE, 3, i_d_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* c */
stat = nc_put_att_text(ncid, f_id, "c", 1, "x");
check_err(stat,__LINE__,__FILE__);
}
{ /* c */
stat = nc_put_att_text(ncid, d_id, "c", 8, "abcd\tZ$&");
check_err(stat,__LINE__,__FILE__);
}
/* leave define mode */
stat = nc_enddef (ncid);
check_err(stat,__LINE__,__FILE__);
/* assign variable data */
{
size_t zero = 0;
static char c_data[1] = {'2'};
stat = nc_put_var1(ncid, c_id, &zero, c_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static signed char b_data[1] = {-2};
stat = nc_put_var1(ncid, b_id, &zero, b_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static short s_data[1] = {-5};
stat = nc_put_var1(ncid, s_id, &zero, s_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static int i_data[1] = {-20};
stat = nc_put_var1(ncid, i_id, &zero, i_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static float f_data[1] = {-9};
stat = nc_put_var1(ncid, f_id, &zero, f_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static double d_data[1] = {-10};
stat = nc_put_var1(ncid, d_id, &zero, d_data); check_err(stat,__LINE__,__FILE__);
}
{
char cr_data[2] = "ab" ;
size_t cr_startset[1] = {0} ;
size_t cr_countset[1] = {2} ;
stat = nc_put_vara(ncid, cr_id, cr_startset, cr_countset, cr_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char br_data[2] = {-128, 127} ;
size_t br_startset[1] = {0} ;
size_t br_countset[1] = {2} ;
stat = nc_put_vara(ncid, br_id, br_startset, br_countset, br_data);
check_err(stat,__LINE__,__FILE__);
}
{
short sr_data[2] = {-32768, 32767} ;
size_t sr_startset[1] = {0} ;
size_t sr_countset[1] = {2} ;
stat = nc_put_vara(ncid, sr_id, sr_startset, sr_countset, sr_data);
check_err(stat,__LINE__,__FILE__);
}
{
int ir_data[2] = {-2147483646, 2147483647} ;
size_t ir_startset[1] = {0} ;
size_t ir_countset[1] = {2} ;
stat = nc_put_vara(ncid, ir_id, ir_startset, ir_countset, ir_data);
check_err(stat,__LINE__,__FILE__);
}
{
float fr_data[2] = {-9.9999996e+35, 9.9999996e+35} ;
size_t fr_startset[1] = {0} ;
size_t fr_countset[1] = {2} ;
stat = nc_put_vara(ncid, fr_id, fr_startset, fr_countset, fr_data);
check_err(stat,__LINE__,__FILE__);
}
{
double dr_data[2] = {-1e+308, 1e+308} ;
size_t dr_startset[1] = {0} ;
size_t dr_countset[1] = {2} ;
stat = nc_put_vara(ncid, dr_id, dr_startset, dr_countset, dr_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c1_data[1] = "\000" ;
size_t c1_startset[1] = {0} ;
size_t c1_countset[1] = {1} ;
stat = nc_put_vara(ncid, c1_id, c1_startset, c1_countset, c1_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b1_data[1] = {-128} ;
size_t b1_startset[1] = {0} ;
size_t b1_countset[1] = {1} ;
stat = nc_put_vara(ncid, b1_id, b1_startset, b1_countset, b1_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s1_data[1] = {-32768} ;
size_t s1_startset[1] = {0} ;
size_t s1_countset[1] = {1} ;
stat = nc_put_vara(ncid, s1_id, s1_startset, s1_countset, s1_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i1_data[1] = {-2147483646} ;
size_t i1_startset[1] = {0} ;
size_t i1_countset[1] = {1} ;
stat = nc_put_vara(ncid, i1_id, i1_startset, i1_countset, i1_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f1_data[1] = {-9.9999996e+35} ;
size_t f1_startset[1] = {0} ;
size_t f1_countset[1] = {1} ;
stat = nc_put_vara(ncid, f1_id, f1_startset, f1_countset, f1_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d1_data[1] = {-1e+308} ;
size_t d1_startset[1] = {0} ;
size_t d1_countset[1] = {1} ;
stat = nc_put_vara(ncid, d1_id, d1_startset, d1_countset, d1_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c2_data[2] = "ab" ;
size_t c2_startset[1] = {0} ;
size_t c2_countset[1] = {2} ;
stat = nc_put_vara(ncid, c2_id, c2_startset, c2_countset, c2_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b2_data[2] = {-128, 127} ;
size_t b2_startset[1] = {0} ;
size_t b2_countset[1] = {2} ;
stat = nc_put_vara(ncid, b2_id, b2_startset, b2_countset, b2_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s2_data[2] = {-32768, 32767} ;
size_t s2_startset[1] = {0} ;
size_t s2_countset[1] = {2} ;
stat = nc_put_vara(ncid, s2_id, s2_startset, s2_countset, s2_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i2_data[2] = {-2147483646, 2147483647} ;
size_t i2_startset[1] = {0} ;
size_t i2_countset[1] = {2} ;
stat = nc_put_vara(ncid, i2_id, i2_startset, i2_countset, i2_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f2_data[2] = {-9.9999996e+35, 9.9999996e+35} ;
size_t f2_startset[1] = {0} ;
size_t f2_countset[1] = {2} ;
stat = nc_put_vara(ncid, f2_id, f2_startset, f2_countset, f2_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d2_data[2] = {-1e+308, 1e+308} ;
size_t d2_startset[1] = {0} ;
size_t d2_countset[1] = {2} ;
stat = nc_put_vara(ncid, d2_id, d2_startset, d2_countset, d2_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c3_data[3] = "\001À." ;
size_t c3_startset[1] = {0} ;
size_t c3_countset[1] = {3} ;
stat = nc_put_vara(ncid, c3_id, c3_startset, c3_countset, c3_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b3_data[3] = {-128, 127, -1} ;
size_t b3_startset[1] = {0} ;
size_t b3_countset[1] = {3} ;
stat = nc_put_vara(ncid, b3_id, b3_startset, b3_countset, b3_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s3_data[3] = {-32768, 0, 32767} ;
size_t s3_startset[1] = {0} ;
size_t s3_countset[1] = {3} ;
stat = nc_put_vara(ncid, s3_id, s3_startset, s3_countset, s3_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i3_data[3] = {-2147483646, 0, 2147483647} ;
size_t i3_startset[1] = {0} ;
size_t i3_countset[1] = {3} ;
stat = nc_put_vara(ncid, i3_id, i3_startset, i3_countset, i3_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f3_data[3] = {-9.9999996e+35, 0, 9.9999996e+35} ;
size_t f3_startset[1] = {0} ;
size_t f3_countset[1] = {3} ;
stat = nc_put_vara(ncid, f3_id, f3_startset, f3_countset, f3_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d3_data[3] = {-1e+308, 0, 1e+308} ;
size_t d3_startset[1] = {0} ;
size_t d3_countset[1] = {3} ;
stat = nc_put_vara(ncid, d3_id, d3_startset, d3_countset, d3_data);
check_err(stat,__LINE__,__FILE__);
}
{
char cr1_data[2] = "xy" ;
size_t cr1_startset[2] = {0, 0} ;
size_t cr1_countset[2] = {2, 1} ;
stat = nc_put_vara(ncid, cr1_id, cr1_startset, cr1_countset, cr1_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char br2_data[4] = {-24, -26, -20, -22} ;
size_t br2_startset[2] = {0, 0} ;
size_t br2_countset[2] = {2, 2} ;
stat = nc_put_vara(ncid, br2_id, br2_startset, br2_countset, br2_data);
check_err(stat,__LINE__,__FILE__);
}
{
short sr3_data[6] = {-375, -380, -385, -350, -355, -360} ;
size_t sr3_startset[2] = {0, 0} ;
size_t sr3_countset[2] = {2, 3} ;
stat = nc_put_vara(ncid, sr3_id, sr3_startset, sr3_countset, sr3_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f11_data[1] = {-2187} ;
size_t f11_startset[2] = {0, 0} ;
size_t f11_countset[2] = {1, 1} ;
stat = nc_put_vara(ncid, f11_id, f11_startset, f11_countset, f11_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d12_data[2] = {-3000, -3010} ;
size_t d12_startset[2] = {0, 0} ;
size_t d12_countset[2] = {1, 2} ;
stat = nc_put_vara(ncid, d12_id, d12_startset, d12_countset, d12_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c13_data[3] = "\tb\177" ;
size_t c13_startset[2] = {0, 0} ;
size_t c13_countset[2] = {1, 3} ;
stat = nc_put_vara(ncid, c13_id, c13_startset, c13_countset, c13_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s21_data[2] = {-375, -350} ;
size_t s21_startset[2] = {0, 0} ;
size_t s21_countset[2] = {2, 1} ;
stat = nc_put_vara(ncid, s21_id, s21_startset, s21_countset, s21_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i22_data[4] = {-24000, -24020, -23600, -23620} ;
size_t i22_startset[2] = {0, 0} ;
size_t i22_countset[2] = {2, 2} ;
stat = nc_put_vara(ncid, i22_id, i22_startset, i22_countset, i22_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f23_data[6] = {-2187, -2196, -2205, -2106, -2115, -2124} ;
size_t f23_startset[2] = {0, 0} ;
size_t f23_countset[2] = {2, 3} ;
stat = nc_put_vara(ncid, f23_id, f23_startset, f23_countset, f23_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c31_data[3] = "+- " ;
size_t c31_startset[2] = {0, 0} ;
size_t c31_countset[2] = {3, 1} ;
stat = nc_put_vara(ncid, c31_id, c31_startset, c31_countset, c31_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b32_data[6] = {-24, -26, -20, -22, -16, -18} ;
size_t b32_startset[2] = {0, 0} ;
size_t b32_countset[2] = {3, 2} ;
stat = nc_put_vara(ncid, b32_id, b32_startset, b32_countset, b32_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s33_data[9] = {-375, -380, -385, -350, -355, -360, -325, -330, -335} ;
size_t s33_startset[2] = {0, 0} ;
size_t s33_countset[2] = {3, 3} ;
stat = nc_put_vara(ncid, s33_id, s33_startset, s33_countset, s33_data);
check_err(stat,__LINE__,__FILE__);
}
{
short sr11_data[2] = {2500, 2375} ;
size_t sr11_startset[3] = {0, 0, 0} ;
size_t sr11_countset[3] = {2, 1, 1} ;
stat = nc_put_vara(ncid, sr11_id, sr11_startset, sr11_countset, sr11_data);
check_err(stat,__LINE__,__FILE__);
}
{
int ir12_data[4] = {640000, 639980, 632000, 631980} ;
size_t ir12_startset[3] = {0, 0, 0} ;
size_t ir12_countset[3] = {2, 1, 2} ;
stat = nc_put_vara(ncid, ir12_id, ir12_startset, ir12_countset, ir12_data);
check_err(stat,__LINE__,__FILE__);
}
{
float fr13_data[6] = {26244, 26235, 26226, 25515, 25506, 25497} ;
size_t fr13_startset[3] = {0, 0, 0} ;
size_t fr13_countset[3] = {2, 1, 3} ;
stat = nc_put_vara(ncid, fr13_id, fr13_startset, fr13_countset, fr13_data);
check_err(stat,__LINE__,__FILE__);
}
{
char cr21_data[4] = "@DHL" ;
size_t cr21_startset[3] = {0, 0, 0} ;
size_t cr21_countset[3] = {2, 2, 1} ;
stat = nc_put_vara(ncid, cr21_id, cr21_startset, cr21_countset, cr21_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char br22_data[8] = {64, 62, 68, 66, 56, 54, 60, 58} ;
size_t br22_startset[3] = {0, 0, 0} ;
size_t br22_countset[3] = {2, 2, 2} ;
stat = nc_put_vara(ncid, br22_id, br22_startset, br22_countset, br22_data);
check_err(stat,__LINE__,__FILE__);
}
{
short sr23_data[12] = {2500, 2495, 2490, 2525, 2520, 2515, 2375, 2370, 2365, 2400, 2395, 2390} ;
size_t sr23_startset[3] = {0, 0, 0} ;
size_t sr23_countset[3] = {2, 2, 3} ;
stat = nc_put_vara(ncid, sr23_id, sr23_startset, sr23_countset, sr23_data);
check_err(stat,__LINE__,__FILE__);
}
{
float fr31_data[6] = {26244, 26325, 26406, 25515, 25596, 25677} ;
size_t fr31_startset[3] = {0, 0, 0} ;
size_t fr31_countset[3] = {2, 3, 1} ;
stat = nc_put_vara(ncid, fr31_id, fr31_startset, fr31_countset, fr31_data);
check_err(stat,__LINE__,__FILE__);
}
{
double dr32_data[12] = {40000, 39990, 40100, 40090, 40200, 40190, 39000, 38990, 39100, 39090, 39200, 39190} ;
size_t dr32_startset[3] = {0, 0, 0} ;
size_t dr32_countset[3] = {2, 3, 2} ;
stat = nc_put_vara(ncid, dr32_id, dr32_startset, dr32_countset, dr32_data);
check_err(stat,__LINE__,__FILE__);
}
{
char cr33_data[18] = "1\000\000two3\000\0004\000\0005\000\000six" ;
size_t cr33_startset[3] = {0, 0, 0} ;
size_t cr33_countset[3] = {2, 3, 3} ;
stat = nc_put_vara(ncid, cr33_id, cr33_startset, cr33_countset, cr33_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c111_data[1] = "@" ;
size_t c111_startset[3] = {0, 0, 0} ;
size_t c111_countset[3] = {1, 1, 1} ;
stat = nc_put_vara(ncid, c111_id, c111_startset, c111_countset, c111_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b112_data[2] = {64, 62} ;
size_t b112_startset[3] = {0, 0, 0} ;
size_t b112_countset[3] = {1, 1, 2} ;
stat = nc_put_vara(ncid, b112_id, b112_startset, b112_countset, b112_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s113_data[3] = {2500, 2495, 2490} ;
size_t s113_startset[3] = {0, 0, 0} ;
size_t s113_countset[3] = {1, 1, 3} ;
stat = nc_put_vara(ncid, s113_id, s113_startset, s113_countset, s113_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f121_data[2] = {26244, 26325} ;
size_t f121_startset[3] = {0, 0, 0} ;
size_t f121_countset[3] = {1, 2, 1} ;
stat = nc_put_vara(ncid, f121_id, f121_startset, f121_countset, f121_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d122_data[4] = {40000, 39990, 40100, 40090} ;
size_t d122_startset[3] = {0, 0, 0} ;
size_t d122_countset[3] = {1, 2, 2} ;
stat = nc_put_vara(ncid, d122_id, d122_startset, d122_countset, d122_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c123_data[6] = "one2\000\000" ;
size_t c123_startset[3] = {0, 0, 0} ;
size_t c123_countset[3] = {1, 2, 3} ;
stat = nc_put_vara(ncid, c123_id, c123_startset, c123_countset, c123_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s131_data[3] = {2500, 2525, 2550} ;
size_t s131_startset[3] = {0, 0, 0} ;
size_t s131_countset[3] = {1, 3, 1} ;
stat = nc_put_vara(ncid, s131_id, s131_startset, s131_countset, s131_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i132_data[6] = {640000, 639980, 640400, 640380, 640800, 640780} ;
size_t i132_startset[3] = {0, 0, 0} ;
size_t i132_countset[3] = {1, 3, 2} ;
stat = nc_put_vara(ncid, i132_id, i132_startset, i132_countset, i132_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f133_data[9] = {26244, 26235, 26226, 26325, 26316, 26307, 26406, 26397, 26388} ;
size_t f133_startset[3] = {0, 0, 0} ;
size_t f133_countset[3] = {1, 3, 3} ;
stat = nc_put_vara(ncid, f133_id, f133_startset, f133_countset, f133_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f211_data[2] = {26244, 25515} ;
size_t f211_startset[3] = {0, 0, 0} ;
size_t f211_countset[3] = {2, 1, 1} ;
stat = nc_put_vara(ncid, f211_id, f211_startset, f211_countset, f211_data);
check_err(stat,__LINE__,__FILE__);
}
{
double d212_data[4] = {40000, 39990, 39000, 38990} ;
size_t d212_startset[3] = {0, 0, 0} ;
size_t d212_countset[3] = {2, 1, 2} ;
stat = nc_put_vara(ncid, d212_id, d212_startset, d212_countset, d212_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s221_data[4] = {2500, 2525, 2375, 2400} ;
size_t s221_startset[3] = {0, 0, 0} ;
size_t s221_countset[3] = {2, 2, 1} ;
stat = nc_put_vara(ncid, s221_id, s221_startset, s221_countset, s221_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i222_data[8] = {640000, 639980, 640400, 640380, 632000, 631980, 632400, 632380} ;
size_t i222_startset[3] = {0, 0, 0} ;
size_t i222_countset[3] = {2, 2, 2} ;
stat = nc_put_vara(ncid, i222_id, i222_startset, i222_countset, i222_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f223_data[12] = {26244, 26235, 26226, 26325, 26316, 26307, 25515, 25506, 25497, 25596, 25587, 25578} ;
size_t f223_startset[3] = {0, 0, 0} ;
size_t f223_countset[3] = {2, 2, 3} ;
stat = nc_put_vara(ncid, f223_id, f223_startset, f223_countset, f223_data);
check_err(stat,__LINE__,__FILE__);
}
{
char c231_data[6] = "@DHHLP" ;
size_t c231_startset[3] = {0, 0, 0} ;
size_t c231_countset[3] = {2, 3, 1} ;
stat = nc_put_vara(ncid, c231_id, c231_startset, c231_countset, c231_data);
check_err(stat,__LINE__,__FILE__);
}
{
signed char b232_data[12] = {64, 62, 68, 66, 72, 70, 56, 54, 60, 58, 64, 62} ;
size_t b232_startset[3] = {0, 0, 0} ;
size_t b232_countset[3] = {2, 3, 2} ;
stat = nc_put_vara(ncid, b232_id, b232_startset, b232_countset, b232_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s233_data[18] = {2500, 2495, 2490, 2525, 2520, 2515, 2550, 2545, 2540, 2375, 2370, 2365, 2400, 2395, 2390, 2425, 2420, 2415} ;
size_t s233_startset[3] = {0, 0, 0} ;
size_t s233_countset[3] = {2, 3, 3} ;
stat = nc_put_vara(ncid, s233_id, s233_startset, s233_countset, s233_data);
check_err(stat,__LINE__,__FILE__);
}
{
short s311_data[3] = {2500, 2375, 2250} ;
size_t s311_startset[3] = {0, 0, 0} ;
size_t s311_countset[3] = {3, 1, 1} ;
stat = nc_put_vara(ncid, s311_id, s311_startset, s311_countset, s311_data);
check_err(stat,__LINE__,__FILE__);
}
{
int i312_data[6] = {640000, 639980, 632000, 631980, 624000, 623980} ;
size_t i312_startset[3] = {0, 0, 0} ;
size_t i312_countset[3] = {3, 1, 2} ;
stat = nc_put_vara(ncid, i312_id, i312_startset, i312_countset, i312_data);
check_err(stat,__LINE__,__FILE__);
}
{
float f313_data[9] = {26244, 26235, 26226, 25515, 25506, 25497, 24786, 24777, 24768} ;
size_t f313_startset[3] = {0, 0, 0} ;
size_t f313_countset[3] = {3, 1, 3} ;
stat = nc_put_vara(ncid, f313_id, f313_startset, f313_countset, f313_data);
check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static double var_MINUS_name_MINUS_dashes_data[1] = {-1};
stat = nc_put_var1(ncid, var_MINUS_name_MINUS_dashes_id, &zero, var_MINUS_name_MINUS_dashes_data); check_err(stat,__LINE__,__FILE__);
}
{
size_t zero = 0;
static double var_PERIOD_name_PERIOD_dots_data[1] = {-2};
stat = nc_put_var1(ncid, var_PERIOD_name_PERIOD_dots_id, &zero, var_PERIOD_name_PERIOD_dots_data); check_err(stat,__LINE__,__FILE__);
}
stat = nc_close(ncid);
check_err(stat,__LINE__,__FILE__);
return 0;
}
void websocket_hybi_17::do_write(void const* data, size_t size, bool is_binary, bool async)
{
shared_buffer buf = boost::make_shared<buffer>();
buf->reserve(size + FRAME_START_LEN + FRAME_PAYLOAD_LEN + FRAME_MASK_LEN);
size_t frame_len = FRAME_START_LEN;
buf->push_back(0x80 | (is_binary ? opcodes::BINARY : opcodes::TEXT));
if ( size < 126 )
{
buf->push_back(static_cast<uint8_t>(size));
}
else if ( size <= std::numeric_limits<uint16_t>::max() )
{
buf->push_back(126);
uint16_t const len = htons(static_cast<uint16_t>(size));
buf->resize(buf->size() + sizeof(len));
memcpy(&*(buf->begin() + frame_len), &len, sizeof(len));
frame_len += sizeof(len);
}
else
{
_aspect_assert(size > std::numeric_limits<uint16_t>::max());
buf->push_back(127);
uint64_t const len = htonll(size);
buf->resize(buf->size() + sizeof(len));
memcpy(&*(buf->begin() + frame_len), &len, sizeof(len));
frame_len += sizeof(len);
}
if ( async || is_client_side() )
{
uint8_t const* src = static_cast<uint8_t const*>(data);
if ( is_client_side() )
{
// data from client are masked
(*buf)[1] |= 0x80;
uint8_t mask[FRAME_MASK_LEN];
std::generate_n(mask, FRAME_MASK_LEN, rand_byte);
buf->resize(buf->size() + FRAME_MASK_LEN);
memcpy(&*(buf->begin() + frame_len), mask, FRAME_MASK_LEN);
frame_len += FRAME_MASK_LEN;
for (size_t i = 0; i != size; ++i)
{
buf->push_back(src[i] ^ mask[i % 4]);
}
}
else
{
buf->insert(buf->end(), src, src + size);
}
tcp_conn_->async_write(boost::asio::buffer(*buf),
boost::bind(&websocket_hybi_17::on_write_completed, this, buf,
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
else
{
boost::array<boost::asio::const_buffer, 2> bufs;
bufs[0] = boost::asio::buffer(*buf);
bufs[1] = boost::asio::buffer(data, size);
error_code err;
tcp_conn_->write(bufs, err);
check_err(err, "send");
}
}
int
run_attr_tests(char *testfile)
{
int ret = -1;
char *res = NULL;
struct stat buf;
struct statfs sbuf;
struct statvfs svbuf;
assert(testfile);
fprintf(stdout, "Testing chmod");
ret = chmod(testfile, 0);
check_err(ret, "chmod", 2);
fprintf(stdout, "Testing chown");
ret = chown(testfile, 0, 0);
check_err(ret, "chown", 2);
fprintf(stdout, "Testing link");
ret = link(testfile, testfile);
check_err(ret, "link", 2);
fprintf(stdout, "Testing rename");
ret = rename(testfile, testfile);
check_err(ret, "rename", 2);
fprintf(stdout, "Testing utimes");
ret = utimes(testfile, NULL);
check_err(ret, "utimes", 2);
fprintf(stdout, "Testing utime");
ret = utime(testfile, NULL);
check_err(ret, "utime", 2);
fprintf(stdout, "Testing unlink");
ret = unlink(testfile);
check_err(ret, "unlink", 2);
fprintf(stdout, "Testing symlink");
ret = symlink(testfile, testfile);
check_err(ret, "symlink", 2);
fprintf(stdout, "Testing readlink");
ret = readlink(testfile, testfile, 0);
check_err(ret, "readlink", 2);
fprintf(stdout, "Testing realpath");
ret = 0;
res = realpath((const char *)testfile, testfile);
if (!res)
ret = -1;
check_err(ret, "realpath", 2);
fprintf(stdout, "Testing stat");
ret = stat(testfile, &buf);
check_err(ret, "stat", 1);
fprintf(stdout, "Testing lstat");
ret = lstat(testfile, &buf);
check_err(ret, "lstat", 1);
fprintf(stdout, "Testing statfs");
ret = statfs(testfile, &sbuf);
check_err(ret, "statfs", 2);
fprintf(stdout, "Testing statvfs");
ret = statvfs(testfile, &svbuf);
check_err(ret, "statvfs", 1);
fprintf(stdout, "Testing getxattr");
ret = getxattr(testfile, NULL, NULL, 0);
check_err(ret, "getxattr", 2);
fprintf(stdout, "Testing lgetxattr");
ret = lgetxattr(testfile, NULL, NULL, 0);
check_err(ret, "lgetxattr", 1);
fprintf(stdout, "Testing lchown");
ret = lchown(testfile, 0, 0);
check_err(ret, "lchown", 2);
return 0;
}
static int
Test_verifierMakeFrame(void)
{
size_t i;
enum {
cst_size = 5,
var_size = 4,
flt_size = 4,
ess_size = 1
};
const char* cstSyms[cst_size] = {"|-", "wff", "0", "1", "+"};
size_t cstIds[cst_size];
const char* varSyms[var_size] = {"x", "y", "z", "w"};
size_t varIds[var_size];
const char* fltSyms[flt_size] = {"wff_x", "wff_y", "wff_z", "wff_w"};
size_t fltIds[flt_size];
size_t fltSS[flt_size][2];
const char* essSyms[ess_size] = {"plus"};
// size_t essIds[ess_size];
struct verifier vrf;
verifierInit(&vrf);
/* make a mock file because verifierAdd... requires vrf->rId to be valid */
LOG_DEBUG("making mock file because verifierAdd...() requires valid "
"vrf->rId");
struct reader file;
readerInitString(&file, "");
verifierBeginReadingFile(&vrf, &file);
size_tArrayAdd(&vrf.disjointScope, 0);
LOG_DEBUG("adding constants");
for (i = 0; i < cst_size; i++) {
cstIds[i] = verifierAddConstant(&vrf, cstSyms[i]);
}
LOG_DEBUG("adding variables");
for (i = 0; i < var_size; i++) {
varIds[i] = verifierAddVariable(&vrf, varSyms[i]);
}
ut_assert(vrf.symCount[symType_variable] == var_size,
"added %lu variables, expected %d", vrf.symCount[symType_variable],
var_size);
LOG_DEBUG("preparing floats");
struct symstring wff[flt_size];
for (i = 0; i < flt_size; i++) {
fltSS[i][0] = cstIds[1];
fltSS[i][1] = varIds[i];
symstringInit(&wff[i]);
size_tArrayAppend(&wff[i], fltSS[i], 2);
}
LOG_DEBUG("preparing essentials");
struct symstring plus;
size_t ssplus[4] = {cstIds[0], varIds[0], cstIds[4], varIds[1]};
symstringInit(&plus);
size_tArrayAppend(&plus, ssplus, 4);
LOG_DEBUG("adding floats and essentials");
fltIds[0] = verifierAddFloating(&vrf, fltSyms[0], &wff[0]);
check_err(vrf.err, error_none);
fltIds[1] = verifierAddFloating(&vrf, fltSyms[1], &wff[1]);
check_err(vrf.err, error_none);
verifierAddEssential(&vrf, essSyms[0], &plus);
check_err(vrf.err, error_none);
fltIds[2] = verifierAddFloating(&vrf, fltSyms[2], &wff[2]);
check_err(vrf.err, error_none);
fltIds[3] = verifierAddFloating(&vrf, fltSyms[3], &wff[3]);
check_err(vrf.err, error_none);
ut_assert(vrf.symCount[symType_floating] == 4, "added %lu floating, "
"expected 4", vrf.symCount[symType_floating]);
ut_assert(vrf.symCount[symType_essential] == 1, "added %lu essential, "
"expected 1", vrf.symCount[symType_essential]);
ut_assert(vrf.hypotheses.size == 5, "added %lu "
"hypotheses, expected 5", vrf.hypotheses.size);
LOG_DEBUG("preparing disjoint");
struct symstring disjoint;
symstringInit(&disjoint);
symstringAdd(&disjoint, varIds[0]);
symstringAdd(&disjoint, varIds[1]);
LOG_DEBUG("adding disjoint");
verifierAddDisjoint(&vrf, &disjoint);
ut_assert(vrf.disjoint1.size == 1, "added %lu disjoints, "
"expected 1", vrf.disjoint1.size);
LOG_DEBUG("preparing assertion");
struct symstring asr;
symstringInit(&asr);
size_t ssasr[6] =
{cstIds[0], varIds[0], cstIds[4], varIds[1], cstIds[4], varIds[2]};
size_tArrayAppend(&asr, ssasr, 6);
LOG_DEBUG("making the frame");
struct frame frm;
frameInit(&frm);
LOG_DEBUG("calling verifierMakeFrame()");
verifierMakeFrame(&vrf, &frm, &asr);
check_err(vrf.err, error_none);
ut_assert(frm.disjoint1.size == 1, "%lu disjoints in frame, expected 1",
frm.disjoint1.size);
LOG_DEBUG("make sure frame is the right size");
ut_assert(frm.stmts.size == 4, "frame has size %lu, expected 4",
frm.stmts.size);
LOG_DEBUG("make sure wff_w has not been added to the frame");
for (i = 0; i < frm.stmts.size; i++) {
ut_assert(frm.stmts.vals[i] != fltIds[3],
"wff_w should not be in the frame");
}
LOG_DEBUG("cleaning up");
frameClean(&frm);
symstringClean(&asr);
readerClean(&file);
verifierClean(&vrf);
return 0;
}
// 1419 is the mtu using a 1500 byte ethernet mtu - ipv4 header - udp - dtls with default ciphersuite (I think)
// TODO: read mtu from interface on each OS instead of hard coding 1419 (also have installer set sensible interface MTU)
tuntap::tuntap() : mtu(1419)
{
// TODO: use configuration parameters for registry key names instead of hard coded values
// TODO: package TAP-Windows and change component ID or otherwise figure out how to make it not collide with what OpenVPN uses
// see comment in %PROGRAMFILES%\TAP-Windows\driver\OemWin2k.inf after installing OpenVPN TAP driver
#ifdef WINDOWS
sent_sync = true; // no async send in progress
received_sync = 0;
memset(&recv_overlapped, 0, sizeof(OVERLAPPED));
memset(&send_overlapped, 0, sizeof(OVERLAPPED));
recv_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
if(recv_event == INVALID_HANDLE_VALUE)
throw check_err_exception("CreateEvent failed for tuntap recv_event");
recv_overlapped.hEvent = recv_event;
// default callback emits error
read_ready_cb = []() { eout() << "BUG: tuntap read ready callback called but not set"; };
if(RegisterWaitForSingleObject(&recv_wait, recv_event, &tuntap::read_event_cb, this, INFINITE, WT_EXECUTEINWAITTHREAD) == FALSE)
throw check_err_exception("RegisterWaitForSingleObject on tuntap read event");
adapter_GUID = snow::conf[snow::VIRTUAL_INTERFACE];
if(adapter_GUID == "auto") {
try {
// open registry key for all network adapters
registry_key adapters(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}", KEY_READ);
for(auto &it : adapters.subkeys()) {
try {
registry_key adapter = it.get(KEY_READ);
// TODO: change ComponentId from "tap0901" to some other string to remove possible namespace collision with OpenVPN (this has to occur in the driver too)
if(adapter.values().get_value_string("ComponentId") == "tap0901") {
adapter_GUID = adapter.values().get_value_string("NetCfgInstanceId");
break;
}
} catch(const registry_exception &re) {
dout() << "Failed to access registry subkey: " << re;
}
}
} catch (const registry_exception &re) {
eout() << "FATAL: Failed to open network adapters registry key, cannot determine TUN adapter to use: " << re;
throw;
}
}
dout() << "Adapter GUID: " << adapter_GUID;
if(adapter_GUID == "auto")
throw e_not_found("no usable tuntap interface");
// [at this point GUID is value of NetCfgInstanceId, although there could be more than one interface: check all against something else? (interface name?)]
// TODO: probably the thing to do is: on install, create a TAP-Windows interface and set its name to 'snow tunnel interface' or so,
// then set the GUID in the configuration file [or registry setting], and GUI config program can list interfaces by name and allow user to choose
// then the configured GUID is the interface we use and all of this mess doesn't even need to go here -- it just goes once on install and in the config editor
// what would then really be useful would be a way (other than changing the ComponentId) to tell other software (e.g. OpenVPN) not to use a particular interface
// two possible solutions may be to either make sure that snow starts before the other service [somehow] and gets there first,
// or setting permissions [somehow] so that only snow process has access
std::string tap_filename("\\\\.\\Global\\");
tap_filename += adapter_GUID + ".tap";
fd = CreateFile(tap_filename.c_str(), GENERIC_READ | GENERIC_WRITE, 0/*no shared access*/, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, nullptr);
if(fd == INVALID_HANDLE_VALUE)
throw check_err_exception("Failed to open Windows TUN/TAP device");
// name of specific instance of adapter as shown in control panel can be found in:
// "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\" + adapter_GUID + "\\Connection"
// value is "Name"
// set to TUN mode
// TAP_WIN_IOCTL_CONFIG_TUN takes three args: interface IP addr, network addr and netmask
if_info ifinfo = get_if_info();
uint32_t tun_addrs[3] = { ifinfo.if_addr, ifinfo.if_addr & ifinfo.netmask, ifinfo.netmask };
DWORD rsize;
if(DeviceIoControl(fd, TAP_WINDOWS_IOCTL_CONFIG_TUN, tun_addrs, sizeof(tun_addrs), tun_addrs, sizeof(tun_addrs), &rsize, nullptr))
dout() << "TAP-Windows CONFIG_TUN success: " << ss_ipaddr(tun_addrs[0]) << " " << ss_ipaddr(tun_addrs[1]) << " " << ss_ipaddr(tun_addrs[2]);
else
eout() << "TAP-Windows CONFIG_TUN FAIL: " << ss_ipaddr(tun_addrs[0]) << " " << ss_ipaddr(tun_addrs[1]) << " " << ss_ipaddr(tun_addrs[2]);
// set media status as connected
ULONG connected = TRUE;
if(DeviceIoControl(fd, TAP_WINDOWS_IOCTL_SET_MEDIA_STATUS, &connected, sizeof(connected), &connected, sizeof(connected), &rsize, nullptr) == FALSE)
wout() << "Failed to set TAP-Windows media status to connected";
ULONG ifmtu;
if(DeviceIoControl(fd, TAP_WINDOWS_IOCTL_GET_MTU, &ifmtu, sizeof(ifmtu), &ifmtu, sizeof(ifmtu), &rsize, nullptr)) {
dout() << "Read mtu from TAP-Windows interface: " << ifmtu;
if(ifmtu > MIN_PMTU)
mtu = ifmtu;
} else {
wout() << "Failed to get Tap-Windows MTU, assuming default";
}
// [flush ARP cache? -> probably unnecessary with tun, but maybe do it anyway? certainly don't want invalid ARP cache entries for pool addrs from before interface startup]
// ... also (may) need to undo whatever configuration (remove addrs from if, routes, etc.) on destruction, CloseHandle on fd, set media status to disconnected, etc.
#else
check_err((fd = open(snow::conf[snow::CLONE_DEVICE].c_str(), O_RDWR)), "opening tun/tap clone device");
ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
// check size manually instead of using strncpy: strncpy fails silently and doesn't null terminate if there is insufficient space
if(snow::conf[snow::VIRTUAL_INTERFACE].size() >= IFNAMSIZ)
throw check_err_exception("VIRTUAL_INTERFACE name is too long", false);
strcpy(ifr.ifr_name, snow::conf[snow::VIRTUAL_INTERFACE].c_str());
check_err(fcntl(fd, F_SETFL, O_NONBLOCK), "setting tuntap socket to non-blocking");
#ifdef __linux__
ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
check_err(ioctl(fd, TUNSETIFF, (void*) &ifr), "opening tun/tap interface");
#endif
// note: Mac and BSD require a stupid hack to make tun behave properly because they insist on a single destination address being specified
// solution is to exclude an address from the address pool and specify it as the destination when configuring the interface
// then set a route specifying that address as the gateway for the entire snow subnet so OS will send them all to the tun interface
// TODO: write code to do that programmatically for Mac/BSD
// existing code seems to work on BSD if you set CLONE_DEVICE to e.g. /dev/tun0 and VIRTUAL_INTERFACE to e.g. tun0 and configure the tun interface manually, e.g.:
// # ifconfig tun0 create 172.16.0.1 netmask 255.240.0.0 172.31.255.254 mtu 1419
// # route add -net 172.16.0.0 172.31.255.254 255.240.0.0
// (note: this must be done each time you start the daemon, when the daemon exits the interface remains but configuration is forgotten; same two commands w/o "create")
// (note: 'ifconfig tun create' will create next tun# necessary, see if there is any simple way to replicate with API)
// doing this programmatically requires call to ioctl passing SIOCSIFPHYADDR with in_aliasreq struct as follows:
// ifra_name = "tun[#]"
// ifra_addr as local interface addr
// ifra_dstaddr as fake addr
// ifra_mask as subnet mask
// and then adding the route via some call to the BSD routing API
csocket sock(AF_INET, SOCK_DGRAM); // need ordinary socket for SIOC[GS]*, can't use tun fd
check_err(ioctl(sock.fd(), SIOCGIFFLAGS, (void*) &ifr), "getting tuntap interface flags");
if((ifr.ifr_flags & IFF_UP) == 0) {
dout() << "tuntap interface was not up, trying to bring it up";
ifr.ifr_flags |= IFF_UP; // make sure interface is up
check_err(ioctl(sock.fd(), SIOCSIFFLAGS, (void*) &ifr), "setting tuntap interface flags");
} else {
dout() << "tuntap interface was up";
}
// there are two possible ways of doing this which are both supported: either snow launches as root or with CAP_NET_ADMIN and sets these here,
// or the interface is persistent and configured ahead of time, in which case only ownership of the interface is necessary
// so what we do is check that everything is configured correctly and try to fix it if it isn't
// that way everything is fine as long as the interface is correctly preconfigured -or- it isn't but we have rights to fix it
in_addr addr, netmask;
inet_pton(AF_INET, snow::conf[snow::NATPOOL_NETWORK].c_str(), &addr.s_addr);
addr.s_addr = htonl(ntohl(addr.s_addr) + 1);
netmask.s_addr = ~htonl((1 << (32 - snow::conf[snow::NATPOOL_NETMASK_BITS])) - 1);
ifr.ifr_addr.sa_family = AF_INET;
// EADDRNOTAVAIL is returned if no address is assigned which just means we have to assign the address, so then ifr_addr will be zero and not match addr
int rv = ioctl(sock.fd(), SIOCGIFADDR, &ifr);
if(rv < 0 && errno != EADDRNOTAVAIL)
throw check_err_exception("getting tun/tap interface IP address");
sockaddrunion su;
su.s = ifr.ifr_addr;
dout() << "Got tuntap ifaddr " << ss_ipaddr(su.sa.sin_addr.s_addr);
if(su.sa.sin_addr.s_addr != addr.s_addr) {
dout() << "Virtual interface IP addr was " << ss_ipaddr(su.sa.sin_addr.s_addr) << ", should be " << ss_ipaddr(addr.s_addr) << ", trying to fix";
su.sa.sin_addr = addr;
ifr.ifr_addr = su.s;
check_err(ioctl(sock.fd(), SIOCSIFADDR, &ifr), "setting tun/tap interface IP address");
}
check_err(ioctl(sock.fd(), SIOCGIFNETMASK, &ifr), "getting tun/tap interface netmask");
su.s = ifr.ifr_addr;
dout() << "Got tuntap netmask " << ss_ipaddr(su.sa.sin_addr.s_addr);
if(su.sa.sin_addr.s_addr != netmask.s_addr) {
dout() << "Virtual interface netmask was " << ss_ipaddr(su.sa.sin_addr.s_addr) << ", should be " << ss_ipaddr(netmask.s_addr) << ", trying to fix";
su.sa.sin_addr = netmask;
ifr.ifr_addr = su.s;
check_err(ioctl(sock.fd(), SIOCSIFNETMASK, &ifr), "setting tun/tap interface netmask");
}
mtu = snow::conf[snow::VIRTUAL_INTERFACE_MTU];
check_err(ioctl(sock.fd(), SIOCGIFMTU, (void*) &ifr), "getting tun/tap interface MTU");
dout() << "Existing tuntap interface MTU: " << ifr.ifr_mtu;
if(ifr.ifr_mtu < MIN_PMTU || mtu != static_cast<unsigned>(ifr.ifr_mtu)) {
dout() << "Virtual interface mtu was " << ifr.ifr_mtu << ", should be " << mtu << ", trying to fix";
ifr.ifr_mtu = mtu;
check_err(ioctl(sock.fd(), SIOCSIFMTU, (void*) &ifr), "setting tun/tap interface MTU");
}
iout() << "Virtual interface configured with network " << ss_ipaddr(addr.s_addr&netmask.s_addr) << " netmask " << ss_ipaddr(netmask.s_addr) << " address " << ss_ipaddr(addr.s_addr) << " MTU " << mtu;
#endif
}
int
main() {/* create tst_diskless2.nc */
int stat; /* return status */
int ncid; /* netCDF id */
/* group ids */
int root_grp;
int g_grp;
int h_grp;
/* type ids */
int enum_t_typ;
int opaque_t_typ;
int vlen_t_typ;
int g_cmpd_t_typ;
/* dimension ids */
int lat_dim;
int lon_dim;
int time_dim;
/* dimension lengths */
size_t lat_len = 10;
size_t lon_len = 5;
size_t time_len = NC_UNLIMITED;
/* variable ids */
int lat_id;
int lon_id;
int time_id;
int Z_id;
int t_id;
int p_id;
int rh_id;
int country_id;
int tag_id;
int h_compoundvar_id;
/* rank (number of dimensions) for each variable */
# define RANK_lat 1
# define RANK_lon 1
# define RANK_time 1
# define RANK_Z 3
# define RANK_t 3
# define RANK_p 3
# define RANK_rh 3
# define RANK_country 3
# define RANK_tag 0
# define RANK_h_compoundvar 0
/* variable shapes */
int lat_dims[RANK_lat];
int lon_dims[RANK_lon];
int time_dims[RANK_time];
int Z_dims[RANK_Z];
int t_dims[RANK_t];
int p_dims[RANK_p];
int rh_dims[RANK_rh];
int country_dims[RANK_country];
/* enter define mode */
stat = nc_create("tst_diskless2.nc", NC_DISKLESS|NC_WRITE|NC_CLOBBER|NC_NETCDF4, &ncid);
check_err(stat,__LINE__,__FILE__);
root_grp = ncid;
stat = nc_def_grp(root_grp, "g", &g_grp);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_grp(root_grp, "h", &h_grp);
check_err(stat,__LINE__,__FILE__);
{
unsigned char econst;
stat = nc_def_enum(root_grp, NC_UBYTE, "enum_t", &enum_t_typ);
check_err(stat,__LINE__,__FILE__);
econst = 0;
stat = nc_insert_enum(root_grp, enum_t_typ, "Clear", &econst);
check_err(stat,__LINE__,__FILE__);
econst = 1;
stat = nc_insert_enum(root_grp, enum_t_typ, "Cumulonimbus", &econst);
check_err(stat,__LINE__,__FILE__);
econst = 2;
stat = nc_insert_enum(root_grp, enum_t_typ, "Stratus", &econst);
check_err(stat,__LINE__,__FILE__);
}
stat = nc_def_opaque(root_grp, 11, "opaque_t", &opaque_t_typ);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_vlen(root_grp, "vlen_t", NC_INT, &vlen_t_typ);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_compound(g_grp, sizeof(g_cmpd_t), "cmpd_t", &g_cmpd_t_typ);
check_err(stat,__LINE__,__FILE__);
{
stat = nc_insert_compound(g_grp, g_cmpd_t_typ, "f1", NC_COMPOUND_OFFSET(g_cmpd_t,f1), vlen_t_typ);
check_err(stat,__LINE__,__FILE__);
stat = nc_insert_compound(g_grp, g_cmpd_t_typ, "f2", NC_COMPOUND_OFFSET(g_cmpd_t,f2), enum_t_typ);
check_err(stat,__LINE__,__FILE__);
}
/* define dimensions */
stat = nc_def_dim(root_grp, "lat", lat_len, &lat_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(root_grp, "lon", lon_len, &lon_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(root_grp, "time", time_len, &time_dim);
check_err(stat,__LINE__,__FILE__);
/* define variables */
lat_dims[0] = lat_dim;
stat = nc_def_var(root_grp, "lat", NC_INT, RANK_lat, lat_dims, &lat_id);
check_err(stat,__LINE__,__FILE__);
lon_dims[0] = lon_dim;
stat = nc_def_var(root_grp, "lon", NC_INT, RANK_lon, lon_dims, &lon_id);
check_err(stat,__LINE__,__FILE__);
time_dims[0] = time_dim;
stat = nc_def_var(root_grp, "time", NC_INT, RANK_time, time_dims, &time_id);
check_err(stat,__LINE__,__FILE__);
Z_dims[0] = time_dim;
Z_dims[1] = lat_dim;
Z_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "Z", NC_FLOAT, RANK_Z, Z_dims, &Z_id);
check_err(stat,__LINE__,__FILE__);
t_dims[0] = time_dim;
t_dims[1] = lat_dim;
t_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "t", NC_FLOAT, RANK_t, t_dims, &t_id);
check_err(stat,__LINE__,__FILE__);
p_dims[0] = time_dim;
p_dims[1] = lat_dim;
p_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "p", NC_DOUBLE, RANK_p, p_dims, &p_id);
check_err(stat,__LINE__,__FILE__);
rh_dims[0] = time_dim;
rh_dims[1] = lat_dim;
rh_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "rh", NC_INT, RANK_rh, rh_dims, &rh_id);
check_err(stat,__LINE__,__FILE__);
country_dims[0] = time_dim;
country_dims[1] = lat_dim;
country_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "country", NC_STRING, RANK_country, country_dims, &country_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(root_grp, "tag", NC_UBYTE, RANK_tag, 0, &tag_id);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(h_grp, "compoundvar", g_cmpd_t_typ, RANK_h_compoundvar, 0, &h_compoundvar_id);
check_err(stat,__LINE__,__FILE__);
/* assign global attributes */
{
static const int vlen_2[] = {17, 18, 19} ;
static const vlen_t globalatt_att[1] = {{3, (void*)vlen_2}} ;
stat = nc_put_att(root_grp, NC_GLOBAL, "globalatt", vlen_t_typ, 1, globalatt_att);
check_err(stat,__LINE__,__FILE__);
}
/* assign per-variable attributes */
{
stat = nc_put_att_text(root_grp, lat_id, "long_name", 8, "latitude");
check_err(stat,__LINE__,__FILE__);
}
{
stat = nc_put_att_text(root_grp, lat_id, "units", 13, "degrees_north");
check_err(stat,__LINE__,__FILE__);
}
{
stat = nc_put_att_text(root_grp, lon_id, "long_name", 9, "longitude");
check_err(stat,__LINE__,__FILE__);
}
{
stat = nc_put_att_text(root_grp, lon_id, "units", 12, "degrees_east");
check_err(stat,__LINE__,__FILE__);
}
{
stat = nc_put_att_text(root_grp, time_id, "units", 31, "seconds since 1992-1-1 00:00:00");
check_err(stat,__LINE__,__FILE__);
}
{
static const char* Z_units_att[1] = {"geopotential meters"} ;
stat = nc_put_att_string(root_grp, Z_id, "units", 1, Z_units_att);
check_err(stat,__LINE__,__FILE__);
}
{
static const float Z_valid_range_att[2] = {((float)0), ((float)5000)} ;
stat = nc_put_att_float(root_grp, Z_id, "valid_range", NC_FLOAT, 2, Z_valid_range_att);
check_err(stat,__LINE__,__FILE__);
}
{
static const double p_FillValue_att[1] = {((double)-9999)} ;
stat = nc_put_att_double(root_grp, p_id, "_FillValue", NC_DOUBLE, 1, p_FillValue_att);
check_err(stat,__LINE__,__FILE__);
}
{
static const int rh_FillValue_att[1] = {-1} ;
stat = nc_put_att_int(root_grp, rh_id, "_FillValue", NC_INT, 1, rh_FillValue_att);
check_err(stat,__LINE__,__FILE__);
}
/* leave define mode */
stat = nc_enddef (root_grp);
check_err(stat,__LINE__,__FILE__);
/* assign variable data */
{
int lat_data[10] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90} ;
size_t lat_startset[1] = {0} ;
size_t lat_countset[1] = {10};
stat = nc_put_vara(root_grp, lat_id, lat_startset, lat_countset, lat_data);
check_err(stat,__LINE__,__FILE__);
}
{
int lon_data[5] = {-140, -118, -96, -84, -52} ;
size_t lon_startset[1] = {0} ;
size_t lon_countset[1] = {5};
stat = nc_put_vara(root_grp, lon_id, lon_startset, lon_countset, lon_data);
check_err(stat,__LINE__,__FILE__);
}
{
static const int vlen_10[] = {3, 4, 5} ;
size_t zero = 0;
static g_cmpd_t h_compoundvar_data[1] = {{{3, (void*)vlen_10}, 2}};
stat = nc_put_var1(h_grp, h_compoundvar_id, &zero, h_compoundvar_data);
check_err(stat,__LINE__,__FILE__);
}
stat = nc_close(root_grp);
check_err(stat,__LINE__,__FILE__);
return 0;
}
int
main(int argc, char **argv) {
int stat; /* return status */
int ncid; /* netCDF id */
int rec, i, j, k, rank, nprocs, nerrs=0;
signed char x[] = {42, 21};
/* dimension ids */
int rec_dim;
int i_dim;
int j_dim;
int k_dim;
int n_dim;
#define NUMRECS 1
#define I_LEN 4104
#define J_LEN 1023
#define K_LEN 1023
#define N_LEN 2
/* dimension lengths */
MPI_Offset rec_len = NC_UNLIMITED;
MPI_Offset i_len = I_LEN;
MPI_Offset j_len = J_LEN;
MPI_Offset k_len = K_LEN;
MPI_Offset n_len = N_LEN;
/* variable ids */
int var1_id;
int x_id;
/* rank (number of dimensions) for each variable */
# define RANK_var1 4
# define RANK_x 2
/* variable shapes */
int var1_dims[RANK_var1];
int x_dims[RANK_x];
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (rank > 0) goto fn_exit;
printf("\n*** Testing large files, slowly.\n");
printf("*** Creating large file %s...", FILE_NAME);
/* enter define mode */
stat = ncmpi_create(MPI_COMM_SELF, FILE_NAME, NC_CLOBBER|NC_64BIT_DATA,
MPI_INFO_NULL, &ncid);
check_err(stat,__LINE__,__FILE__);
/* define dimensions */
stat = ncmpi_def_dim(ncid, "rec", rec_len, &rec_dim);
check_err(stat,__LINE__,__FILE__);
stat = ncmpi_def_dim(ncid, "i", i_len, &i_dim);
check_err(stat,__LINE__,__FILE__);
stat = ncmpi_def_dim(ncid, "j", j_len, &j_dim);
check_err(stat,__LINE__,__FILE__);
stat = ncmpi_def_dim(ncid, "k", k_len, &k_dim);
check_err(stat,__LINE__,__FILE__);
stat = ncmpi_def_dim(ncid, "n", n_len, &n_dim);
check_err(stat,__LINE__,__FILE__);
/* define variables */
var1_dims[0] = rec_dim;
var1_dims[1] = i_dim;
var1_dims[2] = j_dim;
var1_dims[3] = k_dim;
stat = ncmpi_def_var(ncid, "var1", NC_BYTE, RANK_var1, var1_dims, &var1_id);
check_err(stat,__LINE__,__FILE__);
x_dims[0] = rec_dim;
x_dims[1] = n_dim;
stat = ncmpi_def_var(ncid, "x", NC_BYTE, RANK_x, x_dims, &x_id);
check_err(stat,__LINE__,__FILE__);
/* don't initialize variables with fill values */
stat = ncmpi_set_fill(ncid, NC_NOFILL, 0);
check_err(stat,__LINE__,__FILE__);
/* leave define mode */
stat = ncmpi_enddef (ncid);
check_err(stat,__LINE__,__FILE__);
{ /* store var1 */
int n = 0;
static signed char var1[J_LEN][K_LEN];
static MPI_Offset var1_start[RANK_var1] = {0, 0, 0, 0};
static MPI_Offset var1_count[RANK_var1] = {1, 1, J_LEN, K_LEN};
static MPI_Offset x_start[RANK_x] = {0, 0};
static MPI_Offset x_count[RANK_x] = {1, N_LEN};
for(rec=0; rec<NUMRECS; rec++) {
var1_start[0] = rec;
x_start[0] = rec;
for(i=0; i<I_LEN; i++) {
for(j=0; j<J_LEN; j++) {
for (k=0; k<K_LEN; k++) {
var1[j][k] = n++;
}
}
var1_start[1] = i;
stat = ncmpi_put_vara_schar_all(ncid, var1_id, var1_start, var1_count, &var1[0][0]);
check_err(stat,__LINE__,__FILE__);
}
}
stat = ncmpi_put_vara_schar_all(ncid, x_id, x_start, x_count, x);
check_err(stat,__LINE__,__FILE__);
}
stat = ncmpi_close(ncid);
check_err(stat,__LINE__,__FILE__);
printf("ok\n");
printf("*** Reading large file %s...", FILE_NAME);
stat = ncmpi_open(MPI_COMM_SELF, FILE_NAME, NC_NOWRITE,
MPI_INFO_NULL, &ncid);
check_err(stat,__LINE__,__FILE__);
{ /* read var1 */
int n = 0;
static signed char var1[J_LEN][K_LEN];
static MPI_Offset var1_start[RANK_var1] = {0, 0, 0, 0};
static MPI_Offset var1_count[RANK_var1] = {1, 1, J_LEN, K_LEN};
static MPI_Offset x_start[RANK_x] = {0, 0};
static MPI_Offset x_count[RANK_x] = {1, N_LEN};
for(rec=0; rec<NUMRECS; rec++) {
var1_start[0] = rec;
x_start[0] = rec;
for(i=0; i<I_LEN; i++) {
var1_start[1] = i;
stat = ncmpi_get_vara_schar_all(ncid, var1_id, var1_start, var1_count, &var1[0][0]);
check_err(stat,__LINE__,__FILE__);
for(j=0; j<J_LEN; j++) {
for (k=0; k<K_LEN; k++) {
if (var1[j][k] != (signed char) n) {
printf("Error on read, var1[%d, %d, %d, %d] = %d wrong, "
"should be %d !\n", rec, i, j, k, var1[j][k], (signed char) n);
nerrs++;
}
n++;
}
}
}
ncmpi_get_vara_schar_all(ncid, x_id, x_start, x_count, x);
if(x[0] != 42 || x[1] != 21) {
printf("Error on read, x[] = %d, %d\n", x[0], x[1]);
nerrs++;
}
}
}
stat = ncmpi_close(ncid);
check_err(stat,__LINE__,__FILE__);
printf("ok\n");
printf("*** Tests successful!\n");
fn_exit:
MPI_Finalize();
return 0;
}
static void
cl_netcdf(void)
{
int stat = nc_close(ncid);
check_err(stat);
}
/* create netCDF from in-memory structure */
static void
gen_netcdf(
char *filename) /* name for output netcdf file */
{
int idim, ivar, iatt;
int dimid;
int varid;
int stat;
stat = nc_create(filename, cmode_modifier, &ncid);
check_err(stat);
/* define dimensions from info in dims array */
for (idim = 0; idim < ndims; idim++) {
stat = nc_def_dim(ncid, dims[idim].name, dims[idim].size, &dimid);
check_err(stat);
}
/* define variables from info in vars array */
for (ivar = 0; ivar < nvars; ivar++) {
stat = nc_def_var(ncid,
vars[ivar].name,
vars[ivar].type,
vars[ivar].ndims,
vars[ivar].dims,
&varid);
check_err(stat);
}
/* define attributes from info in atts array */
for (iatt = 0; iatt < natts; iatt++) {
varid = (atts[iatt].var == -1) ? NC_GLOBAL : atts[iatt].var;
switch(atts[iatt].type) {
case NC_BYTE:
stat = nc_put_att_schar(ncid, varid, atts[iatt].name,
atts[iatt].type, atts[iatt].len,
(signed char *) atts[iatt].val);
break;
case NC_CHAR:
stat = nc_put_att_text(ncid, varid, atts[iatt].name,
atts[iatt].len,
(char *) atts[iatt].val);
break;
case NC_SHORT:
stat = nc_put_att_short(ncid, varid, atts[iatt].name,
atts[iatt].type, atts[iatt].len,
(short *) atts[iatt].val);
break;
case NC_INT:
stat = nc_put_att_int(ncid, varid, atts[iatt].name,
atts[iatt].type, atts[iatt].len,
(int *) atts[iatt].val);
break;
case NC_FLOAT:
stat = nc_put_att_float(ncid, varid, atts[iatt].name,
atts[iatt].type, atts[iatt].len,
(float *) atts[iatt].val);
break;
case NC_DOUBLE:
stat = nc_put_att_double(ncid, varid, atts[iatt].name,
atts[iatt].type, atts[iatt].len,
(double *) atts[iatt].val);
break;
default:
stat = NC_EBADTYPE;
}
check_err(stat);
}
if (nofill_flag) {
stat = nc_set_fill(ncid, NC_NOFILL, 0); /* don't initialize with fill values */
check_err(stat);
}
stat = nc_enddef(ncid);
check_err(stat);
}
int
main(int argc, char **argv)
{
int c, stat;
int ncid;
NChdr* hdr;
init();
opterr=1;
while ((c = getopt(argc, argv, "dvau:D:l:p:c:t:R:")) != EOF) {
switch(c) {
case 'v': verbose=1; break;
case 'd': debug=1; break;
case 'D': debug=atoi(optarg); break;
default: break;
}
}
if(debug > 0) {ocdebug = debug;}
argc -= optind;
argv += optind;
if(argc > 0 && fileurl == NULL)
fileurl = nulldup(argv[0]);
if(fileurl == NULL) fileurl = getenv("FILEURL");
if(fileurl == NULL) {
fprintf(stderr,"no file url specified\n");
usage();
}
if(verbose) dumpflags();
if(verbose) {fprintf(stdout,"initializing\n"); fflush(stdout);}
stat = nc_open(fileurl,NC_NOWRITE,&ncid);
check_err(stat);
/* dump meta data */
stat = dumpmetadata(ncid,&hdr);
check_err(stat);
/* Get data */
if(1)
{
int i,j,limited;
size_t start[NC_MAX_VAR_DIMS];
size_t count[NC_MAX_VAR_DIMS];
/* Walk each variable */
for(i=0;i<hdr->nvars;i++) {
Var* var = &hdr->vars[i];
size_t nelems = 1;
limited = 0;
for(j=0;j<var->ndims;j++) {
start[j] = 0;
assert(var->dimids[j] == hdr->dims[var->dimids[j]].dimid);
count[j] = hdr->dims[var->dimids[j]].size;
/* put a limit on each count */
if(count[j] > LIMIT) {count[j] = LIMIT; limited = 1;}
nelems *= count[j];
}
if(nelems > 0) {
size_t typesize = nctypesizeof(var->nctype);
size_t memsize = typesize*nelems;
void* memory = malloc(memsize);
fprintf(stdout,"%s: size=%lu (%lu * %lu) ; ",
var->name, (unsigned long)memsize, (unsigned long)typesize, (unsigned long)nelems);
fflush(stdout);
stat = nc_get_vara(ncid,var->varid,start,count,memory);
check_err(stat);
/* dump memory */
switch (var->nctype){
case NC_CHAR:
fprintf(stdout,"\""); fflush(stdout);
dumpchars(nelems,memory);
fprintf(stdout,"\"");
break;
default:
for(j=0;j<nelems;j++) {
if(j > 0) fprintf(stdout," ");
dumpdata1(var->nctype,j,memory);
}
}
if(limited) fprintf(stdout,"...");
fprintf(stdout,"\n");
free(memory);
} else
fprintf(stdout,"%s: no data\n",var->name);
}
fprintf(stdout,"\n");
}
nc_close(ncid);
return 0;
}
/* write out variable's data from in-memory structure */
void
load_netcdf(
void *rec_start
)
{
int idim;
int stat = NC_NOERR;
size_t start[NC_MAX_VAR_DIMS];
size_t count[NC_MAX_VAR_DIMS];
char *charvalp;
short *shortvalp;
int *intvalp;
float *floatvalp;
double *doublevalp;
/* load values into variable */
switch (vars[varnum].type) {
case NC_CHAR:
case NC_BYTE:
charvalp = (char *) rec_start;
break;
case NC_SHORT:
shortvalp = (short *) rec_start;
break;
case NC_INT:
intvalp = (int *) rec_start;
break;
case NC_FLOAT:
floatvalp = (float *) rec_start;
break;
case NC_DOUBLE:
doublevalp = (double *) rec_start;
break;
default: break;
}
if (vars[varnum].ndims > 0) {
/* initialize start to upper left corner (0,0,0,...) */
start[0] = 0;
if (vars[varnum].dims[0] == rec_dim) {
count[0] = vars[varnum].nrecs;
}
else {
count[0] = dims[vars[varnum].dims[0]].size;
}
}
for (idim = 1; idim < vars[varnum].ndims; idim++) {
start[idim] = 0;
count[idim] = dims[vars[varnum].dims[idim]].size;
}
switch (vars[varnum].type) {
case NC_BYTE:
stat = nc_put_vara_schar(ncid, varnum, start, count,
(signed char *)charvalp);
break;
case NC_CHAR:
stat = nc_put_vara_text(ncid, varnum, start, count, charvalp);
break;
case NC_SHORT:
stat = nc_put_vara_short(ncid, varnum, start, count, shortvalp);
break;
case NC_INT:
stat = nc_put_vara_int(ncid, varnum, start, count, intvalp);
break;
case NC_FLOAT:
stat = nc_put_vara_float(ncid, varnum, start, count, floatvalp);
break;
case NC_DOUBLE:
stat = nc_put_vara_double(ncid, varnum, start, count, doublevalp);
break;
default: break;
}
check_err(stat);
}
int
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 coordinate variables and dimensions.\n");
printf("**** testing Jeff Whitakers reported 4.1 bug...");
{
#define NDIMS 2
#define NLAT 10
#define NLON 20
#define LAT_NAME "lat"
#define LON_NAME "lon"
#define NVARS 2
#define START_LAT 25.0
#define START_LON -125.0
{
int ncid, lon_dimid, lat_dimid;
int lat_varid, lon_varid;
float lats[NLAT], lons[NLON];
int lat, lon;
int nvars, ndims, ngatts, unlimdimid, nvars_in, varids_in[NVARS];
int ndims_in, natts_in, dimids_in[NDIMS];
char var_name_in[NC_MAX_NAME + 1];
nc_type xtype_in;
/* Initialize coord data. */
for (lat = 0; lat < NLAT; lat++)
lats[lat] = START_LAT + 5. * lat;
for (lon = 0; lon < NLON; lon++)
lons[lon] = START_LON + 5. * lon;
/* Create file with two dimensions. */
if (nc_create(FILE_NAME, NC_NETCDF4 | NC_CLOBBER, &ncid)) ERR;
if (nc_def_dim(ncid, LAT_NAME, NLAT, &lat_dimid)) ERR;
if (nc_def_dim(ncid, LON_NAME, NLON, &lon_dimid)) ERR;
if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, &lon_dimid, &lon_varid)) ERR;
/* Define and write longitude coord variable. */
if (nc_put_var_float(ncid, lon_varid, &lons[0])) ERR;
/* Define and write latitude coord variable. */
if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, &lat_dimid, &lat_varid)) ERR;
if (nc_put_var_float(ncid, lat_varid, &lats[0])) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 1 || natts_in != 0) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
/* Re-open and check the file. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 2 || ndims != 2 || ngatts != 0 || unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 1 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
}
SUMMARIZE_ERR;
printf("**** testing setting cache values for coordinate variables...");
{
#define RANK_1 1
#define DIM0_NAME "d0"
#define CACHE_SIZE 1000000
#define CACHE_NELEMS 1009
#define CACHE_PREEMPTION .90
int ncid, dimid, varid;
char name_in[NC_MAX_NAME + 1];
/* Create a test file with one dim and coord variable. */
if (nc_create(FILE_NAME, NC_CLASSIC_MODEL|NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM0_NAME, NC_UNLIMITED, &dimid)) ERR;
if (nc_def_var(ncid, DIM0_NAME, NC_DOUBLE, 1, &dimid, &varid)) ERR;
if (nc_set_var_chunk_cache(ncid, varid, CACHE_SIZE, CACHE_NELEMS, CACHE_PREEMPTION)) ERR;
if (nc_close(ncid)) ERR;
/* Reopen the file and check. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, DIM0_NAME)) ERR;
if (nc_set_var_chunk_cache(ncid, 0, CACHE_SIZE, CACHE_NELEMS, CACHE_PREEMPTION)) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, DIM0_NAME)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing multi-line strings in attributes...");
{
int ncid_classic, ncid_nc4;
/*int attid;*/
char att_in_classic[NC_MAX_NAME + 1], att_in_nc4[NC_MAX_NAME + 1];
#define FILE_CLASSIC "tst_coords_classic_att.nc"
#define FILE_NC4 "tst_coords_nc4_att.nc"
/* Create a classic and a netcdf-4 file. */
if (nc_create(FILE_CLASSIC, 0, &ncid_classic)) ERR;
if (nc_create(FILE_NC4, NC_NETCDF4|NC_CLASSIC_MODEL, &ncid_nc4)) ERR;
/* Write an att to both. */
if (nc_put_att_text(ncid_classic, NC_GLOBAL, INST_NAME, strlen(INSTITUTION) + 1, INSTITUTION)) ERR;
if (nc_put_att_text(ncid_nc4, NC_GLOBAL, INST_NAME, strlen(INSTITUTION) + 1, INSTITUTION)) ERR;
/* Close them. */
if (nc_close(ncid_classic)) ERR;
if (nc_close(ncid_nc4)) ERR;
/* Reopen the files. */
if (nc_open(FILE_CLASSIC, 0, &ncid_classic)) ERR;
if (nc_open(FILE_NC4, 0, &ncid_nc4)) ERR;
/* I'll show you mine, if you show me yours... */
if (nc_get_att_text(ncid_classic, NC_GLOBAL, INST_NAME, att_in_classic)) ERR;
if (nc_get_att_text(ncid_nc4, NC_GLOBAL, INST_NAME, att_in_nc4)) ERR;
if (strcmp(att_in_classic, INSTITUTION) || strcmp(att_in_nc4, INSTITUTION) ||
strcmp(att_in_classic, att_in_nc4)) ERR;
if (memcmp(att_in_classic, att_in_nc4, strlen(INSTITUTION) + 1)) ERR;
/* Close them. */
if (nc_close(ncid_classic)) ERR;
if (nc_close(ncid_nc4)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing ar-4 example metadata with ncgen-generated code...");
{
int stat; /* return status */
int ncid; /* netCDF id */
/* group ids */
int root_grp;
/* dimension ids */
int lon_dim;
int lat_dim;
int bnds_dim;
int time_dim;
/* dimension lengths */
size_t lon_len = 256;
size_t lat_len = 128;
size_t bnds_len = 2;
size_t time_len = NC_UNLIMITED;
/* variable ids */
int lon_bnds_id;
int lat_bnds_id;
int time_bnds_id;
int time_id;
int lat_id;
int lon_id;
int pr_id;
/* rank (number of dimensions) for each variable */
# define RANK_lon_bnds 2
# define RANK_lat_bnds 2
# define RANK_time_bnds 2
# define RANK_time 1
# define RANK_lat 1
# define RANK_lon 1
# define RANK_pr 3
/* variable shapes */
int lon_bnds_dims[RANK_lon_bnds];
int lat_bnds_dims[RANK_lat_bnds];
int time_bnds_dims[RANK_time_bnds];
int time_dims[RANK_time];
int lat_dims[RANK_lat];
int lon_dims[RANK_lon];
int pr_dims[RANK_pr];
/* enter define mode */
stat = nc_create(FILE_NAME, NC_NETCDF4 | NC_CLASSIC_MODEL, &ncid);
check_err(stat,__LINE__,__FILE__);
root_grp = ncid;
/* define dimensions */
stat = nc_def_dim(root_grp, "lon", lon_len, &lon_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(root_grp, "lat", lat_len, &lat_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(root_grp, "bnds", bnds_len, &bnds_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(root_grp, "time", time_len, &time_dim);
check_err(stat,__LINE__,__FILE__);
/* define variables */
lon_bnds_dims[0] = lon_dim;
lon_bnds_dims[1] = bnds_dim;
stat = nc_def_var(root_grp, "lon_bnds", NC_DOUBLE, RANK_lon_bnds, lon_bnds_dims, &lon_bnds_id);
check_err(stat,__LINE__,__FILE__);
lat_bnds_dims[0] = lat_dim;
lat_bnds_dims[1] = bnds_dim;
stat = nc_def_var(root_grp, "lat_bnds", NC_DOUBLE, RANK_lat_bnds, lat_bnds_dims, &lat_bnds_id);
check_err(stat,__LINE__,__FILE__);
time_bnds_dims[0] = time_dim;
time_bnds_dims[1] = bnds_dim;
stat = nc_def_var(root_grp, "time_bnds", NC_DOUBLE, RANK_time_bnds, time_bnds_dims, &time_bnds_id);
check_err(stat,__LINE__,__FILE__);
time_dims[0] = time_dim;
stat = nc_def_var(root_grp, "time", NC_DOUBLE, RANK_time, time_dims, &time_id);
check_err(stat,__LINE__,__FILE__);
lat_dims[0] = lat_dim;
stat = nc_def_var(root_grp, "lat", NC_DOUBLE, RANK_lat, lat_dims, &lat_id);
check_err(stat,__LINE__,__FILE__);
lon_dims[0] = lon_dim;
stat = nc_def_var(root_grp, "lon", NC_DOUBLE, RANK_lon, lon_dims, &lon_id);
check_err(stat,__LINE__,__FILE__);
pr_dims[0] = time_dim;
pr_dims[1] = lat_dim;
pr_dims[2] = lon_dim;
stat = nc_def_var(root_grp, "pr", NC_FLOAT, RANK_pr, pr_dims, &pr_id);
check_err(stat,__LINE__,__FILE__);
/* assign global attributes */
{ /* table_id */
static const char table_id_att[8] = {"Table A1"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "table_id", 8, table_id_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* title */
static const char title_att[34] = {"model output prepared for IPCC AR4"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "title", 34, title_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* institution */
static const char institution_att[66] = {INSTITUTION} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, INST_NAME, 66, institution_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* source */
static const char source_att[153] = {"CCSM3.0, version vector05 (2004): \natmosphere: CAM3.0, T85L26;\nocean : POP1.4.3 (modified), gx1v3\nsea ice : CSIM5.0, gx1v3;\nland : CLM3.0, T85"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "source", 153, source_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* contact */
static const char contact_att[13] = {"*****@*****.**"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "contact", 13, contact_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* project_id */
static const char project_id_att[22] = {"IPCC Fourth Assessment"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "project_id", 22, project_id_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* Conventions */
static const char Conventions_att[6] = {"CF-1.0"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "Conventions", 6, Conventions_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* references */
static const char references_att[137] = {"Collins, W.D., et al., 2005:\n The Community Climate System Model, Version 3\n Journal of Climate\n \n Main website: http://www.ccsm.ucar.edu"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "references", 137, references_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* acknowledgment */
static const char acknowledgment_att[847] = {" Any use of CCSM data should acknowledge the contribution\n of the CCSM project and CCSM sponsor agencies with the \n following citation:\n 'This research uses data provided by the Community Climate\n System Model project (www.ccsm.ucar.edu), supported by the\n Directorate for Geosciences of the National Science Foundation\n and the Office of Biological and Environmental Research of\n the U.S. Department of Energy.'\nIn addition, the words 'Community Climate System Model' and\n 'CCSM' should be included as metadata for webpages referencing\n work using CCSM data or as keywords provided to journal or book\npublishers of your manuscripts.\nUsers of CCSM data accept the responsibility of emailing\n citations of publications of research using CCSM data to\n [email protected].\nAny redistribution of CCSM data must include this data\n acknowledgement statement."} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "acknowledgment", 847, acknowledgment_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* realization */
static const int realization_att[1] = {8} ;
stat = nc_put_att_int(root_grp, NC_GLOBAL, "realization", NC_INT, 1, realization_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* experiment_id */
static const char experiment_id_att[46] = {"climate of the 20th Century experiment (20C3M)"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "experiment_id", 46, experiment_id_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* history */
static const char history_att[139] = {"Created from CCSM3 case b30.030g.ES01\n by [email protected]\n on Wed Sep 10 12:22:06 MDT 2008\n \n For all data, added IPCC requested metadata"} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "history", 139, history_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* comment */
static const char comment_att[1105] = {"This simulation was initiated from year 460 of \n CCSM3 model run b30.020.ES01 and executed on \n hardware Earth Simulator Center, JAMSTEC. The input external forcings are\nozone forcing : mozart.o3.128x64_L18_1870-2000_c040515.nc\naerosol optics : AerosolOptics_c040105.nc\naerosol MMR : AerosolMass_V_128x256_clim_c031022.nc\ncarbon scaling : carbonscaling_1870-2000_c040225.nc\nsolar forcing : scon_lean_1870-2100_c040123.nc\nGHGs : ghg_1870_2100_c040122.nc\nGHG loss rates : noaamisc.r8.nc\nvolcanic forcing : VolcanicMass_1870-1999_64x1_L18_c040123.nc\nDMS emissions : DMS_emissions_128x256_clim_c040122.nc\noxidants : oxid_128x256_L26_clim_c040112.nc\nSOx emissions : SOx_emissions_128x256_L2_1850-2000_c040321.nc\n Physical constants used for derived data:\n Lv (latent heat of evaporation): 2.501e6 J kg-1\n Lf (latent heat of fusion ): 3.337e5 J kg-1\n r[h2o] (density of water ): 1000 kg m-3\n g2kg (grams to kilograms ): 1000 g kg-1\n \n Integrations were performed by NCAR and CRIEPI with support\n and facilities provided by NSF, DOE, MEXT and ESC/JAMSTEC."} ;
stat = nc_put_att_text(root_grp, NC_GLOBAL, "comment", 1105, comment_att);
check_err(stat,__LINE__,__FILE__);
}
/* assign per-variable attributes */
{ /* calendar */
static const char time_calendar_att[6] = {"noleap"} ;
stat = nc_put_att_text(root_grp, time_id, "calendar", 6, time_calendar_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* standard_name */
static const char time_standard_name_att[4] = {"time"} ;
stat = nc_put_att_text(root_grp, time_id, "standard_name", 4, time_standard_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* axis */
static const char time_axis_att[1] = {"T"} ;
stat = nc_put_att_text(root_grp, time_id, "axis", 1, time_axis_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* units */
static const char time_units_att[19] = {"days since 0000-1-1"} ;
stat = nc_put_att_text(root_grp, time_id, "units", 19, time_units_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* bounds */
static const char time_bounds_att[9] = {"time_bnds"} ;
stat = nc_put_att_text(root_grp, time_id, "bounds", 9, time_bounds_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* long_name */
static const char time_long_name_att[4] = {"time"} ;
stat = nc_put_att_text(root_grp, time_id, "long_name", 4, time_long_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* axis */
static const char lat_axis_att[1] = {"Y"} ;
stat = nc_put_att_text(root_grp, lat_id, "axis", 1, lat_axis_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* standard_name */
static const char lat_standard_name_att[8] = {"latitude"} ;
stat = nc_put_att_text(root_grp, lat_id, "standard_name", 8, lat_standard_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* bounds */
static const char lat_bounds_att[8] = {"lat_bnds"} ;
stat = nc_put_att_text(root_grp, lat_id, "bounds", 8, lat_bounds_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* long_name */
static const char lat_long_name_att[8] = {"latitude"} ;
stat = nc_put_att_text(root_grp, lat_id, "long_name", 8, lat_long_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* units */
static const char lat_units_att[13] = {"degrees_north"} ;
stat = nc_put_att_text(root_grp, lat_id, "units", 13, lat_units_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* axis */
static const char lon_axis_att[1] = {"X"} ;
stat = nc_put_att_text(root_grp, lon_id, "axis", 1, lon_axis_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* standard_name */
static const char lon_standard_name_att[9] = {"longitude"} ;
stat = nc_put_att_text(root_grp, lon_id, "standard_name", 9, lon_standard_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* bounds */
static const char lon_bounds_att[8] = {"lon_bnds"} ;
stat = nc_put_att_text(root_grp, lon_id, "bounds", 8, lon_bounds_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* long_name */
static const char lon_long_name_att[9] = {"longitude"} ;
stat = nc_put_att_text(root_grp, lon_id, "long_name", 9, lon_long_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* units */
static const char lon_units_att[12] = {"degrees_east"} ;
stat = nc_put_att_text(root_grp, lon_id, "units", 12, lon_units_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* comment */
static const char pr_comment_att[60] = {"Created using NCL code CCSM_atmm_2cf.ncl on\n machine mineral"} ;
stat = nc_put_att_text(root_grp, pr_id, "comment", 60, pr_comment_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* missing_value */
static const float pr_missing_value_att[1] = {1e+20} ;
stat = nc_put_att_float(root_grp, pr_id, "missing_value", NC_FLOAT, 1, pr_missing_value_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* _FillValue */
static const float pr_FillValue_att[1] = {1e+20} ;
stat = nc_put_att_float(root_grp, pr_id, "_FillValue", NC_FLOAT, 1, pr_FillValue_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* cell_methods */
static const char pr_cell_methods_att[30] = {"time: mean (interval: 1 month)"} ;
stat = nc_put_att_text(root_grp, pr_id, "cell_methods", 30, pr_cell_methods_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* history */
static const char pr_history_att[20] = {"(PRECC+PRECL)*r[h2o]"} ;
stat = nc_put_att_text(root_grp, pr_id, "history", 20, pr_history_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* original_units */
static const char pr_original_units_att[7] = {"m-1 s-1"} ;
stat = nc_put_att_text(root_grp, pr_id, "original_units", 7, pr_original_units_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* original_name */
static const char pr_original_name_att[12] = {"PRECC, PRECL"} ;
stat = nc_put_att_text(root_grp, pr_id, "original_name", 12, pr_original_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* standard_name */
static const char pr_standard_name_att[18] = {"precipitation_flux"} ;
stat = nc_put_att_text(root_grp, pr_id, "standard_name", 18, pr_standard_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* units */
static const char pr_units_att[10] = {"kg m-2 s-1"} ;
stat = nc_put_att_text(root_grp, pr_id, "units", 10, pr_units_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* long_name */
static const char pr_long_name_att[18] = {"precipitation_flux"} ;
stat = nc_put_att_text(root_grp, pr_id, "long_name", 18, pr_long_name_att);
check_err(stat,__LINE__,__FILE__);
}
{ /* cell_method */
static const char pr_cell_method_att[10] = {"time: mean"} ;
stat = nc_put_att_text(root_grp, pr_id, "cell_method", 10, pr_cell_method_att);
check_err(stat,__LINE__,__FILE__);
}
/* don't initialize variables with fill values */
stat = nc_set_fill(root_grp, NC_NOFILL, 0);
check_err(stat,__LINE__,__FILE__);
/* leave define mode */
stat = nc_enddef (root_grp);
check_err(stat,__LINE__,__FILE__);
stat = nc_close(root_grp);
check_err(stat,__LINE__,__FILE__);
{
#define NDIMS4 4
int ndims, dimids_in[NDIMS4];
char name_in[NC_MAX_NAME + 1];
char institution_att_in[NC_MAX_NAME + 1];
/* Now open this file and check order of dimensions. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check dimids. */
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, "lon")) ERR;
if (nc_inq_dimname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, "lat")) ERR;
if (nc_inq_dimname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, "bnds")) ERR;
if (nc_inq_dimname(ncid, 3, name_in)) ERR;
if (strcmp(name_in, "time")) ERR;
/* Check inq_dimids function. */
if (nc_inq_dimids(ncid, &ndims, dimids_in, 0)) ERR;
if (ndims != NDIMS4 || dimids_in[0] != 0 || dimids_in[1] != 1 ||
dimids_in[2] != 2 || dimids_in[3] != 3) ERR;
/* Check attribute with line breaks. */
if (nc_get_att_text(ncid, NC_GLOBAL, INST_NAME,
institution_att_in)) ERR;
if (strncmp(institution_att_in, INSTITUTION, strlen(INSTITUTION))) ERR;
if (nc_close(ncid)) ERR;
}
}
SUMMARIZE_ERR;
printf("**** testing dim order when coord vars are defined in the wrong order...");
{
#define RANK_2 2
#define DIM0 "d0"
#define DIM1 "d1"
int ncid, dimids[RANK_2], varid[RANK_2];
char name_in[NC_MAX_NAME + 1];
/* Create a test file. */
if (nc_create(FILE_NAME, NC_CLASSIC_MODEL|NC_NETCDF4, &ncid)) ERR;
/* Define dimensions in order. */
if (nc_def_dim(ncid, DIM0, NC_UNLIMITED, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM1, 4, &dimids[1])) ERR;
/* Define coordinate variables in a different order. */
if (nc_def_var(ncid, DIM1, NC_DOUBLE, 1, &dimids[1], &varid[1])) ERR;
if (nc_def_var(ncid, DIM0, NC_DOUBLE, 1, &dimids[0], &varid[0])) ERR;
/* That's it! */
if (nc_close(ncid)) ERR;
/* Reopen the file and check dimension order. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, DIM0)) ERR;
if (nc_inq_dimname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, DIM1)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing order of coordinate dims...");
{
#define RANK_3 3
#define DIM1_NAME "d1"
#define DIM2_NAME "d2"
#define DIM3_NAME "d3"
int ncid, dimids[RANK_3], varid[RANK_3];
char name_in[NC_MAX_NAME + 1];
/* Create a 3D test file. */
if (nc_create(FILE_NAME, NC_CLASSIC_MODEL|NC_NETCDF4, &ncid)) ERR;
/* Define dimensions in order. */
if (nc_def_dim(ncid, DIM1_NAME, NC_UNLIMITED, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, 4, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, 3, &dimids[2])) ERR;
/* Define coordinate variables in a different order. */
if (nc_def_var(ncid, DIM1_NAME, NC_DOUBLE, 1, &dimids[0], &varid[0])) ERR;
if (nc_def_var(ncid, DIM2_NAME, NC_DOUBLE, 1, &dimids[1], &varid[1])) ERR;
if (nc_def_var(ncid, DIM3_NAME, NC_DOUBLE, 1, &dimids[2], &varid[2])) ERR;
/* That's it! */
if (nc_close(ncid)) ERR;
/* Reopen the file and check dimension order. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, DIM1_NAME)) ERR;
if (nc_inq_dimname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, DIM2_NAME)) ERR;
if (nc_inq_dimname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, DIM3_NAME)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing coordinate vars...");
{
# define RANK_Coordinates_lat 1
int ncid;
int Coordinates_grp;
int lat_dim;
size_t lat_len = 3;
int Coordinates_lat_id;
if(nc_create(FILE_NAME, NC_CLOBBER|NC_NETCDF4, &ncid)) ERR;
if (nc_def_grp(ncid, "Coordinates", &Coordinates_grp)) ERR;
/* Define dimensions in root group. */
if (nc_def_dim(ncid, "lat", lat_len, &lat_dim)) ERR;
/* Define coordinate variable in Coordinates group. */
if (nc_def_var(Coordinates_grp, "lat", NC_FLOAT,
1, &lat_dim, &Coordinates_lat_id)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing 2D non-coordinate variable...");
{
#define VAR_NAME "Britany"
#define NDIMS 2
#define TEXT_LEN 15
#define D0_NAME "time"
#define D1_NAME "tl"
int ncid, nvars_in, varids_in[1];
int time_dimids[NDIMS], time_id;
size_t time_count[NDIMS], time_index[NDIMS] = {0, 0};
const char ttext[TEXT_LEN]="20051224.150000";
int nvars, ndims, ngatts, unlimdimid;
int ndims_in, natts_in, dimids_in[NDIMS];
char var_name_in[NC_MAX_NAME + 1];
nc_type xtype_in;
/* Create a netcdf-4 file with 2D coordinate var. */
if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
if (nc_def_dim(ncid, D0_NAME, NC_UNLIMITED, &time_dimids[0])) ERR;
if (nc_def_dim(ncid, D1_NAME, TEXT_LEN, &time_dimids[1])) ERR;
if (nc_def_var(ncid, VAR_NAME, NC_USHORT, NDIMS, time_dimids,
&time_id) != NC_ESTRICTNC3) ERR;
if (nc_def_var(ncid, VAR_NAME, NC_CHAR, NDIMS, time_dimids, &time_id)) ERR;
if (nc_enddef(ncid)) ERR;
/* Write one time to the coordinate variable. */
time_count[0] = 1;
time_count[1] = TEXT_LEN;
if (nc_put_vara_text(ncid, time_id, time_index, time_count, ttext)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 1 || ndims != 2 || ngatts != 0 || unlimdimid != 0) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 1 || varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, VAR_NAME) || xtype_in != NC_CHAR || ndims_in != 2 ||
dimids_in[0] != 0 || dimids_in[1] != 1 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing 2D coordinate variable...");
{
#define NDIMS 2
#define TEXT_LEN 15
#define D0_NAME "time"
#define D1_NAME "tl"
int ncid, nvars_in, varids_in[1];
int time_dimids[NDIMS], time_id;
size_t time_count[NDIMS], time_index[NDIMS] = {0, 0};
const char ttext[TEXT_LEN + 1]="20051224.150000";
int nvars, ndims, ngatts, unlimdimid;
int ndims_in, natts_in, dimids_in[NDIMS];
char var_name_in[NC_MAX_NAME + 1];
nc_type xtype_in;
/* Create a netcdf-4 file with 2D coordinate var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, D0_NAME, NC_UNLIMITED, &time_dimids[0])) ERR;
if (nc_def_dim(ncid, D1_NAME, TEXT_LEN, &time_dimids[1])) ERR;
if (nc_def_var(ncid, D0_NAME, NC_CHAR, NDIMS, time_dimids, &time_id)) ERR;
/* Write one time to the coordinate variable. */
time_count[0] = 1;
time_count[1] = TEXT_LEN;
if (nc_put_vara_text(ncid, time_id, time_index, time_count, ttext)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 1 || ndims != 2 || ngatts != 0 || unlimdimid != 0) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 1 || varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, D0_NAME) || xtype_in != NC_CHAR || ndims_in != 2 ||
dimids_in[0] != 0 || dimids_in[1] != 1 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing new order of doing things with coordinate variable...");
{
/* In this test:
define a dimension
define a variable that uses that dimension
put values in the variable
define coordinate values for the dimension
*/
#define VAR_NAME_BB "The_Birth_of_Britain"
#define NDIMS_1 1
#define TEXT_LEN 15
#define WINSTON_CHURCHILL "Winston_S_Churchill"
#define D0_LEN 2
#define NUM_VARS_2 2
int ncid, nvars_in, varids_in[NUM_VARS_2];
int dimid, varid, varid2;
int nvars, ndims, ngatts, unlimdimid;
int ndims_in, natts_in, dimids_in[NDIMS];
char var_name_in[NC_MAX_NAME + 1];
nc_type xtype_in;
int data[D0_LEN] = {42, -42};
/* Create a netcdf-4 file with 2D coordinate var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, WINSTON_CHURCHILL, NC_UNLIMITED, &dimid)) ERR;
if (nc_def_var(ncid, VAR_NAME, NC_INT, NDIMS_1, &dimid, &varid)) ERR;
if (nc_put_var_int(ncid, varid, data)) ERR;
if (nc_def_var(ncid, WINSTON_CHURCHILL, NC_INT, NDIMS_1, &dimid, &varid2)) ERR;
if (nc_put_var_int(ncid, varid2, data)) ERR;
/* Check things. */
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 2 || ndims != 1 || ngatts != 0 || unlimdimid != 0) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, VAR_NAME) || xtype_in != NC_INT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != 2 || ndims != 1 || ngatts != 0 || unlimdimid != 0) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, VAR_NAME) || xtype_in != NC_INT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("**** testing 2D coordinate variable with dimensions defined in different order...");
{
#define NDIMS 2
#define TEXT_LEN 15
#define D0_NAME "time"
#define D1_NAME "tl"
#define NUM_VARS 2
int ncid, nvars_in, varids_in[NUM_VARS];
int time_dimids[NDIMS], time_id, tl_id;
size_t time_count[NDIMS], time_index[NDIMS] = {0, 0};
const char ttext[TEXT_LEN + 1]="20051224.150000";
char ttext_in[TEXT_LEN + 1];
int nvars, ndims, ngatts, unlimdimid;
int ndims_in, natts_in, dimids_in[NDIMS];
char var_name_in[NC_MAX_NAME + 1], dim_name_in[NC_MAX_NAME + 1];
size_t len_in;
nc_type xtype_in;
/* Create a netcdf-4 file with 2D coordinate var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, D1_NAME, TEXT_LEN, &time_dimids[1])) ERR;
if (nc_def_dim(ncid, D0_NAME, NC_UNLIMITED, &time_dimids[0])) ERR;
if (nc_def_var(ncid, D0_NAME, NC_CHAR, NDIMS, time_dimids, &time_id)) ERR;
if (nc_def_var(ncid, D1_NAME, NC_CHAR, 1, &time_dimids[0], &tl_id)) ERR;
/* Write one time to the coordinate variable. */
time_count[0] = 1;
time_count[1] = TEXT_LEN;
if (nc_put_vara_text(ncid, time_id, time_index, time_count, ttext)) ERR;
/* Check the data. */
if (nc_get_vara_text(ncid, time_id, time_index, time_count, ttext_in)) ERR;
if (strncmp(ttext, ttext_in, TEXT_LEN)) ERR;
/* Close up. */
if (nc_close(ncid)) ERR;
/* Open the file and check. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &ngatts, &unlimdimid)) ERR;
if (nvars != NUM_VARS || ndims != NDIMS || ngatts != 0 || unlimdimid != 1) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != NUM_VARS || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_inq_var(ncid, 0, var_name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(var_name_in, D0_NAME) || xtype_in != NC_CHAR || ndims_in != NDIMS ||
dimids_in[0] != 1 || dimids_in[1] != 0 || natts_in != 0) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != NDIMS || dimids_in[0] != 0 || dimids_in[1] != 1) ERR;
if (nc_inq_dim(ncid, 0, dim_name_in, &len_in)) ERR;
if (strcmp(dim_name_in, D1_NAME) || len_in != TEXT_LEN) ERR;
if (nc_inq_dim(ncid, 1, dim_name_in, &len_in)) ERR;
if (strcmp(dim_name_in, D0_NAME) || len_in != 1) ERR;
/* Check the data. */
if (nc_get_vara_text(ncid, time_id, time_index, time_count, ttext_in)) ERR;
if (strncmp(ttext, ttext_in, TEXT_LEN)) ERR;
/* Close up. */
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
void step1(int *n, int nthreads) {
int nprocs, procid;
MPI_Comm_rank(MPI_COMM_WORLD, &procid);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* Create Cartesian Communicator */
int c_dims[2] = { 0 };
MPI_Comm c_comm;
accfft_create_comm(MPI_COMM_WORLD, c_dims, &c_comm);
float *data;
Complexf *data_hat;
double f_time = 0 * MPI_Wtime(), i_time = 0, setup_time = 0;
int alloc_max = 0;
int isize[3], osize[3], istart[3], ostart[3];
/* Get the local pencil size and the allocation size */
alloc_max = accfft_local_size_dft_r2cf(n, isize, istart, osize, ostart,
c_comm);
data = (float*) accfft_alloc(alloc_max);
data_hat = (Complexf*) accfft_alloc(alloc_max);
accfft_init(nthreads);
/* Create FFT plan */
setup_time = -MPI_Wtime();
accfft_planf * plan = accfft_plan_dft_3d_r2cf(n, data, (float*) data_hat,
c_comm, ACCFFT_MEASURE);
setup_time += MPI_Wtime();
/* Warm Up */
accfft_execute_r2cf(plan, data, data_hat);
accfft_execute_r2cf(plan, data, data_hat);
/* Initialize data */
initialize(data, n, c_comm);
MPI_Barrier(c_comm);
/* Perform forward FFT */
f_time -= MPI_Wtime();
accfft_execute_r2cf(plan, data, data_hat);
f_time += MPI_Wtime();
MPI_Barrier(c_comm);
float * data2 = (float*) accfft_alloc(
isize[0] * isize[1] * isize[2] * sizeof(float));
/* Perform backward FFT */
i_time -= MPI_Wtime();
accfft_execute_c2rf(plan, data_hat, data2);
i_time += MPI_Wtime();
/* Check Error */
check_err(data2, n, c_comm);
/* Compute some timings statistics */
double g_f_time, g_i_time, g_setup_time;
MPI_Reduce(&f_time, &g_f_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&i_time, &g_i_time, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
MPI_Reduce(&setup_time, &g_setup_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
PCOUT << "Timing for FFT of size " << n[0] << "*" << n[1] << "*" << n[2]
<< std::endl;
PCOUT << "Setup \t" << g_setup_time << std::endl;
PCOUT << "FFT \t" << g_f_time << std::endl;
PCOUT << "IFFT \t" << g_i_time << std::endl;
accfft_free(data);
accfft_free(data_hat);
accfft_free(data2);
accfft_destroy_plan(plan);
accfft_cleanup();
MPI_Comm_free(&c_comm);
return;
} // end step1
int
run_file_tests(char *testfile)
{
int ret = -1;
struct stat buf;
assert(testfile);
fprintf(stdout, "Testing creat");
ret = creat(testfile, S_IRWXU);
check_err(ret, "creat", 2);
fprintf(stdout, "Testing close");
ret = close(ret);
check_err(ret, "close", 2);
fprintf(stdout, "Testing open");
ret = open(testfile, O_RDONLY);
check_err(ret, "open", 2);
fprintf(stdout, "Testing read");
ret = read(0, NULL, 0);
check_err(ret, "read", 2);
fprintf(stdout, "Testing readv");
ret = readv(0, NULL, 0);
check_err(ret, "readv", 2);
fprintf(stdout, "Testing pread");
ret = pread(0, NULL, 0, 0);
check_err(ret, "pread", 2);
fprintf(stdout, "Testing write");
ret = write(0, NULL, 0);
check_err(ret, "write", 2);
fprintf(stdout, "Testing writev");
ret = writev(0, NULL, 0);
check_err(ret, "writev", 2);
fprintf(stdout, "Testing pwrite");
ret = pwrite(0, NULL, 0, 0);
check_err(ret, "pwrite", 2);
fprintf(stdout, "Testing lseek");
ret = lseek(0, 0, 0);
check_err(ret, "lseek", 2);
fprintf(stdout, "Testing dup");
ret = dup(0);
check_err(ret, "dup", 2);
fprintf(stdout, "Testing dup2");
ret = dup2(0, 0);
check_err(ret, "dup2", 2);
fprintf(stdout, "Testing fchmod");
ret = fchmod(0, 0);
check_err(ret, "fchmod", 2);
fprintf(stdout, "Testing fchown");
ret = fchown(0, 0, 0);
check_err(ret, "fchown", 2);
fprintf(stdout, "Testing fsync");
ret = fsync(0);
check_err(ret, "fsync", 2);
fprintf(stdout, "Testing ftruncate");
ret = ftruncate(0, 0);
check_err(ret, "ftruncate", 1);
fprintf(stdout, "Testing fstat");
ret = fstat(0, &buf);
check_err(ret, "fstat", 1);
fprintf(stdout, "Testing sendfile");
ret = sendfile(0, 0, NULL, 0);
check_err(ret, "sendfile", 1);
fprintf(stdout, "Testing fcntl");
ret = fcntl(0, 0, NULL);
check_err(ret, "fcntl", 2);
fprintf(stdout, "Testing close");
ret = close(ret);
check_err(ret, "close", 2);
fprintf(stdout, "Testing remove");
ret = remove(testfile);
check_err(ret, "remove", 2);
return ret;
}
void seissol::LoopStatistics::writeSamples() {
std::string loopStatFile = utils::Env::get<std::string>("SEISSOL_LOOP_STAT_PREFIX", "");
if (!loopStatFile.empty()) {
#if defined(USE_NETCDF) && defined(USE_MPI)
unsigned nRegions = m_times.size();
for (unsigned region = 0; region < nRegions; ++region) {
std::ofstream file;
std::stringstream ss;
ss << loopStatFile << m_regions[region] << ".nc";
std::string fileName = ss.str();
int nSamples = m_times[region].size();
int sampleOffset;
MPI_Scan(&nSamples, &sampleOffset, 1, MPI_INT, MPI_SUM, seissol::MPI::mpi.comm());
int ncid, stat;
stat = nc_create_par(fileName.c_str(), NC_MPIIO | NC_CLOBBER | NC_NETCDF4, seissol::MPI::mpi.comm(), MPI_INFO_NULL, &ncid); check_err(stat,__LINE__,__FILE__);
int sampledim, rankdim, sampletyp, offsetid, sampleid;
stat = nc_def_dim(ncid, "rank", 1+seissol::MPI::mpi.size(), &rankdim); check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "sample", NC_UNLIMITED, &sampledim); check_err(stat,__LINE__,__FILE__);
stat = nc_def_compound(ncid, sizeof(Sample), "Sample", &sampletyp); check_err(stat,__LINE__,__FILE__);
{
stat = nc_insert_compound(ncid, sampletyp, "time", NC_COMPOUND_OFFSET(Sample,time), NC_DOUBLE); check_err(stat,__LINE__,__FILE__);
stat = nc_insert_compound(ncid, sampletyp, "loopLength", NC_COMPOUND_OFFSET(Sample,numIters), NC_UINT); check_err(stat,__LINE__,__FILE__);
}
stat = nc_def_var(ncid, "offset", NC_INT, 1, &rankdim, &offsetid); check_err(stat,__LINE__,__FILE__);
stat = nc_def_var(ncid, "sample", sampletyp, 1, &sampledim, &sampleid); check_err(stat,__LINE__,__FILE__);
stat = nc_enddef(ncid); check_err(stat,__LINE__,__FILE__);
stat = nc_var_par_access(ncid, offsetid, NC_COLLECTIVE); check_err(stat,__LINE__,__FILE__);
stat = nc_var_par_access(ncid, sampleid, NC_COLLECTIVE); check_err(stat,__LINE__,__FILE__);
size_t start, count;
int offsetData[2];
if (seissol::MPI::mpi.rank() == 0) {
start = 0;
count = 2;
offsetData[0] = 0;
} else {
start = 1+seissol::MPI::mpi.rank();
count = 1;
}
offsetData[count-1] = sampleOffset;
stat = nc_put_vara_int(ncid, offsetid, &start, &count, offsetData); check_err(stat,__LINE__,__FILE__);
start = sampleOffset-nSamples;
count = nSamples;
stat = nc_put_vara(ncid, sampleid, &start, &count, m_times[region].data()); check_err(stat,__LINE__,__FILE__);
stat = nc_close(ncid); check_err(stat,__LINE__,__FILE__);
}
#else
logWarning(seissol::MPI::mpi.rank()) << "Writing loop statistics requires NetCDF and MPI.";
#endif
}
}
void step3_gpu(int *n) {
int nprocs, procid;
MPI_Comm_rank(MPI_COMM_WORLD, &procid);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* Create Cartesian Communicator */
int c_dims[2]={0};
MPI_Comm c_comm;
accfft_create_comm(MPI_COMM_WORLD,c_dims,&c_comm);
Complexf *data, *data_cpu;
Complexf *data_hat;
double f_time=0*MPI_Wtime(),i_time=0, setup_time=0;
int alloc_max=0;
int isize[3],osize[3],istart[3],ostart[3];
/* Get the local pencil size and the allocation size */
alloc_max=accfft_local_size_dft_c2c_gpuf(n,isize,istart,osize,ostart,c_comm);
#ifdef INPLACE
data_cpu=(Complexf*)malloc(alloc_max);
cudaMalloc((void**) &data, alloc_max);
#else
data_cpu=(Complexf*)malloc(isize[0]*isize[1]*isize[2]*2*sizeof(float));
cudaMalloc((void**) &data,isize[0]*isize[1]*isize[2]*2*sizeof(float));
cudaMalloc((void**) &data_hat, alloc_max);
#endif
//accfft_init(nthreads);
setup_time=-MPI_Wtime();
/* Create FFT plan */
#ifdef INPLACE
accfft_plan_gpuf * plan=accfft_plan_dft_3d_c2c_gpuf(n,data,data,c_comm,ACCFFT_MEASURE);
#else
accfft_plan_gpuf * plan=accfft_plan_dft_3d_c2c_gpuf(n,data,data_hat,c_comm,ACCFFT_MEASURE);
#endif
setup_time+=MPI_Wtime();
/* Warmup Runs */
#ifdef INPLACE
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data);
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data);
#else
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data_hat);
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data_hat);
#endif
/* Initialize data */
initialize(data_cpu,n,c_comm);
#ifdef INPLACE
cudaMemcpy(data, data_cpu,alloc_max, cudaMemcpyHostToDevice);
#else
cudaMemcpy(data, data_cpu,isize[0]*isize[1]*isize[2]*2*sizeof(float), cudaMemcpyHostToDevice);
#endif
MPI_Barrier(c_comm);
/* Perform forward FFT */
f_time-=MPI_Wtime();
#ifdef INPLACE
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data);
#else
accfft_execute_c2c_gpuf(plan,ACCFFT_FORWARD,data,data_hat);
#endif
f_time+=MPI_Wtime();
MPI_Barrier(c_comm);
#ifndef INPLACE
Complexf *data2_cpu, *data2;
cudaMalloc((void**) &data2, isize[0]*isize[1]*isize[2]*2*sizeof(float));
data2_cpu=(Complexf*) malloc(isize[0]*isize[1]*isize[2]*2*sizeof(float));
#endif
/* Perform backward FFT */
i_time-=MPI_Wtime();
#ifdef INPLACE
accfft_execute_c2c_gpuf(plan,ACCFFT_BACKWARD,data,data);
#else
accfft_execute_c2c_gpuf(plan,ACCFFT_BACKWARD,data_hat,data2);
#endif
i_time+=MPI_Wtime();
/* copy back results on CPU and check error*/
#ifdef INPLACE
cudaMemcpy(data_cpu, data, alloc_max, cudaMemcpyDeviceToHost);
check_err(data_cpu,n,c_comm);
#else
cudaMemcpy(data2_cpu, data2, isize[0]*isize[1]*isize[2]*2*sizeof(float), cudaMemcpyDeviceToHost);
check_err(data2_cpu,n,c_comm);
#endif
/* Compute some timings statistics */
double g_f_time, g_i_time, g_setup_time;
MPI_Reduce(&f_time,&g_f_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
MPI_Reduce(&i_time,&g_i_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
MPI_Reduce(&setup_time,&g_setup_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
#ifdef INPLACE
PCOUT<<"GPU Timing for Inplace FFT of size "<<n[0]<<"*"<<n[1]<<"*"<<n[2]<<std::endl;
#else
PCOUT<<"GPU Timing for Outplace FFT of size "<<n[0]<<"*"<<n[1]<<"*"<<n[2]<<std::endl;
#endif
PCOUT<<"Setup \t"<<g_setup_time<<std::endl;
PCOUT<<"FFT \t"<<g_f_time<<std::endl;
PCOUT<<"IFFT \t"<<g_i_time<<std::endl;
MPI_Barrier(c_comm);
cudaDeviceSynchronize();
free(data_cpu);
cudaFree(data);
#ifndef INPLACE
cudaFree(data_hat);
free(data2_cpu);
cudaFree(data2);
#endif
accfft_destroy_plan_gpu(plan);
accfft_cleanup_gpuf();
MPI_Comm_free(&c_comm);
return ;
} // end step3_gpu
void do_m68k_simcall(CPUM68KState *env, int nr)
{
uint32_t *args;
args = (uint32_t *)(env->aregs[7] + 4);
switch (nr) {
case SYS_EXIT:
exit(ARG(0));
case SYS_READ:
check_err(env, read(ARG(0), (void *)ARG(1), ARG(2)));
break;
case SYS_WRITE:
check_err(env, write(ARG(0), (void *)ARG(1), ARG(2)));
break;
case SYS_OPEN:
check_err(env, open((char *)ARG(0), translate_openflags(ARG(1)),
ARG(2)));
break;
case SYS_CLOSE:
{
/* Ignore attempts to close stdin/out/err. */
int fd = ARG(0);
if (fd > 2)
check_err(env, close(fd));
else
check_err(env, 0);
break;
}
case SYS_BRK:
{
int32_t ret;
ret = do_brk((void *)ARG(0));
if (ret == -ENOMEM)
ret = -1;
check_err(env, ret);
}
break;
case SYS_FSTAT:
{
struct stat s;
int rc;
struct m86k_sim_stat *p;
rc = check_err(env, fstat(ARG(0), &s));
if (rc == 0) {
p = (struct m86k_sim_stat *)ARG(1);
p->sim_st_dev = tswap16(s.st_dev);
p->sim_st_ino = tswap16(s.st_ino);
p->sim_st_mode = tswap32(s.st_mode);
p->sim_st_nlink = tswap16(s.st_nlink);
p->sim_st_uid = tswap16(s.st_uid);
p->sim_st_gid = tswap16(s.st_gid);
p->sim_st_rdev = tswap16(s.st_rdev);
p->sim_st_size = tswap32(s.st_size);
p->sim_st_atime = tswap32(s.st_atime);
p->sim_st_mtime = tswap32(s.st_mtime);
p->sim_st_ctime = tswap32(s.st_ctime);
p->sim_st_blksize = tswap32(s.st_blksize);
p->sim_st_blocks = tswap32(s.st_blocks);
}
}
break;
case SYS_ISATTY:
check_err(env, isatty(ARG(0)));
break;
case SYS_LSEEK:
check_err(env, lseek(ARG(0), (int32_t)ARG(1), ARG(2)));
break;
default:
cpu_abort(env, "Unsupported m68k sim syscall %d\n", nr);
}
}
int main(int argc, char **argv)
{
cl_int err = 0;
cl_context context = 0;
cl_device_id * devices = NULL;
cl_command_queue queue = 0;
cl_program program = 0;
cl_mem cl_a = 0, cl_b = 0, cl_res = 0;
cl_kernel adder = 0;
cl_event event;
// The iteration variable
int i;
// Define our data set
cl_float a[DATA_SIZE], b[DATA_SIZE], res[DATA_SIZE];
// Initialize array
srand(time(0));
for (i = 0; i < DATA_SIZE; i++) {
a[i] = (rand() % 100) / 100.0;
b[i] = (rand() % 100) / 100.0;
res[i] = 0;
}
check_release(get_cl_context(&context, &devices, 0) == false,
"Fail to create context");
// Specify the queue to be profile-able
queue = clCreateCommandQueue(context, devices[0], CL_QUEUE_PROFILING_ENABLE, 0);
check_release(queue == NULL, "Can't create command queue");
program = load_program(context, devices[0], "shader.cl");
check_release(program == NULL, "Fail to build program");
cl_a =
clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_float) * DATA_SIZE, NULL, NULL);
cl_b =
clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_float) * DATA_SIZE, NULL, NULL);
cl_res = clCreateBuffer(
context, CL_MEM_WRITE_ONLY, sizeof(cl_float) * DATA_SIZE, NULL, NULL);
if (cl_a == 0 || cl_b == 0 || cl_res == 0) {
printf("Can't create OpenCL buffer\n");
goto release;
}
check_release(clEnqueueWriteBuffer(
queue, cl_a, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, a, 0, 0, 0),
"Write Buffer 1");
check_release(clEnqueueWriteBuffer(
queue, cl_b, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, b, 0, 0, 0),
"Write Buffer 2");
adder = clCreateKernel(program, "adder", &err);
if (err == CL_INVALID_KERNEL_NAME) printf("CL_INVALID_KERNEL_NAME\n");
check_release(adder == NULL, "Can't load kernel");
clSetKernelArg(adder, 0, sizeof(cl_mem), &cl_a);
clSetKernelArg(adder, 1, sizeof(cl_mem), &cl_b);
clSetKernelArg(adder, 2, sizeof(cl_mem), &cl_res);
size_t work_size = DATA_SIZE;
check_release(clEnqueueNDRangeKernel(queue, adder, 1, 0, &work_size, 0, 0, 0, &event),
"Can't enqueue kernel");
check_release(
clEnqueueReadBuffer(
queue, cl_res, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, res, 0, 0, 0),
"Can't enqueue read buffer");
clWaitForEvents(1, &event);
printf("Execution Time: %.04lf ms\n\n", get_event_exec_time(event));
// Make sure everything is done before we do anything
clFinish(queue);
err = 0;
for (i = 0; i < DATA_SIZE; i++) {
if (res[i] != a[i] + b[i]) {
printf("%f + %f = %f(answer %f)\n", a[i], b[i], res[i], a[i] + b[i]);
err++;
}
}
if (err == 0)
printf("Validation passed\n");
else
printf("Validation failed\n");
printf("------\n");
//--------------------------------
// Second test
for (i = 0; i < DATA_SIZE; i++) {
a[i] = i;
b[i] = i;
res[i] = 0;
}
check_err(clEnqueueWriteBuffer(
queue, cl_a, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, a, 0, 0, 0),
"Write Buffer 1");
check_err(clEnqueueWriteBuffer(
queue, cl_b, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, b, 0, 0, 0),
"Write Buffer 2");
check_err(clEnqueueNDRangeKernel(queue, adder, 1, 0, &work_size, 0, 0, 0, &event),
"Can't enqueue kernel");
check_err(clEnqueueReadBuffer(
queue, cl_res, CL_TRUE, 0, sizeof(cl_float) * DATA_SIZE, res, 0, 0, 0),
"Can't enqueue read buffer");
clWaitForEvents(1, &event);
printf("Execution Time: %.04lf ms\n\n", get_event_exec_time(event));
// Make sure everything is done before we do anything
clFinish(queue);
err = 0;
for (i = 0; i < DATA_SIZE; i++) {
if (res[i] != a[i] + b[i]) {
printf("%f + %f = %f(answer %f)\n", a[i], b[i], res[i], a[i] + b[i]);
err++;
}
}
if (err == 0)
printf("Validation passed\n");
else
printf("Validation failed\n");
release:
clReleaseKernel(adder);
clReleaseProgram(program);
clReleaseMemObject(cl_a);
clReleaseMemObject(cl_b);
clReleaseMemObject(cl_res);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}
int
create_file(char *file_name, int fill_mode, size_t* sizehintp)
{
int i;
int stat; /* return status */
int ncid; /* netCDF id */
/* dimension ids */
int lon_dim;
int lat_dim;
int lvl_dim;
int time_dim;
/* dimension lengths */
size_t lon_len = LON_LEN;
size_t lat_len = LAT_LEN;
size_t lvl_len = LVL_LEN;
size_t time_len = TIME_LEN;
/* variable ids */
int time_id;
int lat_id;
int lon_id;
int lvl_id;
int sfc_pres_id;
int temp_scrn_id;
int qsair_scrn_id;
int topog_id;
int mslp_id;
int sfc_temp_id;
int zonal_wnd_id;
/* rank (number of dimensions) for each variable */
# define RANK_time 1
# define RANK_lat 1
# define RANK_lon 1
# define RANK_lvl 1
# define RANK_sfc_pres 3
# define RANK_temp_scrn 3
# define RANK_qsair_scrn 3
# define RANK_topog 3
# define RANK_mslp 3
# define RANK_sfc_temp 3
# define RANK_zonal_wnd 4
/* variable shapes */
int time_dims[RANK_time];
int lat_dims[RANK_lat];
int lon_dims[RANK_lon];
int lvl_dims[RANK_lvl];
int sfc_pres_dims[RANK_sfc_pres];
int temp_scrn_dims[RANK_temp_scrn];
int qsair_scrn_dims[RANK_qsair_scrn];
int topog_dims[RANK_topog];
int mslp_dims[RANK_mslp];
int sfc_temp_dims[RANK_sfc_temp];
int zonal_wnd_dims[RANK_zonal_wnd];
size_t zonal_wnd_start[RANK_zonal_wnd];
size_t zonal_wnd_count[RANK_zonal_wnd];
float zonal_wnd[LON_LEN*LAT_LEN*TIME_LEN];
int ii;
int old_fill_mode;
size_t default_initialsize = 0;
/* To test bug on filesystem without large block size, we can get
* the same effect by providing the desired value as sizehint to
* nc__create() instead of calling nc_create() and getting the
* block size reported by fstat */
stat = nc__create(file_name, NC_CLOBBER, default_initialsize, sizehintp, &ncid);
check_err(stat,__LINE__,__FILE__);
stat = nc_set_fill(ncid, fill_mode, &old_fill_mode);
check_err(stat,__LINE__,__FILE__);
/* define dimensions */
stat = nc_def_dim(ncid, "lon", lon_len, &lon_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "lat", lat_len, &lat_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "lvl", lvl_len, &lvl_dim);
check_err(stat,__LINE__,__FILE__);
stat = nc_def_dim(ncid, "time", time_len, &time_dim);
check_err(stat,__LINE__,__FILE__);
/* define variables */
time_dims[0] = time_dim;
stat = nc_def_var(ncid, "time", NC_DOUBLE, RANK_time, time_dims, &time_id);
check_err(stat,__LINE__,__FILE__);
lat_dims[0] = lat_dim;
stat = nc_def_var(ncid, "lat", NC_FLOAT, RANK_lat, lat_dims, &lat_id);
check_err(stat,__LINE__,__FILE__);
lon_dims[0] = lon_dim;
stat = nc_def_var(ncid, "lon", NC_FLOAT, RANK_lon, lon_dims, &lon_id);
check_err(stat,__LINE__,__FILE__);
lvl_dims[0] = lvl_dim;
stat = nc_def_var(ncid, "lvl", NC_FLOAT, RANK_lvl, lvl_dims, &lvl_id);
check_err(stat,__LINE__,__FILE__);
sfc_pres_dims[0] = time_dim;
sfc_pres_dims[1] = lat_dim;
sfc_pres_dims[2] = lon_dim;
stat = nc_def_var(ncid, "sfc_pres", NC_FLOAT, RANK_sfc_pres, sfc_pres_dims, &sfc_pres_id);
check_err(stat,__LINE__,__FILE__);
temp_scrn_dims[0] = time_dim;
temp_scrn_dims[1] = lat_dim;
temp_scrn_dims[2] = lon_dim;
stat = nc_def_var(ncid, "temp_scrn", NC_FLOAT, RANK_temp_scrn, temp_scrn_dims, &temp_scrn_id);
check_err(stat,__LINE__,__FILE__);
qsair_scrn_dims[0] = time_dim;
qsair_scrn_dims[1] = lat_dim;
qsair_scrn_dims[2] = lon_dim;
stat = nc_def_var(ncid, "qsair_scrn", NC_FLOAT, RANK_qsair_scrn, qsair_scrn_dims, &qsair_scrn_id);
check_err(stat,__LINE__,__FILE__);
topog_dims[0] = time_dim;
topog_dims[1] = lat_dim;
topog_dims[2] = lon_dim;
stat = nc_def_var(ncid, "topog", NC_FLOAT, RANK_topog, topog_dims, &topog_id);
check_err(stat,__LINE__,__FILE__);
mslp_dims[0] = time_dim;
mslp_dims[1] = lat_dim;
mslp_dims[2] = lon_dim;
stat = nc_def_var(ncid, "mslp", NC_FLOAT, RANK_mslp, mslp_dims, &mslp_id);
check_err(stat,__LINE__,__FILE__);
sfc_temp_dims[0] = time_dim;
sfc_temp_dims[1] = lat_dim;
sfc_temp_dims[2] = lon_dim;
stat = nc_def_var(ncid, "sfc_temp", NC_FLOAT, RANK_sfc_temp, sfc_temp_dims, &sfc_temp_id);
check_err(stat,__LINE__,__FILE__);
zonal_wnd_dims[0] = time_dim;
zonal_wnd_dims[1] = lvl_dim;
zonal_wnd_dims[2] = lat_dim;
zonal_wnd_dims[3] = lon_dim;
stat = nc_def_var(ncid, "zonal_wnd", NC_FLOAT, RANK_zonal_wnd, zonal_wnd_dims, &zonal_wnd_id);
check_err(stat,__LINE__,__FILE__);
/* leave define mode */
stat = nc_enddef (ncid);
check_err(stat,__LINE__,__FILE__);
{ /* store time */
size_t time_start[RANK_time];
size_t time_count[RANK_time];
double time[TIME_LEN] = {1.};
time_len = 1;
time_start[0] = 0;
time_count[0] = time_len;
stat = nc_put_vara_double(ncid, time_id, time_start, time_count, time);
check_err(stat,__LINE__,__FILE__);
}
{ /* store lat */
float lat[] = {90, 88.5, 87, 85.5, 84, 82.5, 81, 79.5, 78, 76.5, 75, 73.5, 72, 70.5, 69, 67.5, 66, 64.5, 63, 61.5, 60, 58.5, 57, 55.5, 54, 52.5, 51, 49.5, 48, 46.5, 45, 43.5, 42, 40.5, 39, 37.5, 36, 34.5, 33, 31.5, 30, 28.5, 27, 25.5, 24, 22.5, 21, 19.5, 18, 16.5, 15, 13.5, 12, 10.5, 9, 7.5, 6, 4.5, 3, 1.5, 0, -1.5, -3, -4.5, -6, -7.5, -9, -10.5, -12, -13.5, -15, -16.5, -18, -19.5, -21, -22.5, -24, -25.5, -27, -28.5, -30, -31.5, -33, -34.5, -36, -37.5, -39, -40.5, -42, -43.5, -45, -46.5, -48, -49.5, -51, -52.5, -54, -55.5, -57, -58.5, -60, -61.5, -63, -64.5, -66, -67.5, -69, -70.5, -72, -73.5, -75, -76.5, -78, -79.5, -81, -82.5, -84, -85.5, -87, -88.5, -90};
stat = nc_put_var_float(ncid, lat_id, lat);
check_err(stat,__LINE__,__FILE__);
}
{ /* store lon */
float lon[] = {0, 1.5, 3, 4.5, 6, 7.5, 9, 10.5, 12, 13.5, 15, 16.5, 18, 19.5, 21, 22.5, 24, 25.5, 27, 28.5, 30, 31.5, 33, 34.5, 36, 37.5, 39, 40.5, 42, 43.5, 45, 46.5, 48, 49.5, 51, 52.5, 54, 55.5, 57, 58.5, 60, 61.5, 63, 64.5, 66, 67.5, 69, 70.5, 72, 73.5, 75, 76.5, 78, 79.5, 81, 82.5, 84, 85.5, 87, 88.5, 90, 91.5, 93, 94.5, 96, 97.5, 99, 100.5, 102, 103.5, 105, 106.5, 108, 109.5, 111, 112.5, 114, 115.5, 117, 118.5, 120, 121.5, 123, 124.5, 126, 127.5, 129, 130.5, 132, 133.5, 135, 136.5, 138, 139.5, 141, 142.5, 144, 145.5, 147, 148.5, 150, 151.5, 153, 154.5, 156, 157.5, 159, 160.5, 162, 163.5, 165, 166.5, 168, 169.5, 171, 172.5, 174, 175.5, 177, 178.5, 180, 181.5, 183, 184.5, 186, 187.5, 189, 190.5, 192, 193.5, 195, 196.5, 198, 199.5, 201, 202.5, 204, 205.5, 207, 208.5, 210, 211.5, 213, 214.5, 216, 217.5, 219, 220.5, 222, 223.5, 225, 226.5, 228, 229.5, 231, 232.5, 234, 235.5, 237, 238.5, 240, 241.5, 243, 244.5, 246, 247.5, 249, 250.5, 252, 253.5, 255, 256.5, 258, 259.5, 261, 262.5, 264, 265.5, 267, 268.5, 270, 271.5, 273, 274.5, 276, 277.5, 279, 280.5, 282, 283.5, 285, 286.5, 288, 289.5, 291, 292.5, 294, 295.5, 297, 298.5, 300, 301.5, 303, 304.5, 306, 307.5, 309, 310.5, 312, 313.5, 315, 316.5, 318, 319.5, 321, 322.5, 324, 325.5, 327, 328.5, 330, 331.5, 333, 334.5, 336, 337.5, 339, 340.5, 342, 343.5, 345, 346.5, 348, 349.5, 351, 352.5, 354, 355.5, 357, 358.5};
stat = nc_put_var_float(ncid, lon_id, lon);
check_err(stat,__LINE__,__FILE__);
}
{ /* store lvl */
float lvl[] = {1000, 995, 990, 985, 975, 950, 925, 900, 875, 850, 800, 750, 700, 600, 500, 450, 400, 350, 300, 275, 250, 225, 200, 175, 150, 100, 70, 50, 30, 20, 10};
stat = nc_put_var_float(ncid, lvl_id, lvl);
check_err(stat,__LINE__,__FILE__);
}
{ /* store sfc_pres */
size_t sfc_pres_start[RANK_sfc_pres];
size_t sfc_pres_count[RANK_sfc_pres];
float sfc_pres[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
sfc_pres[ii] = 6;
}
sfc_pres_start[0] = 0;
sfc_pres_start[1] = 0;
sfc_pres_start[2] = 0;
sfc_pres_count[0] = time_len;
sfc_pres_count[1] = lat_len;
sfc_pres_count[2] = lon_len;
stat = nc_put_vara_float(ncid, sfc_pres_id, sfc_pres_start, sfc_pres_count, sfc_pres);
check_err(stat,__LINE__,__FILE__);
}
{ /* store temp_scrn */
size_t temp_scrn_start[RANK_temp_scrn];
size_t temp_scrn_count[RANK_temp_scrn];
float temp_scrn[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
temp_scrn[ii] = 11;
}
temp_scrn_start[0] = 0;
temp_scrn_start[1] = 0;
temp_scrn_start[2] = 0;
temp_scrn_count[0] = time_len;
temp_scrn_count[1] = lat_len;
temp_scrn_count[2] = lon_len;
stat = nc_put_vara_float(ncid, temp_scrn_id, temp_scrn_start, temp_scrn_count, temp_scrn);
check_err(stat,__LINE__,__FILE__);
}
{ /* store qsair_scrn */
size_t qsair_scrn_start[RANK_qsair_scrn];
size_t qsair_scrn_count[RANK_qsair_scrn];
float qsair_scrn[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
qsair_scrn[ii] = 22;
}
qsair_scrn_start[0] = 0;
qsair_scrn_start[1] = 0;
qsair_scrn_start[2] = 0;
qsair_scrn_count[0] = time_len;
qsair_scrn_count[1] = lat_len;
qsair_scrn_count[2] = lon_len;
stat = nc_put_vara_float(ncid, qsair_scrn_id, qsair_scrn_start, qsair_scrn_count, qsair_scrn);
check_err(stat,__LINE__,__FILE__);
}
{ /* store topog */
size_t topog_start[RANK_topog];
size_t topog_count[RANK_topog];
float topog[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
topog[ii] = 33;
}
topog_start[0] = 0;
topog_start[1] = 0;
topog_start[2] = 0;
topog_count[0] = time_len;
topog_count[1] = lat_len;
topog_count[2] = lon_len;
stat = nc_put_vara_float(ncid, topog_id, topog_start, topog_count, topog);
check_err(stat,__LINE__,__FILE__);
}
{ /* store mslp */
size_t mslp_start[RANK_mslp];
size_t mslp_count[RANK_mslp];
float mslp[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
mslp[ii] = 44;
}
mslp_start[0] = 0;
mslp_start[1] = 0;
mslp_start[2] = 0;
mslp_count[0] = time_len;
mslp_count[1] = lat_len;
mslp_count[2] = lon_len;
stat = nc_put_vara_float(ncid, mslp_id, mslp_start, mslp_count, mslp);
check_err(stat,__LINE__,__FILE__);
}
{ /* store sfc_temp */
size_t sfc_temp_start[RANK_sfc_temp];
size_t sfc_temp_count[RANK_sfc_temp];
float sfc_temp[LON_LEN*LAT_LEN];
for(ii = 0; ii < LAT_LEN * LON_LEN; ii++) {
sfc_temp[ii] = 55;
}
sfc_temp_start[0] = 0;
sfc_temp_start[1] = 0;
sfc_temp_start[2] = 0;
sfc_temp_count[0] = time_len;
sfc_temp_count[1] = lat_len;
sfc_temp_count[2] = lon_len;
stat = nc_put_vara_float(ncid, sfc_temp_id, sfc_temp_start, sfc_temp_count, sfc_temp);
check_err(stat,__LINE__,__FILE__);
}
{ /* store zonal_wnd */
/* Bug exposed when written in reverse order. */
for(i = LVL_LEN - 1; i>=0; i--)
/* for(i = 0; i < LVL_LEN; i++) */
{
int izw;
for(izw = 0; izw < TIME_LEN * LAT_LEN * LON_LEN; izw++) {
zonal_wnd[izw] = 100 + i;
}
zonal_wnd_start[0] = 0;
zonal_wnd_start[1] = i;
zonal_wnd_start[2] = 0;
zonal_wnd_start[3] = 0;
zonal_wnd_count[0] = time_len;
zonal_wnd_count[1] = 1;
zonal_wnd_count[2] = lat_len;
zonal_wnd_count[3] = lon_len;
stat = nc_put_vara_float(ncid, zonal_wnd_id, zonal_wnd_start, zonal_wnd_count, zonal_wnd);
check_err(stat,__LINE__,__FILE__);
}
}
stat = nc_close(ncid);
check_err(stat,__LINE__,__FILE__);
return 0;
}
/* Check the return from the routine */
static int checkType(const char str[], int p, int r, int f90kind, int err, MPI_Datatype dtype)
{
int errs = 0;
if (dtype == MPI_DATATYPE_NULL) {
printf("Unable to find a real type for (p=%d,r=%d) in %s\n", p, r, str);
errs++;
}
if (err) {
errs++;
MTestPrintError(err);
}
if (!errs) {
int nints, nadds, ndtypes, combiner;
/* Check that we got the correct type */
MPI_Type_get_envelope(dtype, &nints, &nadds, &ndtypes, &combiner);
if (combiner != f90kind) {
errs++;
printf("Wrong combiner type (got %d, should be %d) for %s\n", combiner, f90kind, str);
}
else {
int parms[2];
MPI_Datatype outtype;
parms[0] = 0;
parms[1] = 0;
if (ndtypes != 0) {
errs++;
printf
("Section 8.6 states that the array_of_datatypes entry is empty for the create_f90 types\n");
}
MPI_Type_get_contents(dtype, 2, 0, 1, parms, 0, &outtype);
switch (combiner) {
case MPI_COMBINER_F90_REAL:
case MPI_COMBINER_F90_COMPLEX:
if (nints != 2) {
errs++;
printf("Returned %d integer values, 2 expected for %s\n", nints, str);
}
if (parms[0] != p || parms[1] != r) {
errs++;
printf("Returned (p=%d,r=%d); expected (p=%d,r=%d) for %s\n",
parms[0], parms[1], p, r, str);
}
break;
case MPI_COMBINER_F90_INTEGER:
if (nints != 1) {
errs++;
printf("Returned %d integer values, 1 expected for %s\n", nints, str);
}
if (parms[0] != p) {
errs++;
printf("Returned (p=%d); expected (p=%d) for %s\n", parms[0], p, str);
}
break;
default:
errs++;
printf("Unrecognized combiner for %s\n", str);
break;
}
}
}
if (!errs) {
char buf0[64]; /* big enough to hold any single type */
char buf1[64]; /* big enough to hold any single type */
MPI_Request req[2];
int dt_size = 0;
/* check that we can actually use the type for communication,
* regression for tt#1028 */
err = MPI_Type_size(dtype, &dt_size);
check_err(MPI_Type_size);
assert(dt_size <= sizeof(buf0));
memset(buf0, 0, sizeof(buf0));
memset(buf1, 0, sizeof(buf1));
if (!errs) {
err = MPI_Isend(&buf0, 1, dtype, 0, 42, MPI_COMM_SELF, &req[0]);
check_err(MPI_Isend);
}
if (!errs) {
err = MPI_Irecv(&buf1, 1, dtype, 0, 42, MPI_COMM_SELF, &req[1]);
check_err(MPI_Irecv);
}
if (!errs) {
err = MPI_Waitall(2, req, MPI_STATUSES_IGNORE);
check_err(MPI_Waitall);
}
}
return errs;
}
static int
Test_verifierParseBlock(void)
{
enum { file_size = 4 };
const char* file[file_size] = {
/* file 0 */
"$c |- wff S 0 $. "
"${ "
"$v x y z w $. "
"${ "
"$v a b c $. "
"$} "
"$v a b c $. "
"$} "
"$v x $. \n",
/* file 1 - parse two proofs */
"$c |- num 0 S $. "
"$v x $. "
"a.num.0 $a num 0 $. "
"num.x $f num x $. "
"a.num.succ $a num S x $. "
"thm.one $p num S 0 $= a.num.0 a.num.succ $. "
"thm.succ2 $p num S S x $= num.x a.num.succ a.num.succ $.\n",
/* file 2 - test compressed proof */
"$c |- num S 0 $. $v x y $. "
"numt.0 $a num 0 $. "
"num.0 $a |- num 0 $. "
"num.x $f num x $. "
"num.succ $a |- num S x $. "
"thm $p |- num S 0 $= ( numt.0 num.succ ) "
"AB $. \n",
/* file 3 - test disjoint variable restriction */
"$c | $. \n"
"$v x y B R $. \n"
"tx $f | x $. ty $f | y $. tB $f | B $. tR $f | R $. \n"
"${ $d x y $. $d y B $. $d y R $. $} \n",
/* to do: write test for compressed proof with Z tag */
};
const enum error errs[file_size] = {
error_none,
error_none,
error_none,
error_none,
};
const size_t errc[file_size] = {
0,
0,
0,
0,
};
const size_t dsymnum[file_size] = {
0,
0,
0,
3
};
size_t i;
for (i = 0; i < file_size; i++) {
LOG_DEBUG("testing file %lu", i);
struct verifier vrf;
verifierInit(&vrf);
verifierSetVerbosity(&vrf, 5);
struct reader r;
readerInitString(&r, file[i]);
verifierBeginReadingFile(&vrf, &r);
// verifierSetVerbosity(&vrf, 5);
verifierParseBlock(&vrf);
check_err(vrf.err, errs[i]);
ut_assert(vrf.symCount[symType_disjoint] == dsymnum[i],
"found %lu disjoint pairs, expected %lu", vrf.symCount[symType_disjoint],
dsymnum[i]);
ut_assert(vrf.errc == errc[i], "found %lu errors, expected %lu",
vrf.errc, errc[i]);
readerClean(&r);
verifierClean(&vrf);
}
return 0;
}
int
main(int argc, char ** argv)
{
/* IDs for the netCDF file, dimensions, and variables. */
int nprocs, rank;
int ncid;
int lon_dimid, lat_dimid, lvl_dimid, rec_dimid;
int lat_varid, lon_varid, pres_varid, temp_varid;
int dimids[NDIMS];
/* The start and count arrays will tell the netCDF library where to
write our data. */
MPI_Offset start[NDIMS], count[NDIMS];
/* Program variables to hold the data we will write out. We will only
need enough space to hold one timestep of data; one record. */
float pres_out[NLVL][NLAT][NLON];
float temp_out[NLVL][NLAT][NLON];
/* These program variables hold the latitudes and longitudes. */
float lats[NLAT], lons[NLON];
/* Loop indexes. */
int lvl, lat, lon, rec, i = 0;
/* Error handling. */
int retval;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/* Create some pretend data. If this wasn't an example program, we
* would have some real data to write, for example, model
* output. */
for (lat = 0; lat < NLAT; lat++)
lats[lat] = START_LAT + 5.*lat;
for (lon = 0; lon < NLON; lon++)
lons[lon] = START_LON + 5.*lon;
for (lvl = 0; lvl < NLVL; lvl++)
for (lat = 0; lat < NLAT; lat++)
for (lon = 0; lon < NLON; lon++)
{
pres_out[lvl][lat][lon] = SAMPLE_PRESSURE + i;
temp_out[lvl][lat][lon] = SAMPLE_TEMP + i++;
}
/* Create the file. */
if ((retval = ncmpi_create(MPI_COMM_WORLD, FILE_NAME, NC_CLOBBER, MPI_INFO_NULL, &ncid)))
check_err(retval,__LINE__,__FILE__);
/* Define the dimensions. The record dimension is defined to have
* unlimited length - it can grow as needed. In this example it is
* the time dimension.*/
if ((retval = ncmpi_def_dim(ncid, LVL_NAME, NLVL, &lvl_dimid)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_def_dim(ncid, LAT_NAME, NLAT, &lat_dimid)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_def_dim(ncid, LON_NAME, NLON, &lon_dimid)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_def_dim(ncid, REC_NAME, NC_UNLIMITED, &rec_dimid)))
check_err(retval,__LINE__,__FILE__);
/* Define the coordinate variables. We will only define coordinate
variables for lat and lon. Ordinarily we would need to provide
an array of dimension IDs for each variable's dimensions, but
since coordinate variables only have one dimension, we can
simply provide the address of that dimension ID (&lat_dimid) and
similarly for (&lon_dimid). */
if ((retval = ncmpi_def_var(ncid, LAT_NAME, NC_FLOAT, 1, &lat_dimid,
&lat_varid)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_def_var(ncid, LON_NAME, NC_FLOAT, 1, &lon_dimid,
&lon_varid)))
check_err(retval,__LINE__,__FILE__);
/* Assign units attributes to coordinate variables. */
if ((retval = ncmpi_put_att_text(ncid, lat_varid, UNITS,
strlen(DEGREES_NORTH), DEGREES_NORTH)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_put_att_text(ncid, lon_varid, UNITS,
strlen(DEGREES_EAST), DEGREES_EAST)))
check_err(retval,__LINE__,__FILE__);
/* The dimids array is used to pass the dimids of the dimensions of
the netCDF variables. Both of the netCDF variables we are
creating share the same four dimensions. In C, the
unlimited dimension must come first on the list of dimids. */
dimids[0] = rec_dimid;
dimids[1] = lvl_dimid;
dimids[2] = lat_dimid;
dimids[3] = lon_dimid;
/* Define the netCDF variables for the pressure and temperature
* data. */
if ((retval = ncmpi_def_var(ncid, PRES_NAME, NC_FLOAT, NDIMS,
dimids, &pres_varid)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_def_var(ncid, TEMP_NAME, NC_FLOAT, NDIMS,
dimids, &temp_varid)))
check_err(retval,__LINE__,__FILE__);
/* Assign units attributes to the netCDF variables. */
if ((retval = ncmpi_put_att_text(ncid, pres_varid, UNITS,
strlen(PRES_UNITS), PRES_UNITS)))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_put_att_text(ncid, temp_varid, UNITS,
strlen(TEMP_UNITS), TEMP_UNITS)))
check_err(retval,__LINE__,__FILE__);
/* End define mode. */
if ((retval = ncmpi_enddef(ncid)))
check_err(retval,__LINE__,__FILE__);
retval = ncmpi_begin_indep_data(ncid);
/* Write the coordinate variable data. This will put the latitudes
and longitudes of our data grid into the netCDF file. */
if ((retval = ncmpi_put_var_float(ncid, lat_varid, &lats[0]))){
check_err(retval,__LINE__,__FILE__);
printf("------------------------\n");
}
if ((retval = ncmpi_put_var_float(ncid, lon_varid, &lons[0])))
check_err(retval,__LINE__,__FILE__);
retval = ncmpi_end_indep_data(ncid);
/* These settings tell netcdf to write one timestep of data. (The
setting of start[0] inside the loop below tells netCDF which
&data[0][0][0]);
timestep to write.) */
count[0] = 1;
count[1] = NLVL;
count[2] = NLAT;
count[3] = NLON;
start[1] = 0;
start[2] = 0;
start[3] = 0;
/* Write the pretend data. This will write our surface pressure and
surface temperature data. The arrays only hold one timestep worth
of data. We will just rewrite the same data for each timestep. In
a real application, the data would change between timesteps. */
for (rec = 0; rec < NREC; rec++)
{
start[0] = rec;
if ((retval = ncmpi_put_vara_float_all(ncid, pres_varid, start, count, &pres_out[0][0][0])))
check_err(retval,__LINE__,__FILE__);
if ((retval = ncmpi_put_vara_float_all(ncid, temp_varid, start, count, &temp_out[0][0][0])))
check_err(retval,__LINE__,__FILE__);
}
/* Close the file. */
if ((retval = ncmpi_close(ncid)))
check_err(retval,__LINE__,__FILE__);
printf("*** SUCCESS writing example file %s!\n", FILE_NAME);
MPI_Finalize();
return 0;
}
int main(int argc, char* argv[])
{
program_name = argv[0];
if (argc < 3) {
print_help();
exit(EXIT_FAILURE);
}
char binfile[50];
base = argv[1];
strapp(binfile, ".nc");
int total_ids = atoi(argv[2]);
FILE *fp;
if (argc > 2) {
infile = argv[3];
fp = fopen(infile, "r");
if (!fp)
error(1, errno, "%s", infile);
} else {
infile = "stdin";
fp = stdin;
}
/* Get the first line with the SNP names */
char *line = NULL;
size_t n = 0;
int read = getlin(&line, &n, fp);
if (read == -1)
error(1, errno, "%s", infile);
int nsnps = getsnps(line);
free(line);
line = NULL;
printf("%d markers\n", nsnps);
printf("Converting intensity values to binary\n");
int ncid, stat, sampid, varid;
size_t nids = 0, perkey;
size_t count[3] = { 1, 0, 0 };
size_t start[3] = { 0, 0, 0 };
char *id;
float *vals;
while (getlin(&line, &n, fp) != -1) {
if (nids == 0) {
/* Count number of vals in first line to alloc indv_dat */
read = getstrings(line, NULL, DELIM) - 1;
if (read < 1)
error(2, 0, "No values found");
if (read % nsnps != 0)
error(2, 0, "Not same number of values for each marker");
perkey = read / nsnps;
printf("%zu values per marker\n", perkey);
vals = malloc(sizeof(float) * read);
if (vals == NULL)
error(1, errno, "dat.vals");
/* Create netcdf file and write snp names */
ncid = create_nc(binfile, total_ids, nsnps, perkey);
stat = nc_inq_varid(ncid, "sample", &sampid);
check_err(stat,__LINE__,__FILE__);
stat = nc_inq_varid(ncid, "intensity", &varid);
check_err(stat,__LINE__,__FILE__);
writesnps(ncid, nsnps);
count[1] = nsnps;
count[2] = perkey;
}
/* Read valuess from line */
id = linevals(line, vals);
/* Write sample id */
stat = nc_put_var1_string(ncid, sampid, &nids, (const char **) &id);
check_err(stat,__LINE__,__FILE__);
/* Write intensity values */
start[0] = nids;
stat = nc_put_vara_float(ncid, varid, start, count, vals);
check_err(stat,__LINE__,__FILE__);
free(line);
line = NULL;
nids++;
printf("Read %zu\r", nids);
fflush(stdout);
}
fclose(fp);
stat = nc_close(ncid);
check_err(stat,__LINE__,__FILE__);
free(vals);
free(line);
printf("Wrote %zu samples to [ %s ]\n", nids, binfile);
exit(EXIT_SUCCESS);
}
/* test case from tt#1030 ported to C
*
* Thanks to Matthias Lieber for reporting the bug and providing a good test
* program. */
int struct_struct_test(void)
{
int err, errs = 0;
int i, j, dt_size = 0;
MPI_Request req[2];
#define COUNT (2)
MPI_Aint displ[COUNT];
int blens[COUNT];
MPI_Datatype types[COUNT];
MPI_Datatype datatype;
/* A slight difference from the F90 test: F90 arrays are column-major, C
* arrays are row-major. So we invert the order of dimensions. */
#define N (2)
#define M (4)
int array[N][M] = { {-1, -1, -1, -1}, {-1, -1, -1, -1} };
int expected[N][M] = { {-1, 1, 2, 5}, {-1, 3, 4, 6} };
int seq_array[N*M];
MPI_Aint astart, aend;
MPI_Aint size_exp = 0;
/* 1st section selects elements 1 and 2 out of 2nd dimension, complete 1st dim.
* should receive the values 1, 2, 3, 4 */
astart = 1;
aend = 2;
err = build_array_section_type(M, astart, aend, &types[0]);
if (err) {
errs++;
if (verbose) fprintf(stderr, "build_array_section_type failed\n");
return errs;
}
blens[0] = N;
displ[0] = 0;
size_exp = size_exp + N * (aend-astart+1) * sizeof(int);
/* 2nd section selects last element of 2nd dimension, complete 1st dim.
* should receive the values 5, 6 */
astart = 3;
aend = 3;
err = build_array_section_type(M, astart, aend, &types[1]);
if (err) {
errs++;
if (verbose) fprintf(stderr, "build_array_section_type failed\n");
return errs;
}
blens[1] = N;
displ[1] = 0;
size_exp = size_exp + N * (aend-astart+1) * sizeof(int);
/* create type */
err = MPI_Type_create_struct(COUNT, blens, displ, types, &datatype);
check_err(MPI_Type_create_struct);
err = MPI_Type_commit(&datatype);
check_err(MPI_Type_commit);
err = MPI_Type_size(datatype, &dt_size);
check_err(MPI_Type_size);
if (dt_size != size_exp) {
errs++;
if (verbose) fprintf(stderr, "unexpected type size\n");
}
/* send the type to ourselves to make sure that the type describes data correctly */
for (i = 0; i < (N*M) ; ++i)
seq_array[i] = i + 1; /* source values 1..(N*M) */
err = MPI_Isend(&seq_array[0], dt_size/sizeof(int), MPI_INT, 0, 42, MPI_COMM_SELF, &req[0]);
check_err(MPI_Isend);
err = MPI_Irecv(&array[0][0], 1, datatype, 0, 42, MPI_COMM_SELF, &req[1]);
check_err(MPI_Irecv);
err = MPI_Waitall(2, req, MPI_STATUSES_IGNORE);
check_err(MPI_Waitall);
/* check against expected */
for (i = 0; i < N; ++i) {
for (j = 0; j < M; ++j) {
if (array[i][j] != expected[i][j]) {
errs++;
if (verbose)
fprintf(stderr, "array[%d][%d]=%d, should be %d\n", i, j, array[i][j], expected[i][j]);
}
}
}
err = MPI_Type_free(&datatype);
check_err(MPI_Type_free);
err = MPI_Type_free(&types[0]);
check_err(MPI_Type_free);
err = MPI_Type_free(&types[1]);
check_err(MPI_Type_free);
return errs;
#undef M
#undef N
#undef COUNT
}
bool websocket_hybi_17::handshake(url const& target)
{
_aspect_assert(state() == CONNECTING);
// create websocket handshake request
pion::http::request req(target.path_for_request());
req.add_header("Connection", "Upgrade");
req.add_header("Upgrade", "WebSocket");
req.add_header("Host", target.hostport());
req.add_header("Origin", target.origin());
string key(16, 0);
std::generate(key.begin(), key.end(), rand_byte);
string encoded_key;
if ( !pion::algorithm::base64_encode(key, encoded_key) )
{
return false;
}
req.add_header("Sec-WebSocket-Key", encoded_key);
req.add_header("Sec-WebSocket-Version", "13");
// send request, recieve response
error_code err = send_message(req);
if ( !check_err(err, "send request") )
{
return false;
}
pion::http::response resp(req);
resp.receive(*tcp_conn_, err);
if ( !check_err(err, "recieve response") )
{
return false;
}
// check response
if ( !is_websocket_upgrade(resp) )
{
// it is not a hybi connection upgrade, give a chance for another protocol
return false;
}
// Check reply key
encoded_key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
encoded_key = crypto::sha1_digest(encoded_key.data(), encoded_key.size());
string resp_key;
if ( !pion::algorithm::base64_encode(encoded_key, resp_key) )
{
return false;
}
if ( resp_key != resp.get_header("Sec-WebSocket-Accept") )
{
return false;
}
state_ = OPEN;
on_connect(target.to_string());
wait_data();
return true;
}
/* regression for tt#1030, checks for bad offset math in the
* blockindexed and indexed dataloop flattening code */
int flatten_test(void)
{
int err, errs = 0;
#define ARR_SIZE (9)
/* real indices 0 1 2 3 4 5 6 7 8
* indices w/ &array[3] -3 -2 -1 0 1 2 3 4 5 */
int array[ARR_SIZE] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
int expected[ARR_SIZE] = {-1, 0, 1,-1, 2,-1, 3,-1, 4};
MPI_Datatype idx_type = MPI_DATATYPE_NULL;
MPI_Datatype blkidx_type = MPI_DATATYPE_NULL;
MPI_Datatype combo = MPI_DATATYPE_NULL;
#define COUNT (2)
int displ[COUNT];
MPI_Aint adispl[COUNT];
int blens[COUNT];
MPI_Datatype types[COUNT];
/* indexed type layout:
* XX_X
* 2101 <-- pos (left of 0 is neg)
*
* different blens to prevent optimization into a blockindexed
*/
blens[0] = 2;
displ[0] = -2; /* elements, puts byte after block end at 0 */
blens[1] = 1;
displ[1] = 1; /*elements*/
err = MPI_Type_indexed(COUNT, blens, displ, MPI_INT, &idx_type);
check_err(MPI_Type_indexed);
err = MPI_Type_commit(&idx_type);
check_err(MPI_Type_commit);
/* indexed type layout:
* _X_X
* 2101 <-- pos (left of 0 is neg)
*/
displ[0] = -1;
displ[1] = 1;
err = MPI_Type_create_indexed_block(COUNT, 1, displ, MPI_INT, &blkidx_type);
check_err(MPI_Type_indexed_block);
err = MPI_Type_commit(&blkidx_type);
check_err(MPI_Type_commit);
/* struct type layout:
* II_I_B_B (I=idx_type, B=blkidx_type)
* 21012345 <-- pos (left of 0 is neg)
*/
blens[0] = 1;
adispl[0] = 0; /*bytes*/
types[0] = idx_type;
blens[1] = 1;
adispl[1] = 4 * sizeof(int); /* bytes */
types[1] = blkidx_type;
/* must be a struct in order to trigger flattening code */
err = MPI_Type_create_struct(COUNT, blens, adispl, types, &combo);
check_err(MPI_Type_indexed);
err = MPI_Type_commit(&combo);
check_err(MPI_Type_commit);
/* pack/unpack with &array[3] */
errs += pack_and_check_expected(combo, "combo", 3, ARR_SIZE, array, expected);
MPI_Type_free(&combo);
MPI_Type_free(&idx_type);
MPI_Type_free(&blkidx_type);
return errs;
#undef COUNT
}
void websocket_hybi_17::on_write_completed(shared_buffer buf, error_code err, size_t bytes_transferred)
{
check_err(!err && bytes_transferred >= buf->size(), "async send");
}
void step3(int *n, int nthreads) {
int nprocs, procid;
MPI_Comm_rank(MPI_COMM_WORLD, &procid);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* Create Cartesian Communicator */
int c_dims[2]={0};
MPI_Comm c_comm;
accfft_create_comm(MPI_COMM_WORLD,c_dims,&c_comm);
#ifdef INPLACE
Complex *data;
#else
Complex *data;
Complex *data_hat;
#endif
double f_time=0*MPI_Wtime(),i_time=0, setup_time=0;
int alloc_max=0;
int isize[3],osize[3],istart[3],ostart[3];
/* Get the local pencil size and the allocation size */
alloc_max=accfft_local_size_dft_c2c(n,isize,istart,osize,ostart,c_comm);
#ifdef INPLACE
data=(Complex*)accfft_alloc(alloc_max);
#else
data=(Complex*)accfft_alloc(isize[0]*isize[1]*isize[2]*2*sizeof(double));
data_hat=(Complex*)accfft_alloc(alloc_max);
#endif
accfft_init(nthreads);
/* Create FFT plan */
setup_time=-MPI_Wtime();
#ifdef INPLACE
accfft_plan * plan=accfft_plan_dft_3d_c2c(n,data,data,c_comm,ACCFFT_MEASURE);
#else
accfft_plan * plan=accfft_plan_dft_3d_c2c(n,data,data_hat,c_comm,ACCFFT_MEASURE);
#endif
setup_time+=MPI_Wtime();
/* Initialize data */
initialize(data,n,c_comm);
MPI_Barrier(c_comm);
/* Perform forward FFT */
f_time-=MPI_Wtime();
#ifdef INPLACE
accfft_execute_c2c(plan,ACCFFT_FORWARD,data,data);
#else
accfft_execute_c2c(plan,ACCFFT_FORWARD,data,data_hat);
#endif
f_time+=MPI_Wtime();
MPI_Barrier(c_comm);
/* Perform backward FFT */
#ifdef INPLACE
i_time-=MPI_Wtime();
accfft_execute_c2c(plan,ACCFFT_BACKWARD,data,data);
i_time+=MPI_Wtime();
#else
Complex * data2=(Complex*)accfft_alloc(isize[0]*isize[1]*isize[2]*2*sizeof(double));
i_time-=MPI_Wtime();
accfft_execute_c2c(plan,ACCFFT_BACKWARD,data_hat,data2);
i_time+=MPI_Wtime();
#endif
/* Check Error */
#ifdef INPLACE
check_err(data,n,c_comm);
#else
check_err(data2,n,c_comm);
#endif
/* Compute some timings statistics */
double g_f_time, g_i_time, g_setup_time;
MPI_Reduce(&f_time,&g_f_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
MPI_Reduce(&i_time,&g_i_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
MPI_Reduce(&setup_time,&g_setup_time,1, MPI_DOUBLE, MPI_MAX,0, MPI_COMM_WORLD);
#ifdef INPLACE
PCOUT<<"Timing for Inplace FFT of size "<<n[0]<<"*"<<n[1]<<"*"<<n[2]<<std::endl;
#else
PCOUT<<"Timing for Outplace FFT of size "<<n[0]<<"*"<<n[1]<<"*"<<n[2]<<std::endl;
#endif
PCOUT<<"Setup \t"<<g_setup_time<<std::endl;
PCOUT<<"FFT \t"<<g_f_time<<std::endl;
PCOUT<<"IFFT \t"<<g_i_time<<std::endl;
accfft_free(data);
#ifndef INPLACE
accfft_free(data_hat);
accfft_free(data2);
#endif
accfft_destroy_plan(plan);
accfft_cleanup();
MPI_Comm_free(&c_comm);
return ;
} // end step3
