perf_toy_common.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
 
#include "yac.h"
#include "yac_utils.h"
#include "perf_toy_common.h"
 
struct timer_data {
  char * user_string; 
  MPI_Comm comm;      
  double tic;         
};
 
void * start_timer(MPI_Comm comm, char const * fmt, ...) {
 
  // generate user string for timer label
  va_list args1;
  va_start(args1, fmt);
  va_list args2;
  va_copy(args2, args1);
  char buf[1 + vsnprintf(NULL, 0, fmt, args1)];
  va_end(args1);
  vsnprintf(buf, sizeof buf, fmt, args2);
  va_end(args2);
 
  // wait for all processes to reach this point before starting the timer
  MPI_Barrier(comm);
 
  // allocate and initialize timer data
  struct timer_data * timer = malloc(1 * sizeof(*timer));
  timer->user_string = strdup(buf);
  timer->comm = comm;
  timer->tic = MPI_Wtime();
 
  return (void*)timer;
}
 
void stop_timer(void * timer_) {
 
  struct timer_data * timer = (struct timer_data*)timer_;
 
  // Measure the elapsed time since the timer was started
  int rank, size;
  MPI_Comm_rank(timer->comm, &rank);
  MPI_Comm_size(timer->comm, &size);
  struct {
    double value;
    int rank;
  } time, time_min, time_max;
  double time_sum;
  time.value = MPI_Wtime() - timer->tic;
  time.rank = rank;
 
  // Reduce the timing results to find the minimum, maximum, and average times
  // across all processes
  // (also acts as a barrier to ensure all processes have finished timing)
  MPI_Reduce(&time, &time_min, 1, MPI_DOUBLE_INT, MPI_MINLOC, 0, timer->comm);
  MPI_Reduce(&time, &time_max, 1, MPI_DOUBLE_INT, MPI_MAXLOC, 0, timer->comm);
  MPI_Reduce(&time.value, &time_sum, 1, MPI_DOUBLE, MPI_SUM, 0, timer->comm);
 
  // Print the timing results on the root process
  if (!rank) {
    fprintf(
      stderr, "%s;%e;%e;%e\n",
      timer->user_string, time_sum / (double)size,
      time_min.value, time_max.value);
  }
 
  // cleanup
  free(timer->user_string);
  free(timer);
}
 
void init_grid(
  int comp_id, char const * grid_name, char const * grid_filename,
  int * cell_point_id, int * corner_point_id) {
 
  // get component communicator
  MPI_Comm comp_comm;
  yac_cget_comp_comm(comp_id, &comp_comm);
 
  // get basic grid data
  int num_vertices;
  int num_cells;
  int * num_vertices_per_cell;
  int * cell_to_vertex;
  double * x_vertices;
  double * y_vertices;
  double * x_cells;
  double * y_cells;
 
  int * cell_mask;
  int * global_cell_ids;
  int * cell_core_mask;
  int * global_vertex_ids;
  int * vertex_core_mask;
 
  // read the grid information in parallel
  // (global grid is automatically evenly distributed among all component
  //  processes based on the global index of the cells and vertices)
  void * read_timer =
    start_timer(
      comp_comm, "%s;%s", "read_grid", grid_filename);
  yac_read_icon_grid_information_parallel(
    grid_filename, comp_comm, &num_vertices, &num_cells,
    &num_vertices_per_cell, &cell_to_vertex, &global_cell_ids,
    &cell_core_mask, &global_vertex_ids, &vertex_core_mask,
    &x_vertices, &y_vertices, &x_cells, &y_cells, &cell_mask);
  stop_timer(read_timer);
 
  // returned cell core mask arrays contain -1 for all locally owned cells
  // and the rank of the owner for all halo cells. Convert them to
  // boolean arrays with 1 for locally owned cells and 0 for halo.
  for (int i = 0; i < num_cells; ++i)
    cell_core_mask[i] = cell_core_mask[i] == -1;
 
  // mark all vertices as core vertices that are used by at least one core cell
  memset(vertex_core_mask, 0, num_vertices * sizeof(*vertex_core_mask));
  for (int i = 0, offset = 0; i < num_cells; ++i) {
    if (cell_core_mask[i]) {
      for (int j = 0; j < num_vertices_per_cell[i]; ++j) {
        int vertex_idx = cell_to_vertex[offset + j];
        vertex_core_mask[vertex_idx] = 1;
      }
    }
    offset += num_vertices_per_cell[i];
  }
 
  // define grid
  int grid_id;
  yac_cdef_grid_unstruct(
    grid_name, num_vertices, num_cells, num_vertices_per_cell,
    x_vertices, y_vertices, cell_to_vertex, &grid_id);
 
  // set global ids and core mask
  yac_cset_global_index(global_cell_ids, YAC_LOCATION_CELL, grid_id);
  yac_cset_core_mask(cell_core_mask, YAC_LOCATION_CELL, grid_id);
  yac_cset_global_index(global_vertex_ids, YAC_LOCATION_CORNER, grid_id);
  yac_cset_core_mask(vertex_core_mask, YAC_LOCATION_CORNER, grid_id);
 
  // define points (cell centers and vertices)
  yac_cdef_points_unstruct(
    grid_id, num_cells, YAC_LOCATION_CELL,
    x_cells, y_cells, cell_point_id);
  yac_cdef_points_unstruct(
    grid_id, num_vertices, YAC_LOCATION_CORNER,
    x_vertices, y_vertices, corner_point_id);
 
  // cleanup
  free(num_vertices_per_cell);
  free(cell_to_vertex);
  free(x_cells);
  free(y_cells);
  free(x_vertices);
  free(y_vertices);
  free(cell_mask);
  free(global_cell_ids);
  free(cell_core_mask);
  free(global_vertex_ids);
  free(vertex_core_mask);
 
  MPI_Comm_free(&comp_comm);
}