p4est_communication.h

Go to the documentation of this file.

/*
  This file is part of p4est.
  p4est is a C library to manage a collection (a forest) of multiple
  connected adaptive quadtrees or octrees in parallel.
 
  Copyright (C) 2010 The University of Texas System
  Additional copyright (C) 2011 individual authors
  Written by Carsten Burstedde, Lucas C. Wilcox, and Tobin Isaac
 
  p4est is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
 
  p4est is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with p4est; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
#ifndef P4EST_COMMUNICATION_H
#define P4EST_COMMUNICATION_H
 
#include <p4est.h>
 
SC_EXTERN_C_BEGIN;
 
int                 p4est_bsearch_partition (p4est_gloidx_t target,
                                             const p4est_gloidx_t * gfq,
                                             int nmemb);
 
void                p4est_comm_parallel_env_assign (p4est_t * p4est,
                                                    sc_MPI_Comm mpicomm);
 
void                p4est_comm_parallel_env_duplicate (p4est_t * p4est);
 
void                p4est_comm_parallel_env_release (p4est_t * p4est);
 
void                p4est_comm_parallel_env_replace (p4est_t * p4est,
                                                     sc_MPI_Comm mpicomm);
 
void                p4est_comm_parallel_env_get_info (p4est_t * p4est);
 
int                 p4est_comm_parallel_env_is_null (p4est_t * p4est);
 
int                 p4est_comm_parallel_env_reduce (p4est_t **
                                                    p4est_supercomm);
 
int                 p4est_comm_parallel_env_reduce_ext (p4est_t **
                                                        p4est_supercomm,
                                                        sc_MPI_Group
                                                        group_add,
                                                        int add_to_beginning,
                                                        int **ranks_subcomm);
 
void                p4est_comm_count_quadrants (p4est_t * p4est);
 
void                p4est_comm_global_partition (p4est_t * p4est,
                                                 p4est_quadrant_t *
                                                 first_quad);
 
void                p4est_comm_global_first_quadrant (p4est_gloidx_t
                                                      global_num_quadrants,
                                                      int mpisize,
                                                      p4est_gloidx_t * gfq);
 
void                p4est_comm_count_pertree (p4est_t * p4est,
                                              p4est_gloidx_t * pertree);
 
int                 p4est_comm_is_empty (p4est_t *p4est, int p);
 
int                 p4est_comm_is_empty_gfq (const p4est_gloidx_t *gfq,
                                             int num_procs, int p);
 
int                 p4est_comm_is_empty_gfp (const p4est_quadrant_t *gfp,
                                             int num_procs, int p);
 
int                 p4est_comm_is_contained (p4est_t * p4est,
                                             p4est_locidx_t which_tree,
                                             const p4est_quadrant_t * q,
                                             int rank);
 
int                 p4est_comm_is_owner (p4est_t *p4est,
                                         p4est_locidx_t which_tree,
                                         const p4est_quadrant_t *q,
                                         int rank);
 
int                 p4est_comm_is_owner_gfp
  (const p4est_quadrant_t *gfp, int num_procs, p4est_topidx_t num_trees,
   p4est_locidx_t which_tree, const p4est_quadrant_t *q, int rank);
 
int                 p4est_comm_find_owner (p4est_t * p4est,
                                           p4est_locidx_t which_tree,
                                           const p4est_quadrant_t * q,
                                           int guess);
 
void                p4est_comm_tree_info (p4est_t * p4est,
                                          p4est_locidx_t which_tree,
                                          int full_tree[],
                                          int tree_contact[],
                                          const p4est_quadrant_t ** firstq,
                                          const p4est_quadrant_t ** nextq);
 
int                 p4est_comm_neighborhood_owned (p4est_t * p4est,
                                                   p4est_locidx_t which_tree,
                                                   int full_tree[],
                                                   int tree_contact[],
                                                   p4est_quadrant_t * q);
 
int                 p4est_comm_sync_flag (p4est_t * p4est,
                                          int flag, sc_MPI_Op operation);
 
unsigned            p4est_comm_checksum (p4est_t * p4est,
                                         unsigned local_crc,
                                         size_t local_bytes);
 
typedef struct p4est_transfer_context
{
  int                 variable;
  int                 num_senders;
  int                 num_receivers;
  sc_MPI_Request     *recv_req;
  sc_MPI_Request     *send_req;
}
p4est_transfer_context_t;
 
void                p4est_transfer_fixed (const p4est_gloidx_t * dest_gfq,
                                          const p4est_gloidx_t * src_gfq,
                                          sc_MPI_Comm mpicomm, int tag,
                                          void *dest_data,
                                          const void *src_data,
                                          size_t data_size);
 
p4est_transfer_context_t *p4est_transfer_fixed_begin (const p4est_gloidx_t *
                                                      dest_gfq,
                                                      const p4est_gloidx_t *
                                                      src_gfq,
                                                      sc_MPI_Comm mpicomm,
                                                      int tag,
                                                      void *dest_data,
                                                      const void *src_data,
                                                      size_t data_size);
 
void                p4est_transfer_fixed_end (p4est_transfer_context_t * tc);
 
void                p4est_transfer_custom (const p4est_gloidx_t * dest_gfq,
                                           const p4est_gloidx_t * src_gfq,
                                           sc_MPI_Comm mpicomm, int tag,
                                           void *dest_data,
                                           const int *dest_sizes,
                                           const void *src_data,
                                           const int *src_sizes);
 
p4est_transfer_context_t *p4est_transfer_custom_begin (const p4est_gloidx_t *
                                                       dest_gfq,
                                                       const p4est_gloidx_t *
                                                       src_gfq,
                                                       sc_MPI_Comm mpicomm,
                                                       int tag,
                                                       void *dest_data,
                                                       const int *dest_sizes,
                                                       const void *src_data,
                                                       const int *src_sizes);
 
void                p4est_transfer_custom_end (p4est_transfer_context_t * tc);
 
void                p4est_transfer_items
  (const p4est_gloidx_t * dest_gfq, const p4est_gloidx_t * src_gfq,
   sc_MPI_Comm mpicomm, int tag,
   void *dest_data, const int *dest_counts,
   const void *src_data, const int *src_counts, size_t item_size);
 
p4est_transfer_context_t *p4est_transfer_items_begin
  (const p4est_gloidx_t * dest_gfq, const p4est_gloidx_t * src_gfq,
   sc_MPI_Comm mpicomm, int tag,
   void *dest_data, const int *dest_counts,
   const void *src_data, const int *src_counts, size_t item_size);
 
void                p4est_transfer_items_end (p4est_transfer_context_t * tc);
 
void                p4est_transfer_end (p4est_transfer_context_t * tc);
 
SC_EXTERN_C_END;
 
#endif /* !P4EST_COMMUNICATION_H */