sc_notify.h

Go to the documentation of this file.

/*
  This file is part of the SC Library.
  The SC Library provides support for parallel scientific applications.
 
  Copyright (C) 2010 The University of Texas System
  Additional copyright (C) 2011 individual authors
 
  The SC Library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  The SC Library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with the SC Library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
*/
 
#ifndef SC_NOTIFY_H
#define SC_NOTIFY_H
 
#include <sc_statistics.h>
 
SC_EXTERN_C_BEGIN;
 
extern int          sc_notify_nary_ntop_default;
 
extern int          sc_notify_nary_nint_default;
 
extern int          sc_notify_nary_nbot_default;
 
int                 sc_notify_allgather (int *receivers, int num_receivers,
                                         int *senders, int *num_senders,
                                         sc_MPI_Comm mpicomm);
 
int                 sc_notify (int *receivers, int num_receivers,
                               int *senders, int *num_senders,
                               sc_MPI_Comm mpicomm);
 
void                sc_notify_nary (sc_array_t * receivers,
                                    sc_array_t * senders,
                                    sc_array_t * in_payload,
                                    sc_array_t * out_payload,
                                    sc_MPI_Comm mpicomm);
 
void                sc_notify_ext (sc_array_t * receivers,
                                   sc_array_t * senders,
                                   sc_array_t * in_payload,
                                   sc_array_t * out_payload,
                                   sc_MPI_Comm mpicomm);
 
typedef struct sc_notify_s sc_notify_t;
 
typedef void        (*sc_compute_superset_t) (sc_array_t *, sc_array_t *,
                                              sc_array_t *, sc_notify_t *,
                                              void *);
 
typedef enum
{
  SC_NOTIFY_DEFAULT = -1,  
  SC_NOTIFY_ALLGATHER = 0, 
  SC_NOTIFY_BINARY,        
  SC_NOTIFY_NARY,          
  SC_NOTIFY_PEX,           
  SC_NOTIFY_PCX,           
  SC_NOTIFY_RSX,           
  SC_NOTIFY_NBX,           
  SC_NOTIFY_RANGES,        
  SC_NOTIFY_SUPERSET,      
  SC_NOTIFY_NUM_TYPES      
}
sc_notify_type_t;
 
#define SC_NOTIFY_STR_ALLGATHER "allgather" 
#define SC_NOTIFY_STR_BINARY "binary"       
#define SC_NOTIFY_STR_NARY "nary"           
#define SC_NOTIFY_STR_PEX "pex"             
#define SC_NOTIFY_STR_PCX "pcx"             
#define SC_NOTIFY_STR_RSX "rsx"             
#define SC_NOTIFY_STR_NBX "nbx"             
#define SC_NOTIFY_STR_RANGES "ranges"       
#define SC_NOTIFY_STR_SUPERSET "superset"   
extern const char  *sc_notify_type_strings[SC_NOTIFY_NUM_TYPES];
 
extern sc_notify_type_t sc_notify_type_default;
 
extern size_t       sc_notify_eager_threshold_default;
 
sc_notify_t        *sc_notify_new (sc_MPI_Comm mpicomm);
 
void                sc_notify_destroy (sc_notify_t * notify);
 
size_t              sc_notify_get_eager_threshold (sc_notify_t * notify);
 
void                sc_notify_set_eager_threshold (sc_notify_t * notify,
                                                   size_t thresh);
 
sc_statistics_t    *sc_notify_get_stats (sc_notify_t * notify);
 
void                sc_notify_set_stats (sc_notify_t * notify,
                                         sc_statistics_t * stats);
 
sc_MPI_Comm         sc_notify_get_comm (sc_notify_t * notify);
 
int                 sc_notify_supports_type (sc_notify_type_t type);
 
sc_notify_type_t    sc_notify_get_type (sc_notify_t * notify);
 
int                 sc_notify_set_type (sc_notify_t * notify,
                                        sc_notify_type_t type);
 
void                sc_notify_nary_get_widths (sc_notify_t * notify,
                                               int *ntop, int *nint,
                                               int *nbot);
 
void                sc_notify_nary_set_widths (sc_notify_t * notify, int ntop,
                                               int nint, int nbot);
 
int                 sc_notify_ranges_get_num_ranges (sc_notify_t * notify);
 
void                sc_notify_ranges_set_num_ranges (sc_notify_t * notify,
                                                     int num_ranges);
 
int                 sc_notify_ranges_get_package_id (sc_notify_t * notify);
 
void                sc_notify_ranges_set_package_id (sc_notify_t * notify,
                                                     int package_id);
const int          *sc_notify_ranges_get_procs (sc_notify_t * notify,
                                                int *num_procs);
void                sc_notify_ranges_set_procs (sc_notify_t * notify,
                                                int num_procs,
                                                const int *procs);
void                sc_notify_ranges_get_peer_range (sc_notify_t * notify,
                                                     int *first_peer,
                                                     int *last_peer);
void                sc_notify_ranges_set_peer_range (sc_notify_t * notify,
                                                     int first_peer,
                                                     int last_peer);
 
void                sc_notify_superset_get_callback
  (sc_notify_t * notify, sc_compute_superset_t * compute_superset, void *ctx);
 
void                sc_notify_superset_set_callback
  (sc_notify_t * notify, sc_compute_superset_t compute_superset, void *ctx);
 
void                sc_notify_payload (sc_array_t * receivers,
                                       sc_array_t * senders,
                                       sc_array_t * in_payload,
                                       sc_array_t * out_payload,
                                       int sorted, sc_notify_t * notify);
 
void                sc_notify_payloadv (sc_array_t * receivers,
                                        sc_array_t * senders,
                                        sc_array_t * out_payload,
                                        sc_array_t * in_payload,
                                        sc_array_t * out_offsets,
                                        sc_array_t * in_offsets,
                                        int sorted, sc_notify_t * notify);
 
extern int          sc_notify_ranges_num_ranges_default;
 
SC_EXTERN_C_END;
 
#endif /* !SC_NOTIFY_H */