← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nwchem/trusty-proposed

« back to all changes in this revision

Viewing changes to src/tools/ga-5-1/tools/ga-wapi.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Daniel Leidert, Andreas Tille, Michael Banck
  • Date: 2013-07-04 12:14:55 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130704121455-5tvsx2qabor3nrui
Tags: 6.3-1
http://bugs.debian.org/696361
* New upstream release.
* Fixes anisotropic properties (Closes: #696361).
* New features include:
  + Multi-reference coupled cluster (MRCC) approaches
  + Hybrid DFT calculations with short-range HF 
  + New density-functionals including Minnesota (M08, M11) and HSE hybrid
    functionals
  + X-ray absorption spectroscopy (XAS) with TDDFT
  + Analytical gradients for the COSMO solvation model
  + Transition densities from TDDFT 
  + DFT+U and Electron-Transfer (ET) methods for plane wave calculations
  + Exploitation of space group symmetry in plane wave geometry optimizations
  + Local density of states (LDOS) collective variable added to Metadynamics
  + Various new XC functionals added for plane wave calculations, including
    hybrid and range-corrected ones
  + Electric field gradients with relativistic corrections 
  + Nudged Elastic Band optimization method
  + Updated basis sets and ECPs 

[ Daniel Leidert ]
* debian/watch: Fixed.

[ Andreas Tille ]
* debian/upstream: References

[ Michael Banck ]
* debian/upstream (Name): New field.
* debian/patches/02_makefile_flags.patch: Refreshed.
* debian/patches/06_statfs_kfreebsd.patch: Likewise.
* debian/patches/07_ga_target_force_linux.patch: Likewise.
* debian/patches/05_avoid_inline_assembler.patch: Removed, no longer needed.
* debian/patches/09_backported_6.1.1_fixes.patch: Likewise.
* debian/control (Build-Depends): Added gfortran-4.7 and gcc-4.7.
* debian/patches/10_force_gcc-4.7.patch: New patch, explicitly sets
  gfortran-4.7 and gcc-4.7, fixes test suite hang with gcc-4.8 (Closes:
  #701328, #713262).
* debian/testsuite: Added tests for COSMO analytical gradients and MRCC.
* debian/rules (MRCC_METHODS): New variable, required to enable MRCC methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-5-1/tools/ga-wapi.c
1
 
 
2
 
#if HAVE_CONFIG_H
3
 
#   include "config.h"
4
 
#endif
5
 
 
6
 
#include <mpi.h>
7
 
#include "ga-papi.h"
8
 
#include "typesf2c.h"
9
 
 
10
 
static int me;
11
 
static int nproc;
12
 
 
13
 
 
14
 
static long count_pnga_abs_value = 0;
15
 
static long count_pnga_abs_value_patch = 0;
16
 
static long count_pnga_acc = 0;
17
 
static long count_pnga_access_block_grid_idx = 0;
18
 
static long count_pnga_access_block_grid_ptr = 0;
19
 
static long count_pnga_access_block_idx = 0;
20
 
static long count_pnga_access_block_ptr = 0;
21
 
static long count_pnga_access_block_segment_idx = 0;
22
 
static long count_pnga_access_block_segment_ptr = 0;
23
 
static long count_pnga_access_ghost_element = 0;
24
 
static long count_pnga_access_ghost_element_ptr = 0;
25
 
static long count_pnga_access_ghost_ptr = 0;
26
 
static long count_pnga_access_ghosts = 0;
27
 
static long count_pnga_access_idx = 0;
28
 
static long count_pnga_access_ptr = 0;
29
 
static long count_pnga_add = 0;
30
 
static long count_pnga_add_constant = 0;
31
 
static long count_pnga_add_constant_patch = 0;
32
 
static long count_pnga_add_diagonal = 0;
33
 
static long count_pnga_add_patch = 0;
34
 
static long count_pnga_allocate = 0;
35
 
static long count_pnga_bin_index = 0;
36
 
static long count_pnga_bin_sorter = 0;
37
 
static long count_pnga_brdcst = 0;
38
 
static long count_pnga_check_handle = 0;
39
 
static long count_pnga_cluster_nnodes = 0;
40
 
static long count_pnga_cluster_nodeid = 0;
41
 
static long count_pnga_cluster_nprocs = 0;
42
 
static long count_pnga_cluster_proc_nodeid = 0;
43
 
static long count_pnga_cluster_procid = 0;
44
 
static long count_pnga_comp_patch = 0;
45
 
static long count_pnga_compare_distr = 0;
46
 
static long count_pnga_copy = 0;
47
 
static long count_pnga_copy_patch = 0;
48
 
static long count_pnga_copy_patch_dp = 0;
49
 
static long count_pnga_create = 0;
50
 
static long count_pnga_create_bin_range = 0;
51
 
static long count_pnga_create_config = 0;
52
 
static long count_pnga_create_ghosts = 0;
53
 
static long count_pnga_create_ghosts_config = 0;
54
 
static long count_pnga_create_ghosts_irreg = 0;
55
 
static long count_pnga_create_ghosts_irreg_config = 0;
56
 
static long count_pnga_create_handle = 0;
57
 
static long count_pnga_create_irreg = 0;
58
 
static long count_pnga_create_irreg_config = 0;
59
 
static long count_pnga_create_mutexes = 0;
60
 
static long count_pnga_ddot_patch_dp = 0;
61
 
static long count_pnga_deregister_type = 0;
62
 
static long count_pnga_destroy = 0;
63
 
static long count_pnga_destroy_mutexes = 0;
64
 
static long count_pnga_diag = 0;
65
 
static long count_pnga_diag_reuse = 0;
66
 
static long count_pnga_diag_seq = 0;
67
 
static long count_pnga_diag_std = 0;
68
 
static long count_pnga_diag_std_seq = 0;
69
 
static long count_pnga_distribution = 0;
70
 
static long count_pnga_dot = 0;
71
 
static long count_pnga_dot_patch = 0;
72
 
static long count_pnga_duplicate = 0;
73
 
static long count_pnga_elem_divide = 0;
74
 
static long count_pnga_elem_divide_patch = 0;
75
 
static long count_pnga_elem_maximum = 0;
76
 
static long count_pnga_elem_maximum_patch = 0;
77
 
static long count_pnga_elem_minimum = 0;
78
 
static long count_pnga_elem_minimum_patch = 0;
79
 
static long count_pnga_elem_multiply = 0;
80
 
static long count_pnga_elem_multiply_patch = 0;
81
 
static long count_pnga_elem_step_divide_patch = 0;
82
 
static long count_pnga_elem_stepb_divide_patch = 0;
83
 
static long count_pnga_error = 0;
84
 
static long count_pnga_fence = 0;
85
 
static long count_pnga_fill = 0;
86
 
static long count_pnga_fill_patch = 0;
87
 
static long count_pnga_gather = 0;
88
 
static long count_pnga_gather2d = 0;
89
 
static long count_pnga_get = 0;
90
 
static long count_pnga_get_block_info = 0;
91
 
static long count_pnga_get_debug = 0;
92
 
static long count_pnga_get_diag = 0;
93
 
static long count_pnga_get_dimension = 0;
94
 
static long count_pnga_get_field = 0;
95
 
static long count_pnga_get_ghost_block = 0;
96
 
static long count_pnga_get_pgroup = 0;
97
 
static long count_pnga_get_pgroup_size = 0;
98
 
static long count_pnga_get_proc_grid = 0;
99
 
static long count_pnga_get_proc_index = 0;
100
 
static long count_pnga_ghost_barrier = 0;
101
 
static long count_pnga_gop = 0;
102
 
static long count_pnga_has_ghosts = 0;
103
 
static long count_pnga_init_fence = 0;
104
 
static long count_pnga_initialize = 0;
105
 
static long count_pnga_initialize_ltd = 0;
106
 
static long count_pnga_inquire = 0;
107
 
static long count_pnga_inquire_memory = 0;
108
 
static long count_pnga_inquire_name = 0;
109
 
static long count_pnga_inquire_type = 0;
110
 
static long count_pnga_is_mirrored = 0;
111
 
static long count_pnga_list_nodeid = 0;
112
 
static long count_pnga_llt_solve = 0;
113
 
static long count_pnga_locate = 0;
114
 
static long count_pnga_locate_nnodes = 0;
115
 
static long count_pnga_locate_num_blocks = 0;
116
 
static long count_pnga_locate_region = 0;
117
 
static long count_pnga_lock = 0;
118
 
static long count_pnga_lu_solve = 0;
119
 
static long count_pnga_lu_solve_alt = 0;
120
 
static long count_pnga_lu_solve_seq = 0;
121
 
static long count_pnga_mask_sync = 0;
122
 
static long count_pnga_matmul = 0;
123
 
static long count_pnga_matmul_mirrored = 0;
124
 
static long count_pnga_matmul_patch = 0;
125
 
static long count_pnga_median = 0;
126
 
static long count_pnga_median_patch = 0;
127
 
static long count_pnga_memory_avail = 0;
128
 
static long count_pnga_memory_avail_type = 0;
129
 
static long count_pnga_memory_limited = 0;
130
 
static long count_pnga_merge_distr_patch = 0;
131
 
static long count_pnga_merge_mirrored = 0;
132
 
static long count_pnga_msg_brdcst = 0;
133
 
static long count_pnga_msg_pgroup_sync = 0;
134
 
static long count_pnga_msg_sync = 0;
135
 
static long count_pnga_nbacc = 0;
136
 
static long count_pnga_nbget = 0;
137
 
static long count_pnga_nbget_field = 0;
138
 
static long count_pnga_nbget_ghost_dir = 0;
139
 
static long count_pnga_nblock = 0;
140
 
static long count_pnga_nbput = 0;
141
 
static long count_pnga_nbput_field = 0;
142
 
static long count_pnga_nbtest = 0;
143
 
static long count_pnga_nbwait = 0;
144
 
static long count_pnga_ndim = 0;
145
 
static long count_pnga_nnodes = 0;
146
 
static long count_pnga_nodeid = 0;
147
 
static long count_pnga_norm1 = 0;
148
 
static long count_pnga_norm_infinity = 0;
149
 
static long count_pnga_pack = 0;
150
 
static long count_pnga_patch_enum = 0;
151
 
static long count_pnga_patch_intersect = 0;
152
 
static long count_pnga_periodic = 0;
153
 
static long count_pnga_pgroup_absolute_id = 0;
154
 
static long count_pnga_pgroup_brdcst = 0;
155
 
static long count_pnga_pgroup_create = 0;
156
 
static long count_pnga_pgroup_destroy = 0;
157
 
static long count_pnga_pgroup_get_default = 0;
158
 
static long count_pnga_pgroup_get_mirror = 0;
159
 
static long count_pnga_pgroup_get_world = 0;
160
 
static long count_pnga_pgroup_gop = 0;
161
 
static long count_pnga_pgroup_nnodes = 0;
162
 
static long count_pnga_pgroup_nodeid = 0;
163
 
static long count_pnga_pgroup_set_default = 0;
164
 
static long count_pnga_pgroup_split = 0;
165
 
static long count_pnga_pgroup_split_irreg = 0;
166
 
static long count_pnga_pgroup_sync = 0;
167
 
static long count_pnga_print = 0;
168
 
static long count_pnga_print_distribution = 0;
169
 
static long count_pnga_print_file = 0;
170
 
static long count_pnga_print_patch = 0;
171
 
static long count_pnga_print_patch2d = 0;
172
 
static long count_pnga_print_patch_file = 0;
173
 
static long count_pnga_print_patch_file2d = 0;
174
 
static long count_pnga_print_stats = 0;
175
 
static long count_pnga_proc_topology = 0;
176
 
static long count_pnga_put = 0;
177
 
static long count_pnga_put_field = 0;
178
 
static long count_pnga_randomize = 0;
179
 
static long count_pnga_read_inc = 0;
180
 
static long count_pnga_recip = 0;
181
 
static long count_pnga_recip_patch = 0;
182
 
static long count_pnga_register_type = 0;
183
 
static long count_pnga_release = 0;
184
 
static long count_pnga_release_block = 0;
185
 
static long count_pnga_release_block_grid = 0;
186
 
static long count_pnga_release_block_segment = 0;
187
 
static long count_pnga_release_ghost_element = 0;
188
 
static long count_pnga_release_ghosts = 0;
189
 
static long count_pnga_release_update = 0;
190
 
static long count_pnga_release_update_block = 0;
191
 
static long count_pnga_release_update_block_grid = 0;
192
 
static long count_pnga_release_update_block_segment = 0;
193
 
static long count_pnga_release_update_ghost_element = 0;
194
 
static long count_pnga_release_update_ghosts = 0;
195
 
static long count_pnga_scale = 0;
196
 
static long count_pnga_scale_cols = 0;
197
 
static long count_pnga_scale_patch = 0;
198
 
static long count_pnga_scale_rows = 0;
199
 
static long count_pnga_scan_add = 0;
200
 
static long count_pnga_scan_copy = 0;
201
 
static long count_pnga_scatter = 0;
202
 
static long count_pnga_scatter2d = 0;
203
 
static long count_pnga_scatter_acc = 0;
204
 
static long count_pnga_scatter_acc2d = 0;
205
 
static long count_pnga_select_elem = 0;
206
 
static long count_pnga_set_array_name = 0;
207
 
static long count_pnga_set_block_cyclic = 0;
208
 
static long count_pnga_set_block_cyclic_proc_grid = 0;
209
 
static long count_pnga_set_chunk = 0;
210
 
static long count_pnga_set_data = 0;
211
 
static long count_pnga_set_debug = 0;
212
 
static long count_pnga_set_diagonal = 0;
213
 
static long count_pnga_set_ghost_corner_flag = 0;
214
 
static long count_pnga_set_ghost_info = 0;
215
 
static long count_pnga_set_ghosts = 0;
216
 
static long count_pnga_set_irreg_distr = 0;
217
 
static long count_pnga_set_irreg_flag = 0;
218
 
static long count_pnga_set_memory_limit = 0;
219
 
static long count_pnga_set_pgroup = 0;
220
 
static long count_pnga_set_restricted = 0;
221
 
static long count_pnga_set_restricted_range = 0;
222
 
static long count_pnga_set_update4_info = 0;
223
 
static long count_pnga_set_update5_info = 0;
224
 
static long count_pnga_shift_diagonal = 0;
225
 
static long count_pnga_solve = 0;
226
 
static long count_pnga_spd_invert = 0;
227
 
static long count_pnga_step_bound_info = 0;
228
 
static long count_pnga_step_bound_info_patch = 0;
229
 
static long count_pnga_step_mask_patch = 0;
230
 
static long count_pnga_step_max = 0;
231
 
static long count_pnga_step_max_patch = 0;
232
 
static long count_pnga_strided_acc = 0;
233
 
static long count_pnga_strided_get = 0;
234
 
static long count_pnga_strided_put = 0;
235
 
static long count_pnga_summarize = 0;
236
 
static long count_pnga_symmetrize = 0;
237
 
static long count_pnga_sync = 0;
238
 
static long count_pnga_terminate = 0;
239
 
static long count_pnga_timer = 0;
240
 
static long count_pnga_total_blocks = 0;
241
 
static long count_pnga_transpose = 0;
242
 
static long count_pnga_type_c2f = 0;
243
 
static long count_pnga_type_f2c = 0;
244
 
static long count_pnga_unlock = 0;
245
 
static long count_pnga_unpack = 0;
246
 
static long count_pnga_update1_ghosts = 0;
247
 
static long count_pnga_update2_ghosts = 0;
248
 
static long count_pnga_update3_ghosts = 0;
249
 
static long count_pnga_update44_ghosts = 0;
250
 
static long count_pnga_update4_ghosts = 0;
251
 
static long count_pnga_update55_ghosts = 0;
252
 
static long count_pnga_update5_ghosts = 0;
253
 
static long count_pnga_update6_ghosts = 0;
254
 
static long count_pnga_update7_ghosts = 0;
255
 
static long count_pnga_update_ghost_dir = 0;
256
 
static long count_pnga_update_ghosts = 0;
257
 
static long count_pnga_uses_ma = 0;
258
 
static long count_pnga_uses_proc_grid = 0;
259
 
static long count_pnga_valid_handle = 0;
260
 
static long count_pnga_verify_handle = 0;
261
 
static long count_pnga_wtime = 0;
262
 
static long count_pnga_zero = 0;
263
 
static long count_pnga_zero_diagonal = 0;
264
 
static long count_pnga_zero_patch = 0;
265
 
 
266
 
static double time_pnga_abs_value = 0;
267
 
static double time_pnga_abs_value_patch = 0;
268
 
static double time_pnga_acc = 0;
269
 
static double time_pnga_access_block_grid_idx = 0;
270
 
static double time_pnga_access_block_grid_ptr = 0;
271
 
static double time_pnga_access_block_idx = 0;
272
 
static double time_pnga_access_block_ptr = 0;
273
 
static double time_pnga_access_block_segment_idx = 0;
274
 
static double time_pnga_access_block_segment_ptr = 0;
275
 
static double time_pnga_access_ghost_element = 0;
276
 
static double time_pnga_access_ghost_element_ptr = 0;
277
 
static double time_pnga_access_ghost_ptr = 0;
278
 
static double time_pnga_access_ghosts = 0;
279
 
static double time_pnga_access_idx = 0;
280
 
static double time_pnga_access_ptr = 0;
281
 
static double time_pnga_add = 0;
282
 
static double time_pnga_add_constant = 0;
283
 
static double time_pnga_add_constant_patch = 0;
284
 
static double time_pnga_add_diagonal = 0;
285
 
static double time_pnga_add_patch = 0;
286
 
static double time_pnga_allocate = 0;
287
 
static double time_pnga_bin_index = 0;
288
 
static double time_pnga_bin_sorter = 0;
289
 
static double time_pnga_brdcst = 0;
290
 
static double time_pnga_check_handle = 0;
291
 
static double time_pnga_cluster_nnodes = 0;
292
 
static double time_pnga_cluster_nodeid = 0;
293
 
static double time_pnga_cluster_nprocs = 0;
294
 
static double time_pnga_cluster_proc_nodeid = 0;
295
 
static double time_pnga_cluster_procid = 0;
296
 
static double time_pnga_comp_patch = 0;
297
 
static double time_pnga_compare_distr = 0;
298
 
static double time_pnga_copy = 0;
299
 
static double time_pnga_copy_patch = 0;
300
 
static double time_pnga_copy_patch_dp = 0;
301
 
static double time_pnga_create = 0;
302
 
static double time_pnga_create_bin_range = 0;
303
 
static double time_pnga_create_config = 0;
304
 
static double time_pnga_create_ghosts = 0;
305
 
static double time_pnga_create_ghosts_config = 0;
306
 
static double time_pnga_create_ghosts_irreg = 0;
307
 
static double time_pnga_create_ghosts_irreg_config = 0;
308
 
static double time_pnga_create_handle = 0;
309
 
static double time_pnga_create_irreg = 0;
310
 
static double time_pnga_create_irreg_config = 0;
311
 
static double time_pnga_create_mutexes = 0;
312
 
static double time_pnga_ddot_patch_dp = 0;
313
 
static double time_pnga_deregister_type = 0;
314
 
static double time_pnga_destroy = 0;
315
 
static double time_pnga_destroy_mutexes = 0;
316
 
static double time_pnga_diag = 0;
317
 
static double time_pnga_diag_reuse = 0;
318
 
static double time_pnga_diag_seq = 0;
319
 
static double time_pnga_diag_std = 0;
320
 
static double time_pnga_diag_std_seq = 0;
321
 
static double time_pnga_distribution = 0;
322
 
static double time_pnga_dot = 0;
323
 
static double time_pnga_dot_patch = 0;
324
 
static double time_pnga_duplicate = 0;
325
 
static double time_pnga_elem_divide = 0;
326
 
static double time_pnga_elem_divide_patch = 0;
327
 
static double time_pnga_elem_maximum = 0;
328
 
static double time_pnga_elem_maximum_patch = 0;
329
 
static double time_pnga_elem_minimum = 0;
330
 
static double time_pnga_elem_minimum_patch = 0;
331
 
static double time_pnga_elem_multiply = 0;
332
 
static double time_pnga_elem_multiply_patch = 0;
333
 
static double time_pnga_elem_step_divide_patch = 0;
334
 
static double time_pnga_elem_stepb_divide_patch = 0;
335
 
static double time_pnga_error = 0;
336
 
static double time_pnga_fence = 0;
337
 
static double time_pnga_fill = 0;
338
 
static double time_pnga_fill_patch = 0;
339
 
static double time_pnga_gather = 0;
340
 
static double time_pnga_gather2d = 0;
341
 
static double time_pnga_get = 0;
342
 
static double time_pnga_get_block_info = 0;
343
 
static double time_pnga_get_debug = 0;
344
 
static double time_pnga_get_diag = 0;
345
 
static double time_pnga_get_dimension = 0;
346
 
static double time_pnga_get_field = 0;
347
 
static double time_pnga_get_ghost_block = 0;
348
 
static double time_pnga_get_pgroup = 0;
349
 
static double time_pnga_get_pgroup_size = 0;
350
 
static double time_pnga_get_proc_grid = 0;
351
 
static double time_pnga_get_proc_index = 0;
352
 
static double time_pnga_ghost_barrier = 0;
353
 
static double time_pnga_gop = 0;
354
 
static double time_pnga_has_ghosts = 0;
355
 
static double time_pnga_init_fence = 0;
356
 
static double time_pnga_initialize = 0;
357
 
static double time_pnga_initialize_ltd = 0;
358
 
static double time_pnga_inquire = 0;
359
 
static double time_pnga_inquire_memory = 0;
360
 
static double time_pnga_inquire_name = 0;
361
 
static double time_pnga_inquire_type = 0;
362
 
static double time_pnga_is_mirrored = 0;
363
 
static double time_pnga_list_nodeid = 0;
364
 
static double time_pnga_llt_solve = 0;
365
 
static double time_pnga_locate = 0;
366
 
static double time_pnga_locate_nnodes = 0;
367
 
static double time_pnga_locate_num_blocks = 0;
368
 
static double time_pnga_locate_region = 0;
369
 
static double time_pnga_lock = 0;
370
 
static double time_pnga_lu_solve = 0;
371
 
static double time_pnga_lu_solve_alt = 0;
372
 
static double time_pnga_lu_solve_seq = 0;
373
 
static double time_pnga_mask_sync = 0;
374
 
static double time_pnga_matmul = 0;
375
 
static double time_pnga_matmul_mirrored = 0;
376
 
static double time_pnga_matmul_patch = 0;
377
 
static double time_pnga_median = 0;
378
 
static double time_pnga_median_patch = 0;
379
 
static double time_pnga_memory_avail = 0;
380
 
static double time_pnga_memory_avail_type = 0;
381
 
static double time_pnga_memory_limited = 0;
382
 
static double time_pnga_merge_distr_patch = 0;
383
 
static double time_pnga_merge_mirrored = 0;
384
 
static double time_pnga_msg_brdcst = 0;
385
 
static double time_pnga_msg_pgroup_sync = 0;
386
 
static double time_pnga_msg_sync = 0;
387
 
static double time_pnga_nbacc = 0;
388
 
static double time_pnga_nbget = 0;
389
 
static double time_pnga_nbget_field = 0;
390
 
static double time_pnga_nbget_ghost_dir = 0;
391
 
static double time_pnga_nblock = 0;
392
 
static double time_pnga_nbput = 0;
393
 
static double time_pnga_nbput_field = 0;
394
 
static double time_pnga_nbtest = 0;
395
 
static double time_pnga_nbwait = 0;
396
 
static double time_pnga_ndim = 0;
397
 
static double time_pnga_nnodes = 0;
398
 
static double time_pnga_nodeid = 0;
399
 
static double time_pnga_norm1 = 0;
400
 
static double time_pnga_norm_infinity = 0;
401
 
static double time_pnga_pack = 0;
402
 
static double time_pnga_patch_enum = 0;
403
 
static double time_pnga_patch_intersect = 0;
404
 
static double time_pnga_periodic = 0;
405
 
static double time_pnga_pgroup_absolute_id = 0;
406
 
static double time_pnga_pgroup_brdcst = 0;
407
 
static double time_pnga_pgroup_create = 0;
408
 
static double time_pnga_pgroup_destroy = 0;
409
 
static double time_pnga_pgroup_get_default = 0;
410
 
static double time_pnga_pgroup_get_mirror = 0;
411
 
static double time_pnga_pgroup_get_world = 0;
412
 
static double time_pnga_pgroup_gop = 0;
413
 
static double time_pnga_pgroup_nnodes = 0;
414
 
static double time_pnga_pgroup_nodeid = 0;
415
 
static double time_pnga_pgroup_set_default = 0;
416
 
static double time_pnga_pgroup_split = 0;
417
 
static double time_pnga_pgroup_split_irreg = 0;
418
 
static double time_pnga_pgroup_sync = 0;
419
 
static double time_pnga_print = 0;
420
 
static double time_pnga_print_distribution = 0;
421
 
static double time_pnga_print_file = 0;
422
 
static double time_pnga_print_patch = 0;
423
 
static double time_pnga_print_patch2d = 0;
424
 
static double time_pnga_print_patch_file = 0;
425
 
static double time_pnga_print_patch_file2d = 0;
426
 
static double time_pnga_print_stats = 0;
427
 
static double time_pnga_proc_topology = 0;
428
 
static double time_pnga_put = 0;
429
 
static double time_pnga_put_field = 0;
430
 
static double time_pnga_randomize = 0;
431
 
static double time_pnga_read_inc = 0;
432
 
static double time_pnga_recip = 0;
433
 
static double time_pnga_recip_patch = 0;
434
 
static double time_pnga_register_type = 0;
435
 
static double time_pnga_release = 0;
436
 
static double time_pnga_release_block = 0;
437
 
static double time_pnga_release_block_grid = 0;
438
 
static double time_pnga_release_block_segment = 0;
439
 
static double time_pnga_release_ghost_element = 0;
440
 
static double time_pnga_release_ghosts = 0;
441
 
static double time_pnga_release_update = 0;
442
 
static double time_pnga_release_update_block = 0;
443
 
static double time_pnga_release_update_block_grid = 0;
444
 
static double time_pnga_release_update_block_segment = 0;
445
 
static double time_pnga_release_update_ghost_element = 0;
446
 
static double time_pnga_release_update_ghosts = 0;
447
 
static double time_pnga_scale = 0;
448
 
static double time_pnga_scale_cols = 0;
449
 
static double time_pnga_scale_patch = 0;
450
 
static double time_pnga_scale_rows = 0;
451
 
static double time_pnga_scan_add = 0;
452
 
static double time_pnga_scan_copy = 0;
453
 
static double time_pnga_scatter = 0;
454
 
static double time_pnga_scatter2d = 0;
455
 
static double time_pnga_scatter_acc = 0;
456
 
static double time_pnga_scatter_acc2d = 0;
457
 
static double time_pnga_select_elem = 0;
458
 
static double time_pnga_set_array_name = 0;
459
 
static double time_pnga_set_block_cyclic = 0;
460
 
static double time_pnga_set_block_cyclic_proc_grid = 0;
461
 
static double time_pnga_set_chunk = 0;
462
 
static double time_pnga_set_data = 0;
463
 
static double time_pnga_set_debug = 0;
464
 
static double time_pnga_set_diagonal = 0;
465
 
static double time_pnga_set_ghost_corner_flag = 0;
466
 
static double time_pnga_set_ghost_info = 0;
467
 
static double time_pnga_set_ghosts = 0;
468
 
static double time_pnga_set_irreg_distr = 0;
469
 
static double time_pnga_set_irreg_flag = 0;
470
 
static double time_pnga_set_memory_limit = 0;
471
 
static double time_pnga_set_pgroup = 0;
472
 
static double time_pnga_set_restricted = 0;
473
 
static double time_pnga_set_restricted_range = 0;
474
 
static double time_pnga_set_update4_info = 0;
475
 
static double time_pnga_set_update5_info = 0;
476
 
static double time_pnga_shift_diagonal = 0;
477
 
static double time_pnga_solve = 0;
478
 
static double time_pnga_spd_invert = 0;
479
 
static double time_pnga_step_bound_info = 0;
480
 
static double time_pnga_step_bound_info_patch = 0;
481
 
static double time_pnga_step_mask_patch = 0;
482
 
static double time_pnga_step_max = 0;
483
 
static double time_pnga_step_max_patch = 0;
484
 
static double time_pnga_strided_acc = 0;
485
 
static double time_pnga_strided_get = 0;
486
 
static double time_pnga_strided_put = 0;
487
 
static double time_pnga_summarize = 0;
488
 
static double time_pnga_symmetrize = 0;
489
 
static double time_pnga_sync = 0;
490
 
static double time_pnga_terminate = 0;
491
 
static double time_pnga_timer = 0;
492
 
static double time_pnga_total_blocks = 0;
493
 
static double time_pnga_transpose = 0;
494
 
static double time_pnga_type_c2f = 0;
495
 
static double time_pnga_type_f2c = 0;
496
 
static double time_pnga_unlock = 0;
497
 
static double time_pnga_unpack = 0;
498
 
static double time_pnga_update1_ghosts = 0;
499
 
static double time_pnga_update2_ghosts = 0;
500
 
static double time_pnga_update3_ghosts = 0;
501
 
static double time_pnga_update44_ghosts = 0;
502
 
static double time_pnga_update4_ghosts = 0;
503
 
static double time_pnga_update55_ghosts = 0;
504
 
static double time_pnga_update5_ghosts = 0;
505
 
static double time_pnga_update6_ghosts = 0;
506
 
static double time_pnga_update7_ghosts = 0;
507
 
static double time_pnga_update_ghost_dir = 0;
508
 
static double time_pnga_update_ghosts = 0;
509
 
static double time_pnga_uses_ma = 0;
510
 
static double time_pnga_uses_proc_grid = 0;
511
 
static double time_pnga_valid_handle = 0;
512
 
static double time_pnga_verify_handle = 0;
513
 
static double time_pnga_wtime = 0;
514
 
static double time_pnga_zero = 0;
515
 
static double time_pnga_zero_diagonal = 0;
516
 
static double time_pnga_zero_patch = 0;
517
 
 
518
 
 
519
 
void wnga_abs_value(Integer g_a)
520
 
{
521
 
    double local_start, local_stop;
522
 
    ++count_pnga_abs_value;
523
 
    local_start = MPI_Wtime();
524
 
    pnga_abs_value(g_a);
525
 
    local_stop = MPI_Wtime();
526
 
    time_pnga_abs_value += local_stop - local_start;
527
 
}
528
 
 
529
 
 
530
 
void wnga_abs_value_patch(Integer g_a, Integer *lo, Integer *hi)
531
 
{
532
 
    double local_start, local_stop;
533
 
    ++count_pnga_abs_value_patch;
534
 
    local_start = MPI_Wtime();
535
 
    pnga_abs_value_patch(g_a, lo, hi);
536
 
    local_stop = MPI_Wtime();
537
 
    time_pnga_abs_value_patch += local_stop - local_start;
538
 
}
539
 
 
540
 
 
541
 
void wnga_acc(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld, void *alpha)
542
 
{
543
 
    double local_start, local_stop;
544
 
    ++count_pnga_acc;
545
 
    local_start = MPI_Wtime();
546
 
    pnga_acc(g_a, lo, hi, buf, ld, alpha);
547
 
    local_stop = MPI_Wtime();
548
 
    time_pnga_acc += local_stop - local_start;
549
 
}
550
 
 
551
 
 
552
 
void wnga_access_block_grid_idx(Integer g_a, Integer *subscript, AccessIndex *index, Integer *ld)
553
 
{
554
 
    double local_start, local_stop;
555
 
    ++count_pnga_access_block_grid_idx;
556
 
    local_start = MPI_Wtime();
557
 
    pnga_access_block_grid_idx(g_a, subscript, index, ld);
558
 
    local_stop = MPI_Wtime();
559
 
    time_pnga_access_block_grid_idx += local_stop - local_start;
560
 
}
561
 
 
562
 
 
563
 
void wnga_access_block_grid_ptr(Integer g_a, Integer *index, void *ptr, Integer *ld)
564
 
{
565
 
    double local_start, local_stop;
566
 
    ++count_pnga_access_block_grid_ptr;
567
 
    local_start = MPI_Wtime();
568
 
    pnga_access_block_grid_ptr(g_a, index, ptr, ld);
569
 
    local_stop = MPI_Wtime();
570
 
    time_pnga_access_block_grid_ptr += local_stop - local_start;
571
 
}
572
 
 
573
 
 
574
 
void wnga_access_block_idx(Integer g_a, Integer idx, AccessIndex *index, Integer *ld)
575
 
{
576
 
    double local_start, local_stop;
577
 
    ++count_pnga_access_block_idx;
578
 
    local_start = MPI_Wtime();
579
 
    pnga_access_block_idx(g_a, idx, index, ld);
580
 
    local_stop = MPI_Wtime();
581
 
    time_pnga_access_block_idx += local_stop - local_start;
582
 
}
583
 
 
584
 
 
585
 
void wnga_access_block_ptr(Integer g_a, Integer idx, void *ptr, Integer *ld)
586
 
{
587
 
    double local_start, local_stop;
588
 
    ++count_pnga_access_block_ptr;
589
 
    local_start = MPI_Wtime();
590
 
    pnga_access_block_ptr(g_a, idx, ptr, ld);
591
 
    local_stop = MPI_Wtime();
592
 
    time_pnga_access_block_ptr += local_stop - local_start;
593
 
}
594
 
 
595
 
 
596
 
void wnga_access_block_segment_idx(Integer g_a, Integer proc, AccessIndex *index, Integer *len)
597
 
{
598
 
    double local_start, local_stop;
599
 
    ++count_pnga_access_block_segment_idx;
600
 
    local_start = MPI_Wtime();
601
 
    pnga_access_block_segment_idx(g_a, proc, index, len);
602
 
    local_stop = MPI_Wtime();
603
 
    time_pnga_access_block_segment_idx += local_stop - local_start;
604
 
}
605
 
 
606
 
 
607
 
void wnga_access_block_segment_ptr(Integer g_a, Integer proc, void *ptr, Integer *len)
608
 
{
609
 
    double local_start, local_stop;
610
 
    ++count_pnga_access_block_segment_ptr;
611
 
    local_start = MPI_Wtime();
612
 
    pnga_access_block_segment_ptr(g_a, proc, ptr, len);
613
 
    local_stop = MPI_Wtime();
614
 
    time_pnga_access_block_segment_ptr += local_stop - local_start;
615
 
}
616
 
 
617
 
 
618
 
void wnga_access_ghost_element(Integer g_a, AccessIndex *index, Integer subscript[], Integer ld[])
619
 
{
620
 
    double local_start, local_stop;
621
 
    ++count_pnga_access_ghost_element;
622
 
    local_start = MPI_Wtime();
623
 
    pnga_access_ghost_element(g_a, index, subscript, ld);
624
 
    local_stop = MPI_Wtime();
625
 
    time_pnga_access_ghost_element += local_stop - local_start;
626
 
}
627
 
 
628
 
 
629
 
void wnga_access_ghost_element_ptr(Integer g_a, void *ptr, Integer subscript[], Integer ld[])
630
 
{
631
 
    double local_start, local_stop;
632
 
    ++count_pnga_access_ghost_element_ptr;
633
 
    local_start = MPI_Wtime();
634
 
    pnga_access_ghost_element_ptr(g_a, ptr, subscript, ld);
635
 
    local_stop = MPI_Wtime();
636
 
    time_pnga_access_ghost_element_ptr += local_stop - local_start;
637
 
}
638
 
 
639
 
 
640
 
void wnga_access_ghost_ptr(Integer g_a, Integer dims[], void *ptr, Integer ld[])
641
 
{
642
 
    double local_start, local_stop;
643
 
    ++count_pnga_access_ghost_ptr;
644
 
    local_start = MPI_Wtime();
645
 
    pnga_access_ghost_ptr(g_a, dims, ptr, ld);
646
 
    local_stop = MPI_Wtime();
647
 
    time_pnga_access_ghost_ptr += local_stop - local_start;
648
 
}
649
 
 
650
 
 
651
 
void wnga_access_ghosts(Integer g_a, Integer dims[], AccessIndex *index, Integer ld[])
652
 
{
653
 
    double local_start, local_stop;
654
 
    ++count_pnga_access_ghosts;
655
 
    local_start = MPI_Wtime();
656
 
    pnga_access_ghosts(g_a, dims, index, ld);
657
 
    local_stop = MPI_Wtime();
658
 
    time_pnga_access_ghosts += local_stop - local_start;
659
 
}
660
 
 
661
 
 
662
 
void wnga_access_idx(Integer g_a, Integer *lo, Integer *hi, AccessIndex *index, Integer *ld)
663
 
{
664
 
    double local_start, local_stop;
665
 
    ++count_pnga_access_idx;
666
 
    local_start = MPI_Wtime();
667
 
    pnga_access_idx(g_a, lo, hi, index, ld);
668
 
    local_stop = MPI_Wtime();
669
 
    time_pnga_access_idx += local_stop - local_start;
670
 
}
671
 
 
672
 
 
673
 
void wnga_access_ptr(Integer g_a, Integer *lo, Integer *hi, void *ptr, Integer *ld)
674
 
{
675
 
    double local_start, local_stop;
676
 
    ++count_pnga_access_ptr;
677
 
    local_start = MPI_Wtime();
678
 
    pnga_access_ptr(g_a, lo, hi, ptr, ld);
679
 
    local_stop = MPI_Wtime();
680
 
    time_pnga_access_ptr += local_stop - local_start;
681
 
}
682
 
 
683
 
 
684
 
void wnga_add(void *alpha, Integer g_a, void *beta, Integer g_b, Integer g_c)
685
 
{
686
 
    double local_start, local_stop;
687
 
    ++count_pnga_add;
688
 
    local_start = MPI_Wtime();
689
 
    pnga_add(alpha, g_a, beta, g_b, g_c);
690
 
    local_stop = MPI_Wtime();
691
 
    time_pnga_add += local_stop - local_start;
692
 
}
693
 
 
694
 
 
695
 
void wnga_add_constant(Integer g_a, void *alpha)
696
 
{
697
 
    double local_start, local_stop;
698
 
    ++count_pnga_add_constant;
699
 
    local_start = MPI_Wtime();
700
 
    pnga_add_constant(g_a, alpha);
701
 
    local_stop = MPI_Wtime();
702
 
    time_pnga_add_constant += local_stop - local_start;
703
 
}
704
 
 
705
 
 
706
 
void wnga_add_constant_patch(Integer g_a, Integer *lo, Integer *hi, void *alpha)
707
 
{
708
 
    double local_start, local_stop;
709
 
    ++count_pnga_add_constant_patch;
710
 
    local_start = MPI_Wtime();
711
 
    pnga_add_constant_patch(g_a, lo, hi, alpha);
712
 
    local_stop = MPI_Wtime();
713
 
    time_pnga_add_constant_patch += local_stop - local_start;
714
 
}
715
 
 
716
 
 
717
 
void wnga_add_diagonal(Integer g_a, Integer g_v)
718
 
{
719
 
    double local_start, local_stop;
720
 
    ++count_pnga_add_diagonal;
721
 
    local_start = MPI_Wtime();
722
 
    pnga_add_diagonal(g_a, g_v);
723
 
    local_stop = MPI_Wtime();
724
 
    time_pnga_add_diagonal += local_stop - local_start;
725
 
}
726
 
 
727
 
 
728
 
void wnga_add_patch(void *alpha, Integer g_a, Integer *alo, Integer *ahi, void *beta, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
729
 
{
730
 
    double local_start, local_stop;
731
 
    ++count_pnga_add_patch;
732
 
    local_start = MPI_Wtime();
733
 
    pnga_add_patch(alpha, g_a, alo, ahi, beta, g_b, blo, bhi, g_c, clo, chi);
734
 
    local_stop = MPI_Wtime();
735
 
    time_pnga_add_patch += local_stop - local_start;
736
 
}
737
 
 
738
 
 
739
 
logical wnga_allocate(Integer g_a)
740
 
{
741
 
    logical return_value;
742
 
    double local_start, local_stop;
743
 
    ++count_pnga_allocate;
744
 
    local_start = MPI_Wtime();
745
 
    return_value = pnga_allocate(g_a);
746
 
    local_stop = MPI_Wtime();
747
 
    time_pnga_allocate += local_stop - local_start;
748
 
    return return_value;
749
 
}
750
 
 
751
 
 
752
 
void wnga_bin_index(Integer g_bin, Integer g_cnt, Integer g_off, Integer *values, Integer *subs, Integer n, Integer sortit)
753
 
{
754
 
    double local_start, local_stop;
755
 
    ++count_pnga_bin_index;
756
 
    local_start = MPI_Wtime();
757
 
    pnga_bin_index(g_bin, g_cnt, g_off, values, subs, n, sortit);
758
 
    local_stop = MPI_Wtime();
759
 
    time_pnga_bin_index += local_stop - local_start;
760
 
}
761
 
 
762
 
 
763
 
void wnga_bin_sorter(Integer g_bin, Integer g_cnt, Integer g_off)
764
 
{
765
 
    double local_start, local_stop;
766
 
    ++count_pnga_bin_sorter;
767
 
    local_start = MPI_Wtime();
768
 
    pnga_bin_sorter(g_bin, g_cnt, g_off);
769
 
    local_stop = MPI_Wtime();
770
 
    time_pnga_bin_sorter += local_stop - local_start;
771
 
}
772
 
 
773
 
 
774
 
void wnga_brdcst(Integer type, void *buf, Integer len, Integer originator)
775
 
{
776
 
    double local_start, local_stop;
777
 
    ++count_pnga_brdcst;
778
 
    local_start = MPI_Wtime();
779
 
    pnga_brdcst(type, buf, len, originator);
780
 
    local_stop = MPI_Wtime();
781
 
    time_pnga_brdcst += local_stop - local_start;
782
 
}
783
 
 
784
 
 
785
 
void wnga_check_handle(Integer g_a, char *string)
786
 
{
787
 
    double local_start, local_stop;
788
 
    ++count_pnga_check_handle;
789
 
    local_start = MPI_Wtime();
790
 
    pnga_check_handle(g_a, string);
791
 
    local_stop = MPI_Wtime();
792
 
    time_pnga_check_handle += local_stop - local_start;
793
 
}
794
 
 
795
 
 
796
 
Integer wnga_cluster_nnodes()
797
 
{
798
 
    Integer return_value;
799
 
    double local_start, local_stop;
800
 
    ++count_pnga_cluster_nnodes;
801
 
    local_start = MPI_Wtime();
802
 
    return_value = pnga_cluster_nnodes();
803
 
    local_stop = MPI_Wtime();
804
 
    time_pnga_cluster_nnodes += local_stop - local_start;
805
 
    return return_value;
806
 
}
807
 
 
808
 
 
809
 
Integer wnga_cluster_nodeid()
810
 
{
811
 
    Integer return_value;
812
 
    double local_start, local_stop;
813
 
    ++count_pnga_cluster_nodeid;
814
 
    local_start = MPI_Wtime();
815
 
    return_value = pnga_cluster_nodeid();
816
 
    local_stop = MPI_Wtime();
817
 
    time_pnga_cluster_nodeid += local_stop - local_start;
818
 
    return return_value;
819
 
}
820
 
 
821
 
 
822
 
Integer wnga_cluster_nprocs(Integer node)
823
 
{
824
 
    Integer return_value;
825
 
    double local_start, local_stop;
826
 
    ++count_pnga_cluster_nprocs;
827
 
    local_start = MPI_Wtime();
828
 
    return_value = pnga_cluster_nprocs(node);
829
 
    local_stop = MPI_Wtime();
830
 
    time_pnga_cluster_nprocs += local_stop - local_start;
831
 
    return return_value;
832
 
}
833
 
 
834
 
 
835
 
Integer wnga_cluster_proc_nodeid(Integer proc)
836
 
{
837
 
    Integer return_value;
838
 
    double local_start, local_stop;
839
 
    ++count_pnga_cluster_proc_nodeid;
840
 
    local_start = MPI_Wtime();
841
 
    return_value = pnga_cluster_proc_nodeid(proc);
842
 
    local_stop = MPI_Wtime();
843
 
    time_pnga_cluster_proc_nodeid += local_stop - local_start;
844
 
    return return_value;
845
 
}
846
 
 
847
 
 
848
 
Integer wnga_cluster_procid(Integer node, Integer loc_proc_id)
849
 
{
850
 
    Integer return_value;
851
 
    double local_start, local_stop;
852
 
    ++count_pnga_cluster_procid;
853
 
    local_start = MPI_Wtime();
854
 
    return_value = pnga_cluster_procid(node, loc_proc_id);
855
 
    local_stop = MPI_Wtime();
856
 
    time_pnga_cluster_procid += local_stop - local_start;
857
 
    return return_value;
858
 
}
859
 
 
860
 
 
861
 
logical wnga_comp_patch(Integer andim, Integer *alo, Integer *ahi, Integer bndim, Integer *blo, Integer *bhi)
862
 
{
863
 
    logical return_value;
864
 
    double local_start, local_stop;
865
 
    ++count_pnga_comp_patch;
866
 
    local_start = MPI_Wtime();
867
 
    return_value = pnga_comp_patch(andim, alo, ahi, bndim, blo, bhi);
868
 
    local_stop = MPI_Wtime();
869
 
    time_pnga_comp_patch += local_stop - local_start;
870
 
    return return_value;
871
 
}
872
 
 
873
 
 
874
 
logical wnga_compare_distr(Integer g_a, Integer g_b)
875
 
{
876
 
    logical return_value;
877
 
    double local_start, local_stop;
878
 
    ++count_pnga_compare_distr;
879
 
    local_start = MPI_Wtime();
880
 
    return_value = pnga_compare_distr(g_a, g_b);
881
 
    local_stop = MPI_Wtime();
882
 
    time_pnga_compare_distr += local_stop - local_start;
883
 
    return return_value;
884
 
}
885
 
 
886
 
 
887
 
void wnga_copy(Integer g_a, Integer g_b)
888
 
{
889
 
    double local_start, local_stop;
890
 
    ++count_pnga_copy;
891
 
    local_start = MPI_Wtime();
892
 
    pnga_copy(g_a, g_b);
893
 
    local_stop = MPI_Wtime();
894
 
    time_pnga_copy += local_stop - local_start;
895
 
}
896
 
 
897
 
 
898
 
void wnga_copy_patch(char *trans, Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi)
899
 
{
900
 
    double local_start, local_stop;
901
 
    ++count_pnga_copy_patch;
902
 
    local_start = MPI_Wtime();
903
 
    pnga_copy_patch(trans, g_a, alo, ahi, g_b, blo, bhi);
904
 
    local_stop = MPI_Wtime();
905
 
    time_pnga_copy_patch += local_stop - local_start;
906
 
}
907
 
 
908
 
 
909
 
void wnga_copy_patch_dp(char *t_a, Integer g_a, Integer ailo, Integer aihi, Integer ajlo, Integer ajhi, Integer g_b, Integer bilo, Integer bihi, Integer bjlo, Integer bjhi)
910
 
{
911
 
    double local_start, local_stop;
912
 
    ++count_pnga_copy_patch_dp;
913
 
    local_start = MPI_Wtime();
914
 
    pnga_copy_patch_dp(t_a, g_a, ailo, aihi, ajlo, ajhi, g_b, bilo, bihi, bjlo, bjhi);
915
 
    local_stop = MPI_Wtime();
916
 
    time_pnga_copy_patch_dp += local_stop - local_start;
917
 
}
918
 
 
919
 
 
920
 
logical wnga_create(Integer type, Integer ndim, Integer *dims, char *name, Integer *chunk, Integer *g_a)
921
 
{
922
 
    logical return_value;
923
 
    double local_start, local_stop;
924
 
    ++count_pnga_create;
925
 
    local_start = MPI_Wtime();
926
 
    return_value = pnga_create(type, ndim, dims, name, chunk, g_a);
927
 
    local_stop = MPI_Wtime();
928
 
    time_pnga_create += local_stop - local_start;
929
 
    return return_value;
930
 
}
931
 
 
932
 
 
933
 
logical wnga_create_bin_range(Integer g_bin, Integer g_cnt, Integer g_off, Integer *g_range)
934
 
{
935
 
    logical return_value;
936
 
    double local_start, local_stop;
937
 
    ++count_pnga_create_bin_range;
938
 
    local_start = MPI_Wtime();
939
 
    return_value = pnga_create_bin_range(g_bin, g_cnt, g_off, g_range);
940
 
    local_stop = MPI_Wtime();
941
 
    time_pnga_create_bin_range += local_stop - local_start;
942
 
    return return_value;
943
 
}
944
 
 
945
 
 
946
 
logical wnga_create_config(Integer type, Integer ndim, Integer *dims, char *name, Integer *chunk, Integer p_handle, Integer *g_a)
947
 
{
948
 
    logical return_value;
949
 
    double local_start, local_stop;
950
 
    ++count_pnga_create_config;
951
 
    local_start = MPI_Wtime();
952
 
    return_value = pnga_create_config(type, ndim, dims, name, chunk, p_handle, g_a);
953
 
    local_stop = MPI_Wtime();
954
 
    time_pnga_create_config += local_stop - local_start;
955
 
    return return_value;
956
 
}
957
 
 
958
 
 
959
 
logical wnga_create_ghosts(Integer type, Integer ndim, Integer *dims, Integer *width, char *name, Integer *chunk, Integer *g_a)
960
 
{
961
 
    logical return_value;
962
 
    double local_start, local_stop;
963
 
    ++count_pnga_create_ghosts;
964
 
    local_start = MPI_Wtime();
965
 
    return_value = pnga_create_ghosts(type, ndim, dims, width, name, chunk, g_a);
966
 
    local_stop = MPI_Wtime();
967
 
    time_pnga_create_ghosts += local_stop - local_start;
968
 
    return return_value;
969
 
}
970
 
 
971
 
 
972
 
logical wnga_create_ghosts_config(Integer type, Integer ndim, Integer *dims, Integer *width, char *name, Integer *chunk, Integer p_handle, Integer *g_a)
973
 
{
974
 
    logical return_value;
975
 
    double local_start, local_stop;
976
 
    ++count_pnga_create_ghosts_config;
977
 
    local_start = MPI_Wtime();
978
 
    return_value = pnga_create_ghosts_config(type, ndim, dims, width, name, chunk, p_handle, g_a);
979
 
    local_stop = MPI_Wtime();
980
 
    time_pnga_create_ghosts_config += local_stop - local_start;
981
 
    return return_value;
982
 
}
983
 
 
984
 
 
985
 
logical wnga_create_ghosts_irreg(Integer type, Integer ndim, Integer *dims, Integer *width, char *name, Integer *map, Integer *block, Integer *g_a)
986
 
{
987
 
    logical return_value;
988
 
    double local_start, local_stop;
989
 
    ++count_pnga_create_ghosts_irreg;
990
 
    local_start = MPI_Wtime();
991
 
    return_value = pnga_create_ghosts_irreg(type, ndim, dims, width, name, map, block, g_a);
992
 
    local_stop = MPI_Wtime();
993
 
    time_pnga_create_ghosts_irreg += local_stop - local_start;
994
 
    return return_value;
995
 
}
996
 
 
997
 
 
998
 
logical wnga_create_ghosts_irreg_config(Integer type, Integer ndim, Integer *dims, Integer *width, char *name, Integer *map, Integer *block, Integer p_handle, Integer *g_a)
999
 
{
1000
 
    logical return_value;
1001
 
    double local_start, local_stop;
1002
 
    ++count_pnga_create_ghosts_irreg_config;
1003
 
    local_start = MPI_Wtime();
1004
 
    return_value = pnga_create_ghosts_irreg_config(type, ndim, dims, width, name, map, block, p_handle, g_a);
1005
 
    local_stop = MPI_Wtime();
1006
 
    time_pnga_create_ghosts_irreg_config += local_stop - local_start;
1007
 
    return return_value;
1008
 
}
1009
 
 
1010
 
 
1011
 
Integer wnga_create_handle()
1012
 
{
1013
 
    Integer return_value;
1014
 
    double local_start, local_stop;
1015
 
    ++count_pnga_create_handle;
1016
 
    local_start = MPI_Wtime();
1017
 
    return_value = pnga_create_handle();
1018
 
    local_stop = MPI_Wtime();
1019
 
    time_pnga_create_handle += local_stop - local_start;
1020
 
    return return_value;
1021
 
}
1022
 
 
1023
 
 
1024
 
logical wnga_create_irreg(Integer type, Integer ndim, Integer *dims, char *name, Integer *map, Integer *block, Integer *g_a)
1025
 
{
1026
 
    logical return_value;
1027
 
    double local_start, local_stop;
1028
 
    ++count_pnga_create_irreg;
1029
 
    local_start = MPI_Wtime();
1030
 
    return_value = pnga_create_irreg(type, ndim, dims, name, map, block, g_a);
1031
 
    local_stop = MPI_Wtime();
1032
 
    time_pnga_create_irreg += local_stop - local_start;
1033
 
    return return_value;
1034
 
}
1035
 
 
1036
 
 
1037
 
logical wnga_create_irreg_config(Integer type, Integer ndim, Integer *dims, char *name, Integer *map, Integer *block, Integer p_handle, Integer *g_a)
1038
 
{
1039
 
    logical return_value;
1040
 
    double local_start, local_stop;
1041
 
    ++count_pnga_create_irreg_config;
1042
 
    local_start = MPI_Wtime();
1043
 
    return_value = pnga_create_irreg_config(type, ndim, dims, name, map, block, p_handle, g_a);
1044
 
    local_stop = MPI_Wtime();
1045
 
    time_pnga_create_irreg_config += local_stop - local_start;
1046
 
    return return_value;
1047
 
}
1048
 
 
1049
 
 
1050
 
logical wnga_create_mutexes(Integer num)
1051
 
{
1052
 
    logical return_value;
1053
 
    double local_start, local_stop;
1054
 
    ++count_pnga_create_mutexes;
1055
 
    local_start = MPI_Wtime();
1056
 
    return_value = pnga_create_mutexes(num);
1057
 
    local_stop = MPI_Wtime();
1058
 
    time_pnga_create_mutexes += local_stop - local_start;
1059
 
    return return_value;
1060
 
}
1061
 
 
1062
 
 
1063
 
DoublePrecision wnga_ddot_patch_dp(Integer g_a, char *t_a, Integer ailo, Integer aihi, Integer ajlo, Integer ajhi, Integer g_b, char *t_b, Integer bilo, Integer bihi, Integer bjlo, Integer bjhi)
1064
 
{
1065
 
    DoublePrecision return_value;
1066
 
    double local_start, local_stop;
1067
 
    ++count_pnga_ddot_patch_dp;
1068
 
    local_start = MPI_Wtime();
1069
 
    return_value = pnga_ddot_patch_dp(g_a, t_a, ailo, aihi, ajlo, ajhi, g_b, t_b, bilo, bihi, bjlo, bjhi);
1070
 
    local_stop = MPI_Wtime();
1071
 
    time_pnga_ddot_patch_dp += local_stop - local_start;
1072
 
    return return_value;
1073
 
}
1074
 
 
1075
 
 
1076
 
int wnga_deregister_type(int type)
1077
 
{
1078
 
    int return_value;
1079
 
    double local_start, local_stop;
1080
 
    ++count_pnga_deregister_type;
1081
 
    local_start = MPI_Wtime();
1082
 
    return_value = pnga_deregister_type(type);
1083
 
    local_stop = MPI_Wtime();
1084
 
    time_pnga_deregister_type += local_stop - local_start;
1085
 
    return return_value;
1086
 
}
1087
 
 
1088
 
 
1089
 
logical wnga_destroy(Integer g_a)
1090
 
{
1091
 
    logical return_value;
1092
 
    double local_start, local_stop;
1093
 
    ++count_pnga_destroy;
1094
 
    local_start = MPI_Wtime();
1095
 
    return_value = pnga_destroy(g_a);
1096
 
    local_stop = MPI_Wtime();
1097
 
    time_pnga_destroy += local_stop - local_start;
1098
 
    return return_value;
1099
 
}
1100
 
 
1101
 
 
1102
 
logical wnga_destroy_mutexes()
1103
 
{
1104
 
    logical return_value;
1105
 
    double local_start, local_stop;
1106
 
    ++count_pnga_destroy_mutexes;
1107
 
    local_start = MPI_Wtime();
1108
 
    return_value = pnga_destroy_mutexes();
1109
 
    local_stop = MPI_Wtime();
1110
 
    time_pnga_destroy_mutexes += local_stop - local_start;
1111
 
    return return_value;
1112
 
}
1113
 
 
1114
 
 
1115
 
void wnga_diag(Integer g_a, Integer g_s, Integer g_v, DoublePrecision *eval)
1116
 
{
1117
 
    double local_start, local_stop;
1118
 
    ++count_pnga_diag;
1119
 
    local_start = MPI_Wtime();
1120
 
    pnga_diag(g_a, g_s, g_v, eval);
1121
 
    local_stop = MPI_Wtime();
1122
 
    time_pnga_diag += local_stop - local_start;
1123
 
}
1124
 
 
1125
 
 
1126
 
void wnga_diag_reuse(Integer reuse, Integer g_a, Integer g_s, Integer g_v, DoublePrecision *eval)
1127
 
{
1128
 
    double local_start, local_stop;
1129
 
    ++count_pnga_diag_reuse;
1130
 
    local_start = MPI_Wtime();
1131
 
    pnga_diag_reuse(reuse, g_a, g_s, g_v, eval);
1132
 
    local_stop = MPI_Wtime();
1133
 
    time_pnga_diag_reuse += local_stop - local_start;
1134
 
}
1135
 
 
1136
 
 
1137
 
void wnga_diag_seq(Integer g_a, Integer g_s, Integer g_v, DoublePrecision *eval)
1138
 
{
1139
 
    double local_start, local_stop;
1140
 
    ++count_pnga_diag_seq;
1141
 
    local_start = MPI_Wtime();
1142
 
    pnga_diag_seq(g_a, g_s, g_v, eval);
1143
 
    local_stop = MPI_Wtime();
1144
 
    time_pnga_diag_seq += local_stop - local_start;
1145
 
}
1146
 
 
1147
 
 
1148
 
void wnga_diag_std(Integer g_a, Integer g_v, DoublePrecision *eval)
1149
 
{
1150
 
    double local_start, local_stop;
1151
 
    ++count_pnga_diag_std;
1152
 
    local_start = MPI_Wtime();
1153
 
    pnga_diag_std(g_a, g_v, eval);
1154
 
    local_stop = MPI_Wtime();
1155
 
    time_pnga_diag_std += local_stop - local_start;
1156
 
}
1157
 
 
1158
 
 
1159
 
void wnga_diag_std_seq(Integer g_a, Integer g_v, DoublePrecision *eval)
1160
 
{
1161
 
    double local_start, local_stop;
1162
 
    ++count_pnga_diag_std_seq;
1163
 
    local_start = MPI_Wtime();
1164
 
    pnga_diag_std_seq(g_a, g_v, eval);
1165
 
    local_stop = MPI_Wtime();
1166
 
    time_pnga_diag_std_seq += local_stop - local_start;
1167
 
}
1168
 
 
1169
 
 
1170
 
void wnga_distribution(Integer g_a, Integer proc, Integer *lo, Integer *hi)
1171
 
{
1172
 
    double local_start, local_stop;
1173
 
    ++count_pnga_distribution;
1174
 
    local_start = MPI_Wtime();
1175
 
    pnga_distribution(g_a, proc, lo, hi);
1176
 
    local_stop = MPI_Wtime();
1177
 
    time_pnga_distribution += local_stop - local_start;
1178
 
}
1179
 
 
1180
 
 
1181
 
void wnga_dot(int type, Integer g_a, Integer g_b, void *value)
1182
 
{
1183
 
    double local_start, local_stop;
1184
 
    ++count_pnga_dot;
1185
 
    local_start = MPI_Wtime();
1186
 
    pnga_dot(type, g_a, g_b, value);
1187
 
    local_stop = MPI_Wtime();
1188
 
    time_pnga_dot += local_stop - local_start;
1189
 
}
1190
 
 
1191
 
 
1192
 
void wnga_dot_patch(Integer g_a, char *t_a, Integer *alo, Integer *ahi, Integer g_b, char *t_b, Integer *blo, Integer *bhi, void *retval)
1193
 
{
1194
 
    double local_start, local_stop;
1195
 
    ++count_pnga_dot_patch;
1196
 
    local_start = MPI_Wtime();
1197
 
    pnga_dot_patch(g_a, t_a, alo, ahi, g_b, t_b, blo, bhi, retval);
1198
 
    local_stop = MPI_Wtime();
1199
 
    time_pnga_dot_patch += local_stop - local_start;
1200
 
}
1201
 
 
1202
 
 
1203
 
logical wnga_duplicate(Integer g_a, Integer *g_b, char *array_name)
1204
 
{
1205
 
    logical return_value;
1206
 
    double local_start, local_stop;
1207
 
    ++count_pnga_duplicate;
1208
 
    local_start = MPI_Wtime();
1209
 
    return_value = pnga_duplicate(g_a, g_b, array_name);
1210
 
    local_stop = MPI_Wtime();
1211
 
    time_pnga_duplicate += local_stop - local_start;
1212
 
    return return_value;
1213
 
}
1214
 
 
1215
 
 
1216
 
void wnga_elem_divide(Integer g_a, Integer g_b, Integer g_c)
1217
 
{
1218
 
    double local_start, local_stop;
1219
 
    ++count_pnga_elem_divide;
1220
 
    local_start = MPI_Wtime();
1221
 
    pnga_elem_divide(g_a, g_b, g_c);
1222
 
    local_stop = MPI_Wtime();
1223
 
    time_pnga_elem_divide += local_stop - local_start;
1224
 
}
1225
 
 
1226
 
 
1227
 
void wnga_elem_divide_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1228
 
{
1229
 
    double local_start, local_stop;
1230
 
    ++count_pnga_elem_divide_patch;
1231
 
    local_start = MPI_Wtime();
1232
 
    pnga_elem_divide_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1233
 
    local_stop = MPI_Wtime();
1234
 
    time_pnga_elem_divide_patch += local_stop - local_start;
1235
 
}
1236
 
 
1237
 
 
1238
 
void wnga_elem_maximum(Integer g_a, Integer g_b, Integer g_c)
1239
 
{
1240
 
    double local_start, local_stop;
1241
 
    ++count_pnga_elem_maximum;
1242
 
    local_start = MPI_Wtime();
1243
 
    pnga_elem_maximum(g_a, g_b, g_c);
1244
 
    local_stop = MPI_Wtime();
1245
 
    time_pnga_elem_maximum += local_stop - local_start;
1246
 
}
1247
 
 
1248
 
 
1249
 
void wnga_elem_maximum_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1250
 
{
1251
 
    double local_start, local_stop;
1252
 
    ++count_pnga_elem_maximum_patch;
1253
 
    local_start = MPI_Wtime();
1254
 
    pnga_elem_maximum_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1255
 
    local_stop = MPI_Wtime();
1256
 
    time_pnga_elem_maximum_patch += local_stop - local_start;
1257
 
}
1258
 
 
1259
 
 
1260
 
void wnga_elem_minimum(Integer g_a, Integer g_b, Integer g_c)
1261
 
{
1262
 
    double local_start, local_stop;
1263
 
    ++count_pnga_elem_minimum;
1264
 
    local_start = MPI_Wtime();
1265
 
    pnga_elem_minimum(g_a, g_b, g_c);
1266
 
    local_stop = MPI_Wtime();
1267
 
    time_pnga_elem_minimum += local_stop - local_start;
1268
 
}
1269
 
 
1270
 
 
1271
 
void wnga_elem_minimum_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1272
 
{
1273
 
    double local_start, local_stop;
1274
 
    ++count_pnga_elem_minimum_patch;
1275
 
    local_start = MPI_Wtime();
1276
 
    pnga_elem_minimum_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1277
 
    local_stop = MPI_Wtime();
1278
 
    time_pnga_elem_minimum_patch += local_stop - local_start;
1279
 
}
1280
 
 
1281
 
 
1282
 
void wnga_elem_multiply(Integer g_a, Integer g_b, Integer g_c)
1283
 
{
1284
 
    double local_start, local_stop;
1285
 
    ++count_pnga_elem_multiply;
1286
 
    local_start = MPI_Wtime();
1287
 
    pnga_elem_multiply(g_a, g_b, g_c);
1288
 
    local_stop = MPI_Wtime();
1289
 
    time_pnga_elem_multiply += local_stop - local_start;
1290
 
}
1291
 
 
1292
 
 
1293
 
void wnga_elem_multiply_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1294
 
{
1295
 
    double local_start, local_stop;
1296
 
    ++count_pnga_elem_multiply_patch;
1297
 
    local_start = MPI_Wtime();
1298
 
    pnga_elem_multiply_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1299
 
    local_stop = MPI_Wtime();
1300
 
    time_pnga_elem_multiply_patch += local_stop - local_start;
1301
 
}
1302
 
 
1303
 
 
1304
 
void wnga_elem_step_divide_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1305
 
{
1306
 
    double local_start, local_stop;
1307
 
    ++count_pnga_elem_step_divide_patch;
1308
 
    local_start = MPI_Wtime();
1309
 
    pnga_elem_step_divide_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1310
 
    local_stop = MPI_Wtime();
1311
 
    time_pnga_elem_step_divide_patch += local_stop - local_start;
1312
 
}
1313
 
 
1314
 
 
1315
 
void wnga_elem_stepb_divide_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
1316
 
{
1317
 
    double local_start, local_stop;
1318
 
    ++count_pnga_elem_stepb_divide_patch;
1319
 
    local_start = MPI_Wtime();
1320
 
    pnga_elem_stepb_divide_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1321
 
    local_stop = MPI_Wtime();
1322
 
    time_pnga_elem_stepb_divide_patch += local_stop - local_start;
1323
 
}
1324
 
 
1325
 
 
1326
 
void wnga_error(char *string, Integer icode)
1327
 
{
1328
 
    double local_start, local_stop;
1329
 
    ++count_pnga_error;
1330
 
    local_start = MPI_Wtime();
1331
 
    pnga_error(string, icode);
1332
 
    local_stop = MPI_Wtime();
1333
 
    time_pnga_error += local_stop - local_start;
1334
 
}
1335
 
 
1336
 
 
1337
 
void wnga_fence()
1338
 
{
1339
 
    double local_start, local_stop;
1340
 
    ++count_pnga_fence;
1341
 
    local_start = MPI_Wtime();
1342
 
    pnga_fence();
1343
 
    local_stop = MPI_Wtime();
1344
 
    time_pnga_fence += local_stop - local_start;
1345
 
}
1346
 
 
1347
 
 
1348
 
void wnga_fill(Integer g_a, void *val)
1349
 
{
1350
 
    double local_start, local_stop;
1351
 
    ++count_pnga_fill;
1352
 
    local_start = MPI_Wtime();
1353
 
    pnga_fill(g_a, val);
1354
 
    local_stop = MPI_Wtime();
1355
 
    time_pnga_fill += local_stop - local_start;
1356
 
}
1357
 
 
1358
 
 
1359
 
void wnga_fill_patch(Integer g_a, Integer *lo, Integer *hi, void *val)
1360
 
{
1361
 
    double local_start, local_stop;
1362
 
    ++count_pnga_fill_patch;
1363
 
    local_start = MPI_Wtime();
1364
 
    pnga_fill_patch(g_a, lo, hi, val);
1365
 
    local_stop = MPI_Wtime();
1366
 
    time_pnga_fill_patch += local_stop - local_start;
1367
 
}
1368
 
 
1369
 
 
1370
 
void wnga_gather(Integer g_a, void *v, Integer subscript[], Integer nv)
1371
 
{
1372
 
    double local_start, local_stop;
1373
 
    ++count_pnga_gather;
1374
 
    local_start = MPI_Wtime();
1375
 
    pnga_gather(g_a, v, subscript, nv);
1376
 
    local_stop = MPI_Wtime();
1377
 
    time_pnga_gather += local_stop - local_start;
1378
 
}
1379
 
 
1380
 
 
1381
 
void wnga_gather2d(Integer g_a, void *v, Integer *i, Integer *j, Integer nv)
1382
 
{
1383
 
    double local_start, local_stop;
1384
 
    ++count_pnga_gather2d;
1385
 
    local_start = MPI_Wtime();
1386
 
    pnga_gather2d(g_a, v, i, j, nv);
1387
 
    local_stop = MPI_Wtime();
1388
 
    time_pnga_gather2d += local_stop - local_start;
1389
 
}
1390
 
 
1391
 
 
1392
 
void wnga_get(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld)
1393
 
{
1394
 
    double local_start, local_stop;
1395
 
    ++count_pnga_get;
1396
 
    local_start = MPI_Wtime();
1397
 
    pnga_get(g_a, lo, hi, buf, ld);
1398
 
    local_stop = MPI_Wtime();
1399
 
    time_pnga_get += local_stop - local_start;
1400
 
}
1401
 
 
1402
 
 
1403
 
void wnga_get_block_info(Integer g_a, Integer *num_blocks, Integer *block_dims)
1404
 
{
1405
 
    double local_start, local_stop;
1406
 
    ++count_pnga_get_block_info;
1407
 
    local_start = MPI_Wtime();
1408
 
    pnga_get_block_info(g_a, num_blocks, block_dims);
1409
 
    local_stop = MPI_Wtime();
1410
 
    time_pnga_get_block_info += local_stop - local_start;
1411
 
}
1412
 
 
1413
 
 
1414
 
logical wnga_get_debug()
1415
 
{
1416
 
    logical return_value;
1417
 
    double local_start, local_stop;
1418
 
    ++count_pnga_get_debug;
1419
 
    local_start = MPI_Wtime();
1420
 
    return_value = pnga_get_debug();
1421
 
    local_stop = MPI_Wtime();
1422
 
    time_pnga_get_debug += local_stop - local_start;
1423
 
    return return_value;
1424
 
}
1425
 
 
1426
 
 
1427
 
void wnga_get_diag(Integer g_a, Integer g_v)
1428
 
{
1429
 
    double local_start, local_stop;
1430
 
    ++count_pnga_get_diag;
1431
 
    local_start = MPI_Wtime();
1432
 
    pnga_get_diag(g_a, g_v);
1433
 
    local_stop = MPI_Wtime();
1434
 
    time_pnga_get_diag += local_stop - local_start;
1435
 
}
1436
 
 
1437
 
 
1438
 
Integer wnga_get_dimension(Integer g_a)
1439
 
{
1440
 
    Integer return_value;
1441
 
    double local_start, local_stop;
1442
 
    ++count_pnga_get_dimension;
1443
 
    local_start = MPI_Wtime();
1444
 
    return_value = pnga_get_dimension(g_a);
1445
 
    local_stop = MPI_Wtime();
1446
 
    time_pnga_get_dimension += local_stop - local_start;
1447
 
    return return_value;
1448
 
}
1449
 
 
1450
 
 
1451
 
void wnga_get_field(Integer g_a, Integer *lo, Integer *hi, Integer foff, Integer fsize, void *buf, Integer *ld)
1452
 
{
1453
 
    double local_start, local_stop;
1454
 
    ++count_pnga_get_field;
1455
 
    local_start = MPI_Wtime();
1456
 
    pnga_get_field(g_a, lo, hi, foff, fsize, buf, ld);
1457
 
    local_stop = MPI_Wtime();
1458
 
    time_pnga_get_field += local_stop - local_start;
1459
 
}
1460
 
 
1461
 
 
1462
 
void wnga_get_ghost_block(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld)
1463
 
{
1464
 
    double local_start, local_stop;
1465
 
    ++count_pnga_get_ghost_block;
1466
 
    local_start = MPI_Wtime();
1467
 
    pnga_get_ghost_block(g_a, lo, hi, buf, ld);
1468
 
    local_stop = MPI_Wtime();
1469
 
    time_pnga_get_ghost_block += local_stop - local_start;
1470
 
}
1471
 
 
1472
 
 
1473
 
Integer wnga_get_pgroup(Integer g_a)
1474
 
{
1475
 
    Integer return_value;
1476
 
    double local_start, local_stop;
1477
 
    ++count_pnga_get_pgroup;
1478
 
    local_start = MPI_Wtime();
1479
 
    return_value = pnga_get_pgroup(g_a);
1480
 
    local_stop = MPI_Wtime();
1481
 
    time_pnga_get_pgroup += local_stop - local_start;
1482
 
    return return_value;
1483
 
}
1484
 
 
1485
 
 
1486
 
Integer wnga_get_pgroup_size(Integer grp_id)
1487
 
{
1488
 
    Integer return_value;
1489
 
    double local_start, local_stop;
1490
 
    ++count_pnga_get_pgroup_size;
1491
 
    local_start = MPI_Wtime();
1492
 
    return_value = pnga_get_pgroup_size(grp_id);
1493
 
    local_stop = MPI_Wtime();
1494
 
    time_pnga_get_pgroup_size += local_stop - local_start;
1495
 
    return return_value;
1496
 
}
1497
 
 
1498
 
 
1499
 
void wnga_get_proc_grid(Integer g_a, Integer *dims)
1500
 
{
1501
 
    double local_start, local_stop;
1502
 
    ++count_pnga_get_proc_grid;
1503
 
    local_start = MPI_Wtime();
1504
 
    pnga_get_proc_grid(g_a, dims);
1505
 
    local_stop = MPI_Wtime();
1506
 
    time_pnga_get_proc_grid += local_stop - local_start;
1507
 
}
1508
 
 
1509
 
 
1510
 
void wnga_get_proc_index(Integer g_a, Integer iproc, Integer *index)
1511
 
{
1512
 
    double local_start, local_stop;
1513
 
    ++count_pnga_get_proc_index;
1514
 
    local_start = MPI_Wtime();
1515
 
    pnga_get_proc_index(g_a, iproc, index);
1516
 
    local_stop = MPI_Wtime();
1517
 
    time_pnga_get_proc_index += local_stop - local_start;
1518
 
}
1519
 
 
1520
 
 
1521
 
void wnga_ghost_barrier()
1522
 
{
1523
 
    double local_start, local_stop;
1524
 
    ++count_pnga_ghost_barrier;
1525
 
    local_start = MPI_Wtime();
1526
 
    pnga_ghost_barrier();
1527
 
    local_stop = MPI_Wtime();
1528
 
    time_pnga_ghost_barrier += local_stop - local_start;
1529
 
}
1530
 
 
1531
 
 
1532
 
void wnga_gop(Integer type, void *x, Integer n, char *op)
1533
 
{
1534
 
    double local_start, local_stop;
1535
 
    ++count_pnga_gop;
1536
 
    local_start = MPI_Wtime();
1537
 
    pnga_gop(type, x, n, op);
1538
 
    local_stop = MPI_Wtime();
1539
 
    time_pnga_gop += local_stop - local_start;
1540
 
}
1541
 
 
1542
 
 
1543
 
logical wnga_has_ghosts(Integer g_a)
1544
 
{
1545
 
    logical return_value;
1546
 
    double local_start, local_stop;
1547
 
    ++count_pnga_has_ghosts;
1548
 
    local_start = MPI_Wtime();
1549
 
    return_value = pnga_has_ghosts(g_a);
1550
 
    local_stop = MPI_Wtime();
1551
 
    time_pnga_has_ghosts += local_stop - local_start;
1552
 
    return return_value;
1553
 
}
1554
 
 
1555
 
 
1556
 
void wnga_init_fence()
1557
 
{
1558
 
    double local_start, local_stop;
1559
 
    ++count_pnga_init_fence;
1560
 
    local_start = MPI_Wtime();
1561
 
    pnga_init_fence();
1562
 
    local_stop = MPI_Wtime();
1563
 
    time_pnga_init_fence += local_stop - local_start;
1564
 
}
1565
 
 
1566
 
 
1567
 
void wnga_inquire(Integer g_a, Integer *type, Integer *ndim, Integer *dims)
1568
 
{
1569
 
    double local_start, local_stop;
1570
 
    ++count_pnga_inquire;
1571
 
    local_start = MPI_Wtime();
1572
 
    pnga_inquire(g_a, type, ndim, dims);
1573
 
    local_stop = MPI_Wtime();
1574
 
    time_pnga_inquire += local_stop - local_start;
1575
 
}
1576
 
 
1577
 
 
1578
 
Integer wnga_inquire_memory()
1579
 
{
1580
 
    Integer return_value;
1581
 
    double local_start, local_stop;
1582
 
    ++count_pnga_inquire_memory;
1583
 
    local_start = MPI_Wtime();
1584
 
    return_value = pnga_inquire_memory();
1585
 
    local_stop = MPI_Wtime();
1586
 
    time_pnga_inquire_memory += local_stop - local_start;
1587
 
    return return_value;
1588
 
}
1589
 
 
1590
 
 
1591
 
void wnga_inquire_name(Integer g_a, char **array_name)
1592
 
{
1593
 
    double local_start, local_stop;
1594
 
    ++count_pnga_inquire_name;
1595
 
    local_start = MPI_Wtime();
1596
 
    pnga_inquire_name(g_a, array_name);
1597
 
    local_stop = MPI_Wtime();
1598
 
    time_pnga_inquire_name += local_stop - local_start;
1599
 
}
1600
 
 
1601
 
 
1602
 
void wnga_inquire_type(Integer g_a, Integer *type)
1603
 
{
1604
 
    double local_start, local_stop;
1605
 
    ++count_pnga_inquire_type;
1606
 
    local_start = MPI_Wtime();
1607
 
    pnga_inquire_type(g_a, type);
1608
 
    local_stop = MPI_Wtime();
1609
 
    time_pnga_inquire_type += local_stop - local_start;
1610
 
}
1611
 
 
1612
 
 
1613
 
logical wnga_is_mirrored(Integer g_a)
1614
 
{
1615
 
    logical return_value;
1616
 
    double local_start, local_stop;
1617
 
    ++count_pnga_is_mirrored;
1618
 
    local_start = MPI_Wtime();
1619
 
    return_value = pnga_is_mirrored(g_a);
1620
 
    local_stop = MPI_Wtime();
1621
 
    time_pnga_is_mirrored += local_stop - local_start;
1622
 
    return return_value;
1623
 
}
1624
 
 
1625
 
 
1626
 
void wnga_list_nodeid(Integer *list, Integer nprocs)
1627
 
{
1628
 
    double local_start, local_stop;
1629
 
    ++count_pnga_list_nodeid;
1630
 
    local_start = MPI_Wtime();
1631
 
    pnga_list_nodeid(list, nprocs);
1632
 
    local_stop = MPI_Wtime();
1633
 
    time_pnga_list_nodeid += local_stop - local_start;
1634
 
}
1635
 
 
1636
 
 
1637
 
Integer wnga_llt_solve(Integer g_a, Integer g_b)
1638
 
{
1639
 
    Integer return_value;
1640
 
    double local_start, local_stop;
1641
 
    ++count_pnga_llt_solve;
1642
 
    local_start = MPI_Wtime();
1643
 
    return_value = pnga_llt_solve(g_a, g_b);
1644
 
    local_stop = MPI_Wtime();
1645
 
    time_pnga_llt_solve += local_stop - local_start;
1646
 
    return return_value;
1647
 
}
1648
 
 
1649
 
 
1650
 
logical wnga_locate(Integer g_a, Integer *subscript, Integer *owner)
1651
 
{
1652
 
    logical return_value;
1653
 
    double local_start, local_stop;
1654
 
    ++count_pnga_locate;
1655
 
    local_start = MPI_Wtime();
1656
 
    return_value = pnga_locate(g_a, subscript, owner);
1657
 
    local_stop = MPI_Wtime();
1658
 
    time_pnga_locate += local_stop - local_start;
1659
 
    return return_value;
1660
 
}
1661
 
 
1662
 
 
1663
 
logical wnga_locate_nnodes(Integer g_a, Integer *lo, Integer *hi, Integer *np)
1664
 
{
1665
 
    logical return_value;
1666
 
    double local_start, local_stop;
1667
 
    ++count_pnga_locate_nnodes;
1668
 
    local_start = MPI_Wtime();
1669
 
    return_value = pnga_locate_nnodes(g_a, lo, hi, np);
1670
 
    local_stop = MPI_Wtime();
1671
 
    time_pnga_locate_nnodes += local_stop - local_start;
1672
 
    return return_value;
1673
 
}
1674
 
 
1675
 
 
1676
 
Integer wnga_locate_num_blocks(Integer g_a, Integer *lo, Integer *hi)
1677
 
{
1678
 
    Integer return_value;
1679
 
    double local_start, local_stop;
1680
 
    ++count_pnga_locate_num_blocks;
1681
 
    local_start = MPI_Wtime();
1682
 
    return_value = pnga_locate_num_blocks(g_a, lo, hi);
1683
 
    local_stop = MPI_Wtime();
1684
 
    time_pnga_locate_num_blocks += local_stop - local_start;
1685
 
    return return_value;
1686
 
}
1687
 
 
1688
 
 
1689
 
logical wnga_locate_region(Integer g_a, Integer *lo, Integer *hi, Integer *map, Integer *proclist, Integer *np)
1690
 
{
1691
 
    logical return_value;
1692
 
    double local_start, local_stop;
1693
 
    ++count_pnga_locate_region;
1694
 
    local_start = MPI_Wtime();
1695
 
    return_value = pnga_locate_region(g_a, lo, hi, map, proclist, np);
1696
 
    local_stop = MPI_Wtime();
1697
 
    time_pnga_locate_region += local_stop - local_start;
1698
 
    return return_value;
1699
 
}
1700
 
 
1701
 
 
1702
 
void wnga_lock(Integer mutex)
1703
 
{
1704
 
    double local_start, local_stop;
1705
 
    ++count_pnga_lock;
1706
 
    local_start = MPI_Wtime();
1707
 
    pnga_lock(mutex);
1708
 
    local_stop = MPI_Wtime();
1709
 
    time_pnga_lock += local_stop - local_start;
1710
 
}
1711
 
 
1712
 
 
1713
 
void wnga_lu_solve(char *tran, Integer g_a, Integer g_b)
1714
 
{
1715
 
    double local_start, local_stop;
1716
 
    ++count_pnga_lu_solve;
1717
 
    local_start = MPI_Wtime();
1718
 
    pnga_lu_solve(tran, g_a, g_b);
1719
 
    local_stop = MPI_Wtime();
1720
 
    time_pnga_lu_solve += local_stop - local_start;
1721
 
}
1722
 
 
1723
 
 
1724
 
void wnga_lu_solve_alt(Integer tran, Integer g_a, Integer g_b)
1725
 
{
1726
 
    double local_start, local_stop;
1727
 
    ++count_pnga_lu_solve_alt;
1728
 
    local_start = MPI_Wtime();
1729
 
    pnga_lu_solve_alt(tran, g_a, g_b);
1730
 
    local_stop = MPI_Wtime();
1731
 
    time_pnga_lu_solve_alt += local_stop - local_start;
1732
 
}
1733
 
 
1734
 
 
1735
 
void wnga_lu_solve_seq(char *trans, Integer g_a, Integer g_b)
1736
 
{
1737
 
    double local_start, local_stop;
1738
 
    ++count_pnga_lu_solve_seq;
1739
 
    local_start = MPI_Wtime();
1740
 
    pnga_lu_solve_seq(trans, g_a, g_b);
1741
 
    local_stop = MPI_Wtime();
1742
 
    time_pnga_lu_solve_seq += local_stop - local_start;
1743
 
}
1744
 
 
1745
 
 
1746
 
void wnga_mask_sync(Integer begin, Integer end)
1747
 
{
1748
 
    double local_start, local_stop;
1749
 
    ++count_pnga_mask_sync;
1750
 
    local_start = MPI_Wtime();
1751
 
    pnga_mask_sync(begin, end);
1752
 
    local_stop = MPI_Wtime();
1753
 
    time_pnga_mask_sync += local_stop - local_start;
1754
 
}
1755
 
 
1756
 
 
1757
 
void wnga_matmul(char *transa, char *transb, void *alpha, void *beta, Integer g_a, Integer ailo, Integer aihi, Integer ajlo, Integer ajhi, Integer g_b, Integer bilo, Integer bihi, Integer bjlo, Integer bjhi, Integer g_c, Integer cilo, Integer cihi, Integer cjlo, Integer cjhi)
1758
 
{
1759
 
    double local_start, local_stop;
1760
 
    ++count_pnga_matmul;
1761
 
    local_start = MPI_Wtime();
1762
 
    pnga_matmul(transa, transb, alpha, beta, g_a, ailo, aihi, ajlo, ajhi, g_b, bilo, bihi, bjlo, bjhi, g_c, cilo, cihi, cjlo, cjhi);
1763
 
    local_stop = MPI_Wtime();
1764
 
    time_pnga_matmul += local_stop - local_start;
1765
 
}
1766
 
 
1767
 
 
1768
 
void wnga_matmul_mirrored(char *transa, char *transb, void *alpha, void *beta, Integer g_a, Integer ailo, Integer aihi, Integer ajlo, Integer ajhi, Integer g_b, Integer bilo, Integer bihi, Integer bjlo, Integer bjhi, Integer g_c, Integer cilo, Integer cihi, Integer cjlo, Integer cjhi)
1769
 
{
1770
 
    double local_start, local_stop;
1771
 
    ++count_pnga_matmul_mirrored;
1772
 
    local_start = MPI_Wtime();
1773
 
    pnga_matmul_mirrored(transa, transb, alpha, beta, g_a, ailo, aihi, ajlo, ajhi, g_b, bilo, bihi, bjlo, bjhi, g_c, cilo, cihi, cjlo, cjhi);
1774
 
    local_stop = MPI_Wtime();
1775
 
    time_pnga_matmul_mirrored += local_stop - local_start;
1776
 
}
1777
 
 
1778
 
 
1779
 
void wnga_matmul_patch(char *transa, char *transb, void *alpha, void *beta, Integer g_a, Integer alo[], Integer ahi[], Integer g_b, Integer blo[], Integer bhi[], Integer g_c, Integer clo[], Integer chi[])
1780
 
{
1781
 
    double local_start, local_stop;
1782
 
    ++count_pnga_matmul_patch;
1783
 
    local_start = MPI_Wtime();
1784
 
    pnga_matmul_patch(transa, transb, alpha, beta, g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
1785
 
    local_stop = MPI_Wtime();
1786
 
    time_pnga_matmul_patch += local_stop - local_start;
1787
 
}
1788
 
 
1789
 
 
1790
 
void wnga_median(Integer g_a, Integer g_b, Integer g_c, Integer g_m)
1791
 
{
1792
 
    double local_start, local_stop;
1793
 
    ++count_pnga_median;
1794
 
    local_start = MPI_Wtime();
1795
 
    pnga_median(g_a, g_b, g_c, g_m);
1796
 
    local_stop = MPI_Wtime();
1797
 
    time_pnga_median += local_stop - local_start;
1798
 
}
1799
 
 
1800
 
 
1801
 
void wnga_median_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi, Integer g_m, Integer *mlo, Integer *mhi)
1802
 
{
1803
 
    double local_start, local_stop;
1804
 
    ++count_pnga_median_patch;
1805
 
    local_start = MPI_Wtime();
1806
 
    pnga_median_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi, g_m, mlo, mhi);
1807
 
    local_stop = MPI_Wtime();
1808
 
    time_pnga_median_patch += local_stop - local_start;
1809
 
}
1810
 
 
1811
 
 
1812
 
Integer wnga_memory_avail()
1813
 
{
1814
 
    Integer return_value;
1815
 
    double local_start, local_stop;
1816
 
    ++count_pnga_memory_avail;
1817
 
    local_start = MPI_Wtime();
1818
 
    return_value = pnga_memory_avail();
1819
 
    local_stop = MPI_Wtime();
1820
 
    time_pnga_memory_avail += local_stop - local_start;
1821
 
    return return_value;
1822
 
}
1823
 
 
1824
 
 
1825
 
Integer wnga_memory_avail_type(Integer datatype)
1826
 
{
1827
 
    Integer return_value;
1828
 
    double local_start, local_stop;
1829
 
    ++count_pnga_memory_avail_type;
1830
 
    local_start = MPI_Wtime();
1831
 
    return_value = pnga_memory_avail_type(datatype);
1832
 
    local_stop = MPI_Wtime();
1833
 
    time_pnga_memory_avail_type += local_stop - local_start;
1834
 
    return return_value;
1835
 
}
1836
 
 
1837
 
 
1838
 
logical wnga_memory_limited()
1839
 
{
1840
 
    logical return_value;
1841
 
    double local_start, local_stop;
1842
 
    ++count_pnga_memory_limited;
1843
 
    local_start = MPI_Wtime();
1844
 
    return_value = pnga_memory_limited();
1845
 
    local_stop = MPI_Wtime();
1846
 
    time_pnga_memory_limited += local_stop - local_start;
1847
 
    return return_value;
1848
 
}
1849
 
 
1850
 
 
1851
 
void wnga_merge_distr_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi)
1852
 
{
1853
 
    double local_start, local_stop;
1854
 
    ++count_pnga_merge_distr_patch;
1855
 
    local_start = MPI_Wtime();
1856
 
    pnga_merge_distr_patch(g_a, alo, ahi, g_b, blo, bhi);
1857
 
    local_stop = MPI_Wtime();
1858
 
    time_pnga_merge_distr_patch += local_stop - local_start;
1859
 
}
1860
 
 
1861
 
 
1862
 
void wnga_merge_mirrored(Integer g_a)
1863
 
{
1864
 
    double local_start, local_stop;
1865
 
    ++count_pnga_merge_mirrored;
1866
 
    local_start = MPI_Wtime();
1867
 
    pnga_merge_mirrored(g_a);
1868
 
    local_stop = MPI_Wtime();
1869
 
    time_pnga_merge_mirrored += local_stop - local_start;
1870
 
}
1871
 
 
1872
 
 
1873
 
void wnga_msg_brdcst(Integer type, void *buffer, Integer len, Integer root)
1874
 
{
1875
 
    double local_start, local_stop;
1876
 
    ++count_pnga_msg_brdcst;
1877
 
    local_start = MPI_Wtime();
1878
 
    pnga_msg_brdcst(type, buffer, len, root);
1879
 
    local_stop = MPI_Wtime();
1880
 
    time_pnga_msg_brdcst += local_stop - local_start;
1881
 
}
1882
 
 
1883
 
 
1884
 
void wnga_msg_pgroup_sync(Integer grp_id)
1885
 
{
1886
 
    double local_start, local_stop;
1887
 
    ++count_pnga_msg_pgroup_sync;
1888
 
    local_start = MPI_Wtime();
1889
 
    pnga_msg_pgroup_sync(grp_id);
1890
 
    local_stop = MPI_Wtime();
1891
 
    time_pnga_msg_pgroup_sync += local_stop - local_start;
1892
 
}
1893
 
 
1894
 
 
1895
 
void wnga_msg_sync()
1896
 
{
1897
 
    double local_start, local_stop;
1898
 
    ++count_pnga_msg_sync;
1899
 
    local_start = MPI_Wtime();
1900
 
    pnga_msg_sync();
1901
 
    local_stop = MPI_Wtime();
1902
 
    time_pnga_msg_sync += local_stop - local_start;
1903
 
}
1904
 
 
1905
 
 
1906
 
void wnga_nbacc(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld, void *alpha, Integer *nbhndl)
1907
 
{
1908
 
    double local_start, local_stop;
1909
 
    ++count_pnga_nbacc;
1910
 
    local_start = MPI_Wtime();
1911
 
    pnga_nbacc(g_a, lo, hi, buf, ld, alpha, nbhndl);
1912
 
    local_stop = MPI_Wtime();
1913
 
    time_pnga_nbacc += local_stop - local_start;
1914
 
}
1915
 
 
1916
 
 
1917
 
void wnga_nbget(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld, Integer *nbhandle)
1918
 
{
1919
 
    double local_start, local_stop;
1920
 
    ++count_pnga_nbget;
1921
 
    local_start = MPI_Wtime();
1922
 
    pnga_nbget(g_a, lo, hi, buf, ld, nbhandle);
1923
 
    local_stop = MPI_Wtime();
1924
 
    time_pnga_nbget += local_stop - local_start;
1925
 
}
1926
 
 
1927
 
 
1928
 
void wnga_nbget_field(Integer g_a, Integer *lo, Integer *hi, Integer foff, Integer fsize, void *buf, Integer *ld, Integer *nbhandle)
1929
 
{
1930
 
    double local_start, local_stop;
1931
 
    ++count_pnga_nbget_field;
1932
 
    local_start = MPI_Wtime();
1933
 
    pnga_nbget_field(g_a, lo, hi, foff, fsize, buf, ld, nbhandle);
1934
 
    local_stop = MPI_Wtime();
1935
 
    time_pnga_nbget_field += local_stop - local_start;
1936
 
}
1937
 
 
1938
 
 
1939
 
void wnga_nbget_ghost_dir(Integer g_a, Integer *mask, Integer *nbhandle)
1940
 
{
1941
 
    double local_start, local_stop;
1942
 
    ++count_pnga_nbget_ghost_dir;
1943
 
    local_start = MPI_Wtime();
1944
 
    pnga_nbget_ghost_dir(g_a, mask, nbhandle);
1945
 
    local_stop = MPI_Wtime();
1946
 
    time_pnga_nbget_ghost_dir += local_stop - local_start;
1947
 
}
1948
 
 
1949
 
 
1950
 
void wnga_nblock(Integer g_a, Integer *nblock)
1951
 
{
1952
 
    double local_start, local_stop;
1953
 
    ++count_pnga_nblock;
1954
 
    local_start = MPI_Wtime();
1955
 
    pnga_nblock(g_a, nblock);
1956
 
    local_stop = MPI_Wtime();
1957
 
    time_pnga_nblock += local_stop - local_start;
1958
 
}
1959
 
 
1960
 
 
1961
 
void wnga_nbput(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld, Integer *nbhandle)
1962
 
{
1963
 
    double local_start, local_stop;
1964
 
    ++count_pnga_nbput;
1965
 
    local_start = MPI_Wtime();
1966
 
    pnga_nbput(g_a, lo, hi, buf, ld, nbhandle);
1967
 
    local_stop = MPI_Wtime();
1968
 
    time_pnga_nbput += local_stop - local_start;
1969
 
}
1970
 
 
1971
 
 
1972
 
void wnga_nbput_field(Integer g_a, Integer *lo, Integer *hi, Integer foff, Integer fsize, void *buf, Integer *ld, Integer *nbhandle)
1973
 
{
1974
 
    double local_start, local_stop;
1975
 
    ++count_pnga_nbput_field;
1976
 
    local_start = MPI_Wtime();
1977
 
    pnga_nbput_field(g_a, lo, hi, foff, fsize, buf, ld, nbhandle);
1978
 
    local_stop = MPI_Wtime();
1979
 
    time_pnga_nbput_field += local_stop - local_start;
1980
 
}
1981
 
 
1982
 
 
1983
 
Integer wnga_nbtest(Integer *nbhandle)
1984
 
{
1985
 
    Integer return_value;
1986
 
    double local_start, local_stop;
1987
 
    ++count_pnga_nbtest;
1988
 
    local_start = MPI_Wtime();
1989
 
    return_value = pnga_nbtest(nbhandle);
1990
 
    local_stop = MPI_Wtime();
1991
 
    time_pnga_nbtest += local_stop - local_start;
1992
 
    return return_value;
1993
 
}
1994
 
 
1995
 
 
1996
 
void wnga_nbwait(Integer *nbhandle)
1997
 
{
1998
 
    double local_start, local_stop;
1999
 
    ++count_pnga_nbwait;
2000
 
    local_start = MPI_Wtime();
2001
 
    pnga_nbwait(nbhandle);
2002
 
    local_stop = MPI_Wtime();
2003
 
    time_pnga_nbwait += local_stop - local_start;
2004
 
}
2005
 
 
2006
 
 
2007
 
Integer wnga_ndim(Integer g_a)
2008
 
{
2009
 
    Integer return_value;
2010
 
    double local_start, local_stop;
2011
 
    ++count_pnga_ndim;
2012
 
    local_start = MPI_Wtime();
2013
 
    return_value = pnga_ndim(g_a);
2014
 
    local_stop = MPI_Wtime();
2015
 
    time_pnga_ndim += local_stop - local_start;
2016
 
    return return_value;
2017
 
}
2018
 
 
2019
 
 
2020
 
Integer wnga_nnodes()
2021
 
{
2022
 
    Integer return_value;
2023
 
    double local_start, local_stop;
2024
 
    ++count_pnga_nnodes;
2025
 
    local_start = MPI_Wtime();
2026
 
    return_value = pnga_nnodes();
2027
 
    local_stop = MPI_Wtime();
2028
 
    time_pnga_nnodes += local_stop - local_start;
2029
 
    return return_value;
2030
 
}
2031
 
 
2032
 
 
2033
 
Integer wnga_nodeid()
2034
 
{
2035
 
    Integer return_value;
2036
 
    double local_start, local_stop;
2037
 
    ++count_pnga_nodeid;
2038
 
    local_start = MPI_Wtime();
2039
 
    return_value = pnga_nodeid();
2040
 
    local_stop = MPI_Wtime();
2041
 
    time_pnga_nodeid += local_stop - local_start;
2042
 
    return return_value;
2043
 
}
2044
 
 
2045
 
 
2046
 
void wnga_norm1(Integer g_a, double *nm)
2047
 
{
2048
 
    double local_start, local_stop;
2049
 
    ++count_pnga_norm1;
2050
 
    local_start = MPI_Wtime();
2051
 
    pnga_norm1(g_a, nm);
2052
 
    local_stop = MPI_Wtime();
2053
 
    time_pnga_norm1 += local_stop - local_start;
2054
 
}
2055
 
 
2056
 
 
2057
 
void wnga_norm_infinity(Integer g_a, double *nm)
2058
 
{
2059
 
    double local_start, local_stop;
2060
 
    ++count_pnga_norm_infinity;
2061
 
    local_start = MPI_Wtime();
2062
 
    pnga_norm_infinity(g_a, nm);
2063
 
    local_stop = MPI_Wtime();
2064
 
    time_pnga_norm_infinity += local_stop - local_start;
2065
 
}
2066
 
 
2067
 
 
2068
 
void wnga_pack(Integer g_a, Integer g_b, Integer g_sbit, Integer lo, Integer hi, Integer *icount)
2069
 
{
2070
 
    double local_start, local_stop;
2071
 
    ++count_pnga_pack;
2072
 
    local_start = MPI_Wtime();
2073
 
    pnga_pack(g_a, g_b, g_sbit, lo, hi, icount);
2074
 
    local_stop = MPI_Wtime();
2075
 
    time_pnga_pack += local_stop - local_start;
2076
 
}
2077
 
 
2078
 
 
2079
 
void wnga_patch_enum(Integer g_a, Integer lo, Integer hi, void *start, void *stride)
2080
 
{
2081
 
    double local_start, local_stop;
2082
 
    ++count_pnga_patch_enum;
2083
 
    local_start = MPI_Wtime();
2084
 
    pnga_patch_enum(g_a, lo, hi, start, stride);
2085
 
    local_stop = MPI_Wtime();
2086
 
    time_pnga_patch_enum += local_stop - local_start;
2087
 
}
2088
 
 
2089
 
 
2090
 
logical wnga_patch_intersect(Integer *lo, Integer *hi, Integer *lop, Integer *hip, Integer ndim)
2091
 
{
2092
 
    logical return_value;
2093
 
    double local_start, local_stop;
2094
 
    ++count_pnga_patch_intersect;
2095
 
    local_start = MPI_Wtime();
2096
 
    return_value = pnga_patch_intersect(lo, hi, lop, hip, ndim);
2097
 
    local_stop = MPI_Wtime();
2098
 
    time_pnga_patch_intersect += local_stop - local_start;
2099
 
    return return_value;
2100
 
}
2101
 
 
2102
 
 
2103
 
void wnga_periodic(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld, void *alpha, Integer op_code)
2104
 
{
2105
 
    double local_start, local_stop;
2106
 
    ++count_pnga_periodic;
2107
 
    local_start = MPI_Wtime();
2108
 
    pnga_periodic(g_a, lo, hi, buf, ld, alpha, op_code);
2109
 
    local_stop = MPI_Wtime();
2110
 
    time_pnga_periodic += local_stop - local_start;
2111
 
}
2112
 
 
2113
 
 
2114
 
Integer wnga_pgroup_absolute_id(Integer grp, Integer pid)
2115
 
{
2116
 
    Integer return_value;
2117
 
    double local_start, local_stop;
2118
 
    ++count_pnga_pgroup_absolute_id;
2119
 
    local_start = MPI_Wtime();
2120
 
    return_value = pnga_pgroup_absolute_id(grp, pid);
2121
 
    local_stop = MPI_Wtime();
2122
 
    time_pnga_pgroup_absolute_id += local_stop - local_start;
2123
 
    return return_value;
2124
 
}
2125
 
 
2126
 
 
2127
 
void wnga_pgroup_brdcst(Integer grp_id, Integer type, void *buf, Integer len, Integer originator)
2128
 
{
2129
 
    double local_start, local_stop;
2130
 
    ++count_pnga_pgroup_brdcst;
2131
 
    local_start = MPI_Wtime();
2132
 
    pnga_pgroup_brdcst(grp_id, type, buf, len, originator);
2133
 
    local_stop = MPI_Wtime();
2134
 
    time_pnga_pgroup_brdcst += local_stop - local_start;
2135
 
}
2136
 
 
2137
 
 
2138
 
Integer wnga_pgroup_create(Integer *list, Integer count)
2139
 
{
2140
 
    Integer return_value;
2141
 
    double local_start, local_stop;
2142
 
    ++count_pnga_pgroup_create;
2143
 
    local_start = MPI_Wtime();
2144
 
    return_value = pnga_pgroup_create(list, count);
2145
 
    local_stop = MPI_Wtime();
2146
 
    time_pnga_pgroup_create += local_stop - local_start;
2147
 
    return return_value;
2148
 
}
2149
 
 
2150
 
 
2151
 
logical wnga_pgroup_destroy(Integer grp)
2152
 
{
2153
 
    logical return_value;
2154
 
    double local_start, local_stop;
2155
 
    ++count_pnga_pgroup_destroy;
2156
 
    local_start = MPI_Wtime();
2157
 
    return_value = pnga_pgroup_destroy(grp);
2158
 
    local_stop = MPI_Wtime();
2159
 
    time_pnga_pgroup_destroy += local_stop - local_start;
2160
 
    return return_value;
2161
 
}
2162
 
 
2163
 
 
2164
 
Integer wnga_pgroup_get_default()
2165
 
{
2166
 
    Integer return_value;
2167
 
    double local_start, local_stop;
2168
 
    ++count_pnga_pgroup_get_default;
2169
 
    local_start = MPI_Wtime();
2170
 
    return_value = pnga_pgroup_get_default();
2171
 
    local_stop = MPI_Wtime();
2172
 
    time_pnga_pgroup_get_default += local_stop - local_start;
2173
 
    return return_value;
2174
 
}
2175
 
 
2176
 
 
2177
 
Integer wnga_pgroup_get_mirror()
2178
 
{
2179
 
    Integer return_value;
2180
 
    double local_start, local_stop;
2181
 
    ++count_pnga_pgroup_get_mirror;
2182
 
    local_start = MPI_Wtime();
2183
 
    return_value = pnga_pgroup_get_mirror();
2184
 
    local_stop = MPI_Wtime();
2185
 
    time_pnga_pgroup_get_mirror += local_stop - local_start;
2186
 
    return return_value;
2187
 
}
2188
 
 
2189
 
 
2190
 
Integer wnga_pgroup_get_world()
2191
 
{
2192
 
    Integer return_value;
2193
 
    double local_start, local_stop;
2194
 
    ++count_pnga_pgroup_get_world;
2195
 
    local_start = MPI_Wtime();
2196
 
    return_value = pnga_pgroup_get_world();
2197
 
    local_stop = MPI_Wtime();
2198
 
    time_pnga_pgroup_get_world += local_stop - local_start;
2199
 
    return return_value;
2200
 
}
2201
 
 
2202
 
 
2203
 
void wnga_pgroup_gop(Integer p_grp, Integer type, void *x, Integer n, char *op)
2204
 
{
2205
 
    double local_start, local_stop;
2206
 
    ++count_pnga_pgroup_gop;
2207
 
    local_start = MPI_Wtime();
2208
 
    pnga_pgroup_gop(p_grp, type, x, n, op);
2209
 
    local_stop = MPI_Wtime();
2210
 
    time_pnga_pgroup_gop += local_stop - local_start;
2211
 
}
2212
 
 
2213
 
 
2214
 
Integer wnga_pgroup_nnodes(Integer grp)
2215
 
{
2216
 
    Integer return_value;
2217
 
    double local_start, local_stop;
2218
 
    ++count_pnga_pgroup_nnodes;
2219
 
    local_start = MPI_Wtime();
2220
 
    return_value = pnga_pgroup_nnodes(grp);
2221
 
    local_stop = MPI_Wtime();
2222
 
    time_pnga_pgroup_nnodes += local_stop - local_start;
2223
 
    return return_value;
2224
 
}
2225
 
 
2226
 
 
2227
 
Integer wnga_pgroup_nodeid(Integer grp)
2228
 
{
2229
 
    Integer return_value;
2230
 
    double local_start, local_stop;
2231
 
    ++count_pnga_pgroup_nodeid;
2232
 
    local_start = MPI_Wtime();
2233
 
    return_value = pnga_pgroup_nodeid(grp);
2234
 
    local_stop = MPI_Wtime();
2235
 
    time_pnga_pgroup_nodeid += local_stop - local_start;
2236
 
    return return_value;
2237
 
}
2238
 
 
2239
 
 
2240
 
void wnga_pgroup_set_default(Integer grp)
2241
 
{
2242
 
    double local_start, local_stop;
2243
 
    ++count_pnga_pgroup_set_default;
2244
 
    local_start = MPI_Wtime();
2245
 
    pnga_pgroup_set_default(grp);
2246
 
    local_stop = MPI_Wtime();
2247
 
    time_pnga_pgroup_set_default += local_stop - local_start;
2248
 
}
2249
 
 
2250
 
 
2251
 
Integer wnga_pgroup_split(Integer grp, Integer grp_num)
2252
 
{
2253
 
    Integer return_value;
2254
 
    double local_start, local_stop;
2255
 
    ++count_pnga_pgroup_split;
2256
 
    local_start = MPI_Wtime();
2257
 
    return_value = pnga_pgroup_split(grp, grp_num);
2258
 
    local_stop = MPI_Wtime();
2259
 
    time_pnga_pgroup_split += local_stop - local_start;
2260
 
    return return_value;
2261
 
}
2262
 
 
2263
 
 
2264
 
Integer wnga_pgroup_split_irreg(Integer grp, Integer mycolor)
2265
 
{
2266
 
    Integer return_value;
2267
 
    double local_start, local_stop;
2268
 
    ++count_pnga_pgroup_split_irreg;
2269
 
    local_start = MPI_Wtime();
2270
 
    return_value = pnga_pgroup_split_irreg(grp, mycolor);
2271
 
    local_stop = MPI_Wtime();
2272
 
    time_pnga_pgroup_split_irreg += local_stop - local_start;
2273
 
    return return_value;
2274
 
}
2275
 
 
2276
 
 
2277
 
void wnga_pgroup_sync(Integer grp_id)
2278
 
{
2279
 
    double local_start, local_stop;
2280
 
    ++count_pnga_pgroup_sync;
2281
 
    local_start = MPI_Wtime();
2282
 
    pnga_pgroup_sync(grp_id);
2283
 
    local_stop = MPI_Wtime();
2284
 
    time_pnga_pgroup_sync += local_stop - local_start;
2285
 
}
2286
 
 
2287
 
 
2288
 
void wnga_print(Integer g_a)
2289
 
{
2290
 
    double local_start, local_stop;
2291
 
    ++count_pnga_print;
2292
 
    local_start = MPI_Wtime();
2293
 
    pnga_print(g_a);
2294
 
    local_stop = MPI_Wtime();
2295
 
    time_pnga_print += local_stop - local_start;
2296
 
}
2297
 
 
2298
 
 
2299
 
void wnga_print_distribution(int fstyle, Integer g_a)
2300
 
{
2301
 
    double local_start, local_stop;
2302
 
    ++count_pnga_print_distribution;
2303
 
    local_start = MPI_Wtime();
2304
 
    pnga_print_distribution(fstyle, g_a);
2305
 
    local_stop = MPI_Wtime();
2306
 
    time_pnga_print_distribution += local_stop - local_start;
2307
 
}
2308
 
 
2309
 
 
2310
 
void wnga_print_file(FILE *file, Integer g_a)
2311
 
{
2312
 
    double local_start, local_stop;
2313
 
    ++count_pnga_print_file;
2314
 
    local_start = MPI_Wtime();
2315
 
    pnga_print_file(file, g_a);
2316
 
    local_stop = MPI_Wtime();
2317
 
    time_pnga_print_file += local_stop - local_start;
2318
 
}
2319
 
 
2320
 
 
2321
 
void wnga_print_patch(Integer g_a, Integer *lo, Integer *hi, Integer pretty)
2322
 
{
2323
 
    double local_start, local_stop;
2324
 
    ++count_pnga_print_patch;
2325
 
    local_start = MPI_Wtime();
2326
 
    pnga_print_patch(g_a, lo, hi, pretty);
2327
 
    local_stop = MPI_Wtime();
2328
 
    time_pnga_print_patch += local_stop - local_start;
2329
 
}
2330
 
 
2331
 
 
2332
 
void wnga_print_patch2d(Integer g_a, Integer ilo, Integer ihi, Integer jlo, Integer jhi, Integer pretty)
2333
 
{
2334
 
    double local_start, local_stop;
2335
 
    ++count_pnga_print_patch2d;
2336
 
    local_start = MPI_Wtime();
2337
 
    pnga_print_patch2d(g_a, ilo, ihi, jlo, jhi, pretty);
2338
 
    local_stop = MPI_Wtime();
2339
 
    time_pnga_print_patch2d += local_stop - local_start;
2340
 
}
2341
 
 
2342
 
 
2343
 
void wnga_print_patch_file(FILE *file, Integer g_a, Integer *lo, Integer *hi, Integer pretty)
2344
 
{
2345
 
    double local_start, local_stop;
2346
 
    ++count_pnga_print_patch_file;
2347
 
    local_start = MPI_Wtime();
2348
 
    pnga_print_patch_file(file, g_a, lo, hi, pretty);
2349
 
    local_stop = MPI_Wtime();
2350
 
    time_pnga_print_patch_file += local_stop - local_start;
2351
 
}
2352
 
 
2353
 
 
2354
 
void wnga_print_patch_file2d(FILE *file, Integer g_a, Integer ilo, Integer ihi, Integer jlo, Integer jhi, Integer pretty)
2355
 
{
2356
 
    double local_start, local_stop;
2357
 
    ++count_pnga_print_patch_file2d;
2358
 
    local_start = MPI_Wtime();
2359
 
    pnga_print_patch_file2d(file, g_a, ilo, ihi, jlo, jhi, pretty);
2360
 
    local_stop = MPI_Wtime();
2361
 
    time_pnga_print_patch_file2d += local_stop - local_start;
2362
 
}
2363
 
 
2364
 
 
2365
 
void wnga_print_stats()
2366
 
{
2367
 
    double local_start, local_stop;
2368
 
    ++count_pnga_print_stats;
2369
 
    local_start = MPI_Wtime();
2370
 
    pnga_print_stats();
2371
 
    local_stop = MPI_Wtime();
2372
 
    time_pnga_print_stats += local_stop - local_start;
2373
 
}
2374
 
 
2375
 
 
2376
 
void wnga_proc_topology(Integer g_a, Integer proc, Integer *subscript)
2377
 
{
2378
 
    double local_start, local_stop;
2379
 
    ++count_pnga_proc_topology;
2380
 
    local_start = MPI_Wtime();
2381
 
    pnga_proc_topology(g_a, proc, subscript);
2382
 
    local_stop = MPI_Wtime();
2383
 
    time_pnga_proc_topology += local_stop - local_start;
2384
 
}
2385
 
 
2386
 
 
2387
 
void wnga_put(Integer g_a, Integer *lo, Integer *hi, void *buf, Integer *ld)
2388
 
{
2389
 
    double local_start, local_stop;
2390
 
    ++count_pnga_put;
2391
 
    local_start = MPI_Wtime();
2392
 
    pnga_put(g_a, lo, hi, buf, ld);
2393
 
    local_stop = MPI_Wtime();
2394
 
    time_pnga_put += local_stop - local_start;
2395
 
}
2396
 
 
2397
 
 
2398
 
void wnga_put_field(Integer g_a, Integer *lo, Integer *hi, Integer foff, Integer fsize, void *buf, Integer *ld)
2399
 
{
2400
 
    double local_start, local_stop;
2401
 
    ++count_pnga_put_field;
2402
 
    local_start = MPI_Wtime();
2403
 
    pnga_put_field(g_a, lo, hi, foff, fsize, buf, ld);
2404
 
    local_stop = MPI_Wtime();
2405
 
    time_pnga_put_field += local_stop - local_start;
2406
 
}
2407
 
 
2408
 
 
2409
 
void wnga_randomize(Integer g_a, void *val)
2410
 
{
2411
 
    double local_start, local_stop;
2412
 
    ++count_pnga_randomize;
2413
 
    local_start = MPI_Wtime();
2414
 
    pnga_randomize(g_a, val);
2415
 
    local_stop = MPI_Wtime();
2416
 
    time_pnga_randomize += local_stop - local_start;
2417
 
}
2418
 
 
2419
 
 
2420
 
Integer wnga_read_inc(Integer g_a, Integer *subscript, Integer inc)
2421
 
{
2422
 
    Integer return_value;
2423
 
    double local_start, local_stop;
2424
 
    ++count_pnga_read_inc;
2425
 
    local_start = MPI_Wtime();
2426
 
    return_value = pnga_read_inc(g_a, subscript, inc);
2427
 
    local_stop = MPI_Wtime();
2428
 
    time_pnga_read_inc += local_stop - local_start;
2429
 
    return return_value;
2430
 
}
2431
 
 
2432
 
 
2433
 
void wnga_recip(Integer g_a)
2434
 
{
2435
 
    double local_start, local_stop;
2436
 
    ++count_pnga_recip;
2437
 
    local_start = MPI_Wtime();
2438
 
    pnga_recip(g_a);
2439
 
    local_stop = MPI_Wtime();
2440
 
    time_pnga_recip += local_stop - local_start;
2441
 
}
2442
 
 
2443
 
 
2444
 
void wnga_recip_patch(Integer g_a, Integer *lo, Integer *hi)
2445
 
{
2446
 
    double local_start, local_stop;
2447
 
    ++count_pnga_recip_patch;
2448
 
    local_start = MPI_Wtime();
2449
 
    pnga_recip_patch(g_a, lo, hi);
2450
 
    local_stop = MPI_Wtime();
2451
 
    time_pnga_recip_patch += local_stop - local_start;
2452
 
}
2453
 
 
2454
 
 
2455
 
int wnga_register_type(size_t size)
2456
 
{
2457
 
    int return_value;
2458
 
    double local_start, local_stop;
2459
 
    ++count_pnga_register_type;
2460
 
    local_start = MPI_Wtime();
2461
 
    return_value = pnga_register_type(size);
2462
 
    local_stop = MPI_Wtime();
2463
 
    time_pnga_register_type += local_stop - local_start;
2464
 
    return return_value;
2465
 
}
2466
 
 
2467
 
 
2468
 
void wnga_release(Integer g_a, Integer *lo, Integer *hi)
2469
 
{
2470
 
    double local_start, local_stop;
2471
 
    ++count_pnga_release;
2472
 
    local_start = MPI_Wtime();
2473
 
    pnga_release(g_a, lo, hi);
2474
 
    local_stop = MPI_Wtime();
2475
 
    time_pnga_release += local_stop - local_start;
2476
 
}
2477
 
 
2478
 
 
2479
 
void wnga_release_block(Integer g_a, Integer iblock)
2480
 
{
2481
 
    double local_start, local_stop;
2482
 
    ++count_pnga_release_block;
2483
 
    local_start = MPI_Wtime();
2484
 
    pnga_release_block(g_a, iblock);
2485
 
    local_stop = MPI_Wtime();
2486
 
    time_pnga_release_block += local_stop - local_start;
2487
 
}
2488
 
 
2489
 
 
2490
 
void wnga_release_block_grid(Integer g_a, Integer *index)
2491
 
{
2492
 
    double local_start, local_stop;
2493
 
    ++count_pnga_release_block_grid;
2494
 
    local_start = MPI_Wtime();
2495
 
    pnga_release_block_grid(g_a, index);
2496
 
    local_stop = MPI_Wtime();
2497
 
    time_pnga_release_block_grid += local_stop - local_start;
2498
 
}
2499
 
 
2500
 
 
2501
 
void wnga_release_block_segment(Integer g_a, Integer iproc)
2502
 
{
2503
 
    double local_start, local_stop;
2504
 
    ++count_pnga_release_block_segment;
2505
 
    local_start = MPI_Wtime();
2506
 
    pnga_release_block_segment(g_a, iproc);
2507
 
    local_stop = MPI_Wtime();
2508
 
    time_pnga_release_block_segment += local_stop - local_start;
2509
 
}
2510
 
 
2511
 
 
2512
 
void wnga_release_ghost_element(Integer g_a, Integer subscript[])
2513
 
{
2514
 
    double local_start, local_stop;
2515
 
    ++count_pnga_release_ghost_element;
2516
 
    local_start = MPI_Wtime();
2517
 
    pnga_release_ghost_element(g_a, subscript);
2518
 
    local_stop = MPI_Wtime();
2519
 
    time_pnga_release_ghost_element += local_stop - local_start;
2520
 
}
2521
 
 
2522
 
 
2523
 
void wnga_release_ghosts(Integer g_a)
2524
 
{
2525
 
    double local_start, local_stop;
2526
 
    ++count_pnga_release_ghosts;
2527
 
    local_start = MPI_Wtime();
2528
 
    pnga_release_ghosts(g_a);
2529
 
    local_stop = MPI_Wtime();
2530
 
    time_pnga_release_ghosts += local_stop - local_start;
2531
 
}
2532
 
 
2533
 
 
2534
 
void wnga_release_update(Integer g_a, Integer *lo, Integer *hi)
2535
 
{
2536
 
    double local_start, local_stop;
2537
 
    ++count_pnga_release_update;
2538
 
    local_start = MPI_Wtime();
2539
 
    pnga_release_update(g_a, lo, hi);
2540
 
    local_stop = MPI_Wtime();
2541
 
    time_pnga_release_update += local_stop - local_start;
2542
 
}
2543
 
 
2544
 
 
2545
 
void wnga_release_update_block(Integer g_a, Integer iblock)
2546
 
{
2547
 
    double local_start, local_stop;
2548
 
    ++count_pnga_release_update_block;
2549
 
    local_start = MPI_Wtime();
2550
 
    pnga_release_update_block(g_a, iblock);
2551
 
    local_stop = MPI_Wtime();
2552
 
    time_pnga_release_update_block += local_stop - local_start;
2553
 
}
2554
 
 
2555
 
 
2556
 
void wnga_release_update_block_grid(Integer g_a, Integer *index)
2557
 
{
2558
 
    double local_start, local_stop;
2559
 
    ++count_pnga_release_update_block_grid;
2560
 
    local_start = MPI_Wtime();
2561
 
    pnga_release_update_block_grid(g_a, index);
2562
 
    local_stop = MPI_Wtime();
2563
 
    time_pnga_release_update_block_grid += local_stop - local_start;
2564
 
}
2565
 
 
2566
 
 
2567
 
void wnga_release_update_block_segment(Integer g_a, Integer iproc)
2568
 
{
2569
 
    double local_start, local_stop;
2570
 
    ++count_pnga_release_update_block_segment;
2571
 
    local_start = MPI_Wtime();
2572
 
    pnga_release_update_block_segment(g_a, iproc);
2573
 
    local_stop = MPI_Wtime();
2574
 
    time_pnga_release_update_block_segment += local_stop - local_start;
2575
 
}
2576
 
 
2577
 
 
2578
 
void wnga_release_update_ghost_element(Integer g_a, Integer subscript[])
2579
 
{
2580
 
    double local_start, local_stop;
2581
 
    ++count_pnga_release_update_ghost_element;
2582
 
    local_start = MPI_Wtime();
2583
 
    pnga_release_update_ghost_element(g_a, subscript);
2584
 
    local_stop = MPI_Wtime();
2585
 
    time_pnga_release_update_ghost_element += local_stop - local_start;
2586
 
}
2587
 
 
2588
 
 
2589
 
void wnga_release_update_ghosts(Integer g_a)
2590
 
{
2591
 
    double local_start, local_stop;
2592
 
    ++count_pnga_release_update_ghosts;
2593
 
    local_start = MPI_Wtime();
2594
 
    pnga_release_update_ghosts(g_a);
2595
 
    local_stop = MPI_Wtime();
2596
 
    time_pnga_release_update_ghosts += local_stop - local_start;
2597
 
}
2598
 
 
2599
 
 
2600
 
void wnga_scale(Integer g_a, void *alpha)
2601
 
{
2602
 
    double local_start, local_stop;
2603
 
    ++count_pnga_scale;
2604
 
    local_start = MPI_Wtime();
2605
 
    pnga_scale(g_a, alpha);
2606
 
    local_stop = MPI_Wtime();
2607
 
    time_pnga_scale += local_stop - local_start;
2608
 
}
2609
 
 
2610
 
 
2611
 
void wnga_scale_cols(Integer g_a, Integer g_v)
2612
 
{
2613
 
    double local_start, local_stop;
2614
 
    ++count_pnga_scale_cols;
2615
 
    local_start = MPI_Wtime();
2616
 
    pnga_scale_cols(g_a, g_v);
2617
 
    local_stop = MPI_Wtime();
2618
 
    time_pnga_scale_cols += local_stop - local_start;
2619
 
}
2620
 
 
2621
 
 
2622
 
void wnga_scale_patch(Integer g_a, Integer *lo, Integer *hi, void *alpha)
2623
 
{
2624
 
    double local_start, local_stop;
2625
 
    ++count_pnga_scale_patch;
2626
 
    local_start = MPI_Wtime();
2627
 
    pnga_scale_patch(g_a, lo, hi, alpha);
2628
 
    local_stop = MPI_Wtime();
2629
 
    time_pnga_scale_patch += local_stop - local_start;
2630
 
}
2631
 
 
2632
 
 
2633
 
void wnga_scale_rows(Integer g_a, Integer g_v)
2634
 
{
2635
 
    double local_start, local_stop;
2636
 
    ++count_pnga_scale_rows;
2637
 
    local_start = MPI_Wtime();
2638
 
    pnga_scale_rows(g_a, g_v);
2639
 
    local_stop = MPI_Wtime();
2640
 
    time_pnga_scale_rows += local_stop - local_start;
2641
 
}
2642
 
 
2643
 
 
2644
 
void wnga_scan_add(Integer g_a, Integer g_b, Integer g_sbit, Integer lo, Integer hi, Integer excl)
2645
 
{
2646
 
    double local_start, local_stop;
2647
 
    ++count_pnga_scan_add;
2648
 
    local_start = MPI_Wtime();
2649
 
    pnga_scan_add(g_a, g_b, g_sbit, lo, hi, excl);
2650
 
    local_stop = MPI_Wtime();
2651
 
    time_pnga_scan_add += local_stop - local_start;
2652
 
}
2653
 
 
2654
 
 
2655
 
void wnga_scan_copy(Integer g_a, Integer g_b, Integer g_sbit, Integer lo, Integer hi)
2656
 
{
2657
 
    double local_start, local_stop;
2658
 
    ++count_pnga_scan_copy;
2659
 
    local_start = MPI_Wtime();
2660
 
    pnga_scan_copy(g_a, g_b, g_sbit, lo, hi);
2661
 
    local_stop = MPI_Wtime();
2662
 
    time_pnga_scan_copy += local_stop - local_start;
2663
 
}
2664
 
 
2665
 
 
2666
 
void wnga_scatter(Integer g_a, void *v, Integer *subscript, Integer nv)
2667
 
{
2668
 
    double local_start, local_stop;
2669
 
    ++count_pnga_scatter;
2670
 
    local_start = MPI_Wtime();
2671
 
    pnga_scatter(g_a, v, subscript, nv);
2672
 
    local_stop = MPI_Wtime();
2673
 
    time_pnga_scatter += local_stop - local_start;
2674
 
}
2675
 
 
2676
 
 
2677
 
void wnga_scatter2d(Integer g_a, void *v, Integer *i, Integer *j, Integer nv)
2678
 
{
2679
 
    double local_start, local_stop;
2680
 
    ++count_pnga_scatter2d;
2681
 
    local_start = MPI_Wtime();
2682
 
    pnga_scatter2d(g_a, v, i, j, nv);
2683
 
    local_stop = MPI_Wtime();
2684
 
    time_pnga_scatter2d += local_stop - local_start;
2685
 
}
2686
 
 
2687
 
 
2688
 
void wnga_scatter_acc(Integer g_a, void *v, Integer subscript[], Integer nv, void *alpha)
2689
 
{
2690
 
    double local_start, local_stop;
2691
 
    ++count_pnga_scatter_acc;
2692
 
    local_start = MPI_Wtime();
2693
 
    pnga_scatter_acc(g_a, v, subscript, nv, alpha);
2694
 
    local_stop = MPI_Wtime();
2695
 
    time_pnga_scatter_acc += local_stop - local_start;
2696
 
}
2697
 
 
2698
 
 
2699
 
void wnga_scatter_acc2d(Integer g_a, void *v, Integer *i, Integer *j, Integer nv, void *alpha)
2700
 
{
2701
 
    double local_start, local_stop;
2702
 
    ++count_pnga_scatter_acc2d;
2703
 
    local_start = MPI_Wtime();
2704
 
    pnga_scatter_acc2d(g_a, v, i, j, nv, alpha);
2705
 
    local_stop = MPI_Wtime();
2706
 
    time_pnga_scatter_acc2d += local_stop - local_start;
2707
 
}
2708
 
 
2709
 
 
2710
 
void wnga_select_elem(Integer g_a, char *op, void *val, Integer *subscript)
2711
 
{
2712
 
    double local_start, local_stop;
2713
 
    ++count_pnga_select_elem;
2714
 
    local_start = MPI_Wtime();
2715
 
    pnga_select_elem(g_a, op, val, subscript);
2716
 
    local_stop = MPI_Wtime();
2717
 
    time_pnga_select_elem += local_stop - local_start;
2718
 
}
2719
 
 
2720
 
 
2721
 
void wnga_set_array_name(Integer g_a, char *array_name)
2722
 
{
2723
 
    double local_start, local_stop;
2724
 
    ++count_pnga_set_array_name;
2725
 
    local_start = MPI_Wtime();
2726
 
    pnga_set_array_name(g_a, array_name);
2727
 
    local_stop = MPI_Wtime();
2728
 
    time_pnga_set_array_name += local_stop - local_start;
2729
 
}
2730
 
 
2731
 
 
2732
 
void wnga_set_block_cyclic(Integer g_a, Integer *dims)
2733
 
{
2734
 
    double local_start, local_stop;
2735
 
    ++count_pnga_set_block_cyclic;
2736
 
    local_start = MPI_Wtime();
2737
 
    pnga_set_block_cyclic(g_a, dims);
2738
 
    local_stop = MPI_Wtime();
2739
 
    time_pnga_set_block_cyclic += local_stop - local_start;
2740
 
}
2741
 
 
2742
 
 
2743
 
void wnga_set_block_cyclic_proc_grid(Integer g_a, Integer *dims, Integer *proc_grid)
2744
 
{
2745
 
    double local_start, local_stop;
2746
 
    ++count_pnga_set_block_cyclic_proc_grid;
2747
 
    local_start = MPI_Wtime();
2748
 
    pnga_set_block_cyclic_proc_grid(g_a, dims, proc_grid);
2749
 
    local_stop = MPI_Wtime();
2750
 
    time_pnga_set_block_cyclic_proc_grid += local_stop - local_start;
2751
 
}
2752
 
 
2753
 
 
2754
 
void wnga_set_chunk(Integer g_a, Integer *chunk)
2755
 
{
2756
 
    double local_start, local_stop;
2757
 
    ++count_pnga_set_chunk;
2758
 
    local_start = MPI_Wtime();
2759
 
    pnga_set_chunk(g_a, chunk);
2760
 
    local_stop = MPI_Wtime();
2761
 
    time_pnga_set_chunk += local_stop - local_start;
2762
 
}
2763
 
 
2764
 
 
2765
 
void wnga_set_data(Integer g_a, Integer ndim, Integer *dims, Integer type)
2766
 
{
2767
 
    double local_start, local_stop;
2768
 
    ++count_pnga_set_data;
2769
 
    local_start = MPI_Wtime();
2770
 
    pnga_set_data(g_a, ndim, dims, type);
2771
 
    local_stop = MPI_Wtime();
2772
 
    time_pnga_set_data += local_stop - local_start;
2773
 
}
2774
 
 
2775
 
 
2776
 
void wnga_set_debug(logical flag)
2777
 
{
2778
 
    double local_start, local_stop;
2779
 
    ++count_pnga_set_debug;
2780
 
    local_start = MPI_Wtime();
2781
 
    pnga_set_debug(flag);
2782
 
    local_stop = MPI_Wtime();
2783
 
    time_pnga_set_debug += local_stop - local_start;
2784
 
}
2785
 
 
2786
 
 
2787
 
void wnga_set_diagonal(Integer g_a, Integer g_v)
2788
 
{
2789
 
    double local_start, local_stop;
2790
 
    ++count_pnga_set_diagonal;
2791
 
    local_start = MPI_Wtime();
2792
 
    pnga_set_diagonal(g_a, g_v);
2793
 
    local_stop = MPI_Wtime();
2794
 
    time_pnga_set_diagonal += local_stop - local_start;
2795
 
}
2796
 
 
2797
 
 
2798
 
void wnga_set_ghost_corner_flag(Integer g_a, logical flag)
2799
 
{
2800
 
    double local_start, local_stop;
2801
 
    ++count_pnga_set_ghost_corner_flag;
2802
 
    local_start = MPI_Wtime();
2803
 
    pnga_set_ghost_corner_flag(g_a, flag);
2804
 
    local_stop = MPI_Wtime();
2805
 
    time_pnga_set_ghost_corner_flag += local_stop - local_start;
2806
 
}
2807
 
 
2808
 
 
2809
 
logical wnga_set_ghost_info(Integer g_a)
2810
 
{
2811
 
    logical return_value;
2812
 
    double local_start, local_stop;
2813
 
    ++count_pnga_set_ghost_info;
2814
 
    local_start = MPI_Wtime();
2815
 
    return_value = pnga_set_ghost_info(g_a);
2816
 
    local_stop = MPI_Wtime();
2817
 
    time_pnga_set_ghost_info += local_stop - local_start;
2818
 
    return return_value;
2819
 
}
2820
 
 
2821
 
 
2822
 
void wnga_set_ghosts(Integer g_a, Integer *width)
2823
 
{
2824
 
    double local_start, local_stop;
2825
 
    ++count_pnga_set_ghosts;
2826
 
    local_start = MPI_Wtime();
2827
 
    pnga_set_ghosts(g_a, width);
2828
 
    local_stop = MPI_Wtime();
2829
 
    time_pnga_set_ghosts += local_stop - local_start;
2830
 
}
2831
 
 
2832
 
 
2833
 
void wnga_set_irreg_distr(Integer g_a, Integer *map, Integer *block)
2834
 
{
2835
 
    double local_start, local_stop;
2836
 
    ++count_pnga_set_irreg_distr;
2837
 
    local_start = MPI_Wtime();
2838
 
    pnga_set_irreg_distr(g_a, map, block);
2839
 
    local_stop = MPI_Wtime();
2840
 
    time_pnga_set_irreg_distr += local_stop - local_start;
2841
 
}
2842
 
 
2843
 
 
2844
 
void wnga_set_irreg_flag(Integer g_a, logical flag)
2845
 
{
2846
 
    double local_start, local_stop;
2847
 
    ++count_pnga_set_irreg_flag;
2848
 
    local_start = MPI_Wtime();
2849
 
    pnga_set_irreg_flag(g_a, flag);
2850
 
    local_stop = MPI_Wtime();
2851
 
    time_pnga_set_irreg_flag += local_stop - local_start;
2852
 
}
2853
 
 
2854
 
 
2855
 
void wnga_set_memory_limit(Integer mem_limit)
2856
 
{
2857
 
    double local_start, local_stop;
2858
 
    ++count_pnga_set_memory_limit;
2859
 
    local_start = MPI_Wtime();
2860
 
    pnga_set_memory_limit(mem_limit);
2861
 
    local_stop = MPI_Wtime();
2862
 
    time_pnga_set_memory_limit += local_stop - local_start;
2863
 
}
2864
 
 
2865
 
 
2866
 
void wnga_set_pgroup(Integer g_a, Integer p_handle)
2867
 
{
2868
 
    double local_start, local_stop;
2869
 
    ++count_pnga_set_pgroup;
2870
 
    local_start = MPI_Wtime();
2871
 
    pnga_set_pgroup(g_a, p_handle);
2872
 
    local_stop = MPI_Wtime();
2873
 
    time_pnga_set_pgroup += local_stop - local_start;
2874
 
}
2875
 
 
2876
 
 
2877
 
void wnga_set_restricted(Integer g_a, Integer *list, Integer size)
2878
 
{
2879
 
    double local_start, local_stop;
2880
 
    ++count_pnga_set_restricted;
2881
 
    local_start = MPI_Wtime();
2882
 
    pnga_set_restricted(g_a, list, size);
2883
 
    local_stop = MPI_Wtime();
2884
 
    time_pnga_set_restricted += local_stop - local_start;
2885
 
}
2886
 
 
2887
 
 
2888
 
void wnga_set_restricted_range(Integer g_a, Integer lo_proc, Integer hi_proc)
2889
 
{
2890
 
    double local_start, local_stop;
2891
 
    ++count_pnga_set_restricted_range;
2892
 
    local_start = MPI_Wtime();
2893
 
    pnga_set_restricted_range(g_a, lo_proc, hi_proc);
2894
 
    local_stop = MPI_Wtime();
2895
 
    time_pnga_set_restricted_range += local_stop - local_start;
2896
 
}
2897
 
 
2898
 
 
2899
 
logical wnga_set_update4_info(Integer g_a)
2900
 
{
2901
 
    logical return_value;
2902
 
    double local_start, local_stop;
2903
 
    ++count_pnga_set_update4_info;
2904
 
    local_start = MPI_Wtime();
2905
 
    return_value = pnga_set_update4_info(g_a);
2906
 
    local_stop = MPI_Wtime();
2907
 
    time_pnga_set_update4_info += local_stop - local_start;
2908
 
    return return_value;
2909
 
}
2910
 
 
2911
 
 
2912
 
logical wnga_set_update5_info(Integer g_a)
2913
 
{
2914
 
    logical return_value;
2915
 
    double local_start, local_stop;
2916
 
    ++count_pnga_set_update5_info;
2917
 
    local_start = MPI_Wtime();
2918
 
    return_value = pnga_set_update5_info(g_a);
2919
 
    local_stop = MPI_Wtime();
2920
 
    time_pnga_set_update5_info += local_stop - local_start;
2921
 
    return return_value;
2922
 
}
2923
 
 
2924
 
 
2925
 
void wnga_shift_diagonal(Integer g_a, void *c)
2926
 
{
2927
 
    double local_start, local_stop;
2928
 
    ++count_pnga_shift_diagonal;
2929
 
    local_start = MPI_Wtime();
2930
 
    pnga_shift_diagonal(g_a, c);
2931
 
    local_stop = MPI_Wtime();
2932
 
    time_pnga_shift_diagonal += local_stop - local_start;
2933
 
}
2934
 
 
2935
 
 
2936
 
Integer wnga_solve(Integer g_a, Integer g_b)
2937
 
{
2938
 
    Integer return_value;
2939
 
    double local_start, local_stop;
2940
 
    ++count_pnga_solve;
2941
 
    local_start = MPI_Wtime();
2942
 
    return_value = pnga_solve(g_a, g_b);
2943
 
    local_stop = MPI_Wtime();
2944
 
    time_pnga_solve += local_stop - local_start;
2945
 
    return return_value;
2946
 
}
2947
 
 
2948
 
 
2949
 
Integer wnga_spd_invert(Integer g_a)
2950
 
{
2951
 
    Integer return_value;
2952
 
    double local_start, local_stop;
2953
 
    ++count_pnga_spd_invert;
2954
 
    local_start = MPI_Wtime();
2955
 
    return_value = pnga_spd_invert(g_a);
2956
 
    local_stop = MPI_Wtime();
2957
 
    time_pnga_spd_invert += local_stop - local_start;
2958
 
    return return_value;
2959
 
}
2960
 
 
2961
 
 
2962
 
void wnga_step_bound_info(Integer g_xx, Integer g_vv, Integer g_xxll, Integer g_xxuu, void *boundmin, void *wolfemin, void *boundmax)
2963
 
{
2964
 
    double local_start, local_stop;
2965
 
    ++count_pnga_step_bound_info;
2966
 
    local_start = MPI_Wtime();
2967
 
    pnga_step_bound_info(g_xx, g_vv, g_xxll, g_xxuu, boundmin, wolfemin, boundmax);
2968
 
    local_stop = MPI_Wtime();
2969
 
    time_pnga_step_bound_info += local_stop - local_start;
2970
 
}
2971
 
 
2972
 
 
2973
 
void wnga_step_bound_info_patch(Integer g_xx, Integer *xxlo, Integer *xxhi, Integer g_vv, Integer *vvlo, Integer *vvhi, Integer g_xxll, Integer *xxlllo, Integer *xxllhi, Integer g_xxuu, Integer *xxuulo, Integer *xxuuhi, void *boundmin, void *wolfemin, void *boundmax)
2974
 
{
2975
 
    double local_start, local_stop;
2976
 
    ++count_pnga_step_bound_info_patch;
2977
 
    local_start = MPI_Wtime();
2978
 
    pnga_step_bound_info_patch(g_xx, xxlo, xxhi, g_vv, vvlo, vvhi, g_xxll, xxlllo, xxllhi, g_xxuu, xxuulo, xxuuhi, boundmin, wolfemin, boundmax);
2979
 
    local_stop = MPI_Wtime();
2980
 
    time_pnga_step_bound_info_patch += local_stop - local_start;
2981
 
}
2982
 
 
2983
 
 
2984
 
void wnga_step_mask_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, Integer g_c, Integer *clo, Integer *chi)
2985
 
{
2986
 
    double local_start, local_stop;
2987
 
    ++count_pnga_step_mask_patch;
2988
 
    local_start = MPI_Wtime();
2989
 
    pnga_step_mask_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, clo, chi);
2990
 
    local_stop = MPI_Wtime();
2991
 
    time_pnga_step_mask_patch += local_stop - local_start;
2992
 
}
2993
 
 
2994
 
 
2995
 
void wnga_step_max(Integer g_a, Integer g_b, void *retval)
2996
 
{
2997
 
    double local_start, local_stop;
2998
 
    ++count_pnga_step_max;
2999
 
    local_start = MPI_Wtime();
3000
 
    pnga_step_max(g_a, g_b, retval);
3001
 
    local_stop = MPI_Wtime();
3002
 
    time_pnga_step_max += local_stop - local_start;
3003
 
}
3004
 
 
3005
 
 
3006
 
void wnga_step_max_patch(Integer g_a, Integer *alo, Integer *ahi, Integer g_b, Integer *blo, Integer *bhi, void *result)
3007
 
{
3008
 
    double local_start, local_stop;
3009
 
    ++count_pnga_step_max_patch;
3010
 
    local_start = MPI_Wtime();
3011
 
    pnga_step_max_patch(g_a, alo, ahi, g_b, blo, bhi, result);
3012
 
    local_stop = MPI_Wtime();
3013
 
    time_pnga_step_max_patch += local_stop - local_start;
3014
 
}
3015
 
 
3016
 
 
3017
 
void wnga_strided_acc(Integer g_a, Integer *lo, Integer *hi, Integer *skip, void *buf, Integer *ld, void *alpha)
3018
 
{
3019
 
    double local_start, local_stop;
3020
 
    ++count_pnga_strided_acc;
3021
 
    local_start = MPI_Wtime();
3022
 
    pnga_strided_acc(g_a, lo, hi, skip, buf, ld, alpha);
3023
 
    local_stop = MPI_Wtime();
3024
 
    time_pnga_strided_acc += local_stop - local_start;
3025
 
}
3026
 
 
3027
 
 
3028
 
void wnga_strided_get(Integer g_a, Integer *lo, Integer *hi, Integer *skip, void *buf, Integer *ld)
3029
 
{
3030
 
    double local_start, local_stop;
3031
 
    ++count_pnga_strided_get;
3032
 
    local_start = MPI_Wtime();
3033
 
    pnga_strided_get(g_a, lo, hi, skip, buf, ld);
3034
 
    local_stop = MPI_Wtime();
3035
 
    time_pnga_strided_get += local_stop - local_start;
3036
 
}
3037
 
 
3038
 
 
3039
 
void wnga_strided_put(Integer g_a, Integer *lo, Integer *hi, Integer *skip, void *buf, Integer *ld)
3040
 
{
3041
 
    double local_start, local_stop;
3042
 
    ++count_pnga_strided_put;
3043
 
    local_start = MPI_Wtime();
3044
 
    pnga_strided_put(g_a, lo, hi, skip, buf, ld);
3045
 
    local_stop = MPI_Wtime();
3046
 
    time_pnga_strided_put += local_stop - local_start;
3047
 
}
3048
 
 
3049
 
 
3050
 
void wnga_summarize(Integer verbose)
3051
 
{
3052
 
    double local_start, local_stop;
3053
 
    ++count_pnga_summarize;
3054
 
    local_start = MPI_Wtime();
3055
 
    pnga_summarize(verbose);
3056
 
    local_stop = MPI_Wtime();
3057
 
    time_pnga_summarize += local_stop - local_start;
3058
 
}
3059
 
 
3060
 
 
3061
 
void wnga_symmetrize(Integer g_a)
3062
 
{
3063
 
    double local_start, local_stop;
3064
 
    ++count_pnga_symmetrize;
3065
 
    local_start = MPI_Wtime();
3066
 
    pnga_symmetrize(g_a);
3067
 
    local_stop = MPI_Wtime();
3068
 
    time_pnga_symmetrize += local_stop - local_start;
3069
 
}
3070
 
 
3071
 
 
3072
 
void wnga_sync()
3073
 
{
3074
 
    double local_start, local_stop;
3075
 
    ++count_pnga_sync;
3076
 
    local_start = MPI_Wtime();
3077
 
    pnga_sync();
3078
 
    local_stop = MPI_Wtime();
3079
 
    time_pnga_sync += local_stop - local_start;
3080
 
}
3081
 
 
3082
 
 
3083
 
double wnga_timer()
3084
 
{
3085
 
    double return_value;
3086
 
    double local_start, local_stop;
3087
 
    ++count_pnga_timer;
3088
 
    local_start = MPI_Wtime();
3089
 
    return_value = pnga_timer();
3090
 
    local_stop = MPI_Wtime();
3091
 
    time_pnga_timer += local_stop - local_start;
3092
 
    return return_value;
3093
 
}
3094
 
 
3095
 
 
3096
 
Integer wnga_total_blocks(Integer g_a)
3097
 
{
3098
 
    Integer return_value;
3099
 
    double local_start, local_stop;
3100
 
    ++count_pnga_total_blocks;
3101
 
    local_start = MPI_Wtime();
3102
 
    return_value = pnga_total_blocks(g_a);
3103
 
    local_stop = MPI_Wtime();
3104
 
    time_pnga_total_blocks += local_stop - local_start;
3105
 
    return return_value;
3106
 
}
3107
 
 
3108
 
 
3109
 
void wnga_transpose(Integer g_a, Integer g_b)
3110
 
{
3111
 
    double local_start, local_stop;
3112
 
    ++count_pnga_transpose;
3113
 
    local_start = MPI_Wtime();
3114
 
    pnga_transpose(g_a, g_b);
3115
 
    local_stop = MPI_Wtime();
3116
 
    time_pnga_transpose += local_stop - local_start;
3117
 
}
3118
 
 
3119
 
 
3120
 
Integer wnga_type_c2f(Integer type)
3121
 
{
3122
 
    Integer return_value;
3123
 
    double local_start, local_stop;
3124
 
    ++count_pnga_type_c2f;
3125
 
    local_start = MPI_Wtime();
3126
 
    return_value = pnga_type_c2f(type);
3127
 
    local_stop = MPI_Wtime();
3128
 
    time_pnga_type_c2f += local_stop - local_start;
3129
 
    return return_value;
3130
 
}
3131
 
 
3132
 
 
3133
 
Integer wnga_type_f2c(Integer type)
3134
 
{
3135
 
    Integer return_value;
3136
 
    double local_start, local_stop;
3137
 
    ++count_pnga_type_f2c;
3138
 
    local_start = MPI_Wtime();
3139
 
    return_value = pnga_type_f2c(type);
3140
 
    local_stop = MPI_Wtime();
3141
 
    time_pnga_type_f2c += local_stop - local_start;
3142
 
    return return_value;
3143
 
}
3144
 
 
3145
 
 
3146
 
void wnga_unlock(Integer mutex)
3147
 
{
3148
 
    double local_start, local_stop;
3149
 
    ++count_pnga_unlock;
3150
 
    local_start = MPI_Wtime();
3151
 
    pnga_unlock(mutex);
3152
 
    local_stop = MPI_Wtime();
3153
 
    time_pnga_unlock += local_stop - local_start;
3154
 
}
3155
 
 
3156
 
 
3157
 
void wnga_unpack(Integer g_a, Integer g_b, Integer g_sbit, Integer lo, Integer hi, Integer *icount)
3158
 
{
3159
 
    double local_start, local_stop;
3160
 
    ++count_pnga_unpack;
3161
 
    local_start = MPI_Wtime();
3162
 
    pnga_unpack(g_a, g_b, g_sbit, lo, hi, icount);
3163
 
    local_stop = MPI_Wtime();
3164
 
    time_pnga_unpack += local_stop - local_start;
3165
 
}
3166
 
 
3167
 
 
3168
 
void wnga_update1_ghosts(Integer g_a)
3169
 
{
3170
 
    double local_start, local_stop;
3171
 
    ++count_pnga_update1_ghosts;
3172
 
    local_start = MPI_Wtime();
3173
 
    pnga_update1_ghosts(g_a);
3174
 
    local_stop = MPI_Wtime();
3175
 
    time_pnga_update1_ghosts += local_stop - local_start;
3176
 
}
3177
 
 
3178
 
 
3179
 
logical wnga_update2_ghosts(Integer g_a)
3180
 
{
3181
 
    logical return_value;
3182
 
    double local_start, local_stop;
3183
 
    ++count_pnga_update2_ghosts;
3184
 
    local_start = MPI_Wtime();
3185
 
    return_value = pnga_update2_ghosts(g_a);
3186
 
    local_stop = MPI_Wtime();
3187
 
    time_pnga_update2_ghosts += local_stop - local_start;
3188
 
    return return_value;
3189
 
}
3190
 
 
3191
 
 
3192
 
logical wnga_update3_ghosts(Integer g_a)
3193
 
{
3194
 
    logical return_value;
3195
 
    double local_start, local_stop;
3196
 
    ++count_pnga_update3_ghosts;
3197
 
    local_start = MPI_Wtime();
3198
 
    return_value = pnga_update3_ghosts(g_a);
3199
 
    local_stop = MPI_Wtime();
3200
 
    time_pnga_update3_ghosts += local_stop - local_start;
3201
 
    return return_value;
3202
 
}
3203
 
 
3204
 
 
3205
 
logical wnga_update44_ghosts(Integer g_a)
3206
 
{
3207
 
    logical return_value;
3208
 
    double local_start, local_stop;
3209
 
    ++count_pnga_update44_ghosts;
3210
 
    local_start = MPI_Wtime();
3211
 
    return_value = pnga_update44_ghosts(g_a);
3212
 
    local_stop = MPI_Wtime();
3213
 
    time_pnga_update44_ghosts += local_stop - local_start;
3214
 
    return return_value;
3215
 
}
3216
 
 
3217
 
 
3218
 
logical wnga_update4_ghosts(Integer g_a)
3219
 
{
3220
 
    logical return_value;
3221
 
    double local_start, local_stop;
3222
 
    ++count_pnga_update4_ghosts;
3223
 
    local_start = MPI_Wtime();
3224
 
    return_value = pnga_update4_ghosts(g_a);
3225
 
    local_stop = MPI_Wtime();
3226
 
    time_pnga_update4_ghosts += local_stop - local_start;
3227
 
    return return_value;
3228
 
}
3229
 
 
3230
 
 
3231
 
logical wnga_update55_ghosts(Integer g_a)
3232
 
{
3233
 
    logical return_value;
3234
 
    double local_start, local_stop;
3235
 
    ++count_pnga_update55_ghosts;
3236
 
    local_start = MPI_Wtime();
3237
 
    return_value = pnga_update55_ghosts(g_a);
3238
 
    local_stop = MPI_Wtime();
3239
 
    time_pnga_update55_ghosts += local_stop - local_start;
3240
 
    return return_value;
3241
 
}
3242
 
 
3243
 
 
3244
 
logical wnga_update5_ghosts(Integer g_a)
3245
 
{
3246
 
    logical return_value;
3247
 
    double local_start, local_stop;
3248
 
    ++count_pnga_update5_ghosts;
3249
 
    local_start = MPI_Wtime();
3250
 
    return_value = pnga_update5_ghosts(g_a);
3251
 
    local_stop = MPI_Wtime();
3252
 
    time_pnga_update5_ghosts += local_stop - local_start;
3253
 
    return return_value;
3254
 
}
3255
 
 
3256
 
 
3257
 
logical wnga_update6_ghosts(Integer g_a)
3258
 
{
3259
 
    logical return_value;
3260
 
    double local_start, local_stop;
3261
 
    ++count_pnga_update6_ghosts;
3262
 
    local_start = MPI_Wtime();
3263
 
    return_value = pnga_update6_ghosts(g_a);
3264
 
    local_stop = MPI_Wtime();
3265
 
    time_pnga_update6_ghosts += local_stop - local_start;
3266
 
    return return_value;
3267
 
}
3268
 
 
3269
 
 
3270
 
logical wnga_update7_ghosts(Integer g_a)
3271
 
{
3272
 
    logical return_value;
3273
 
    double local_start, local_stop;
3274
 
    ++count_pnga_update7_ghosts;
3275
 
    local_start = MPI_Wtime();
3276
 
    return_value = pnga_update7_ghosts(g_a);
3277
 
    local_stop = MPI_Wtime();
3278
 
    time_pnga_update7_ghosts += local_stop - local_start;
3279
 
    return return_value;
3280
 
}
3281
 
 
3282
 
 
3283
 
logical wnga_update_ghost_dir(Integer g_a, Integer pdim, Integer pdir, logical pflag)
3284
 
{
3285
 
    logical return_value;
3286
 
    double local_start, local_stop;
3287
 
    ++count_pnga_update_ghost_dir;
3288
 
    local_start = MPI_Wtime();
3289
 
    return_value = pnga_update_ghost_dir(g_a, pdim, pdir, pflag);
3290
 
    local_stop = MPI_Wtime();
3291
 
    time_pnga_update_ghost_dir += local_stop - local_start;
3292
 
    return return_value;
3293
 
}
3294
 
 
3295
 
 
3296
 
void wnga_update_ghosts(Integer g_a)
3297
 
{
3298
 
    double local_start, local_stop;
3299
 
    ++count_pnga_update_ghosts;
3300
 
    local_start = MPI_Wtime();
3301
 
    pnga_update_ghosts(g_a);
3302
 
    local_stop = MPI_Wtime();
3303
 
    time_pnga_update_ghosts += local_stop - local_start;
3304
 
}
3305
 
 
3306
 
 
3307
 
logical wnga_uses_ma()
3308
 
{
3309
 
    logical return_value;
3310
 
    double local_start, local_stop;
3311
 
    ++count_pnga_uses_ma;
3312
 
    local_start = MPI_Wtime();
3313
 
    return_value = pnga_uses_ma();
3314
 
    local_stop = MPI_Wtime();
3315
 
    time_pnga_uses_ma += local_stop - local_start;
3316
 
    return return_value;
3317
 
}
3318
 
 
3319
 
 
3320
 
logical wnga_uses_proc_grid(Integer g_a)
3321
 
{
3322
 
    logical return_value;
3323
 
    double local_start, local_stop;
3324
 
    ++count_pnga_uses_proc_grid;
3325
 
    local_start = MPI_Wtime();
3326
 
    return_value = pnga_uses_proc_grid(g_a);
3327
 
    local_stop = MPI_Wtime();
3328
 
    time_pnga_uses_proc_grid += local_stop - local_start;
3329
 
    return return_value;
3330
 
}
3331
 
 
3332
 
 
3333
 
logical wnga_valid_handle(Integer g_a)
3334
 
{
3335
 
    logical return_value;
3336
 
    double local_start, local_stop;
3337
 
    ++count_pnga_valid_handle;
3338
 
    local_start = MPI_Wtime();
3339
 
    return_value = pnga_valid_handle(g_a);
3340
 
    local_stop = MPI_Wtime();
3341
 
    time_pnga_valid_handle += local_stop - local_start;
3342
 
    return return_value;
3343
 
}
3344
 
 
3345
 
 
3346
 
Integer wnga_verify_handle(Integer g_a)
3347
 
{
3348
 
    Integer return_value;
3349
 
    double local_start, local_stop;
3350
 
    ++count_pnga_verify_handle;
3351
 
    local_start = MPI_Wtime();
3352
 
    return_value = pnga_verify_handle(g_a);
3353
 
    local_stop = MPI_Wtime();
3354
 
    time_pnga_verify_handle += local_stop - local_start;
3355
 
    return return_value;
3356
 
}
3357
 
 
3358
 
 
3359
 
DoublePrecision wnga_wtime()
3360
 
{
3361
 
    DoublePrecision return_value;
3362
 
    double local_start, local_stop;
3363
 
    ++count_pnga_wtime;
3364
 
    local_start = MPI_Wtime();
3365
 
    return_value = pnga_wtime();
3366
 
    local_stop = MPI_Wtime();
3367
 
    time_pnga_wtime += local_stop - local_start;
3368
 
    return return_value;
3369
 
}
3370
 
 
3371
 
 
3372
 
void wnga_zero(Integer g_a)
3373
 
{
3374
 
    double local_start, local_stop;
3375
 
    ++count_pnga_zero;
3376
 
    local_start = MPI_Wtime();
3377
 
    pnga_zero(g_a);
3378
 
    local_stop = MPI_Wtime();
3379
 
    time_pnga_zero += local_stop - local_start;
3380
 
}
3381
 
 
3382
 
 
3383
 
void wnga_zero_diagonal(Integer g_a)
3384
 
{
3385
 
    double local_start, local_stop;
3386
 
    ++count_pnga_zero_diagonal;
3387
 
    local_start = MPI_Wtime();
3388
 
    pnga_zero_diagonal(g_a);
3389
 
    local_stop = MPI_Wtime();
3390
 
    time_pnga_zero_diagonal += local_stop - local_start;
3391
 
}
3392
 
 
3393
 
 
3394
 
void wnga_zero_patch(Integer g_a, Integer *lo, Integer *hi)
3395
 
{
3396
 
    double local_start, local_stop;
3397
 
    ++count_pnga_zero_patch;
3398
 
    local_start = MPI_Wtime();
3399
 
    pnga_zero_patch(g_a, lo, hi);
3400
 
    local_stop = MPI_Wtime();
3401
 
    time_pnga_zero_patch += local_stop - local_start;
3402
 
}
3403
 
 
3404
 
void wnga_initialize()
3405
 
{
3406
 
    ++count_pnga_initialize;
3407
 
    pnga_initialize();
3408
 
    MPI_Comm_rank(MPI_COMM_WORLD, &me);
3409
 
    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
3410
 
}
3411
 
 
3412
 
void wnga_initialize_ltd(Integer limit)
3413
 
{
3414
 
    ++count_pnga_initialize_ltd;
3415
 
    pnga_initialize_ltd(limit);
3416
 
    MPI_Comm_rank(MPI_COMM_WORLD, &me);
3417
 
    MPI_Comm_size(MPI_COMM_WORLD, &nproc);
3418
 
}
3419
 
 
3420
 
void wnga_terminate()
3421
 
{
3422
 
    ++count_pnga_terminate;
3423
 
    pnga_terminate();
3424
 
    /* don't dump info if terminate more than once */
3425
 
    if (1 == count_pnga_terminate) {
3426
 
 
3427
 
        double recvbuf = 0.0;
3428
 
 
3429
 
        MPI_Reduce(&time_pnga_abs_value, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3430
 
        if (me == 0) {
3431
 
            printf("pnga_abs_value,%ld,%lf\n", count_pnga_abs_value, recvbuf);
3432
 
        }
3433
 
 
3434
 
        MPI_Reduce(&time_pnga_abs_value_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3435
 
        if (me == 0) {
3436
 
            printf("pnga_abs_value_patch,%ld,%lf\n", count_pnga_abs_value_patch, recvbuf);
3437
 
        }
3438
 
 
3439
 
        MPI_Reduce(&time_pnga_acc, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3440
 
        if (me == 0) {
3441
 
            printf("pnga_acc,%ld,%lf\n", count_pnga_acc, recvbuf);
3442
 
        }
3443
 
 
3444
 
        MPI_Reduce(&time_pnga_access_block_grid_idx, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3445
 
        if (me == 0) {
3446
 
            printf("pnga_access_block_grid_idx,%ld,%lf\n", count_pnga_access_block_grid_idx, recvbuf);
3447
 
        }
3448
 
 
3449
 
        MPI_Reduce(&time_pnga_access_block_grid_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3450
 
        if (me == 0) {
3451
 
            printf("pnga_access_block_grid_ptr,%ld,%lf\n", count_pnga_access_block_grid_ptr, recvbuf);
3452
 
        }
3453
 
 
3454
 
        MPI_Reduce(&time_pnga_access_block_idx, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3455
 
        if (me == 0) {
3456
 
            printf("pnga_access_block_idx,%ld,%lf\n", count_pnga_access_block_idx, recvbuf);
3457
 
        }
3458
 
 
3459
 
        MPI_Reduce(&time_pnga_access_block_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3460
 
        if (me == 0) {
3461
 
            printf("pnga_access_block_ptr,%ld,%lf\n", count_pnga_access_block_ptr, recvbuf);
3462
 
        }
3463
 
 
3464
 
        MPI_Reduce(&time_pnga_access_block_segment_idx, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3465
 
        if (me == 0) {
3466
 
            printf("pnga_access_block_segment_idx,%ld,%lf\n", count_pnga_access_block_segment_idx, recvbuf);
3467
 
        }
3468
 
 
3469
 
        MPI_Reduce(&time_pnga_access_block_segment_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3470
 
        if (me == 0) {
3471
 
            printf("pnga_access_block_segment_ptr,%ld,%lf\n", count_pnga_access_block_segment_ptr, recvbuf);
3472
 
        }
3473
 
 
3474
 
        MPI_Reduce(&time_pnga_access_ghost_element, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3475
 
        if (me == 0) {
3476
 
            printf("pnga_access_ghost_element,%ld,%lf\n", count_pnga_access_ghost_element, recvbuf);
3477
 
        }
3478
 
 
3479
 
        MPI_Reduce(&time_pnga_access_ghost_element_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3480
 
        if (me == 0) {
3481
 
            printf("pnga_access_ghost_element_ptr,%ld,%lf\n", count_pnga_access_ghost_element_ptr, recvbuf);
3482
 
        }
3483
 
 
3484
 
        MPI_Reduce(&time_pnga_access_ghost_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3485
 
        if (me == 0) {
3486
 
            printf("pnga_access_ghost_ptr,%ld,%lf\n", count_pnga_access_ghost_ptr, recvbuf);
3487
 
        }
3488
 
 
3489
 
        MPI_Reduce(&time_pnga_access_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3490
 
        if (me == 0) {
3491
 
            printf("pnga_access_ghosts,%ld,%lf\n", count_pnga_access_ghosts, recvbuf);
3492
 
        }
3493
 
 
3494
 
        MPI_Reduce(&time_pnga_access_idx, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3495
 
        if (me == 0) {
3496
 
            printf("pnga_access_idx,%ld,%lf\n", count_pnga_access_idx, recvbuf);
3497
 
        }
3498
 
 
3499
 
        MPI_Reduce(&time_pnga_access_ptr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3500
 
        if (me == 0) {
3501
 
            printf("pnga_access_ptr,%ld,%lf\n", count_pnga_access_ptr, recvbuf);
3502
 
        }
3503
 
 
3504
 
        MPI_Reduce(&time_pnga_add, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3505
 
        if (me == 0) {
3506
 
            printf("pnga_add,%ld,%lf\n", count_pnga_add, recvbuf);
3507
 
        }
3508
 
 
3509
 
        MPI_Reduce(&time_pnga_add_constant, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3510
 
        if (me == 0) {
3511
 
            printf("pnga_add_constant,%ld,%lf\n", count_pnga_add_constant, recvbuf);
3512
 
        }
3513
 
 
3514
 
        MPI_Reduce(&time_pnga_add_constant_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3515
 
        if (me == 0) {
3516
 
            printf("pnga_add_constant_patch,%ld,%lf\n", count_pnga_add_constant_patch, recvbuf);
3517
 
        }
3518
 
 
3519
 
        MPI_Reduce(&time_pnga_add_diagonal, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3520
 
        if (me == 0) {
3521
 
            printf("pnga_add_diagonal,%ld,%lf\n", count_pnga_add_diagonal, recvbuf);
3522
 
        }
3523
 
 
3524
 
        MPI_Reduce(&time_pnga_add_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3525
 
        if (me == 0) {
3526
 
            printf("pnga_add_patch,%ld,%lf\n", count_pnga_add_patch, recvbuf);
3527
 
        }
3528
 
 
3529
 
        MPI_Reduce(&time_pnga_allocate, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3530
 
        if (me == 0) {
3531
 
            printf("pnga_allocate,%ld,%lf\n", count_pnga_allocate, recvbuf);
3532
 
        }
3533
 
 
3534
 
        MPI_Reduce(&time_pnga_bin_index, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3535
 
        if (me == 0) {
3536
 
            printf("pnga_bin_index,%ld,%lf\n", count_pnga_bin_index, recvbuf);
3537
 
        }
3538
 
 
3539
 
        MPI_Reduce(&time_pnga_bin_sorter, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3540
 
        if (me == 0) {
3541
 
            printf("pnga_bin_sorter,%ld,%lf\n", count_pnga_bin_sorter, recvbuf);
3542
 
        }
3543
 
 
3544
 
        MPI_Reduce(&time_pnga_brdcst, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3545
 
        if (me == 0) {
3546
 
            printf("pnga_brdcst,%ld,%lf\n", count_pnga_brdcst, recvbuf);
3547
 
        }
3548
 
 
3549
 
        MPI_Reduce(&time_pnga_check_handle, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3550
 
        if (me == 0) {
3551
 
            printf("pnga_check_handle,%ld,%lf\n", count_pnga_check_handle, recvbuf);
3552
 
        }
3553
 
 
3554
 
        MPI_Reduce(&time_pnga_cluster_nnodes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3555
 
        if (me == 0) {
3556
 
            printf("pnga_cluster_nnodes,%ld,%lf\n", count_pnga_cluster_nnodes, recvbuf);
3557
 
        }
3558
 
 
3559
 
        MPI_Reduce(&time_pnga_cluster_nodeid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3560
 
        if (me == 0) {
3561
 
            printf("pnga_cluster_nodeid,%ld,%lf\n", count_pnga_cluster_nodeid, recvbuf);
3562
 
        }
3563
 
 
3564
 
        MPI_Reduce(&time_pnga_cluster_nprocs, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3565
 
        if (me == 0) {
3566
 
            printf("pnga_cluster_nprocs,%ld,%lf\n", count_pnga_cluster_nprocs, recvbuf);
3567
 
        }
3568
 
 
3569
 
        MPI_Reduce(&time_pnga_cluster_proc_nodeid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3570
 
        if (me == 0) {
3571
 
            printf("pnga_cluster_proc_nodeid,%ld,%lf\n", count_pnga_cluster_proc_nodeid, recvbuf);
3572
 
        }
3573
 
 
3574
 
        MPI_Reduce(&time_pnga_cluster_procid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3575
 
        if (me == 0) {
3576
 
            printf("pnga_cluster_procid,%ld,%lf\n", count_pnga_cluster_procid, recvbuf);
3577
 
        }
3578
 
 
3579
 
        MPI_Reduce(&time_pnga_comp_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3580
 
        if (me == 0) {
3581
 
            printf("pnga_comp_patch,%ld,%lf\n", count_pnga_comp_patch, recvbuf);
3582
 
        }
3583
 
 
3584
 
        MPI_Reduce(&time_pnga_compare_distr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3585
 
        if (me == 0) {
3586
 
            printf("pnga_compare_distr,%ld,%lf\n", count_pnga_compare_distr, recvbuf);
3587
 
        }
3588
 
 
3589
 
        MPI_Reduce(&time_pnga_copy, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3590
 
        if (me == 0) {
3591
 
            printf("pnga_copy,%ld,%lf\n", count_pnga_copy, recvbuf);
3592
 
        }
3593
 
 
3594
 
        MPI_Reduce(&time_pnga_copy_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3595
 
        if (me == 0) {
3596
 
            printf("pnga_copy_patch,%ld,%lf\n", count_pnga_copy_patch, recvbuf);
3597
 
        }
3598
 
 
3599
 
        MPI_Reduce(&time_pnga_copy_patch_dp, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3600
 
        if (me == 0) {
3601
 
            printf("pnga_copy_patch_dp,%ld,%lf\n", count_pnga_copy_patch_dp, recvbuf);
3602
 
        }
3603
 
 
3604
 
        MPI_Reduce(&time_pnga_create, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3605
 
        if (me == 0) {
3606
 
            printf("pnga_create,%ld,%lf\n", count_pnga_create, recvbuf);
3607
 
        }
3608
 
 
3609
 
        MPI_Reduce(&time_pnga_create_bin_range, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3610
 
        if (me == 0) {
3611
 
            printf("pnga_create_bin_range,%ld,%lf\n", count_pnga_create_bin_range, recvbuf);
3612
 
        }
3613
 
 
3614
 
        MPI_Reduce(&time_pnga_create_config, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3615
 
        if (me == 0) {
3616
 
            printf("pnga_create_config,%ld,%lf\n", count_pnga_create_config, recvbuf);
3617
 
        }
3618
 
 
3619
 
        MPI_Reduce(&time_pnga_create_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3620
 
        if (me == 0) {
3621
 
            printf("pnga_create_ghosts,%ld,%lf\n", count_pnga_create_ghosts, recvbuf);
3622
 
        }
3623
 
 
3624
 
        MPI_Reduce(&time_pnga_create_ghosts_config, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3625
 
        if (me == 0) {
3626
 
            printf("pnga_create_ghosts_config,%ld,%lf\n", count_pnga_create_ghosts_config, recvbuf);
3627
 
        }
3628
 
 
3629
 
        MPI_Reduce(&time_pnga_create_ghosts_irreg, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3630
 
        if (me == 0) {
3631
 
            printf("pnga_create_ghosts_irreg,%ld,%lf\n", count_pnga_create_ghosts_irreg, recvbuf);
3632
 
        }
3633
 
 
3634
 
        MPI_Reduce(&time_pnga_create_ghosts_irreg_config, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3635
 
        if (me == 0) {
3636
 
            printf("pnga_create_ghosts_irreg_config,%ld,%lf\n", count_pnga_create_ghosts_irreg_config, recvbuf);
3637
 
        }
3638
 
 
3639
 
        MPI_Reduce(&time_pnga_create_handle, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3640
 
        if (me == 0) {
3641
 
            printf("pnga_create_handle,%ld,%lf\n", count_pnga_create_handle, recvbuf);
3642
 
        }
3643
 
 
3644
 
        MPI_Reduce(&time_pnga_create_irreg, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3645
 
        if (me == 0) {
3646
 
            printf("pnga_create_irreg,%ld,%lf\n", count_pnga_create_irreg, recvbuf);
3647
 
        }
3648
 
 
3649
 
        MPI_Reduce(&time_pnga_create_irreg_config, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3650
 
        if (me == 0) {
3651
 
            printf("pnga_create_irreg_config,%ld,%lf\n", count_pnga_create_irreg_config, recvbuf);
3652
 
        }
3653
 
 
3654
 
        MPI_Reduce(&time_pnga_create_mutexes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3655
 
        if (me == 0) {
3656
 
            printf("pnga_create_mutexes,%ld,%lf\n", count_pnga_create_mutexes, recvbuf);
3657
 
        }
3658
 
 
3659
 
        MPI_Reduce(&time_pnga_ddot_patch_dp, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3660
 
        if (me == 0) {
3661
 
            printf("pnga_ddot_patch_dp,%ld,%lf\n", count_pnga_ddot_patch_dp, recvbuf);
3662
 
        }
3663
 
 
3664
 
        MPI_Reduce(&time_pnga_deregister_type, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3665
 
        if (me == 0) {
3666
 
            printf("pnga_deregister_type,%ld,%lf\n", count_pnga_deregister_type, recvbuf);
3667
 
        }
3668
 
 
3669
 
        MPI_Reduce(&time_pnga_destroy, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3670
 
        if (me == 0) {
3671
 
            printf("pnga_destroy,%ld,%lf\n", count_pnga_destroy, recvbuf);
3672
 
        }
3673
 
 
3674
 
        MPI_Reduce(&time_pnga_destroy_mutexes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3675
 
        if (me == 0) {
3676
 
            printf("pnga_destroy_mutexes,%ld,%lf\n", count_pnga_destroy_mutexes, recvbuf);
3677
 
        }
3678
 
 
3679
 
        MPI_Reduce(&time_pnga_diag, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3680
 
        if (me == 0) {
3681
 
            printf("pnga_diag,%ld,%lf\n", count_pnga_diag, recvbuf);
3682
 
        }
3683
 
 
3684
 
        MPI_Reduce(&time_pnga_diag_reuse, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3685
 
        if (me == 0) {
3686
 
            printf("pnga_diag_reuse,%ld,%lf\n", count_pnga_diag_reuse, recvbuf);
3687
 
        }
3688
 
 
3689
 
        MPI_Reduce(&time_pnga_diag_seq, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3690
 
        if (me == 0) {
3691
 
            printf("pnga_diag_seq,%ld,%lf\n", count_pnga_diag_seq, recvbuf);
3692
 
        }
3693
 
 
3694
 
        MPI_Reduce(&time_pnga_diag_std, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3695
 
        if (me == 0) {
3696
 
            printf("pnga_diag_std,%ld,%lf\n", count_pnga_diag_std, recvbuf);
3697
 
        }
3698
 
 
3699
 
        MPI_Reduce(&time_pnga_diag_std_seq, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3700
 
        if (me == 0) {
3701
 
            printf("pnga_diag_std_seq,%ld,%lf\n", count_pnga_diag_std_seq, recvbuf);
3702
 
        }
3703
 
 
3704
 
        MPI_Reduce(&time_pnga_distribution, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3705
 
        if (me == 0) {
3706
 
            printf("pnga_distribution,%ld,%lf\n", count_pnga_distribution, recvbuf);
3707
 
        }
3708
 
 
3709
 
        MPI_Reduce(&time_pnga_dot, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3710
 
        if (me == 0) {
3711
 
            printf("pnga_dot,%ld,%lf\n", count_pnga_dot, recvbuf);
3712
 
        }
3713
 
 
3714
 
        MPI_Reduce(&time_pnga_dot_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3715
 
        if (me == 0) {
3716
 
            printf("pnga_dot_patch,%ld,%lf\n", count_pnga_dot_patch, recvbuf);
3717
 
        }
3718
 
 
3719
 
        MPI_Reduce(&time_pnga_duplicate, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3720
 
        if (me == 0) {
3721
 
            printf("pnga_duplicate,%ld,%lf\n", count_pnga_duplicate, recvbuf);
3722
 
        }
3723
 
 
3724
 
        MPI_Reduce(&time_pnga_elem_divide, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3725
 
        if (me == 0) {
3726
 
            printf("pnga_elem_divide,%ld,%lf\n", count_pnga_elem_divide, recvbuf);
3727
 
        }
3728
 
 
3729
 
        MPI_Reduce(&time_pnga_elem_divide_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3730
 
        if (me == 0) {
3731
 
            printf("pnga_elem_divide_patch,%ld,%lf\n", count_pnga_elem_divide_patch, recvbuf);
3732
 
        }
3733
 
 
3734
 
        MPI_Reduce(&time_pnga_elem_maximum, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3735
 
        if (me == 0) {
3736
 
            printf("pnga_elem_maximum,%ld,%lf\n", count_pnga_elem_maximum, recvbuf);
3737
 
        }
3738
 
 
3739
 
        MPI_Reduce(&time_pnga_elem_maximum_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3740
 
        if (me == 0) {
3741
 
            printf("pnga_elem_maximum_patch,%ld,%lf\n", count_pnga_elem_maximum_patch, recvbuf);
3742
 
        }
3743
 
 
3744
 
        MPI_Reduce(&time_pnga_elem_minimum, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3745
 
        if (me == 0) {
3746
 
            printf("pnga_elem_minimum,%ld,%lf\n", count_pnga_elem_minimum, recvbuf);
3747
 
        }
3748
 
 
3749
 
        MPI_Reduce(&time_pnga_elem_minimum_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3750
 
        if (me == 0) {
3751
 
            printf("pnga_elem_minimum_patch,%ld,%lf\n", count_pnga_elem_minimum_patch, recvbuf);
3752
 
        }
3753
 
 
3754
 
        MPI_Reduce(&time_pnga_elem_multiply, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3755
 
        if (me == 0) {
3756
 
            printf("pnga_elem_multiply,%ld,%lf\n", count_pnga_elem_multiply, recvbuf);
3757
 
        }
3758
 
 
3759
 
        MPI_Reduce(&time_pnga_elem_multiply_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3760
 
        if (me == 0) {
3761
 
            printf("pnga_elem_multiply_patch,%ld,%lf\n", count_pnga_elem_multiply_patch, recvbuf);
3762
 
        }
3763
 
 
3764
 
        MPI_Reduce(&time_pnga_elem_step_divide_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3765
 
        if (me == 0) {
3766
 
            printf("pnga_elem_step_divide_patch,%ld,%lf\n", count_pnga_elem_step_divide_patch, recvbuf);
3767
 
        }
3768
 
 
3769
 
        MPI_Reduce(&time_pnga_elem_stepb_divide_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3770
 
        if (me == 0) {
3771
 
            printf("pnga_elem_stepb_divide_patch,%ld,%lf\n", count_pnga_elem_stepb_divide_patch, recvbuf);
3772
 
        }
3773
 
 
3774
 
        MPI_Reduce(&time_pnga_error, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3775
 
        if (me == 0) {
3776
 
            printf("pnga_error,%ld,%lf\n", count_pnga_error, recvbuf);
3777
 
        }
3778
 
 
3779
 
        MPI_Reduce(&time_pnga_fence, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3780
 
        if (me == 0) {
3781
 
            printf("pnga_fence,%ld,%lf\n", count_pnga_fence, recvbuf);
3782
 
        }
3783
 
 
3784
 
        MPI_Reduce(&time_pnga_fill, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3785
 
        if (me == 0) {
3786
 
            printf("pnga_fill,%ld,%lf\n", count_pnga_fill, recvbuf);
3787
 
        }
3788
 
 
3789
 
        MPI_Reduce(&time_pnga_fill_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3790
 
        if (me == 0) {
3791
 
            printf("pnga_fill_patch,%ld,%lf\n", count_pnga_fill_patch, recvbuf);
3792
 
        }
3793
 
 
3794
 
        MPI_Reduce(&time_pnga_gather, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3795
 
        if (me == 0) {
3796
 
            printf("pnga_gather,%ld,%lf\n", count_pnga_gather, recvbuf);
3797
 
        }
3798
 
 
3799
 
        MPI_Reduce(&time_pnga_gather2d, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3800
 
        if (me == 0) {
3801
 
            printf("pnga_gather2d,%ld,%lf\n", count_pnga_gather2d, recvbuf);
3802
 
        }
3803
 
 
3804
 
        MPI_Reduce(&time_pnga_get, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3805
 
        if (me == 0) {
3806
 
            printf("pnga_get,%ld,%lf\n", count_pnga_get, recvbuf);
3807
 
        }
3808
 
 
3809
 
        MPI_Reduce(&time_pnga_get_block_info, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3810
 
        if (me == 0) {
3811
 
            printf("pnga_get_block_info,%ld,%lf\n", count_pnga_get_block_info, recvbuf);
3812
 
        }
3813
 
 
3814
 
        MPI_Reduce(&time_pnga_get_debug, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3815
 
        if (me == 0) {
3816
 
            printf("pnga_get_debug,%ld,%lf\n", count_pnga_get_debug, recvbuf);
3817
 
        }
3818
 
 
3819
 
        MPI_Reduce(&time_pnga_get_diag, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3820
 
        if (me == 0) {
3821
 
            printf("pnga_get_diag,%ld,%lf\n", count_pnga_get_diag, recvbuf);
3822
 
        }
3823
 
 
3824
 
        MPI_Reduce(&time_pnga_get_dimension, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3825
 
        if (me == 0) {
3826
 
            printf("pnga_get_dimension,%ld,%lf\n", count_pnga_get_dimension, recvbuf);
3827
 
        }
3828
 
 
3829
 
        MPI_Reduce(&time_pnga_get_field, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3830
 
        if (me == 0) {
3831
 
            printf("pnga_get_field,%ld,%lf\n", count_pnga_get_field, recvbuf);
3832
 
        }
3833
 
 
3834
 
        MPI_Reduce(&time_pnga_get_ghost_block, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3835
 
        if (me == 0) {
3836
 
            printf("pnga_get_ghost_block,%ld,%lf\n", count_pnga_get_ghost_block, recvbuf);
3837
 
        }
3838
 
 
3839
 
        MPI_Reduce(&time_pnga_get_pgroup, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3840
 
        if (me == 0) {
3841
 
            printf("pnga_get_pgroup,%ld,%lf\n", count_pnga_get_pgroup, recvbuf);
3842
 
        }
3843
 
 
3844
 
        MPI_Reduce(&time_pnga_get_pgroup_size, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3845
 
        if (me == 0) {
3846
 
            printf("pnga_get_pgroup_size,%ld,%lf\n", count_pnga_get_pgroup_size, recvbuf);
3847
 
        }
3848
 
 
3849
 
        MPI_Reduce(&time_pnga_get_proc_grid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3850
 
        if (me == 0) {
3851
 
            printf("pnga_get_proc_grid,%ld,%lf\n", count_pnga_get_proc_grid, recvbuf);
3852
 
        }
3853
 
 
3854
 
        MPI_Reduce(&time_pnga_get_proc_index, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3855
 
        if (me == 0) {
3856
 
            printf("pnga_get_proc_index,%ld,%lf\n", count_pnga_get_proc_index, recvbuf);
3857
 
        }
3858
 
 
3859
 
        MPI_Reduce(&time_pnga_ghost_barrier, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3860
 
        if (me == 0) {
3861
 
            printf("pnga_ghost_barrier,%ld,%lf\n", count_pnga_ghost_barrier, recvbuf);
3862
 
        }
3863
 
 
3864
 
        MPI_Reduce(&time_pnga_gop, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3865
 
        if (me == 0) {
3866
 
            printf("pnga_gop,%ld,%lf\n", count_pnga_gop, recvbuf);
3867
 
        }
3868
 
 
3869
 
        MPI_Reduce(&time_pnga_has_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3870
 
        if (me == 0) {
3871
 
            printf("pnga_has_ghosts,%ld,%lf\n", count_pnga_has_ghosts, recvbuf);
3872
 
        }
3873
 
 
3874
 
        MPI_Reduce(&time_pnga_init_fence, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3875
 
        if (me == 0) {
3876
 
            printf("pnga_init_fence,%ld,%lf\n", count_pnga_init_fence, recvbuf);
3877
 
        }
3878
 
 
3879
 
        MPI_Reduce(&time_pnga_initialize, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3880
 
        if (me == 0) {
3881
 
            printf("pnga_initialize,%ld,%lf\n", count_pnga_initialize, recvbuf);
3882
 
        }
3883
 
 
3884
 
        MPI_Reduce(&time_pnga_initialize_ltd, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3885
 
        if (me == 0) {
3886
 
            printf("pnga_initialize_ltd,%ld,%lf\n", count_pnga_initialize_ltd, recvbuf);
3887
 
        }
3888
 
 
3889
 
        MPI_Reduce(&time_pnga_inquire, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3890
 
        if (me == 0) {
3891
 
            printf("pnga_inquire,%ld,%lf\n", count_pnga_inquire, recvbuf);
3892
 
        }
3893
 
 
3894
 
        MPI_Reduce(&time_pnga_inquire_memory, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3895
 
        if (me == 0) {
3896
 
            printf("pnga_inquire_memory,%ld,%lf\n", count_pnga_inquire_memory, recvbuf);
3897
 
        }
3898
 
 
3899
 
        MPI_Reduce(&time_pnga_inquire_name, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3900
 
        if (me == 0) {
3901
 
            printf("pnga_inquire_name,%ld,%lf\n", count_pnga_inquire_name, recvbuf);
3902
 
        }
3903
 
 
3904
 
        MPI_Reduce(&time_pnga_inquire_type, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3905
 
        if (me == 0) {
3906
 
            printf("pnga_inquire_type,%ld,%lf\n", count_pnga_inquire_type, recvbuf);
3907
 
        }
3908
 
 
3909
 
        MPI_Reduce(&time_pnga_is_mirrored, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3910
 
        if (me == 0) {
3911
 
            printf("pnga_is_mirrored,%ld,%lf\n", count_pnga_is_mirrored, recvbuf);
3912
 
        }
3913
 
 
3914
 
        MPI_Reduce(&time_pnga_list_nodeid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3915
 
        if (me == 0) {
3916
 
            printf("pnga_list_nodeid,%ld,%lf\n", count_pnga_list_nodeid, recvbuf);
3917
 
        }
3918
 
 
3919
 
        MPI_Reduce(&time_pnga_llt_solve, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3920
 
        if (me == 0) {
3921
 
            printf("pnga_llt_solve,%ld,%lf\n", count_pnga_llt_solve, recvbuf);
3922
 
        }
3923
 
 
3924
 
        MPI_Reduce(&time_pnga_locate, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3925
 
        if (me == 0) {
3926
 
            printf("pnga_locate,%ld,%lf\n", count_pnga_locate, recvbuf);
3927
 
        }
3928
 
 
3929
 
        MPI_Reduce(&time_pnga_locate_nnodes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3930
 
        if (me == 0) {
3931
 
            printf("pnga_locate_nnodes,%ld,%lf\n", count_pnga_locate_nnodes, recvbuf);
3932
 
        }
3933
 
 
3934
 
        MPI_Reduce(&time_pnga_locate_num_blocks, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3935
 
        if (me == 0) {
3936
 
            printf("pnga_locate_num_blocks,%ld,%lf\n", count_pnga_locate_num_blocks, recvbuf);
3937
 
        }
3938
 
 
3939
 
        MPI_Reduce(&time_pnga_locate_region, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3940
 
        if (me == 0) {
3941
 
            printf("pnga_locate_region,%ld,%lf\n", count_pnga_locate_region, recvbuf);
3942
 
        }
3943
 
 
3944
 
        MPI_Reduce(&time_pnga_lock, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3945
 
        if (me == 0) {
3946
 
            printf("pnga_lock,%ld,%lf\n", count_pnga_lock, recvbuf);
3947
 
        }
3948
 
 
3949
 
        MPI_Reduce(&time_pnga_lu_solve, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3950
 
        if (me == 0) {
3951
 
            printf("pnga_lu_solve,%ld,%lf\n", count_pnga_lu_solve, recvbuf);
3952
 
        }
3953
 
 
3954
 
        MPI_Reduce(&time_pnga_lu_solve_alt, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3955
 
        if (me == 0) {
3956
 
            printf("pnga_lu_solve_alt,%ld,%lf\n", count_pnga_lu_solve_alt, recvbuf);
3957
 
        }
3958
 
 
3959
 
        MPI_Reduce(&time_pnga_lu_solve_seq, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3960
 
        if (me == 0) {
3961
 
            printf("pnga_lu_solve_seq,%ld,%lf\n", count_pnga_lu_solve_seq, recvbuf);
3962
 
        }
3963
 
 
3964
 
        MPI_Reduce(&time_pnga_mask_sync, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3965
 
        if (me == 0) {
3966
 
            printf("pnga_mask_sync,%ld,%lf\n", count_pnga_mask_sync, recvbuf);
3967
 
        }
3968
 
 
3969
 
        MPI_Reduce(&time_pnga_matmul, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3970
 
        if (me == 0) {
3971
 
            printf("pnga_matmul,%ld,%lf\n", count_pnga_matmul, recvbuf);
3972
 
        }
3973
 
 
3974
 
        MPI_Reduce(&time_pnga_matmul_mirrored, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3975
 
        if (me == 0) {
3976
 
            printf("pnga_matmul_mirrored,%ld,%lf\n", count_pnga_matmul_mirrored, recvbuf);
3977
 
        }
3978
 
 
3979
 
        MPI_Reduce(&time_pnga_matmul_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3980
 
        if (me == 0) {
3981
 
            printf("pnga_matmul_patch,%ld,%lf\n", count_pnga_matmul_patch, recvbuf);
3982
 
        }
3983
 
 
3984
 
        MPI_Reduce(&time_pnga_median, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3985
 
        if (me == 0) {
3986
 
            printf("pnga_median,%ld,%lf\n", count_pnga_median, recvbuf);
3987
 
        }
3988
 
 
3989
 
        MPI_Reduce(&time_pnga_median_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3990
 
        if (me == 0) {
3991
 
            printf("pnga_median_patch,%ld,%lf\n", count_pnga_median_patch, recvbuf);
3992
 
        }
3993
 
 
3994
 
        MPI_Reduce(&time_pnga_memory_avail, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
3995
 
        if (me == 0) {
3996
 
            printf("pnga_memory_avail,%ld,%lf\n", count_pnga_memory_avail, recvbuf);
3997
 
        }
3998
 
 
3999
 
        MPI_Reduce(&time_pnga_memory_avail_type, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4000
 
        if (me == 0) {
4001
 
            printf("pnga_memory_avail_type,%ld,%lf\n", count_pnga_memory_avail_type, recvbuf);
4002
 
        }
4003
 
 
4004
 
        MPI_Reduce(&time_pnga_memory_limited, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4005
 
        if (me == 0) {
4006
 
            printf("pnga_memory_limited,%ld,%lf\n", count_pnga_memory_limited, recvbuf);
4007
 
        }
4008
 
 
4009
 
        MPI_Reduce(&time_pnga_merge_distr_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4010
 
        if (me == 0) {
4011
 
            printf("pnga_merge_distr_patch,%ld,%lf\n", count_pnga_merge_distr_patch, recvbuf);
4012
 
        }
4013
 
 
4014
 
        MPI_Reduce(&time_pnga_merge_mirrored, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4015
 
        if (me == 0) {
4016
 
            printf("pnga_merge_mirrored,%ld,%lf\n", count_pnga_merge_mirrored, recvbuf);
4017
 
        }
4018
 
 
4019
 
        MPI_Reduce(&time_pnga_msg_brdcst, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4020
 
        if (me == 0) {
4021
 
            printf("pnga_msg_brdcst,%ld,%lf\n", count_pnga_msg_brdcst, recvbuf);
4022
 
        }
4023
 
 
4024
 
        MPI_Reduce(&time_pnga_msg_pgroup_sync, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4025
 
        if (me == 0) {
4026
 
            printf("pnga_msg_pgroup_sync,%ld,%lf\n", count_pnga_msg_pgroup_sync, recvbuf);
4027
 
        }
4028
 
 
4029
 
        MPI_Reduce(&time_pnga_msg_sync, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4030
 
        if (me == 0) {
4031
 
            printf("pnga_msg_sync,%ld,%lf\n", count_pnga_msg_sync, recvbuf);
4032
 
        }
4033
 
 
4034
 
        MPI_Reduce(&time_pnga_nbacc, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4035
 
        if (me == 0) {
4036
 
            printf("pnga_nbacc,%ld,%lf\n", count_pnga_nbacc, recvbuf);
4037
 
        }
4038
 
 
4039
 
        MPI_Reduce(&time_pnga_nbget, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4040
 
        if (me == 0) {
4041
 
            printf("pnga_nbget,%ld,%lf\n", count_pnga_nbget, recvbuf);
4042
 
        }
4043
 
 
4044
 
        MPI_Reduce(&time_pnga_nbget_field, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4045
 
        if (me == 0) {
4046
 
            printf("pnga_nbget_field,%ld,%lf\n", count_pnga_nbget_field, recvbuf);
4047
 
        }
4048
 
 
4049
 
        MPI_Reduce(&time_pnga_nbget_ghost_dir, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4050
 
        if (me == 0) {
4051
 
            printf("pnga_nbget_ghost_dir,%ld,%lf\n", count_pnga_nbget_ghost_dir, recvbuf);
4052
 
        }
4053
 
 
4054
 
        MPI_Reduce(&time_pnga_nblock, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4055
 
        if (me == 0) {
4056
 
            printf("pnga_nblock,%ld,%lf\n", count_pnga_nblock, recvbuf);
4057
 
        }
4058
 
 
4059
 
        MPI_Reduce(&time_pnga_nbput, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4060
 
        if (me == 0) {
4061
 
            printf("pnga_nbput,%ld,%lf\n", count_pnga_nbput, recvbuf);
4062
 
        }
4063
 
 
4064
 
        MPI_Reduce(&time_pnga_nbput_field, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4065
 
        if (me == 0) {
4066
 
            printf("pnga_nbput_field,%ld,%lf\n", count_pnga_nbput_field, recvbuf);
4067
 
        }
4068
 
 
4069
 
        MPI_Reduce(&time_pnga_nbtest, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4070
 
        if (me == 0) {
4071
 
            printf("pnga_nbtest,%ld,%lf\n", count_pnga_nbtest, recvbuf);
4072
 
        }
4073
 
 
4074
 
        MPI_Reduce(&time_pnga_nbwait, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4075
 
        if (me == 0) {
4076
 
            printf("pnga_nbwait,%ld,%lf\n", count_pnga_nbwait, recvbuf);
4077
 
        }
4078
 
 
4079
 
        MPI_Reduce(&time_pnga_ndim, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4080
 
        if (me == 0) {
4081
 
            printf("pnga_ndim,%ld,%lf\n", count_pnga_ndim, recvbuf);
4082
 
        }
4083
 
 
4084
 
        MPI_Reduce(&time_pnga_nnodes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4085
 
        if (me == 0) {
4086
 
            printf("pnga_nnodes,%ld,%lf\n", count_pnga_nnodes, recvbuf);
4087
 
        }
4088
 
 
4089
 
        MPI_Reduce(&time_pnga_nodeid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4090
 
        if (me == 0) {
4091
 
            printf("pnga_nodeid,%ld,%lf\n", count_pnga_nodeid, recvbuf);
4092
 
        }
4093
 
 
4094
 
        MPI_Reduce(&time_pnga_norm1, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4095
 
        if (me == 0) {
4096
 
            printf("pnga_norm1,%ld,%lf\n", count_pnga_norm1, recvbuf);
4097
 
        }
4098
 
 
4099
 
        MPI_Reduce(&time_pnga_norm_infinity, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4100
 
        if (me == 0) {
4101
 
            printf("pnga_norm_infinity,%ld,%lf\n", count_pnga_norm_infinity, recvbuf);
4102
 
        }
4103
 
 
4104
 
        MPI_Reduce(&time_pnga_pack, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4105
 
        if (me == 0) {
4106
 
            printf("pnga_pack,%ld,%lf\n", count_pnga_pack, recvbuf);
4107
 
        }
4108
 
 
4109
 
        MPI_Reduce(&time_pnga_patch_enum, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4110
 
        if (me == 0) {
4111
 
            printf("pnga_patch_enum,%ld,%lf\n", count_pnga_patch_enum, recvbuf);
4112
 
        }
4113
 
 
4114
 
        MPI_Reduce(&time_pnga_patch_intersect, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4115
 
        if (me == 0) {
4116
 
            printf("pnga_patch_intersect,%ld,%lf\n", count_pnga_patch_intersect, recvbuf);
4117
 
        }
4118
 
 
4119
 
        MPI_Reduce(&time_pnga_periodic, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4120
 
        if (me == 0) {
4121
 
            printf("pnga_periodic,%ld,%lf\n", count_pnga_periodic, recvbuf);
4122
 
        }
4123
 
 
4124
 
        MPI_Reduce(&time_pnga_pgroup_absolute_id, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4125
 
        if (me == 0) {
4126
 
            printf("pnga_pgroup_absolute_id,%ld,%lf\n", count_pnga_pgroup_absolute_id, recvbuf);
4127
 
        }
4128
 
 
4129
 
        MPI_Reduce(&time_pnga_pgroup_brdcst, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4130
 
        if (me == 0) {
4131
 
            printf("pnga_pgroup_brdcst,%ld,%lf\n", count_pnga_pgroup_brdcst, recvbuf);
4132
 
        }
4133
 
 
4134
 
        MPI_Reduce(&time_pnga_pgroup_create, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4135
 
        if (me == 0) {
4136
 
            printf("pnga_pgroup_create,%ld,%lf\n", count_pnga_pgroup_create, recvbuf);
4137
 
        }
4138
 
 
4139
 
        MPI_Reduce(&time_pnga_pgroup_destroy, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4140
 
        if (me == 0) {
4141
 
            printf("pnga_pgroup_destroy,%ld,%lf\n", count_pnga_pgroup_destroy, recvbuf);
4142
 
        }
4143
 
 
4144
 
        MPI_Reduce(&time_pnga_pgroup_get_default, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4145
 
        if (me == 0) {
4146
 
            printf("pnga_pgroup_get_default,%ld,%lf\n", count_pnga_pgroup_get_default, recvbuf);
4147
 
        }
4148
 
 
4149
 
        MPI_Reduce(&time_pnga_pgroup_get_mirror, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4150
 
        if (me == 0) {
4151
 
            printf("pnga_pgroup_get_mirror,%ld,%lf\n", count_pnga_pgroup_get_mirror, recvbuf);
4152
 
        }
4153
 
 
4154
 
        MPI_Reduce(&time_pnga_pgroup_get_world, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4155
 
        if (me == 0) {
4156
 
            printf("pnga_pgroup_get_world,%ld,%lf\n", count_pnga_pgroup_get_world, recvbuf);
4157
 
        }
4158
 
 
4159
 
        MPI_Reduce(&time_pnga_pgroup_gop, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4160
 
        if (me == 0) {
4161
 
            printf("pnga_pgroup_gop,%ld,%lf\n", count_pnga_pgroup_gop, recvbuf);
4162
 
        }
4163
 
 
4164
 
        MPI_Reduce(&time_pnga_pgroup_nnodes, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4165
 
        if (me == 0) {
4166
 
            printf("pnga_pgroup_nnodes,%ld,%lf\n", count_pnga_pgroup_nnodes, recvbuf);
4167
 
        }
4168
 
 
4169
 
        MPI_Reduce(&time_pnga_pgroup_nodeid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4170
 
        if (me == 0) {
4171
 
            printf("pnga_pgroup_nodeid,%ld,%lf\n", count_pnga_pgroup_nodeid, recvbuf);
4172
 
        }
4173
 
 
4174
 
        MPI_Reduce(&time_pnga_pgroup_set_default, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4175
 
        if (me == 0) {
4176
 
            printf("pnga_pgroup_set_default,%ld,%lf\n", count_pnga_pgroup_set_default, recvbuf);
4177
 
        }
4178
 
 
4179
 
        MPI_Reduce(&time_pnga_pgroup_split, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4180
 
        if (me == 0) {
4181
 
            printf("pnga_pgroup_split,%ld,%lf\n", count_pnga_pgroup_split, recvbuf);
4182
 
        }
4183
 
 
4184
 
        MPI_Reduce(&time_pnga_pgroup_split_irreg, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4185
 
        if (me == 0) {
4186
 
            printf("pnga_pgroup_split_irreg,%ld,%lf\n", count_pnga_pgroup_split_irreg, recvbuf);
4187
 
        }
4188
 
 
4189
 
        MPI_Reduce(&time_pnga_pgroup_sync, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4190
 
        if (me == 0) {
4191
 
            printf("pnga_pgroup_sync,%ld,%lf\n", count_pnga_pgroup_sync, recvbuf);
4192
 
        }
4193
 
 
4194
 
        MPI_Reduce(&time_pnga_print, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4195
 
        if (me == 0) {
4196
 
            printf("pnga_print,%ld,%lf\n", count_pnga_print, recvbuf);
4197
 
        }
4198
 
 
4199
 
        MPI_Reduce(&time_pnga_print_distribution, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4200
 
        if (me == 0) {
4201
 
            printf("pnga_print_distribution,%ld,%lf\n", count_pnga_print_distribution, recvbuf);
4202
 
        }
4203
 
 
4204
 
        MPI_Reduce(&time_pnga_print_file, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4205
 
        if (me == 0) {
4206
 
            printf("pnga_print_file,%ld,%lf\n", count_pnga_print_file, recvbuf);
4207
 
        }
4208
 
 
4209
 
        MPI_Reduce(&time_pnga_print_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4210
 
        if (me == 0) {
4211
 
            printf("pnga_print_patch,%ld,%lf\n", count_pnga_print_patch, recvbuf);
4212
 
        }
4213
 
 
4214
 
        MPI_Reduce(&time_pnga_print_patch2d, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4215
 
        if (me == 0) {
4216
 
            printf("pnga_print_patch2d,%ld,%lf\n", count_pnga_print_patch2d, recvbuf);
4217
 
        }
4218
 
 
4219
 
        MPI_Reduce(&time_pnga_print_patch_file, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4220
 
        if (me == 0) {
4221
 
            printf("pnga_print_patch_file,%ld,%lf\n", count_pnga_print_patch_file, recvbuf);
4222
 
        }
4223
 
 
4224
 
        MPI_Reduce(&time_pnga_print_patch_file2d, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4225
 
        if (me == 0) {
4226
 
            printf("pnga_print_patch_file2d,%ld,%lf\n", count_pnga_print_patch_file2d, recvbuf);
4227
 
        }
4228
 
 
4229
 
        MPI_Reduce(&time_pnga_print_stats, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4230
 
        if (me == 0) {
4231
 
            printf("pnga_print_stats,%ld,%lf\n", count_pnga_print_stats, recvbuf);
4232
 
        }
4233
 
 
4234
 
        MPI_Reduce(&time_pnga_proc_topology, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4235
 
        if (me == 0) {
4236
 
            printf("pnga_proc_topology,%ld,%lf\n", count_pnga_proc_topology, recvbuf);
4237
 
        }
4238
 
 
4239
 
        MPI_Reduce(&time_pnga_put, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4240
 
        if (me == 0) {
4241
 
            printf("pnga_put,%ld,%lf\n", count_pnga_put, recvbuf);
4242
 
        }
4243
 
 
4244
 
        MPI_Reduce(&time_pnga_put_field, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4245
 
        if (me == 0) {
4246
 
            printf("pnga_put_field,%ld,%lf\n", count_pnga_put_field, recvbuf);
4247
 
        }
4248
 
 
4249
 
        MPI_Reduce(&time_pnga_randomize, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4250
 
        if (me == 0) {
4251
 
            printf("pnga_randomize,%ld,%lf\n", count_pnga_randomize, recvbuf);
4252
 
        }
4253
 
 
4254
 
        MPI_Reduce(&time_pnga_read_inc, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4255
 
        if (me == 0) {
4256
 
            printf("pnga_read_inc,%ld,%lf\n", count_pnga_read_inc, recvbuf);
4257
 
        }
4258
 
 
4259
 
        MPI_Reduce(&time_pnga_recip, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4260
 
        if (me == 0) {
4261
 
            printf("pnga_recip,%ld,%lf\n", count_pnga_recip, recvbuf);
4262
 
        }
4263
 
 
4264
 
        MPI_Reduce(&time_pnga_recip_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4265
 
        if (me == 0) {
4266
 
            printf("pnga_recip_patch,%ld,%lf\n", count_pnga_recip_patch, recvbuf);
4267
 
        }
4268
 
 
4269
 
        MPI_Reduce(&time_pnga_register_type, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4270
 
        if (me == 0) {
4271
 
            printf("pnga_register_type,%ld,%lf\n", count_pnga_register_type, recvbuf);
4272
 
        }
4273
 
 
4274
 
        MPI_Reduce(&time_pnga_release, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4275
 
        if (me == 0) {
4276
 
            printf("pnga_release,%ld,%lf\n", count_pnga_release, recvbuf);
4277
 
        }
4278
 
 
4279
 
        MPI_Reduce(&time_pnga_release_block, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4280
 
        if (me == 0) {
4281
 
            printf("pnga_release_block,%ld,%lf\n", count_pnga_release_block, recvbuf);
4282
 
        }
4283
 
 
4284
 
        MPI_Reduce(&time_pnga_release_block_grid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4285
 
        if (me == 0) {
4286
 
            printf("pnga_release_block_grid,%ld,%lf\n", count_pnga_release_block_grid, recvbuf);
4287
 
        }
4288
 
 
4289
 
        MPI_Reduce(&time_pnga_release_block_segment, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4290
 
        if (me == 0) {
4291
 
            printf("pnga_release_block_segment,%ld,%lf\n", count_pnga_release_block_segment, recvbuf);
4292
 
        }
4293
 
 
4294
 
        MPI_Reduce(&time_pnga_release_ghost_element, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4295
 
        if (me == 0) {
4296
 
            printf("pnga_release_ghost_element,%ld,%lf\n", count_pnga_release_ghost_element, recvbuf);
4297
 
        }
4298
 
 
4299
 
        MPI_Reduce(&time_pnga_release_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4300
 
        if (me == 0) {
4301
 
            printf("pnga_release_ghosts,%ld,%lf\n", count_pnga_release_ghosts, recvbuf);
4302
 
        }
4303
 
 
4304
 
        MPI_Reduce(&time_pnga_release_update, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4305
 
        if (me == 0) {
4306
 
            printf("pnga_release_update,%ld,%lf\n", count_pnga_release_update, recvbuf);
4307
 
        }
4308
 
 
4309
 
        MPI_Reduce(&time_pnga_release_update_block, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4310
 
        if (me == 0) {
4311
 
            printf("pnga_release_update_block,%ld,%lf\n", count_pnga_release_update_block, recvbuf);
4312
 
        }
4313
 
 
4314
 
        MPI_Reduce(&time_pnga_release_update_block_grid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4315
 
        if (me == 0) {
4316
 
            printf("pnga_release_update_block_grid,%ld,%lf\n", count_pnga_release_update_block_grid, recvbuf);
4317
 
        }
4318
 
 
4319
 
        MPI_Reduce(&time_pnga_release_update_block_segment, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4320
 
        if (me == 0) {
4321
 
            printf("pnga_release_update_block_segment,%ld,%lf\n", count_pnga_release_update_block_segment, recvbuf);
4322
 
        }
4323
 
 
4324
 
        MPI_Reduce(&time_pnga_release_update_ghost_element, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4325
 
        if (me == 0) {
4326
 
            printf("pnga_release_update_ghost_element,%ld,%lf\n", count_pnga_release_update_ghost_element, recvbuf);
4327
 
        }
4328
 
 
4329
 
        MPI_Reduce(&time_pnga_release_update_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4330
 
        if (me == 0) {
4331
 
            printf("pnga_release_update_ghosts,%ld,%lf\n", count_pnga_release_update_ghosts, recvbuf);
4332
 
        }
4333
 
 
4334
 
        MPI_Reduce(&time_pnga_scale, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4335
 
        if (me == 0) {
4336
 
            printf("pnga_scale,%ld,%lf\n", count_pnga_scale, recvbuf);
4337
 
        }
4338
 
 
4339
 
        MPI_Reduce(&time_pnga_scale_cols, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4340
 
        if (me == 0) {
4341
 
            printf("pnga_scale_cols,%ld,%lf\n", count_pnga_scale_cols, recvbuf);
4342
 
        }
4343
 
 
4344
 
        MPI_Reduce(&time_pnga_scale_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4345
 
        if (me == 0) {
4346
 
            printf("pnga_scale_patch,%ld,%lf\n", count_pnga_scale_patch, recvbuf);
4347
 
        }
4348
 
 
4349
 
        MPI_Reduce(&time_pnga_scale_rows, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4350
 
        if (me == 0) {
4351
 
            printf("pnga_scale_rows,%ld,%lf\n", count_pnga_scale_rows, recvbuf);
4352
 
        }
4353
 
 
4354
 
        MPI_Reduce(&time_pnga_scan_add, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4355
 
        if (me == 0) {
4356
 
            printf("pnga_scan_add,%ld,%lf\n", count_pnga_scan_add, recvbuf);
4357
 
        }
4358
 
 
4359
 
        MPI_Reduce(&time_pnga_scan_copy, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4360
 
        if (me == 0) {
4361
 
            printf("pnga_scan_copy,%ld,%lf\n", count_pnga_scan_copy, recvbuf);
4362
 
        }
4363
 
 
4364
 
        MPI_Reduce(&time_pnga_scatter, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4365
 
        if (me == 0) {
4366
 
            printf("pnga_scatter,%ld,%lf\n", count_pnga_scatter, recvbuf);
4367
 
        }
4368
 
 
4369
 
        MPI_Reduce(&time_pnga_scatter2d, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4370
 
        if (me == 0) {
4371
 
            printf("pnga_scatter2d,%ld,%lf\n", count_pnga_scatter2d, recvbuf);
4372
 
        }
4373
 
 
4374
 
        MPI_Reduce(&time_pnga_scatter_acc, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4375
 
        if (me == 0) {
4376
 
            printf("pnga_scatter_acc,%ld,%lf\n", count_pnga_scatter_acc, recvbuf);
4377
 
        }
4378
 
 
4379
 
        MPI_Reduce(&time_pnga_scatter_acc2d, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4380
 
        if (me == 0) {
4381
 
            printf("pnga_scatter_acc2d,%ld,%lf\n", count_pnga_scatter_acc2d, recvbuf);
4382
 
        }
4383
 
 
4384
 
        MPI_Reduce(&time_pnga_select_elem, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4385
 
        if (me == 0) {
4386
 
            printf("pnga_select_elem,%ld,%lf\n", count_pnga_select_elem, recvbuf);
4387
 
        }
4388
 
 
4389
 
        MPI_Reduce(&time_pnga_set_array_name, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4390
 
        if (me == 0) {
4391
 
            printf("pnga_set_array_name,%ld,%lf\n", count_pnga_set_array_name, recvbuf);
4392
 
        }
4393
 
 
4394
 
        MPI_Reduce(&time_pnga_set_block_cyclic, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4395
 
        if (me == 0) {
4396
 
            printf("pnga_set_block_cyclic,%ld,%lf\n", count_pnga_set_block_cyclic, recvbuf);
4397
 
        }
4398
 
 
4399
 
        MPI_Reduce(&time_pnga_set_block_cyclic_proc_grid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4400
 
        if (me == 0) {
4401
 
            printf("pnga_set_block_cyclic_proc_grid,%ld,%lf\n", count_pnga_set_block_cyclic_proc_grid, recvbuf);
4402
 
        }
4403
 
 
4404
 
        MPI_Reduce(&time_pnga_set_chunk, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4405
 
        if (me == 0) {
4406
 
            printf("pnga_set_chunk,%ld,%lf\n", count_pnga_set_chunk, recvbuf);
4407
 
        }
4408
 
 
4409
 
        MPI_Reduce(&time_pnga_set_data, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4410
 
        if (me == 0) {
4411
 
            printf("pnga_set_data,%ld,%lf\n", count_pnga_set_data, recvbuf);
4412
 
        }
4413
 
 
4414
 
        MPI_Reduce(&time_pnga_set_debug, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4415
 
        if (me == 0) {
4416
 
            printf("pnga_set_debug,%ld,%lf\n", count_pnga_set_debug, recvbuf);
4417
 
        }
4418
 
 
4419
 
        MPI_Reduce(&time_pnga_set_diagonal, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4420
 
        if (me == 0) {
4421
 
            printf("pnga_set_diagonal,%ld,%lf\n", count_pnga_set_diagonal, recvbuf);
4422
 
        }
4423
 
 
4424
 
        MPI_Reduce(&time_pnga_set_ghost_corner_flag, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4425
 
        if (me == 0) {
4426
 
            printf("pnga_set_ghost_corner_flag,%ld,%lf\n", count_pnga_set_ghost_corner_flag, recvbuf);
4427
 
        }
4428
 
 
4429
 
        MPI_Reduce(&time_pnga_set_ghost_info, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4430
 
        if (me == 0) {
4431
 
            printf("pnga_set_ghost_info,%ld,%lf\n", count_pnga_set_ghost_info, recvbuf);
4432
 
        }
4433
 
 
4434
 
        MPI_Reduce(&time_pnga_set_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4435
 
        if (me == 0) {
4436
 
            printf("pnga_set_ghosts,%ld,%lf\n", count_pnga_set_ghosts, recvbuf);
4437
 
        }
4438
 
 
4439
 
        MPI_Reduce(&time_pnga_set_irreg_distr, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4440
 
        if (me == 0) {
4441
 
            printf("pnga_set_irreg_distr,%ld,%lf\n", count_pnga_set_irreg_distr, recvbuf);
4442
 
        }
4443
 
 
4444
 
        MPI_Reduce(&time_pnga_set_irreg_flag, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4445
 
        if (me == 0) {
4446
 
            printf("pnga_set_irreg_flag,%ld,%lf\n", count_pnga_set_irreg_flag, recvbuf);
4447
 
        }
4448
 
 
4449
 
        MPI_Reduce(&time_pnga_set_memory_limit, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4450
 
        if (me == 0) {
4451
 
            printf("pnga_set_memory_limit,%ld,%lf\n", count_pnga_set_memory_limit, recvbuf);
4452
 
        }
4453
 
 
4454
 
        MPI_Reduce(&time_pnga_set_pgroup, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4455
 
        if (me == 0) {
4456
 
            printf("pnga_set_pgroup,%ld,%lf\n", count_pnga_set_pgroup, recvbuf);
4457
 
        }
4458
 
 
4459
 
        MPI_Reduce(&time_pnga_set_restricted, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4460
 
        if (me == 0) {
4461
 
            printf("pnga_set_restricted,%ld,%lf\n", count_pnga_set_restricted, recvbuf);
4462
 
        }
4463
 
 
4464
 
        MPI_Reduce(&time_pnga_set_restricted_range, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4465
 
        if (me == 0) {
4466
 
            printf("pnga_set_restricted_range,%ld,%lf\n", count_pnga_set_restricted_range, recvbuf);
4467
 
        }
4468
 
 
4469
 
        MPI_Reduce(&time_pnga_set_update4_info, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4470
 
        if (me == 0) {
4471
 
            printf("pnga_set_update4_info,%ld,%lf\n", count_pnga_set_update4_info, recvbuf);
4472
 
        }
4473
 
 
4474
 
        MPI_Reduce(&time_pnga_set_update5_info, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4475
 
        if (me == 0) {
4476
 
            printf("pnga_set_update5_info,%ld,%lf\n", count_pnga_set_update5_info, recvbuf);
4477
 
        }
4478
 
 
4479
 
        MPI_Reduce(&time_pnga_shift_diagonal, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4480
 
        if (me == 0) {
4481
 
            printf("pnga_shift_diagonal,%ld,%lf\n", count_pnga_shift_diagonal, recvbuf);
4482
 
        }
4483
 
 
4484
 
        MPI_Reduce(&time_pnga_solve, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4485
 
        if (me == 0) {
4486
 
            printf("pnga_solve,%ld,%lf\n", count_pnga_solve, recvbuf);
4487
 
        }
4488
 
 
4489
 
        MPI_Reduce(&time_pnga_spd_invert, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4490
 
        if (me == 0) {
4491
 
            printf("pnga_spd_invert,%ld,%lf\n", count_pnga_spd_invert, recvbuf);
4492
 
        }
4493
 
 
4494
 
        MPI_Reduce(&time_pnga_step_bound_info, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4495
 
        if (me == 0) {
4496
 
            printf("pnga_step_bound_info,%ld,%lf\n", count_pnga_step_bound_info, recvbuf);
4497
 
        }
4498
 
 
4499
 
        MPI_Reduce(&time_pnga_step_bound_info_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4500
 
        if (me == 0) {
4501
 
            printf("pnga_step_bound_info_patch,%ld,%lf\n", count_pnga_step_bound_info_patch, recvbuf);
4502
 
        }
4503
 
 
4504
 
        MPI_Reduce(&time_pnga_step_mask_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4505
 
        if (me == 0) {
4506
 
            printf("pnga_step_mask_patch,%ld,%lf\n", count_pnga_step_mask_patch, recvbuf);
4507
 
        }
4508
 
 
4509
 
        MPI_Reduce(&time_pnga_step_max, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4510
 
        if (me == 0) {
4511
 
            printf("pnga_step_max,%ld,%lf\n", count_pnga_step_max, recvbuf);
4512
 
        }
4513
 
 
4514
 
        MPI_Reduce(&time_pnga_step_max_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4515
 
        if (me == 0) {
4516
 
            printf("pnga_step_max_patch,%ld,%lf\n", count_pnga_step_max_patch, recvbuf);
4517
 
        }
4518
 
 
4519
 
        MPI_Reduce(&time_pnga_strided_acc, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4520
 
        if (me == 0) {
4521
 
            printf("pnga_strided_acc,%ld,%lf\n", count_pnga_strided_acc, recvbuf);
4522
 
        }
4523
 
 
4524
 
        MPI_Reduce(&time_pnga_strided_get, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4525
 
        if (me == 0) {
4526
 
            printf("pnga_strided_get,%ld,%lf\n", count_pnga_strided_get, recvbuf);
4527
 
        }
4528
 
 
4529
 
        MPI_Reduce(&time_pnga_strided_put, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4530
 
        if (me == 0) {
4531
 
            printf("pnga_strided_put,%ld,%lf\n", count_pnga_strided_put, recvbuf);
4532
 
        }
4533
 
 
4534
 
        MPI_Reduce(&time_pnga_summarize, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4535
 
        if (me == 0) {
4536
 
            printf("pnga_summarize,%ld,%lf\n", count_pnga_summarize, recvbuf);
4537
 
        }
4538
 
 
4539
 
        MPI_Reduce(&time_pnga_symmetrize, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4540
 
        if (me == 0) {
4541
 
            printf("pnga_symmetrize,%ld,%lf\n", count_pnga_symmetrize, recvbuf);
4542
 
        }
4543
 
 
4544
 
        MPI_Reduce(&time_pnga_sync, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4545
 
        if (me == 0) {
4546
 
            printf("pnga_sync,%ld,%lf\n", count_pnga_sync, recvbuf);
4547
 
        }
4548
 
 
4549
 
        MPI_Reduce(&time_pnga_terminate, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4550
 
        if (me == 0) {
4551
 
            printf("pnga_terminate,%ld,%lf\n", count_pnga_terminate, recvbuf);
4552
 
        }
4553
 
 
4554
 
        MPI_Reduce(&time_pnga_timer, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4555
 
        if (me == 0) {
4556
 
            printf("pnga_timer,%ld,%lf\n", count_pnga_timer, recvbuf);
4557
 
        }
4558
 
 
4559
 
        MPI_Reduce(&time_pnga_total_blocks, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4560
 
        if (me == 0) {
4561
 
            printf("pnga_total_blocks,%ld,%lf\n", count_pnga_total_blocks, recvbuf);
4562
 
        }
4563
 
 
4564
 
        MPI_Reduce(&time_pnga_transpose, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4565
 
        if (me == 0) {
4566
 
            printf("pnga_transpose,%ld,%lf\n", count_pnga_transpose, recvbuf);
4567
 
        }
4568
 
 
4569
 
        MPI_Reduce(&time_pnga_type_c2f, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4570
 
        if (me == 0) {
4571
 
            printf("pnga_type_c2f,%ld,%lf\n", count_pnga_type_c2f, recvbuf);
4572
 
        }
4573
 
 
4574
 
        MPI_Reduce(&time_pnga_type_f2c, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4575
 
        if (me == 0) {
4576
 
            printf("pnga_type_f2c,%ld,%lf\n", count_pnga_type_f2c, recvbuf);
4577
 
        }
4578
 
 
4579
 
        MPI_Reduce(&time_pnga_unlock, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4580
 
        if (me == 0) {
4581
 
            printf("pnga_unlock,%ld,%lf\n", count_pnga_unlock, recvbuf);
4582
 
        }
4583
 
 
4584
 
        MPI_Reduce(&time_pnga_unpack, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4585
 
        if (me == 0) {
4586
 
            printf("pnga_unpack,%ld,%lf\n", count_pnga_unpack, recvbuf);
4587
 
        }
4588
 
 
4589
 
        MPI_Reduce(&time_pnga_update1_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4590
 
        if (me == 0) {
4591
 
            printf("pnga_update1_ghosts,%ld,%lf\n", count_pnga_update1_ghosts, recvbuf);
4592
 
        }
4593
 
 
4594
 
        MPI_Reduce(&time_pnga_update2_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4595
 
        if (me == 0) {
4596
 
            printf("pnga_update2_ghosts,%ld,%lf\n", count_pnga_update2_ghosts, recvbuf);
4597
 
        }
4598
 
 
4599
 
        MPI_Reduce(&time_pnga_update3_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4600
 
        if (me == 0) {
4601
 
            printf("pnga_update3_ghosts,%ld,%lf\n", count_pnga_update3_ghosts, recvbuf);
4602
 
        }
4603
 
 
4604
 
        MPI_Reduce(&time_pnga_update44_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4605
 
        if (me == 0) {
4606
 
            printf("pnga_update44_ghosts,%ld,%lf\n", count_pnga_update44_ghosts, recvbuf);
4607
 
        }
4608
 
 
4609
 
        MPI_Reduce(&time_pnga_update4_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4610
 
        if (me == 0) {
4611
 
            printf("pnga_update4_ghosts,%ld,%lf\n", count_pnga_update4_ghosts, recvbuf);
4612
 
        }
4613
 
 
4614
 
        MPI_Reduce(&time_pnga_update55_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4615
 
        if (me == 0) {
4616
 
            printf("pnga_update55_ghosts,%ld,%lf\n", count_pnga_update55_ghosts, recvbuf);
4617
 
        }
4618
 
 
4619
 
        MPI_Reduce(&time_pnga_update5_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4620
 
        if (me == 0) {
4621
 
            printf("pnga_update5_ghosts,%ld,%lf\n", count_pnga_update5_ghosts, recvbuf);
4622
 
        }
4623
 
 
4624
 
        MPI_Reduce(&time_pnga_update6_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4625
 
        if (me == 0) {
4626
 
            printf("pnga_update6_ghosts,%ld,%lf\n", count_pnga_update6_ghosts, recvbuf);
4627
 
        }
4628
 
 
4629
 
        MPI_Reduce(&time_pnga_update7_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4630
 
        if (me == 0) {
4631
 
            printf("pnga_update7_ghosts,%ld,%lf\n", count_pnga_update7_ghosts, recvbuf);
4632
 
        }
4633
 
 
4634
 
        MPI_Reduce(&time_pnga_update_ghost_dir, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4635
 
        if (me == 0) {
4636
 
            printf("pnga_update_ghost_dir,%ld,%lf\n", count_pnga_update_ghost_dir, recvbuf);
4637
 
        }
4638
 
 
4639
 
        MPI_Reduce(&time_pnga_update_ghosts, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4640
 
        if (me == 0) {
4641
 
            printf("pnga_update_ghosts,%ld,%lf\n", count_pnga_update_ghosts, recvbuf);
4642
 
        }
4643
 
 
4644
 
        MPI_Reduce(&time_pnga_uses_ma, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4645
 
        if (me == 0) {
4646
 
            printf("pnga_uses_ma,%ld,%lf\n", count_pnga_uses_ma, recvbuf);
4647
 
        }
4648
 
 
4649
 
        MPI_Reduce(&time_pnga_uses_proc_grid, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4650
 
        if (me == 0) {
4651
 
            printf("pnga_uses_proc_grid,%ld,%lf\n", count_pnga_uses_proc_grid, recvbuf);
4652
 
        }
4653
 
 
4654
 
        MPI_Reduce(&time_pnga_valid_handle, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4655
 
        if (me == 0) {
4656
 
            printf("pnga_valid_handle,%ld,%lf\n", count_pnga_valid_handle, recvbuf);
4657
 
        }
4658
 
 
4659
 
        MPI_Reduce(&time_pnga_verify_handle, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4660
 
        if (me == 0) {
4661
 
            printf("pnga_verify_handle,%ld,%lf\n", count_pnga_verify_handle, recvbuf);
4662
 
        }
4663
 
 
4664
 
        MPI_Reduce(&time_pnga_wtime, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4665
 
        if (me == 0) {
4666
 
            printf("pnga_wtime,%ld,%lf\n", count_pnga_wtime, recvbuf);
4667
 
        }
4668
 
 
4669
 
        MPI_Reduce(&time_pnga_zero, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4670
 
        if (me == 0) {
4671
 
            printf("pnga_zero,%ld,%lf\n", count_pnga_zero, recvbuf);
4672
 
        }
4673
 
 
4674
 
        MPI_Reduce(&time_pnga_zero_diagonal, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4675
 
        if (me == 0) {
4676
 
            printf("pnga_zero_diagonal,%ld,%lf\n", count_pnga_zero_diagonal, recvbuf);
4677
 
        }
4678
 
 
4679
 
        MPI_Reduce(&time_pnga_zero_patch, &recvbuf, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
4680
 
        if (me == 0) {
4681
 
            printf("pnga_zero_patch,%ld,%lf\n", count_pnga_zero_patch, recvbuf);
4682
 
        }
4683
 
 
4684
 
    }
4685
 
}
4686