Roccom_base.h

Go to the documentation of this file.

/* *******************************************************************
 * Rocstar Simulation Suite                                          *
 * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
 *                                                                   *
 * Illinois Rocstar LLC                                              *
 * Champaign, IL                                                     *
 * www.illinoisrocstar.com                                           *
 * sales@illinoisrocstar.com                                         *
 *                                                                   *
 * License: See LICENSE file in top level of distribution package or *
 * http://opensource.org/licenses/NCSA                               *
 *********************************************************************/
/* *******************************************************************
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
 * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
 *********************************************************************/
// $Id: Roccom_base.h,v 1.44 2008/12/06 08:43:24 mtcampbe Exp $

/* Author: Xiangmin Jiao */

#ifndef __ROCCOM_BASE_H__
#define __ROCCOM_BASE_H__

#include "roccom_devel.h"
#include "maps.h"
#include <set>

#ifdef __CHARMC__
#include "tcharm.h"
#endif


COM_BEGIN_NAME_SPACE

class Roccom_base {
  typedef Roccom_map<Window*>                                    Window_map;
  typedef Roccom_map<std::pair<void *, std::set<std::string> > > Module_map;
  typedef Roccom_map<Attribute*>                                 Attribute_map;
public:
  typedef Window::Pointer_descriptor Pointer_descriptor;
    
  Roccom_base( int *argc, char ***argv) throw( COM_exception, int);

  ~Roccom_base();

  static void init( int *argc, char ***argv) throw(int);
  static void finalize() throw(int);
  static void abort( int ierr);

  static void set_default_communicator( MPI_Comm comm) 
  { get_roccom()->_comm = comm; }

  static MPI_Comm get_default_communicator() 
  { return get_roccom()->_comm; }

  static void set_roccom( Roccom_base *);
  inline static Roccom_base *get_roccom();

  static bool initialized() { return get_roccom()!=NULL; }
  //\}

  void load_module( const std::string &lname, 
                    const std::string &wname) throw(int);
  
  void unload_module( const std::string &lname,
                      const std::string &wname, int dodl=1) throw(int);
  //\}

  void new_window( const std::string &wname, 
                   MPI_Comm comm) throw(int);

  void delete_window( const std::string &wname) throw(int);
  
  void window_init_done( const std::string &wname, 
                         bool panechanged = true) throw(int);
  
  void delete_pane(const std::string &wname, const int pid) throw(int);

  //\}

  void new_attribute( const std::string &wa, const char loc,
                      const int data_type, int size, 
                      const std::string &unit) throw(int);

  void delete_attribute( const std::string &wa) throw(int);

  void set_size( const std::string &wa_str, 
                 int pane_id, int nitems, int ng=0) throw(int);

  void set_object( const std::string &wa, const int pane_id,
                   void *obj_addr, void *casted_obj) throw(int);

  void get_object( const std::string &wa, const int pane_id,
                   void **ptr) throw(int);

  void set_array( const std::string &wa, const int pane_id,
                  void *addr, int strd=0, int cap=0, 
                  bool is_const=false) throw(int);

  template <class T>
  void set_bounds( const std::string &wa, const int pane_id,
                   T lbnd, T ubnd) throw(int)
  { set_bounds( wa, pane_id, (const void*)&lbnd, (const void*)&ubnd); }

  template <class T>
  void set_bounds( const std::string &wa, const int pane_id,
                   const T* lbnd, const T* ubnd) throw(int)
  { set_bounds( wa, pane_id, (const void*)&lbnd, (const void*)&ubnd); }

  void set_bounds( const std::string &wa, const int pane_id,
                   const void *lbnd, const void *ubnd) throw(int);

  void get_bounds( const std::string &wa, const int pane_id,
                   void *lbnd, void *ubnd) throw(int);

  int check_bounds( const std::string &wa, int pane_id) throw(int);

  void allocate_array( const std::string &wa, const int pane_id=0,
                       void **addr=NULL, int strd=0, int cap=0) throw(int);

  void resize_array( const std::string &wa, const int pane_id=0,
                     void **addr=NULL, int strd=-1, int cap=0) throw(int);

  void append_array( const std::string &wa, const int pane_id,
                     const void *val, int v_strd, int v_size) throw(int);

  void use_attribute( const std::string &wname, 
                      const std::string &pwname,
                      int withghost=1,
                      const char *cndname=NULL,
                      int val=0) throw(int);
  
  void clone_attribute( const std::string &wname, 
                        const std::string &pwname,
                        int withghost=1,
                        const char *cndname=NULL,
                        int val=0) throw(int);

  void copy_attribute( const std::string &wname, 
                       const std::string &pwname,
                       int withghost=1,
                       const char *cndname=NULL,
                       int val=0) throw(int);

  void copy_attribute( int trg_hdl, 
                       int src_hdl,
                       int withghost=1,
                       int ptn_hdl=0,
                       int val=0) throw(int);

  void deallocate_array( const std::string &wa,
                         const int pid=0) throw(int);

  void get_attribute( const std::string &wa_str, char *loc, int *type, 
                      int *size, std::string *unit) throw(int);

  void get_size( const std::string &wa_str, int pane_id, 
                 int *size, int *ng=0) throw(int);

  int get_status( const std::string &wa_str, int pane_id) throw(int);

  void get_array( const std::string &wa, const int pane_id,
                  void **addr, int *strd=NULL, 
                  int *cap=0, bool is_const=false) throw(int);

  void get_array( const std::string &wa, const int pane_id,
                  Pointer_descriptor &addr, int *strd=NULL, 
                  int *cap=0, bool is_const=false) throw(int);

  void copy_array( const std::string &wa, const int pane_id,
                   void *val, int v_strd=0, int v_size=0, 
                   int offset=0) throw(int);

  void set_f90pointer( const std::string &waname, void *ptr,
                       Func_ptr f, long int l) throw(int);
  
  void get_f90pointer( const std::string &waname, void *ptr, 
                       Func_ptr f, long int l) throw(int);
  //\}

  MPI_Comm get_communicator( const std::string &wname) throw(int);

  void get_windows(std::vector<std::string> &) throw(int);

  void get_modules(std::vector<std::string> &) throw(int);

  void get_panes( const std::string &wname, std::vector<int> &paneids_vec, 
                  int rank=-2, int **pane_ids=NULL) throw(int);


  void get_attributes( const std::string &wname, int *na,
                       std::string &str, char **names=NULL) throw(int);
  
  void get_connectivities( const std::string &wname, int pane_id, int *nc, 
                           std::string &str, char **names=NULL) throw(int);

  void get_parent( const std::string &waname, int pane_id,
                   std::string &str, char **name=NULL) throw(int);

  void free_buffer( int **buf);
  void free_buffer( char **buf);

  int get_window_handle( const std::string &wname) throw(int);
  Window *get_window_object( int hdl) throw(int);
  const Window *get_window_object( int hdl) const throw(int);

  Window *get_window_object( const std::string &wname) throw(int) 
  { return get_window_object( get_window_handle( wname)); }
  const Window *get_window_object( const std::string &wname) const throw(int)
  { return get_window_object( const_cast<Roccom_base*>(this)->
                              get_window_handle( wname)); }

  int get_attribute_handle( const std::string &waname) throw(int);
  int get_attribute_handle_const( const std::string &waname) throw(int);
  int get_function_handle( const std::string &wfname) throw(int);
  //\}

  void set_function( const std::string &wf, 
                     Func_ptr ptr, 
                     const std::string &intents,
                     const COM_Type *types, 
                     bool ff=false) throw(int);

  void set_member_function( const std::string &wf, 
                            Func_ptr ptr, 
                            const std::string &wa,
                            const std::string &intents,
                            const COM_Type *types, 
                            bool ff=false) throw(int);

  void set_member_function( const std::string &wf, 
                            Member_func_ptr ptr, 
                            const std::string &wa,
                            const std::string &intents,
                            const COM_Type *types, 
                            bool ff=false) throw(int);

  int get_num_arguments( const std::string &wf) throw(COM_exception);

  int get_num_arguments( const int wf) throw(COM_exception);

  void call_function( int wf, int count, void **args, 
                      const int *lens=NULL, 
                      bool from_c=true) throw(int);

  void icall_function( int wf, int count, void *args[], 
                       int *reqid, const int *lens=NULL) throw(int)
  { *reqid = 0; call_function( wf, count, args, lens); }

  void wait( int) {}
  int test( int) { return 1; }
  //\}

  int     get_verbose() const { return _verbose; }

  int     get_debug() const { return _debug; }

  void    set_verbose( int v) { 
    _verbose = v; _verb1 = ( _verbose<=0) ? 0 :  (_verbose+1)%2+1;
  }

  void    set_debug( bool debug) {
    _debug = debug;
  }

  void set_function_verbose( int i, int level) throw(int);

  void set_profiling( int i); 
  void set_profiling_barrier( int hdl, MPI_Comm comm);
  void print_profile( const std::string &fname, const std::string &header);
  //\}

  static int get_sizeof( COM_Type type, int count=1);

  int get_error_code() const { return _errorcode; }

  void turn_on_exception()  { _exception_on = true; }
  void turn_off_exception() { _exception_on = false; }

  enum { FPTR_NONE=0, FPTR_INSERT=1, FPTR_APPEND=2};
  int f90ptr_treat() const { return _f90ptr_treat; }
  //\}

protected:
  template < class T>
  void set_member_function_helper( const std::string &wf, 
                                   T ptr, 
                                   const std::string &wa,
                                   const std::string &intents,
                                   const COM_Type *types, 
                                   bool ff=false) throw(int);

  std::pair<int,int> get_f90pntoffsets( const Attribute *a);

  Window &get_window( const std::string &wname) throw(COM_exception);

  const Window &get_window( const std::string &wname) const throw(COM_exception)
  { return const_cast<Roccom_base*>(this)->get_window(wname); }

  Attribute &get_attribute( const int) throw(COM_exception);
  const Attribute &get_attribute( const int) const throw(COM_exception);

  Function &get_function( const int) throw(COM_exception);
  const Function &get_function( const int) const throw(COM_exception);

  // \}

  //====================================================
  // Some useful utilities for implementing a specific Roccom implementation
  //====================================================

  int split_name( const std::string &wa, std::string &wname, 
                  std::string &aname, bool tothrow=true) throw(COM_exception);

  void proc_exception( const COM_exception &, const std::string &) throw( int);
  //\}

protected:
  Roccom_base();  // Disable default constructor

protected: // Protected data members
  Module_map      _module_map;
  Window_map      _window_map;
  Attribute_map   _attr_map;
  Function_map    _func_map;

  std::string     _libdir;             
  std::vector<double> _timer;          
  int             _depth;              
  int             _verbose;            
  int             _verb1;              
  bool            _debug;              
  MPI_Comm        _comm;               
  bool            _mpi_initialized;    
  int             _errorcode;          
  bool            _exception_on;       
  bool            _profile_on;         

  int             _f90_mangling;       
  int             _f90ptr_treat;       
  int             _cppobj_casting;     

  static Roccom_base *roccom_base;
};

#ifndef __CHARMC__

Roccom_base *Roccom_base::get_roccom() 
{ return roccom_base; }

#else

typedef enum {
  COMGLOB_FIRST=1,      /*First valid global variable ID*/
  COMGLOB_ROCCOM,       /*Index of Roccom's global data*/
  /*add new global variables before this line*/
  COMGLOB_LAST          /*Last global variable ID+1 (length of global table).*/
} COMGLOB_ID;

//extern "C" void *TCHARM_Get_global(int);
//extern "C" void TCHARM_Set_global( int, void *, void *);

Roccom_base *Roccom_base::get_roccom() {
  extern bool use_tcharm_global;

  return ! use_tcharm_global ?
    roccom_base : (COM::Roccom_base *)TCHARM_Get_global(COMGLOB_ROCCOM);
}

//}

#endif // __CHARMC__

COM_END_NAME_SPACE

inline COM::Roccom_base *COM_get_roccom() 
{ COM::Roccom_base *roccom=COM::Roccom_base::get_roccom(); 
  COM_assertion_msg(roccom, 
                    "Roccom must be initialized before any Roccom calls."); 
  return roccom;
}

inline void COM_set_roccom( COM::Roccom_base *p) 
{ COM::Roccom_base::set_roccom(p); }

#endif // __ROCCOM_BASE_H__