Roccom_base Class Reference

This file indirectly includes the following files: iostream, map, string, vector, and roccom_basic.h. More...

#include <Roccom_base.h>

Inheritance diagram for Roccom_base:

Collaboration diagram for Roccom_base:

Public Types
typedef Window::Pointer_descriptor	Pointer_descriptor

Public Member Functions
Module management
void	load_module (const std::string &lname, const std::string &wname) throw (int)
	Load a module. More...
void	unload_module (const std::string &lname, const std::string &wname, int dodl=1) throw (int)
	Unload a module. More...
Window and pane management
void	new_window (const std::string &wname, MPI_Comm comm) throw (int)
	Creates a window with given name. More...
void	delete_window (const std::string &wname) throw (int)
	Deletes a window with given name. More...
void	window_init_done (const std::string &wname, bool panechanged=true) throw (int)
	Marks the end of the registration of a window. More...
void	delete_pane (const std::string &wname, const int pid) throw (int)
	Deletes a pane and its associated data. More...
Attribute management
void	new_attribute (const std::string &wa, const char loc, const int data_type, int size, const std::string &unit) throw (int)
	Creates a new attribute for a window. More...
void	delete_attribute (const std::string &wa) throw (int)
	Delete an existing attribute from a window. More...
void	set_size (const std::string &wa_str, int pane_id, int nitems, int ng=0) throw (int)
	Set the sizes of an attribute. More...
void	set_object (const std::string &wa, const int pane_id, void *obj_addr, void *casted_obj) throw (int)
	Associates an object with a specific window. More...
void	get_object (const std::string &wa, const int pane_id, void **ptr) throw (int)
	Associates an object with a specific window. More...
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)
	Associates an array with an attribute for a specific pane. More...
template<class T >
void	set_bounds (const std::string &wa, const int pane_id, T lbnd, T ubnd) throw (int)
template<class T >
void	set_bounds (const std::string &wa, const int pane_id, const T *lbnd, const T *ubnd) throw (int)
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)
	Allocate space for an attribute on a specific pane and return the address by setting addr. More...
void	resize_array (const std::string &wa, const int pane_id=0, void **addr=NULL, int strd=-1, int cap=0) throw (int)
	Resize an attribute on a specific pane and return the address by setting addr. More...
void	append_array (const std::string &wa, const int pane_id, const void *val, int v_strd, int v_size) throw (int)
	Append an array to the end of the attribute on a specific pane and return the new address by setting addr. More...
void	use_attribute (const std::string &wname, const std::string &pwname, int withghost=1, const char *cndname=NULL, int val=0) throw (int)
	Use the subset of panes of another window of which the given pane attribute has value val. More...
void	clone_attribute (const std::string &wname, const std::string &pwname, int withghost=1, const char *cndname=NULL, int val=0) throw (int)
	Clone the subset of panes of another window of which the given pane attribute has value val. More...
void	copy_attribute (const std::string &wname, const std::string &pwname, int withghost=1, const char *cndname=NULL, int val=0) throw (int)
	Copy an attribute onto another. More...
void	copy_attribute (int trg_hdl, int src_hdl, int withghost=1, int ptn_hdl=0, int val=0) throw (int)
	Copy an attribute onto another. More...
void	deallocate_array (const std::string &wa, const int pid=0) throw (int)
	Deallocate space for an attribute in a pane, asuming the memory was allocated allocate_mesh or allocate_attribute. More...
void	get_attribute (const std::string &wa_str, char *loc, int *type, int *size, std::string *unit) throw (int)
	Information retrieval Get the information about an attribute. More...
void	get_size (const std::string &wa_str, int pane_id, int *size, int *ng=0) throw (int)
	Get the sizes of an attribute. The opposite of set_size. More...
int	get_status (const std::string &wa_str, int pane_id) throw (int)
	Get the status of an attribute. More...
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)
	Get the address for an attribute on a specific pane. More...
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)
	Get the address for an attribute on a specific pane. More...
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)
	Copy an array from an attribute on a specific pane into a given buffer. More...
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)
Information retrieval
MPI_Comm	get_communicator (const std::string &wname) throw (int)
void	get_windows (std::vector< std::string > &) throw (int)
	Obtain a list of all window names. More...
void	get_modules (std::vector< std::string > &) throw (int)
	Obtain a list of all module names. More...
void	get_panes (const std::string &wname, std::vector< int > &paneids_vec, int rank=-2, int **pane_ids=NULL) throw (int)
	Obtain the panes of a given window on a specific process. More...
void	get_attributes (const std::string &wname, int *na, std::string &str, char **names=NULL) throw (int)
	Obtain the user-defined attributes of the given window. More...
void	get_connectivities (const std::string &wname, int pane_id, int *nc, std::string &str, char **names=NULL) throw (int)
	Obtain the connectivity tables of a pane of the given window. More...
void	get_parent (const std::string &waname, int pane_id, std::string &str, char **name=NULL) throw (int)
	Obtain the parent attribute's name of a given attribute on a given pane. More...
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)
const Window *	get_window_object (const std::string &wname) const throw (int)
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)
Function management
void	set_function (const std::string &wf, Func_ptr ptr, const std::string &intents, const COM_Type *types, bool ff=false) throw (int)
	Registers a function to the window. More...
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)
	Get the number of arguments of a given function "window.function". More...
int	get_num_arguments (const int wf) throw (COM_exception)
	Get the number of arguments of a given function from its handle. More...
void	call_function (int wf, int count, void **args, const int *lens=NULL, bool from_c=true) throw (int)
	Invoke a function with given arguments. More...
void	icall_function (int wf, int count, void *args[], int *reqid, const int *lens=NULL) throw (int)
	Nonblockingly invoke a function with given arguments. More...
void	wait (int)
	Wait for the completion of a nonblocking call. More...
int	test (int)
	Test whether a nonblocking call has finished. More...
Profiling and tracing tools
int	get_verbose () const
	Determines whether verbose is on. More...
int	get_debug () const
	Determines whether verbose is on. More...
void	set_verbose (int v)
	Changes the verbose setting. More...
void	set_debug (bool debug)
	Turns on debuging messages. More...
void	set_function_verbose (int i, int level) throw (int)
void	set_profiling (int i)
	This subroutine turns on (or off) profiling if i==1 (or ==0). More...
void	set_profiling_barrier (int hdl, MPI_Comm comm)
void	print_profile (const std::string &fname, const std::string &header)

Protected Member Functions
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)
	Roccom_base ()
Window management
Window &	get_window (const std::string &wname) throw (COM_exception)
	Obtains a reference to the Window object from its name. More...
const Window &	get_window (const std::string &wname) const throw (COM_exception)
	Obtains a constant reference to the Window object from its name. More...
Attribute &	get_attribute (const int) throw (COM_exception)
	Obtains a reference to an attribute from its handle. More...
const Attribute &	get_attribute (const int) const throw (COM_exception)
	Obtains a const reference to an attribute from its handle. More...
Function &	get_function (const int) throw (COM_exception)
	Obtains a reference to an attribute from its handle. More...
const Function &	get_function (const int) const throw (COM_exception)
	Obtains a const reference to an attribute from its handle. More...

Protected Attributes
Module_map	_module_map
Window_map	_window_map
Attribute_map	_attr_map
Function_map	_func_map
std::string	_libdir
	Library directory. More...
std::vector< double >	_timer
	Timers for function calls. More...
int	_depth
	Depth of procedure calls. More...
int	_verbose
	Indicates whether verbose is on. More...
int	_verb1
	Indicates whether to print detailed information. More...
bool	_debug
	Indicated whether debug mode is on. More...
MPI_Comm	_comm
	Default communicator of Roccom. More...
bool	_mpi_initialized
	Indicates whether MPI was initialized by Roccom. More...
int	_errorcode
	Error code. More...
bool	_exception_on
	Indicates whether Roccom should throw exception. More...
bool	_profile_on
	Indicates whether should profile. More...
int	_f90_mangling
	Encoding name mangling. More...
int	_f90ptr_treat
	Treatement of F90 pointers. More...
int	_cppobj_casting
	Treatement of C++ objects. More...

Static Protected Attributes
static Roccom_base *	roccom_base =NULL

Private Types
typedef Roccom_map< Window * >	Window_map
typedef Roccom_map< std::pair < void *, std::set < std::string > > >	Module_map
typedef Roccom_map< Attribute * >	Attribute_map

Initialization and Finalization
	Roccom_base (int *argc, char ***argv) throw ( COM_exception, int)
	Constructor. More...
	~Roccom_base ()
	Destructor. More...
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)
	Set the default communicator of Roccom. More...
static MPI_Comm	get_default_communicator ()
	Get the default communicator of Roccom. More...
static void	set_roccom (Roccom_base *)
	Set the Roccom pointer to the given object. More...
static Roccom_base *	get_roccom ()
	Get a pointer to the Roccom object. More...
static bool	initialized ()
	Checks whether Roccom has been initialized. More...

Miscellaneous
enum	{ FPTR_NONE =0, FPTR_INSERT =1, FPTR_APPEND =2 }
int	get_error_code () const
	Get the error code. More...
void	turn_on_exception ()
void	turn_off_exception ()
int	f90ptr_treat () const
static int	get_sizeof (COM_Type type, int count=1)
	Gets the size of the data type given by its index. More...
int	split_name (const std::string &wa, std::string &wname, std::string &aname, bool tothrow=true) throw (COM_exception)
	Extracts the window and attribute names from "window.attribute". More...
void	proc_exception (const COM_exception &, const std::string &) throw ( int)

Detailed Description

This file indirectly includes the following files: iostream, map, string, vector, and roccom_basic.h.

The base class for Roccom implementations.

Definition at line 49 of file Roccom_base.h.

Member Typedef Documentation

typedef Roccom_map<Attribute*> Attribute_map

private

Definition at line 52 of file Roccom_base.h.

typedef Roccom_map<std::pair<void *, std::set<std::string> > > Module_map

private

Definition at line 51 of file Roccom_base.h.

typedef Window::Pointer_descriptor Pointer_descriptor

Definition at line 54 of file Roccom_base.h.

typedef Roccom_map<Window*> Window_map

private

Definition at line 50 of file Roccom_base.h.

Member Enumeration Documentation

anonymous enum

Enumerator
FPTR_NONE
FPTR_INSERT
FPTR_APPEND

Definition at line 414 of file Roccom_base.h.

{ FPTR_NONE=0, FPTR_INSERT=1, FPTR_APPEND=2};

Constructor & Destructor Documentation

Roccom_base	(	int *	argc,
		char ***	argv
	)
throw	(	COM_exception,
		int
	)

Constructor.

Definition at line 84 of file Roccom_base.C.

References COMMPI_Comm_rank(), COMMPI_Initialized(), i, MPI_COMM_WORLD, rank, remove_arg(), and s.

  : _depth(0), _verbose(0), _verb1(0), _comm(MPI_COMM_WORLD),
    _mpi_initialized(false), _errorcode(0), _exception_on(true), _profile_on(0),
    _debug(false)
{
  _attr_map.add_object("",NULL);
  _func_map.add_object("",NULL);
  _errorcode = 0;

#ifdef PREFIX
  _libdir = std::string(PREFIX);
#endif

  const char *comhome = std::getenv( "ROCCOM_HOME");
  if ( comhome) _libdir = comhome;
  else {
    comhome = std::getenv( "ROCSTAR_HOME");
    if ( comhome) _libdir = comhome;
  }

  if ( !_libdir.empty()) _libdir.append( "/lib/");

  // Parse command-line options
  std::map<int,int> verb_maps; // Process-specific verbose level
  int i=1;

  while ( argc && i<*argc) {
    if ( std::strncmp((*argv)[i], "-com-v", 6) == 0) {
      // Check whether a number follows -com-v
      const char *s=(*argv)[i]+6;
      int rank = -1; // Default are all processes
      if ( s[0] != '\0') rank = std::atoi( s);

      int verb=1;
      if ( *argc>i+1 && (*argv)[i+1][0]>='0' && (*argv)[i+1][0]<='9')
      { verb = std::atoi( (*argv)[i+1]); remove_arg( argc, argv, i+1); }

      if ( rank == -1) set_verbose(verb); 
      else verb_maps[rank] = verb;

      remove_arg( argc, argv, i);
    }
    else if ( std::strcmp((*argv)[i], "-com-mpi") == 0) {
      if ( !COMMPI_Initialized()) _mpi_initialized=true;

      remove_arg( argc, argv, i);
    }
    else if ( std::strcmp((*argv)[i], "-com-home") == 0) {
      if ( *argc>i+1 && (*argv)[i+1][0]>='0' && (*argv)[i+1][0]<='9') { 
        _libdir = (*argv)[i+1];   _libdir.append( "/lib/");
        remove_arg( argc, argv, i+1); 
      }
      remove_arg( argc, argv, i);
    }
    else
      ++i;
  }


  // Initialize MPI if requested and MPI is not yet initialized.
  //  if ( _mpi_initialized){
    //    std::cout << "INITIALIZING MPI!!!" << std::endl;
  if(!COMMPI_Initialized())
    MPI_Init( argc, argv);
    //  }
  // Set process-specific verbose level
  int rank = 0;
  if ( COMMPI_Initialized()) rank = COMMPI_Comm_rank( MPI_COMM_WORLD);
  std::map<int,int>::const_iterator it=verb_maps.find( rank);
  if ( it!=verb_maps.end()) set_verbose( it->second);

  // Determine the F90 pointer treatment mode
  _f90_mangling = -1;
  _f90ptr_treat = -1; 

#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
  // For GNU C++, we know to use the csated address.
  _cppobj_casting = 1;
#elif defined(_POWER) || defined(__INTEL_COMPILER)
  // For IBM and INTEL compilers, we know to use the object's address
  _cppobj_casting = 0;
#else
  _cppobj_casting = -1;
#endif

  if ( _debug && rank == 0) {
    std::cerr << "Roccom Version 3.0. CVS $Id: Roccom_base.C,v 1.93 2008/12/06 08:43:25 mtcampbe Exp $" << std::endl;
    std::cerr << "Roccom: Started with verbose level " << _verbose << std::endl;
#ifndef DUMMY_MPI
    if ( !COMMPI_Initialized())
      std::cerr << "Roccom: MPI not initialized. Running in serial mode\n";
#else
    std::cerr << "Roccom: Running in serial mode with DUMMY_MPI\n";
#endif
  }
}

Here is the call graph for this function:

~Roccom_base

(

)

Destructor.

Definition at line 181 of file Roccom_base.C.

References _mpi_initialized.

                          {
  // If MPI was initialized by Roccom, then call MPI_Finalize.
  if (_mpi_initialized) MPI_Finalize();
}

Roccom_base ( )

protected

Member Function Documentation

void abort ( int  ierr )

static

Definition at line 205 of file Roccom_base.C.

References COMMPI_Initialized(), and MPI_COMM_WORLD.

Referenced by COM_F_FUNC2(), and generic_list::li_check_list().

                                 {
  if ( COMMPI_Initialized() ) MPI_Abort( MPI_COMM_WORLD, ierr);
  else exit( ierr); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Allocate space for an attribute on a specific pane and return the address by setting addr.

Allocate for all panes if pane-id is 0, in which case, do not set addr.

Definition at line 695 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Allocate array for \"" << wa << "\" on pane " 
                << pid << " with stride ";
      if ( strd) std::cerr << strd;
      else std::cerr << "==#components";

      std::cerr << " and capacity ";

      if ( cap) std::cerr << cap;
      else std::cerr << "==#items";

      std::cerr << std::endl;
    }

    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).alloc_array( aname, pid, addr, strd, cap);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::allocate_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

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

Append an array to the end of the attribute on a specific pane and return the new address by setting addr.

Definition at line 759 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug)
      std::cerr << "Roccom: Appending array " << val << " for \"" << wa 
                << "\" on pane " << pid << " with stride " << v_strd 
                << " and size " << v_size << std::endl;

    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).append_array( aname, pid, val, v_strd, v_size);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::append_array);
    std::string s("When processing attribute "); s.append(wa);
    proc_exception( ex, s);
  }
}

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

Invoke a function with given arguments.

Parameters

wf	the handle to the function.
count	the number of input arguments.
args	the addresses to the arguments.
lens	the lengths of character strings.

Definition at line 1744 of file Roccom_base.C.

References append_frame, Function::attribute(), COM_assertion_msg, COM_CHAR, COM_CHARACTER, COM_DOUBLE, COM_DOUBLE_PRECISION, COM_ERR_ATTRIBUTE_CONST, COM_ERR_IMMUTABLE, COM_ERR_TOO_FEW_ARGS, COM_ERR_TOO_MANY_ARGS, COM_F90POINTER, COM_FLOAT, COM_INT, COM_INTEGER, COM_LOGICAL, COM_LONG, COM_MPI_COMMC, COM_MPI_COMMF, COM_REAL, COM_STRING, COMMPI_Comm_c2f(), COMMPI_Comm_f2c(), Function::data_type(), Attribute::data_type(), get_wtime(), i, iend, Function::intent(), Attribute::is_const(), Function::is_fortran(), Function::is_literal(), Function::is_optional(), Function::is_rawdata(), max(), MAX_NAMELEN, Function::MAX_NUMARG, COM_exception::msg, n, Window::name(), Attribute::name(), Function::num_of_args(), offset(), Attribute::pointer(), and Attribute::window().

Referenced by icall_function().

                                                                     {
  // Roccom prints out the trace upto (verb-1)/2 depth.
  // If verb is even, then it will also print the arguments.
  try {
    if ( wf==0) { 
      if ( _debug) {
        std::cerr << "Roccom: ************* CALL(" << _depth << ") " 
                  << "on NOOP with " << count << " arguments" << std::endl;
      }
      return;  // Null function
    }

    Function *func = &get_function( wf);

    int  verb = std::max(_verbose, int(_func_map.verbs[ wf]))-_depth*2;
    if ( verb<=0) verb = 0; 
    else verb = (verb+1)%2+1;
    if ( _debug) {
      std::cerr << "Roccom: CALL(" << _depth << ") " 
                << _func_map.name(wf);
      if ( _debug) std::cerr << '(';
    }

    std::vector<char> strs[Function::MAX_NUMARG+1];
    bool  needpostproc=false;
  
    int  li=0;
    void *ps[2*Function::MAX_NUMARG+1];
    int  lcount = 0;
    void **plen = NULL;
    if ( func->is_fortran()) plen = ps+func->num_of_args();

    // attr must be const to void throwing exception when pointer is called
    const Attribute *attr = func->attribute();
    int offset = (attr!=NULL);
    count += offset;
    args  -= offset;
    if ( count > func->num_of_args())
      throw COM_exception(COM_ERR_TOO_MANY_ARGS);

    if ( offset) {
      if ( _debug)
        std::cerr << std::endl << "Roccom:\t" << func->intent(0) << ": ";
      
      if ( func->is_rawdata( 0)) {
        if ( attr->is_const() && std::tolower(func->intent(0)) != 'i')
          throw COM_exception( COM_ERR_ATTRIBUTE_CONST);
          
        if ( attr->data_type()==COM_F90POINTER) {
          std::pair<int,int> offs = get_f90pntoffsets( attr);
          
          ps[0] = (char*)const_cast<void*>(attr->pointer())+offs.first;
          // Add pointer information for PortlandGroup Compiler

          COM_assertion_msg( _f90ptr_treat>=0, "No F90 pointer initalized");
          if ( _f90ptr_treat == FPTR_INSERT) {
            *plen = *(void**)((char*)const_cast<void*>(attr->pointer())
                              +offs.second);
            ++lcount; ++plen;
          }
        }
        else 
          ps[0] = (char*)const_cast<void*>(attr->pointer());
        
        if ( _debug)
          std::cerr << "VALUE OF\t@" << ps[0] << "\t\"" 
                    << attr->window()->name() << '.' << attr->name() << '"';
      }
      else {
        ps[0] = const_cast<Attribute*>(attr);
        if ( _debug)
          std::cerr << "METADATA\t@" << ps[0] << "\t\"" 
                    << attr->window()->name() << '.' << attr->name() << '"';
      }
    }

    for ( int i=offset; i<count; ++i) {
      if ( _debug) {
        std::cerr << std::endl << "Roccom:\t" << func->intent(i) << ": ";
      }

      if ( func->is_literal(i)) {
        ps[i] = args[i];
        COM_Type type = func->data_type(i);
        char intent = func->intent(i);
        if ( type == COM_CHARACTER || type == COM_CHAR || type == COM_STRING) {
          if ( type == COM_STRING) {
            // Make sure it is NULL terminated
            if (lens && (intent=='i' || intent=='I' || 
                         intent=='b' || intent=='B') && 
                ( lens[li]==0 || ((char*)args[i])[lens[li]-1] != '\0')) {
              strs[i].resize( lens[li]+1, '\0');
              std::strncpy( &strs[i][0], (char*)args[i], lens[li]);
              ps[i] = &strs[i][0];
              
              if (intent=='b' || intent=='B') needpostproc=true;
            }
            if ( plen) { // Append the length info
              *plen = (char*)NULL+std::strlen((char*)ps[i]); ++plen; ++lcount;
            }
          }
          else if ( plen) {
            *plen = (char*)NULL+1; ++plen; ++lcount;
          }
          ++li;
        }
        else if ( type == COM_MPI_COMMC && !from_c) {
          strs[i].resize( 2*sizeof( MPI_Comm));
          ps[i] = &strs[i][0]+(sizeof( MPI_Comm)-
                               ((long int)&strs[i][0])%sizeof(MPI_Comm));
          if (intent=='i' || intent=='I' || intent=='b' || intent=='B')
            *(MPI_Comm*)ps[i] = COMMPI_Comm_f2c( *(int*)args[i], MPI_Comm());
          if (intent=='o' || intent=='O' || intent=='b' || intent=='B') 
            needpostproc=true;
        }
        else if ( type == COM_MPI_COMMF && from_c) {
          strs[i].resize( 2*sizeof( int));
          ps[i] = &strs[i][0]+(sizeof(int)-((long int)&strs[i][0])%sizeof(int));
          if (intent=='i' || intent=='I' || intent=='b' || intent=='B')
            *(int*)ps[i] = COMMPI_Comm_c2f( *(MPI_Comm*)args[i]);
          if (intent=='o' || intent=='O' || intent=='b' || intent=='B') 
            needpostproc=true;
        }
        if (_debug) {
          switch (type) {
          case COM_STRING:
            std::cerr << "STRING\t@" << args[i] << "\t";
            if ( args[i]) std::cerr << '\"' << (char*)ps[i] << '\"'; 
            break;
          case COM_CHAR: case COM_CHARACTER:
            std::cerr << "CHAR  \t@" << args[i] << "\t";
            if ( args[i]) std::cerr << '\'' << *(char*)args[i] << '\''; 
            break;
          case COM_DOUBLE:
          case COM_DOUBLE_PRECISION: 
            std::cerr << "double\t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(double*)args[i]; 
            break;
          case COM_INT:
          case COM_LONG:
          case COM_INTEGER:
            std::cerr << "int   \t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(int*)args[i]; 
            break;
            case COM_FLOAT:
          case COM_REAL:
            std::cerr << "float \t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(float*)args[i]; 
            break;
          case COM_LOGICAL:
            std::cerr << "logical\t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(int*)args[i]; 
            break;
          case COM_MPI_COMMC:
            std::cerr << "MPI_Comm (C)\t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(MPI_Comm*)args[i]; 
            break;
          case COM_MPI_COMMF:
            std::cerr << "MPI_Comm (F)\t@" << args[i] << '\t';
            if ( args[i]) std::cerr << *(int*)args[i]; 
            break;
          default:
            std::cerr << "type(" << type << ")\t@" << args[i];
          }
        }
      }
      else {
        int h=*(int*)args[i];
        if ( h == 0 && func->intent(i)<='Z') { 
          // Optional attribute received a 0 attribute handle
          ps[i] = NULL;
          if ( _debug)
            std::cerr << "ZERO ATTRIBUTE HANDLE";
          continue;
        }

        // attr must be const to void throwing exception when pointer is called
        const Attribute *attr = &get_attribute( h);
        if ( attr->is_const() && std::tolower(func->intent(i)) != 'i')
          throw COM_exception( COM_ERR_ATTRIBUTE_CONST);

        if ( func->is_rawdata( i)) {
          ps[i] = const_cast<void*>(attr->pointer());
          if ( _debug)
            std::cerr << "VALUE OF\t@" << ps[i] 
                      << "\t\"" << _attr_map.name(h) << '"';
        }
        else {
          ps[i] = const_cast<Attribute*>(attr);
          if ( _debug)
            std::cerr << "METADATA\t@" << ps[i] 
                      << "\t\"" << _attr_map.name(h) << '"';
        }
        
        if ( _attr_map.is_immutable( h) &&
             toupper(func->intent(i)) != 'I') {
          throw COM_exception(COM_ERR_IMMUTABLE);
        }
      }
    }

    if (offset && func->is_rawdata(0) && 
        (attr = func->attribute())->data_type()==COM_F90POINTER) {
      COM_assertion_msg( _f90ptr_treat>=0, "No F90 pointer initalized");

      // Append pointer information
      if ( _f90ptr_treat == FPTR_APPEND) {
        std::pair<int,int> offs = get_f90pntoffsets( attr);
        
        // Add pointer information for Intel Compiler
        *plen = *(void**)((char*)const_cast<void*>(attr->pointer())+offs.second);
        ++lcount; ++plen;
      }
    }

    for ( int i=count, iend=func->num_of_args(); i<iend; ++i) {
      if ( !func->is_optional( i)) throw COM_exception(COM_ERR_TOO_FEW_ARGS);
      ps[i] = NULL;
      if ( _debug) {
        std::cerr << std::endl << "Roccom: OPT\t" << func->intent(i) << ": ";
        std::cerr << ps[i];
      }
    }
    if ( _debug) {
      if ( _debug) std::cerr << std::endl << "Roccom: )";
      std::cerr << std::endl;
    }
    
    // Profiling it
    double t = 0;
    if ( _profile_on) { 
//RAF    MPI_Comm comm = func->communicator();
//RAF    if (comm!=MPI_COMM_NULL) MPI_Barrier( comm);
      t = get_wtime();
#ifdef _CHARM_THREADED_
//RAF      if (comm!=MPI_COMM_NULL) MPI_Barrier( comm);
#endif
    }
    ++_depth;
    if ( _debug && lcount>0) {
      std::cerr << "Roccom: Invoking function with " << lcount 
                << " additional implicit arguments: " << std::endl;
      for ( int i=0; i<lcount; ++i) {
        long int p=(long int)ps[func->num_of_args()+i];
        if ( p<0 || p>MAX_NAMELEN)
          std::cerr << "Roccom:\t@" << (void *)p << std::endl;
        else
          std::cerr << "Roccom:\t" << (long int)p << std::endl;
      }
    }

    // Invoke the function
    (*func)( func->num_of_args()+lcount, ps);
    --_depth;

    if ( _profile_on) {
//RAF      MPI_Comm comm = func->communicator();
//RAF      if (comm!=MPI_COMM_NULL) MPI_Barrier( comm);

      double tnew = get_wtime(); 
#ifdef _CHARM_THREADED_
//RAF      if (comm!=MPI_COMM_NULL) MPI_Barrier( comm);
#endif

      _func_map.counts[wf]++;

      double sec = tnew-t;
      _func_map.wtimes_tree[wf] += sec;
      _func_map.wtimes_self[wf] += sec;
      if ( int(_timer.size()) > _depth) 
        _func_map.wtimes_self[wf] -= _timer[_depth];

      _timer.resize( _depth,0);
      if (_depth>0)  _timer[_depth-1] += sec;
      if (_depth==0) _func_map.wtimes_tree[0] += sec;
    }

    if ( _debug) {
      std::cerr << "Roccom: DONE(" << _depth << ") " << std::endl;
    }

    // Copy back strings
    if ( needpostproc) {
      for ( int i=offset; i<count; ++i) {
        COM_Type type = func->data_type(i);
        char intent = func->intent(i);
        if ( func->is_literal(i) && type == COM_STRING) {
          if (intent=='b' || intent=='B') {
            int n = strs[i].size();
            if ( n>0) std::memcpy( args[i], &strs[i][0], n-1);
          }
        }
        else if ( type == COM_MPI_COMMC && !from_c) {
          if (intent=='o' || intent=='O' || intent=='b' || intent=='B')
            *(int*)args[i] = COMMPI_Comm_c2f( *(MPI_Comm*)ps[i]);
        }
        else if ( type == COM_MPI_COMMF && from_c) {
          if (intent=='o' || intent=='O' || intent=='b' || intent=='B')
            *(MPI_Comm*)args[i] = COMMPI_Comm_f2c( *(int*)ps[i], MPI_Comm());
        }
      }
    }

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::call_function);
    char buf[10];

    std::sprintf( buf, "%d", wf);
    std::string msg = std::string( "When processing function ");
    if ( wf>0) msg.append( _func_map.name(wf));

    msg.append( " with handle "); msg.append( buf);
    proc_exception( ex, msg);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1130 of file Roccom_base.C.

{ return 0; }

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

Clone the subset of panes of another window of which the given pane attribute has value val.

Definition at line 822 of file Roccom_base.C.

References append_frame, COM_ERR_ATTRIBUTE_NOTEXIST, Attribute::empty(), Pane::INHERIT_CLONE, COM_exception::msg, ni, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Cloning attribute \"" << pwaname 
                << "\" onto \"" << waname << '"' << std::endl;
    }
    std::string pawname, paaname;
    split_name( pwaname, pawname, paaname);

    std::string awname, aaname;
    std::string::size_type ni = waname.find(".");
    if ( ni == std::string::npos) {
      awname = waname; aaname = "";
    }
    else 
      split_name( waname, awname, aaname);

    std::string cawname, caaname;
    if ( cndname && *cndname!=0)
      split_name( cndname, cawname, caaname);

    Attribute *cnd=caaname.empty()?NULL:get_window(cawname).attribute(caaname);
    if ( !caaname.empty() && cnd==NULL)
      throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST, cndname);

    get_window(awname).inherit( get_window( pawname).attribute(paaname), 
                                aaname, Pane::INHERIT_CLONE, withghost, cnd, val);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::clone_attribute);
    std::string s;
    s = s + "When window " + waname + " clones attribute " + pwaname;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

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
	)

Copy an array from an attribute on a specific pane into a given buffer.

Definition at line 1093 of file Roccom_base.C.

References append_frame, COM_exception::msg, offset(), and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Copy array for attribute \"" 
                << wa << '"' << " on pane " << pid << std::endl;
    }

    // Invoke Window::get_size
    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).copy_array( aname, pid, val, v_strd, v_size, offset);

    if ( _debug) {
      std::cerr << "Roccom: ";
      std::cerr << " stride is " << v_strd;
      std::cerr << " size is " << v_size;
      std::cerr << std::endl;
    }

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::copy_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

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

Copy an attribute onto another.

Definition at line 862 of file Roccom_base.C.

References append_frame, COM_ERR_ATTRIBUTE_NOTEXIST, Attribute::empty(), Pane::INHERIT_COPY, COM_exception::msg, ni, and s.

Referenced by copy_attribute().

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Copying attribute \"" << pwaname 
                << "\" onto \"" << waname << '"' << std::endl;
    }
    std::string pawname, paaname;
    split_name( pwaname, pawname, paaname);

    std::string awname, aaname;
    std::string::size_type ni = waname.find(".");
    if ( ni == std::string::npos) {
      awname = waname; aaname = "";
    }
    else 
      split_name( waname, awname, aaname);

    std::string cawname, caaname;
    if ( cndname && *cndname!=0)
      split_name( cndname, cawname, caaname);

    Attribute *cnd=caaname.empty()?NULL:get_window(cawname).attribute(caaname);
    if ( !caaname.empty() && cnd==NULL)
      throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST, cndname);

    get_window(awname).inherit( get_window( pawname).attribute(paaname), 
                                aaname, Pane::INHERIT_COPY, withghost, cnd, val);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::copy_attribute);
    std::string s;
    s = s + "When window " + waname + " copies attribute " + pwaname;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Copy an attribute onto another.

Definition at line 902 of file Roccom_base.C.

References append_frame, COM_ERR_IMMUTABLE, COM_ERR_INVALID_ATTRIBUTE_HANDLE, copy_attribute(), Window::inherit(), Pane::INHERIT_COPY, COM_exception::msg, Attribute::name(), and Attribute::window().

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Copying attribute with handle \"" << src_hdl 
                << "\" onto \"" << trg_hdl << '"' << std::endl;
    }

    if ( trg_hdl <= 0 || src_hdl <= 0)
      throw COM_exception( COM_ERR_INVALID_ATTRIBUTE_HANDLE);

    if ( _attr_map.is_immutable( trg_hdl))
      throw COM_exception(COM_ERR_IMMUTABLE);

    Attribute *trg = &get_attribute(trg_hdl);
    trg->window()->inherit( &get_attribute(src_hdl), trg->name(),
                            Pane::INHERIT_COPY, withghost, 
                            ptn_hdl?&get_attribute(ptn_hdl):NULL, val);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::copy_attribute);
    std::ostringstream sout;

    sout << "When copying attribute " << src_hdl << " onto " 
         << trg_hdl << " with pattern attribute " << ptn_hdl;
    proc_exception( ex, sout.str());
  }
}

Here is the call graph for this function:

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

Deallocate space for an attribute in a pane, asuming the memory was allocated allocate_mesh or allocate_attribute.

Definition at line 934 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug)
      std::cerr << "Roccom: Deallocate array for \"" << wa << "\" on pane " 
                << pid << " to" << std::endl;

    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).dealloc_array( aname, pid);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::deallocate_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

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

Delete an existing attribute from a window.

Definition at line 548 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug)
      std::cerr << "Roccom: delete attribute \"" << wa << std::endl;

    // Invoke Window::new_attribute.
    std::string wname, aname;
    split_name( wa, wname, aname);
    
    get_window( wname).delete_attribute( aname);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::delete_attribute);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

void delete_pane	(	const std::string &	wname,
		const int	pid
	)
throw	(	int
	)

Deletes a pane and its associated data.

Definition at line 459 of file Roccom_base.C.

References append_frame, and COM_exception::msg.

{
  try {
    if ( _debug)
      std::cerr << "Roccom: Delete pane " << pane_id << " of window "
                << std::endl;

    get_window( wname).delete_pane( pane_id);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::delete_pane);
    char buf[10];
    std::sprintf( buf, "%d", pane_id);
    std::string msg = std::string( "When processing window ") 
      + wname + " for pane " + buf;
    proc_exception( ex, msg);
  }
}

void delete_window	(	const std::string &	wname	)
throw	(	int
	)

Deletes a window with given name.

Definition at line 441 of file Roccom_base.C.

References append_frame, COM_ERR_WINDOW_NOTEXIST, COM_exception::ierr, COM_exception::msg, and s.

{
  try {
    if ( _debug)
      std::cerr << "Roccom: Deleting window \"" << name << '"' << std::endl;

    _window_map.remove_object( name);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.ierr = COM_ERR_WINDOW_NOTEXIST;
    ex.msg = append_frame( ex.msg, Roccom_base::delete_window);
    std::string s;
    s = s + "When processing window " + name;
    proc_exception( ex, s);
  }
}

int f90ptr_treat ( ) const

inline

Definition at line 415 of file Roccom_base.h.

References _f90ptr_treat.

{ return _f90ptr_treat; }

void finalize ( ) throw ( int )

static

Definition at line 197 of file Roccom_base.C.

References COM_ERR_WASNOT_INITIALIZED, get_roccom(), and set_roccom().

Referenced by COM_F_FUNC2().

                                       {
  COM::Roccom_base *ptr = get_roccom();
  if ( !ptr) throw( COM_ERR_WASNOT_INITIALIZED);

  delete ptr;
  set_roccom( NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_buffer

(

int **

buf

)

Definition at line 1467 of file Roccom_base.C.

{ if ( buf) delete [] *buf; *buf = NULL; }

void free_buffer

(

char **

buf

)

Definition at line 1464 of file Roccom_base.C.

{ if ( buf) delete [] *buf; *buf = NULL; }

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
	)

Get the address for an attribute on a specific pane.

Definition at line 1012 of file Roccom_base.C.

References Window::Pointer_descriptor::ptr.

Referenced by get_array().

{
  Pointer_descriptor ptr(NULL);
  get_array( wa, pane_id, ptr, strd, cap, is_const);
  if (addr) *addr = ptr.ptr;
}

Here is the caller graph for this function:

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
	)

Get the address for an attribute on a specific pane.

Definition at line 1022 of file Roccom_base.C.

References append_frame, get_array(), COM_exception::msg, and s.

                                                                            {
  try {
    if ( _debug) {
      std::cerr << "Roccom: Get array for attribute \"" 
                << wa << '"' << " on pane " << pid << std::endl;
    }

    // Invoke Window::get_size
    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).get_array( aname, pid, addr, strd, cap, is_const);

    if ( _debug) {
      std::cerr << "Roccom: ";
      if ( strd) std::cerr << " stride is " << *strd;
      if ( cap) std::cerr << " capacity is " << *cap;
      std::cerr << std::endl;
    }

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

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

Information retrieval Get the information about an attribute.

The opposite of new_attribute.

Definition at line 958 of file Roccom_base.C.

References append_frame, COM_exception::msg, print_type(), and s.

Referenced by get_attribute().

{
  try {
    if ( _debug) // Print debugging info
      std::cerr << "Roccom: get attribute \"" << wa << "\"" << std::endl;

    // Invoke Window::get_attribute.
    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).get_attribute( aname, loc, type, size, unit);
    _errorcode = 0;

    if ( _debug) { // Print debugging info
      if (loc)  std::cerr << "Roccom:\tLocation: " << *loc 
                          << "\nRoccom:\tType: ";
      if (type) print_type( std::cerr, *type);    
      if ( size) std::cerr << "Roccom:\tSize: " << *size << std::endl;
      if ( unit) std::cerr << "Roccom:\tUnit: \"" << *unit << "\"" << std::endl;
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_attribute);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

protected

Obtains a reference to an attribute from its handle.

Definition at line 2176 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_ATTRIBUTE_HANDLE, and get_attribute().

                                                      {
  Attribute *attr=NULL;

  if ( handle > 0 && handle<_attr_map.size()) 
    attr = _attr_map[handle];
  if (attr==NULL) {
    static char buf[10];
    std::sprintf( buf, "%d", handle);
    throw COM_exception( COM_ERR_INVALID_ATTRIBUTE_HANDLE,
                         append_frame(buf, Roccom_base::get_attribute));
  }
  return *attr; 
}

Here is the call graph for this function:

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

protected

Obtains a const reference to an attribute from its handle.

Definition at line 2191 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_ATTRIBUTE_HANDLE, and get_attribute().

                                                            { 
  const Attribute *attr=NULL;

  if ( handle > 0 && handle<_attr_map.size()) 
    attr = _attr_map[handle];
  if (attr==NULL) {
    static char buf[10];
    std::sprintf( buf, "%d", handle);
    throw COM_exception( COM_ERR_INVALID_ATTRIBUTE_HANDLE,
                         append_frame(buf, Roccom_base::get_attribute));
  }
  return *attr; 
}

Here is the call graph for this function:

int get_attribute_handle	(	const std::string &	waname	)
throw	(	int
	)

Definition at line 1540 of file Roccom_base.C.

References append_frame, COM_exception::msg, and n.

                                                          {
  int n(-1);
  try {
    if ( _debug) 
      std::cerr << "Roccom: get handle of attribute \"" << waname << "\": ";
    std::string wname, aname;
    split_name( waname, wname, aname);
    
    Attribute *a = get_window( wname).attribute( aname);
    
    if ( a!=NULL) n=_attr_map.add_object( waname, a, false);

    if ( _debug) {
      if ( n>0) std::cerr << n << std::endl;
      else std::cerr << " not found" << std::endl;      
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_attribute_handle);
    proc_exception( ex, "");
  }
  return n;
}

int get_attribute_handle_const	(	const std::string &	waname	)
throw	(	int
	)

Definition at line 1513 of file Roccom_base.C.

References append_frame, COM_exception::msg, and n.

                                                                {
  int n(-1);
  try {
    if ( _debug) 
      std::cerr << "Roccom: get const handle of attribute \"" 
                << waname << "\": ";

    std::string wname, aname;
    split_name( waname, wname, aname);
    
    Attribute *a = get_window( wname).attribute( aname);
    
    if ( a!=NULL) n=_attr_map.add_object( waname, a, true);

    if ( _debug) {
      if ( n>0) std::cerr << n << std::endl;
      else std::cerr << " not found" << std::endl;      
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_attribute_handle_const);
    proc_exception( ex, "");
  }
  return n;
}

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

Obtain the user-defined attributes of the given window.

Definition at line 1349 of file Roccom_base.C.

References append_frame, copy, i, COM_exception::msg, n, and s.

{
  try {
    if ( _debug) 
      std::cerr << "Roccom: get attributes of window \"" 
                << wname << '"' << std::endl;

    std::vector<Attribute*> as;
    get_window(wname).attributes( as);

    str.clear();
    if ( natts) *natts = as.size();
    int i=0, n=as.size();
    if (n) for (;;) {
      str = str + as[i]->name();
      if ( ++i<n) str.append(" ");
      else break;
    }
    
    if ( names) {
      *names = new char[str.size()+1];
      std::copy( str.begin(), str.end(), *names);
      (*names)[str.size()]=0;
    }

    if ( _debug) 
      std::cerr << "Roccom: Got attribute names: " << str << std::endl;

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_attributes);
    std::string s;
    s = s + "When processing window " + wname;
    proc_exception( ex, s);
  }
}

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

Definition at line 1126 of file Roccom_base.C.

{}

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

Definition at line 1241 of file Roccom_base.C.

References append_frame, COMMPI_Initialized(), Window::get_communicator(), COM_exception::msg, and s.

                                                     {
  try {
    if ( _debug) 
      std::cerr << "Roccom: get the communicator of window \"" 
                << wname << std::endl;
    if ( COMMPI_Initialized()) {
      Window &w = get_window(wname);
      _errorcode = 0;
      return w.get_communicator();
    }
    else
      return MPI_COMM_NULL;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_window_npanes);
    std::string s;
    s = s + "When processing window " + wname;
    proc_exception( ex, s);
  }
  return 0;
}

Here is the call graph for this function:

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

Obtain the connectivity tables of a pane of the given window.

Definition at line 1390 of file Roccom_base.C.

References append_frame, copy, i, COM_exception::msg, n, and s.

{
  try {
    if ( _debug) 
      std::cerr << "Roccom: get connectivities of window \"" << wname 
                << "\" on pane " << pane_id << std::endl;

    std::vector<Connectivity*> as;
    get_window(wname).pane( pane_id).connectivities( as);

    if ( natts) *natts = as.size();

    str.clear();
    int i=0, n=as.size();
    if (n) for (;;) {
      str = str + as[i]->name();
      if ( ++i<n) str.append(" ");
      else break;
    }
    
    if ( names) {
      *names = new char[str.size()+1];
      std::copy( str.begin(), str.end(), *names);
      (*names)[str.size()]=0;
    }

    if ( _debug) 
      std::cerr << "Roccom: Got connectivity names: " << str << std::endl;

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_connectivities);
    std::string s;
    s = s + "When processing window " + wname;
    proc_exception( ex, s);
  }
}

int get_debug ( ) const

inline

Determines whether verbose is on.

Definition at line 381 of file Roccom_base.h.

References _debug.

{ return _debug; }

static MPI_Comm get_default_communicator ( )

inlinestatic

Get the default communicator of Roccom.

Definition at line 75 of file Roccom_base.h.

References _comm, and get_roccom().

Referenced by COM_F_FUNC2().

  { return get_roccom()->_comm; }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_error_code ( ) const

inline

Get the error code.

Definition at line 409 of file Roccom_base.h.

References _errorcode.

{ return _errorcode; }

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

protected

Definition at line 1135 of file Roccom_base.C.

References _f90ptr_treat, COM_assertion_msg, COM_F90POINTER, FPTR_INSERT, Attribute::get_sizeof(), n, and Attribute::size_of_components().

                                                  {
  
  int n = Attribute::get_sizeof( COM_F90POINTER, a->size_of_components());

  COM_assertion_msg( _f90ptr_treat>=0, "No F90 pointer initalized");
  if ( _f90ptr_treat == FPTR_INSERT) 
    return std::pair<int,int>(n/2-sizeof(void*), n-sizeof(void*));
  else
    return std::pair<int,int>(0,n-sizeof(void*));
}

Here is the call graph for this function:

void get_f90pointer	(	const std::string &	waname,
		void *	ptr,
		Func_ptr	f,
		long int	l
	)
throw	(	int
	)

Definition at line 1202 of file Roccom_base.C.

References append_frame, COM_assertion_msg, COM_ERR_NOT_A_POINTER, COM_ERR_NOT_A_WINDOW_ATTRIBUTE, COM_F90POINTER, Attribute::data_type(), Attribute::location(), COM_exception::msg, and Attribute::pointer().

                                                     {
  try {
    if ( _debug) 
      std::cerr << "Roccom: get pointer \"" << waname 
                << " into " << ptr << std::endl;

    std::string wname, aname;
    split_name( waname, wname, aname);

    Attribute *a = get_window( wname).attribute( aname);
    if ( a->location() != 'w')
      throw COM_exception( COM_ERR_NOT_A_WINDOW_ATTRIBUTE,
                           append_frame(waname, Roccom_base::get_f90pointer));
    if ( a->data_type() == COM_F90POINTER) {
      std::pair<int,int> offs = get_f90pntoffsets( a);

      COM_assertion_msg( _f90ptr_treat>=0, "No F90 pointer initalized");
      if ( _f90ptr_treat == FPTR_INSERT || _f90ptr_treat == FPTR_APPEND) {
        typedef void(*Func2)(void*,void*, long int, long int);
        (*(Func2)f)( (char*)a->pointer()+offs.first, ptr, 
                     *(long int*)((char*)a->pointer()+offs.second), len);
      }
      else {
        typedef void(*Func2)(void*,void*);
        (*(Func2)f)( a->pointer(), (char*)ptr+offs.first);
      }
    }
    else
      throw COM_exception( COM_ERR_NOT_A_POINTER,
                           append_frame(waname, Roccom_base::get_f90pointer));
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_f90pointer);
    proc_exception( ex, "");
  }
}

Here is the call graph for this function:

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

protected

Obtains a reference to an attribute from its handle.

Definition at line 2206 of file Roccom_base.C.

References append_frame, and COM_ERR_INVALID_FUNCTION_HANDLE.

Referenced by get_function(), and set_profiling_barrier().

                                                     { 
  Function *func=NULL;

  if ( handle > 0 && handle<_func_map.size()) 
    func = _func_map[handle];

  if (func==NULL) {
    static char buf[10];
    std::sprintf( buf, "%d", handle);
    throw COM_exception( COM_ERR_INVALID_FUNCTION_HANDLE,
                         append_frame(buf, Roccom_base::get_function));
  }
  return *func; 
}

Here is the caller graph for this function:

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

protected

Obtains a const reference to an attribute from its handle.

Definition at line 2222 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_FUNCTION_HANDLE, and get_function().

                                                           { 
  const Function *func=NULL;

  if ( handle > 0 && handle<_func_map.size()) 
    func = _func_map[handle];
  if (func==NULL) {
    static char buf[10];
    std::sprintf( buf, "%d", handle);
    throw COM_exception( COM_ERR_INVALID_FUNCTION_HANDLE,
                         append_frame(buf, Roccom_base::get_function));
  }
  return *func; 
}

Here is the call graph for this function:

int get_function_handle	(	const std::string &	wfname	)
throw	(	int
	)

Definition at line 1565 of file Roccom_base.C.

References append_frame, COM_exception::msg, and n.

                                                         {
  int n(-1);
  try {
    if ( _debug) 
      std::cerr << "Roccom: get handle of function \"" << wfname << "\": ";
    std::string wname, fname;
    split_name( wfname, wname, fname);
    
    Function *f = get_window( wname).function( fname);

    if ( f!=NULL) n=_func_map.add_object( wfname, f);

    if ( _debug) {
      if ( n>0) std::cerr << n << std::endl;
      else std::cerr << " not found" << std::endl;      
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_function_handle);
    proc_exception( ex, "");
  }
  return n;
}

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

Obtain a list of all module names.

Definition at line 1322 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

                                                   {
  try {
    if ( _debug) {
      std::cerr << "Roccom: get modules";
      //      if ( rank==-2) std::cerr << " this process";
      //      else if ( rank==-1) std::cerr << " all processes";
      //      else std::cerr << " process " << rank;
      
      std::cerr << std::endl;
    }
    names = _module_map.get_names();
    //    get_window(wname).panes( paneids_vec, rank);

    //    if ( pane_ids) {
    //      *pane_ids = new int[paneids_vec.size()];
    //      std::copy( paneids_vec.begin(), paneids_vec.end(), *pane_ids);
    //    }
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_modules);
    std::string s;
    s = s + "When processing get_modules.";
    proc_exception( ex, s);
  }
}

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

Get the number of arguments of a given function "window.function".

Definition at line 1716 of file Roccom_base.C.

References append_frame, COM_ERR_FUNCTION_NOTEXIST, Function::num_of_args(), and set_member_function().

                                                             {
  std::string wname, fname;
  split_name(wf, wname, fname);
  
  Function *func = get_window( wname).function( fname);
  if ( func==NULL) 
    throw COM_exception( COM_ERR_FUNCTION_NOTEXIST,
                         append_frame(wf, Roccom_base::set_member_function));
  return func->num_of_args();
}

Here is the call graph for this function:

int get_num_arguments	(	const int	wf	)
throw	(	COM_exception
	)

Get the number of arguments of a given function from its handle.

Definition at line 1728 of file Roccom_base.C.

References Function::num_of_args().

                                                      {
  Function *func = &get_function( wf);
  return func->num_of_args();
}

Here is the call graph for this function:

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

Associates an object with a specific window.

Definition at line 648 of file Roccom_base.C.

{
  int strd;
  get_array( wa, pid, ptr, &strd);

  if ( strd <= 1) return; else *(char**)ptr -= strd;
}

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

Obtain the panes of a given window on a specific process.

If rank is -2, then the current process is assumed. If rank is -1, then get the panes on all processes within the window's communicator.

Definition at line 1264 of file Roccom_base.C.

References append_frame, copy, COM_exception::msg, rank, and s.

                                               {
  try {
    if ( _debug) {
      std::cerr << "Roccom: get pane ids of window \"" 
                << wname << "\" on ";
      if ( rank==-2) std::cerr << " this process";
      else if ( rank==-1) std::cerr << " all processes";
      else std::cerr << " process " << rank;

      std::cerr << std::endl;
    }

    get_window(wname).panes( paneids_vec, rank);

    if ( pane_ids) {
      *pane_ids = new int[paneids_vec.size()];
      std::copy( paneids_vec.begin(), paneids_vec.end(), *pane_ids);
    }
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_panes);
    std::string s;
    s = s + "When processing window " + wname;
    proc_exception( ex, s);
  }
}

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

Obtain the parent attribute's name of a given attribute on a given pane.

If the attribute has no parent, then set name to empty.

Definition at line 1431 of file Roccom_base.C.

References append_frame, copy, COM_exception::msg, and s.

{
  try {
    if ( _debug) 
      std::cerr << "Roccom: get parent of attribute \"" << waname 
                << "\" on pane " << pane_id << std::endl;

    std::string wname, aname;
    split_name( waname, wname, aname);

    get_window( wname).get_parent( aname, pane_id, str);

    if ( name) {
      *name = new char[str.size()+1];
      std::copy( str.begin(), str.end(), *name);
      (*name)[str.size()]=0;
    }

    if ( _debug) 
      std::cerr << "Roccom: Got parent name: " << str << std::endl;

    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_parent);
    std::string s;
    s = s + "When processing attribute " + waname;
    proc_exception( ex, s);
  }
}

Roccom_base * get_roccom ( )

inlinestatic

Get a pointer to the Roccom object.

Definition at line 505 of file Roccom_base.h.

References roccom_base.

Referenced by finalize(), get_default_communicator(), initialized(), and set_default_communicator().

{ return roccom_base; }

Here is the caller graph for this function:

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

Get the sizes of an attribute. The opposite of set_size.

Definition at line 988 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Get size for attribute \"" 
                << wa << '"' << " for pane " << pid << std::endl;
    }

    // Invoke Window::get_size
    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).get_size( aname, pid, nitems, ng);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_size);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

int get_sizeof ( COM_Type  type, int  count = 1  )

static

Gets the size of the data type given by its index.

See Also

DDT

Definition at line 2162 of file Roccom_base.C.

References Attribute::get_sizeof().

{ return Attribute::get_sizeof( type, count); }

Here is the call graph for this function:

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

Get the status of an attribute.

If the attribute name is empty, and pane ID is 0, then checks whether the window exist (return 0 if does and -1 if not); if attribute name is empty and pane ID is >0, then check whether check whether the given pane exists (return 0 if so and -1 if not). Otherwise, it checks the status of an attribute and returns one of the following values: -1: not exist. 0: not yet initialized 1: set by the user. 2: set by the user with const modifier. 3: inherited from (i.e., use) another attribute. 4: allocated by Roccom.

Definition at line 1055 of file Roccom_base.C.

References append_frame, Window::get_status(), COM_exception::msg, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Get status for attribute \"" 
                << wa << '"' << " on pane " << pid << std::endl;
    }

    std::string wname, aname;
    split_name( wa, wname, aname, false);

    Window **w = _window_map.find( wname).second;

    if ( aname.empty() && pid == 0) {
      if ( w == NULL) return -1;
      else return 0;
    }

    int status = (**w).get_status( aname, pid);

    if ( _debug) {
      std::cerr << "Roccom: ";
      std::cerr << " status is " << status << std::endl;
    }

    _errorcode = 0;
    return status;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_status);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }

  return 0;
}

Here is the call graph for this function:

int get_verbose ( ) const

inline

Determines whether verbose is on.

Definition at line 378 of file Roccom_base.h.

{ return _verbose; }

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

protected

Obtains a reference to the Window object from its name.

Definition at line 2166 of file Roccom_base.C.

References append_frame, and COM_ERR_WINDOW_NOTEXIST.

Referenced by get_window(), and get_window_object().

{
  Window **w = _window_map.find( wname).second;
  if ( w ==NULL) 
    throw COM_exception( COM_ERR_WINDOW_NOTEXIST,
                         append_frame(wname, Roccom_base::get_window));
  return **w;
}

Here is the caller graph for this function:

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

inlineprotected

Obtains a constant reference to the Window object from its name.

Definition at line 436 of file Roccom_base.h.

References get_window().

  { return const_cast<Roccom_base*>(this)->get_window(wname); }

Here is the call graph for this function:

int get_window_handle	(	const std::string &	wname	)
throw	(	int
	)

Definition at line 1471 of file Roccom_base.C.

References append_frame, COM_assertion, COM_exception::msg, and n.

Referenced by get_window_object().

                                                      { 
  int n(-1);
  try {
    if ( _debug) 
      std::cerr << "Roccom: get handle of window \"" << wname << "\": ";
    std::pair<int,Window**> obj = _window_map.find( wname);
    COM_assertion(obj.first<0 || (*obj.second)->name()==wname);

    if ( obj.first>=0)
      n = obj.first+1; 
    
    if ( _debug) {
      if ( n>0) std::cerr << n << std::endl;
      else std::cerr << " not found" << std::endl;      
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_window_handle);
    proc_exception( ex, "");
  }
  return n;
}

Here is the caller graph for this function:

Window * get_window_object	(	int	hdl	)
throw	(	int
	)

Definition at line 1495 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_WINDOW_HANDLE, and get_window().

Referenced by get_window_object().

{
  if ( hdl <= 0) 
    throw COM_exception( COM_ERR_INVALID_WINDOW_HANDLE,
                         append_frame("", Roccom_base::get_window));
  return _window_map[hdl-1];
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Window * get_window_object	(	int	hdl	)	const
throw	(	int
	)

Definition at line 1504 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_WINDOW_HANDLE, and get_window_object().

{
  if ( hdl <= 0) 
    throw COM_exception( COM_ERR_INVALID_WINDOW_HANDLE,
                         append_frame("", Roccom_base::get_window_object));
  return _window_map[hdl-1];
}

Here is the call graph for this function:

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

inline

Definition at line 301 of file Roccom_base.h.

References get_window_handle(), and get_window_object().

  { return get_window_object( get_window_handle( wname)); }

Here is the call graph for this function:

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

inline

Definition at line 303 of file Roccom_base.h.

References get_window_handle(), and get_window_object().

  { return get_window_object( const_cast<Roccom_base*>(this)->
                              get_window_handle( wname)); }

Here is the call graph for this function:

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

Obtain a list of all window names.

Definition at line 1294 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

                                                   {
  try {
    if ( _debug) {
      std::cerr << "Roccom: get windows";
      //      if ( rank==-2) std::cerr << " this process";
      //      else if ( rank==-1) std::cerr << " all processes";
      //      else std::cerr << " process " << rank;
      
      std::cerr << std::endl;
    }
    names = _window_map.get_names();
    //    get_window(wname).panes( paneids_vec, rank);

    //    if ( pane_ids) {
    //      *pane_ids = new int[paneids_vec.size()];
    //      std::copy( paneids_vec.begin(), paneids_vec.end(), *pane_ids);
    //    }
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::get_windows);
    std::string s;
    s = s + "When processing get_windows.";
    proc_exception( ex, s);
  }
}

void icall_function ( int  wf, int  count, void *  args[], int *  reqid, const int *  lens = NULL  ) throw ( int )

inline

Nonblockingly invoke a function with given arguments.

Parameters

wf	the handle to the function.
count	the number of input arguments.
args	the addresses to the arguments.
reqid	is set to the request of the current call.
lens	the lengths of character strings.

Definition at line 364 of file Roccom_base.h.

References call_function().

  { *reqid = 0; call_function( wf, count, args, lens); }

Here is the call graph for this function:

void init ( int *  argc, char ***  argv  ) throw ( int )

static

Definition at line 186 of file Roccom_base.C.

References COM_ERR_WAS_INITIALIZED, and printStackBacktrace().

Referenced by COM_F_FUNC2().

                                                            {
  extern void printStackBacktrace();

  COM::Roccom_base *ptr = get_roccom();
  if ( ptr) throw( COM_ERR_WAS_INITIALIZED);

  ptr = new COM::Roccom_base( argc, argv);
  
  set_roccom( ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool initialized ( )

inlinestatic

Checks whether Roccom has been initialized.

Definition at line 82 of file Roccom_base.h.

References get_roccom().

Referenced by COM_F_FUNC2().

{ return get_roccom()!=NULL; }

Here is the call graph for this function:

Here is the caller graph for this function:

void load_module	(	const std::string &	lname,
		const std::string &	wname
	)
throw	(	int
	)

Load a module.

Definition at line 211 of file Roccom_base.C.

References COM_ERR_COULD_FINDSYM, COM_ERR_COULD_OPENLIB, i, iend, MPI_COMM_SELF, and swap().

{
#ifndef STATIC_LINK
  if ( _debug) 
    std::cerr << "Roccom: Loading module " << lname 
              << " with arguments " << wname << "..." << std::endl;

  void *handle;
  std::string lname_found;

  // Obtain a reference to the library.
  int index = _module_map.find(lname).first;
  if ( index<0) { // Load the library
    std::string lname_short = std::string("lib") + lname + ".so";
    std::string lname_full = _libdir + lname_short;

    // Open the library
    handle = dlopen( lname_full.c_str(), RTLD_LAZY);
    if (handle == NULL)
      std::cerr << "dlopen error: " << dlerror() << std::endl;

    if ( handle == NULL && !_libdir.empty()) {
      handle = dlopen( lname_short.c_str(), RTLD_LAZY);
      if (handle == NULL)
        std::cerr << "dlopen error: " << dlerror() << std::endl;
      lname_found = lname_short;
    }
    else 
      lname_found = lname_full;
    

    if ( handle == NULL) {
      std::string libs;
      if ( _libdir.empty()) libs = lname_full;
      else libs = lname_full+" or "+lname_short;

      proc_exception( COM_exception(COM_ERR_COULD_OPENLIB, libs),
                      "Roccom_base::load_module");
    }

    // Insert a new entry into _module_map.
    index = _module_map.add_object( lname, Module_map::value_type());
    _module_map[index].first = handle;
  }
  else
    handle = _module_map[index].first;
  
  // Insert the handle and the window name into _module_map.
  _module_map[index].second.insert(wname);
  
  // Look for the symbol
  std::string fname = lname + "_load_module";

  // Set the default communicator to MPI_COMM_SELF
  MPI_Comm comm = MPI_COMM_SELF; 
  std::swap(_comm, comm);

  void *fptr = dlsym( handle, fname.c_str());
  if ( fptr != NULL) {
    // This is a C/C++ module
    typedef void(*Func1)(const char*);
    (*(Func1)fptr)( wname.c_str());
  }
  else {
    // Try out different name mangling schemes to figure out automatically.
    int ibegin= ( _f90_mangling == -1 ) ? 0 : _f90_mangling;
    int iend = (_f90_mangling == -1) ? 4: _f90_mangling;

      // 0: lowercase
      // 1: uppercase
      // 2: _
      // 3: uppercase _
      // 4: lowercase __
    for ( int i=ibegin; i<=iend; ++i) {
      if ( i & 1 == 1)
        std::transform( fname.begin(), fname.end(), fname.begin(), toupper);
      else
        std::transform( fname.begin(), fname.end(), fname.begin(), tolower);

      if ( i==2 || (i==3&&i==ibegin)) fname.append( "_");
      if (i==4) { fname.append( "_"); if (ibegin == 4) fname.append( "_"); }

      fptr = dlsym( handle, fname.c_str());
      if ( fptr) { _f90_mangling = i; break; }
    }

    if ( fptr != NULL) {
      // This is a Fortran module
      typedef void(*Func2)(const char*,long int);
      (*(Func2)fptr)( wname.c_str(), wname.size());
    }
    else {
      std::string msg;
      if ( ibegin == iend) msg = fname+" in "+lname_found;
      else msg = fname + " or any its lowercase w/o underscore in " + lname;

      msg.append( "\nError message from libdl is: ");
      msg.append( dlerror());
      proc_exception( COM_exception(COM_ERR_COULD_FINDSYM, msg),
                      "Roccom_base::load_module");
    }
  }

  // Restore the default communicator.
  std::swap(_comm, comm);

  if ( _debug) 
    std::cerr << "Roccom: Module " << lname << " loaded." << std::endl;
#endif
}

Here is the call graph for this function:

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

Creates a new attribute for a window.

Definition at line 516 of file Roccom_base.C.

References append_frame, COM_exception::msg, print_type(), and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: new attribute \"" << wa
                << "\"\nRoccom:\tLocation: " << loc << "\nRoccom:\tType: ";
      print_type( std::cerr, type);
      std::cerr << "\nRoccom:\tSize: " << size << "\nRoccom:\tUnit: \"" << unit << "\""
                << std::endl;
    }

    // Invoke Window::new_attribute.
    std::string wname, aname;
    split_name( wa, wname, aname);
    
    get_window( wname).new_attribute( aname, loc, type, size, unit);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::new_attribute);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

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

Creates a window with given name.

Definition at line 399 of file Roccom_base.C.

References append_frame, COM_WARN_DUP_WINDOW, COM_exception::msg, and s.

{
  // If MPI_COMM_NULL is used, then use the default communicator.
  if ( comm == MPI_COMM_NULL) comm = _comm;

  try {
    if ( _debug) 
      std::cerr << "Roccom: Creating window \"" << name << '"' 
                << " with communicator " << comm << std::endl;
    
    if ( _window_map.find( name).second) 
      throw COM_exception( COM_WARN_DUP_WINDOW,
                           append_frame(name, Roccom_base::new_window));
    
    _window_map.add_object( name, new Window( name, comm));
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::new_window);
    std::string s("When processing "); s.append(name);
    proc_exception( ex, s);
  }
}

void print_profile	(	const std::string &	fname,
		const std::string &	header
	)

Definition at line 2106 of file Roccom_base.C.

References _debug, _func_map, _profile_on, Function_map::counts, cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), i, iend, n, Roccom_map< Object >::name(), Function_map::wtimes_self, and Function_map::wtimes_tree.

                                                                {
  if ( !_profile_on) return;

  if ( _debug){
     std::cerr << "Roccom: Appending profile into file \"" << fname
               << '"' << std::endl;
  }
  std::multimap< double, int>  profs;
  typedef std::multimap< double, int>::value_type MMVT;

  for ( int i=1, n=_func_map.wtimes_self.size(); i<n; ++i) {
    if ( _func_map.wtimes_self[i] > 0.0)
      profs.insert( MMVT( -_func_map.wtimes_self[i], i));
  }

  std::FILE *of = NULL;
  if ( fname.size() == 0)
    of = stdout;
  else {
    of = std::fopen( fname.c_str(), "a");
    if ( of == NULL) {
      std::cerr << "Roccom: Could not open file \"" << fname
                << "\"\nRoccom: Giving up profiling" << std::endl;
      _profile_on = false; return;
    }
  }
  std::fputc('\n', of);

  if ( header.size() == 0)
    std::fputs( "************************Roccom simple profiling tool\
************************", of);
  else
    std::fputs( header.c_str(), of);

  std::fprintf( of, "\n%32s%12s%14s%14s\n", "Function", "#calls", 
                "Time(tree)", "Time(self)");
  std::fputs( "-------------------------------------------------------\
---------------------\n", of);

  std::multimap< double, int>::const_iterator i, iend;
  for ( i=profs.begin(), iend=profs.end(); i!=iend; ++i) {
    std::fprintf( of, "%32.32s%12d%14g%14g\n", 
                  _func_map.name(i->second).c_str(),
                  _func_map.counts[i->second], 
                  _func_map.wtimes_tree[i->second],
                  _func_map.wtimes_self[i->second]);
  }
  std::fputs( "-------------------------------------------------------\
---------------------\n", of);
  std::fprintf( of, "%32s%40g\n", "Total(top level calls)", 
                _func_map.wtimes_tree[0]);

  if ( of != stdout) std::fclose( of);
}

Here is the call graph for this function:

void proc_exception ( const COM_exception &  ex, const std::string &  s  ) throw ( int )

protected

Definition at line 2259 of file Roccom_base.C.

References printStackBacktrace(), and s.

Referenced by set_profiling_barrier().

{
  extern void printStackBacktrace();
  _errorcode = ex.ierr;

  std::cerr << "\nRoccom:" << ex << s << std::endl;
  if ( _exception_on && _errorcode>=1000) {
    printStackBacktrace();
    throw ex.ierr;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Resize an attribute on a specific pane and return the address by setting addr.

Resize for all panes if pane-id is 0, in which case, do not set addr. The difference between resize and allocate is that resize will reallocate memory only if the current array cannot accomodate the requested capacity.

Definition at line 727 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

                                                                           {
  try {
    if ( _debug) {
      std::cerr << "Roccom: Resize array for \"" << wa << "\" on pane " 
                << pid << " with stride ";
      if ( strd<0) std::cerr << "==current";
      else if (strd) std::cerr << strd;
      else std::cerr << "==#components";

      std::cerr << " and capacity ";

      if ( cap) std::cerr << cap;
      else std::cerr << "==#items";

      std::cerr << std::endl;
    }

    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).resize_array( aname, pid, addr, strd, cap);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::resize_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

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
	)

Associates an array with an attribute for a specific pane.

Definition at line 658 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Set array for \"" << wa << "\" on pane " 
                << pid << " to " << addr << " with stride ";
      if ( strd) std::cerr << strd;
      else std::cerr << "==#components";

      std::cerr << " and capacity ";

      if ( cap) std::cerr << cap;
      else std::cerr << "==#items";

      std::cerr << std::endl;
    }

    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).set_array( aname, pid, addr, strd, cap, is_const);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_array);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

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

inline

Definition at line 146 of file Roccom_base.h.

Referenced by set_bounds().

  { set_bounds( wa, pane_id, (const void*)&lbnd, (const void*)&ubnd); }

Here is the caller graph for this function:

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

inline

Definition at line 151 of file Roccom_base.h.

References set_bounds().

  { set_bounds( wa, pane_id, (const void*)&lbnd, (const void*)&ubnd); }

Here is the call graph for this function:

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

Definition at line 691 of file Roccom_base.C.

{}

void set_debug ( bool  debug )

inline

Turns on debuging messages.

Definition at line 389 of file Roccom_base.h.

References _debug.

                                 {
    _debug = debug;
  }

static void set_default_communicator ( MPI_Comm  comm )

inlinestatic

Set the default communicator of Roccom.

This communicator will be used as the default communicator for any new window.

Definition at line 71 of file Roccom_base.h.

References _comm, and get_roccom().

Referenced by COM_F_FUNC2().

  { get_roccom()->_comm = comm; }

Here is the call graph for this function:

Here is the caller graph for this function:

void set_f90pointer	(	const std::string &	waname,
		void *	ptr,
		Func_ptr	f,
		long int	l
	)
throw	(	int
	)

Definition at line 1147 of file Roccom_base.C.

References append_frame, COM_assertion_msg, COM_ERR_NOT_A_POINTER, COM_ERR_NOT_A_WINDOW_ATTRIBUTE, COM_F90POINTER, Attribute::data_type(), get_sizeof(), i, Attribute::location(), COM_exception::msg, n, ni, Attribute::pointer(), and Attribute::size_of_components().

                                                     {
  try {
    if ( _debug) 
      std::cerr << "Roccom: set pointer \"" << waname 
                << " to " << ptr << std::endl;

    std::string wname, aname;
    split_name( waname, wname, aname);

    Attribute *a = get_window( wname).attribute( aname);
    if ( a->location() != 'w')
      throw COM_exception( COM_ERR_NOT_A_WINDOW_ATTRIBUTE,
                           append_frame(waname, Roccom_base::set_f90pointer));
    if ( a->data_type() == COM_F90POINTER) {
      int n=get_sizeof(COM_F90POINTER, a->size_of_components());

      std::pair<int,int> offs = get_f90pntoffsets( a);
      std::memcpy( a->pointer(), (char*)ptr-offs.first, offs.second);

      if ( offs.second<n) {
        *(void**)((char*)a->pointer()+offs.second) = 
          (char*)a->pointer()+offs.first+((char*)len-(char*)ptr);
      }
      
      COM_assertion_msg( _f90ptr_treat>=0, "No F90 pointer initalized");
      if ( _f90ptr_treat == FPTR_INSERT || _f90ptr_treat == FPTR_APPEND) {
        typedef void(*Func2)(void*,void*, long int, long int);
        *(void**)((char*)a->pointer()+offs.first)=NULL;
        (*(Func2)f)( ptr, (char*)a->pointer()+offs.first, 
                     len, *(long int*)((char*)a->pointer()+offs.second));
      }
      else {
        typedef void(*Func2)(void*,void*);
        (*(Func2)f)( (char*)ptr+offs.first, a->pointer());
      }

      if ( _debug) {
        std::cerr << "Roccom: copied values ";
        for ( int i=0, ni=n/sizeof(void*); i<ni; ++i) 
          std::cerr << ((void**)a->pointer())[i] << ' ';
        std::cerr << std::endl;
      }
    }
    else
      throw COM_exception( COM_ERR_NOT_A_POINTER,
                           append_frame(waname, Roccom_base::set_f90pointer));
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_f90pointer);
    proc_exception( ex, "");
  }
}

Here is the call graph for this function:

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

Registers a function to the window.

The names of the window and the function is give by wf in the format of "window.function" (null terminated). The address is given by ptr. The last two arguments specifies the number of the arguments, the intentions and types of the arguments.

Definition at line 1589 of file Roccom_base.C.

References append_frame, COM_ERR_TOO_MANY_ARGS, COM_ERR_UNKNOWN_DATATYPE, COM_ERR_UNKNOWN_INTENT, COM_MAX_TYPEID, COM_MIN_TYPEID, COMMPI_Comm_rank(), i, Function::MAX_NUMARG, MPI_COMM_WORLD, COM_exception::msg, n, print_type(), rank, and s.

Referenced by set_member_function_helper().

                                                                           {
  int rank = COMMPI_Comm_rank( MPI_COMM_WORLD);
  try { 
    if ( _debug) {
      int n=intents.size();
      std::cerr << "Roccom: init function \"" << wfname << '"'
                << " to " << ptr << " with " << n << " parameters";

      for ( int i=0; i<n; ++i) {
        std::cerr << "\nRoccom:\t" << intents[i] << ":";
        print_type( std::cerr, types[i]);
      }
      std::cerr << std::endl;
    }
    std::string wname, fname;
    split_name( wfname, wname, fname);

    if ( intents.size() > Function::MAX_NUMARG) 
      throw COM_exception( COM_ERR_TOO_MANY_ARGS,
                           append_frame(wfname, Roccom_base::set_function));

    for ( int i=0, size=intents.size(); i<size; ++i) {
      if (intents[i] != 'i' && intents[i] != 'o' && intents[i] != 'b' && 
          intents[i] != 'I' && intents[i] != 'O' && intents[i] != 'B')
        throw COM_exception( COM_ERR_UNKNOWN_INTENT,
                             append_frame(wfname, Roccom_base::set_function));
      if ( types[i] < COM_MIN_TYPEID || types[i] > COM_MAX_TYPEID)
        throw COM_exception( COM_ERR_UNKNOWN_DATATYPE,
                             append_frame(wfname, Roccom_base::set_function));
    }
    
    get_window( wname).set_function( fname, ptr, intents, types, NULL, ff);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_function);
    std::string s;
    s = s + "When processing attribute " + wfname;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 2064 of file Roccom_base.C.

References i.

                                                   {
  _func_map.verbs[i] = level;
}

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
	)

Definition at line 1695 of file Roccom_base.C.

Referenced by get_num_arguments(), and set_member_function_helper().

                                                           {
  set_member_function_helper( wfname, ptr, waname, 
                              intents, types, ff);
}

Here is the caller graph for this function:

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
	)

Definition at line 1705 of file Roccom_base.C.

                                                           {
  set_member_function_helper( wfname, ptr, waname, 
                              intents, types, ff);
}

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 )

protected

Definition at line 1636 of file Roccom_base.C.

References append_frame, COM_ERR_ATTRIBUTE_NOTEXIST, COM_ERR_F90FUNC, COM_ERR_TOO_MANY_ARGS, COM_ERR_UNKNOWN_DATATYPE, COM_ERR_UNKNOWN_INTENT, COM_F90POINTER, COM_MAX_TYPEID, COM_MIN_TYPEID, Attribute::data_type(), i, Function::MAX_NUMARG, COM_exception::msg, n, print_type(), s, set_function(), and set_member_function().

                                                {
  try {
    if ( _debug) {
      int n=intents.size();
      std::cerr << "Roccom: init function \"" << wfname  << '"'
                << " to " << ptr << " with " << n << " parameters";
      for ( int i=0; i<n; ++i) {
        std::cerr << "\nRoccom:\t" << intents[i] << ":";
        print_type( std::cerr, types[i]);
        if ( i==0) std::cerr << "\t\"" << waname << "\"";
      }
      std::cerr << std::endl;
    }
    std::string wname, fname;
    split_name( wfname, wname, fname);

    // Allows an additional implicit argument
    if ( intents.size() > Function::MAX_NUMARG+1) 
      throw COM_exception( COM_ERR_TOO_MANY_ARGS,
                           append_frame(wfname, Roccom_base::set_member_function));

    for ( int i=0, size=intents.size(); i<size; ++i) {
      if (intents[i] != 'i' && intents[i] != 'o' && intents[i] != 'b' && 
          intents[i] != 'I' && intents[i] != 'O' && intents[i] != 'B')
        throw COM_exception( COM_ERR_UNKNOWN_INTENT,
                             append_frame(wfname, Roccom_base::set_member_function));
      if ( types[i] < COM_MIN_TYPEID || types[i] > COM_MAX_TYPEID)
        throw COM_exception( COM_ERR_UNKNOWN_DATATYPE,
                             append_frame(wfname, Roccom_base::set_member_function));
    }
    
    std::string wname1, aname1;
    split_name( waname, wname1, aname1);
    
    Attribute *a = get_window( wname1).attribute( aname1);

    if ( a==NULL) 
      throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST,
                           append_frame(wfname, Roccom_base::set_member_function));
    if ( !ff && a->data_type()==COM_F90POINTER) 
      throw COM_exception( COM_ERR_F90FUNC,
                           append_frame(wfname, Roccom_base::set_member_function));

    get_window( wname).set_function( fname, ptr, intents, types, a, ff);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_function);
    std::string s;
    s = s + "When processing attribute " + wfname;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

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

Associates an object with a specific window.

Definition at line 625 of file Roccom_base.C.

References COM_Object_derived::cast_obj(), and COM_assertion_msg.

{
  COM_assertion_msg( obj_addr, "Caught NULL pointer");
  int size;
  get_attribute( wa, NULL, NULL, &size, NULL);
  COM_assertion_msg( size==1, "Must register a scalar with set_object");

  if ( obj_addr == casted_addr) {
    set_array( wa, pid, obj_addr);
    return;
  }
  
  if ( _cppobj_casting == -1)
    _cppobj_casting = COM_Object_derived::cast_obj();

  if ( _cppobj_casting) // Use stride to store the offset
    set_array( wa, pid, casted_addr, (char*)casted_addr-(char*)obj_addr);
  else
    set_array( wa, pid, obj_addr);
}

Here is the call graph for this function:

void set_profiling

(

int

i

)

This subroutine turns on (or off) profiling if i==1 (or ==0).

It (re-)initializes all profiling info to 0.

Definition at line 2069 of file Roccom_base.C.

References _debug, _func_map, _profile_on, Function_map::counts, i, Function_map::wtimes_self, and Function_map::wtimes_tree.

                      {
  if ( _debug) 
    std::cerr << "Roccom: init profiling level to " << i << std::endl; 
  _profile_on = i; 
  std::fill(_func_map.wtimes_tree.begin(),_func_map.wtimes_tree.end(), 0);
  std::fill(_func_map.wtimes_self.begin(),_func_map.wtimes_self.end(), 0);
  std::fill(_func_map.counts.begin(),_func_map.counts.end(), 0);
}

void set_profiling_barrier	(	int	hdl,
		MPI_Comm	comm
	)

Definition at line 2079 of file Roccom_base.C.

References _comm, _debug, _func_map, append_frame, COM_ERR_INVALID_FUNCTION_HANDLE, COMMPI_Initialized(), get_function(), COM_exception::msg, Roccom_map< Object >::name(), proc_exception(), Function::set_communicator(), and Roccom_map< Object >::size().

                                               {
  if ( hdl == 0) return;
  try {
    if ( hdl < 0 || hdl>=_func_map.size()) 
      throw COM_exception( COM_ERR_INVALID_FUNCTION_HANDLE);

    if ( _debug){ 
      std::cerr << "Roccom: init profiling barrier for function handle " << hdl
                << std::endl << "Roccom:\tFunction: " << _func_map.name(hdl)
                << " Communicator: " << comm << std::endl; 
    }

    // Set the communicator only if MPI has been initialized. 
    if ( COMMPI_Initialized()) {
      if ( comm==MPI_COMM_NULL) comm = _comm;
      get_function( hdl).set_communicator( comm);
    }
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_profiling_barrier);
    char buf[100];
    std::sprintf( buf, "Could not get function with handle %d", hdl);
    proc_exception( ex, buf);
  }
}

Here is the call graph for this function:

void set_roccom ( Roccom_base *  r )

static

Set the Roccom pointer to the given object.

It was introduced to support processes.

Definition at line 56 of file Roccom_base.C.

References roccom_base.

Referenced by finalize().

{ roccom_base = r; }

Here is the caller graph for this function:

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

Set the sizes of an attribute.

Note that for nodal or elemental data, setting sizes for one such attributes affects all other attributes.

Definition at line 569 of file Roccom_base.C.

References append_frame, COM_exception::msg, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Set size for attribute \"" 
                << wa << '"' << " on pane " << pid 
                << " to " << nitems << " items with " << ng 
                << " ghosts" << std::endl;
    }

    // Invoke Window::set_size
    std::string wname, aname;
    split_name( wa, wname, aname);

    get_window( wname).set_size( aname, pid, nitems, ng);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::set_size);
    std::string s;
    s = s + "When processing attribute " + wa;
    proc_exception( ex, s);
  }
}

void set_verbose ( int  v )

inline

Changes the verbose setting.

Definition at line 384 of file Roccom_base.h.

References _verb1, _verbose, and v.

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

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

protected

Extracts the window and attribute names from "window.attribute".

Returns nonzero if fails.

Definition at line 2236 of file Roccom_base.C.

References append_frame, COM_ERR_INVALID_ATTRIBUTE_NAME, and ni.

{
  std::string::size_type ni = wa.find(".");

  if ( ni == std::string::npos) 
    wname = wa;
  else {
    wname = wa.substr( 0, ni);
    aname = wa.substr( ni+1, wname.size()-ni-1);
  }

  if ( wname.empty() || aname.empty()) 
    if ( tothrow)
      throw COM_exception(COM_ERR_INVALID_ATTRIBUTE_NAME,
                          append_frame(wa,Roccom_base::split_name));
    else
      return 1;

  return 0;
}

int test ( int  )

inline

Test whether a nonblocking call has finished.

Definition at line 371 of file Roccom_base.h.

{ return 1; }

void turn_off_exception ( )

inline

Definition at line 412 of file Roccom_base.h.

References _exception_on.

{ _exception_on = false; }

void turn_on_exception ( )

inline

Definition at line 411 of file Roccom_base.h.

References _exception_on.

{ _exception_on = true; }

void unload_module	(	const std::string &	lname,
		const std::string &	wname,
		int	dodl = 1
	)
throw	(	int
	)

Unload a module.

Definition at line 324 of file Roccom_base.C.

References COM_ERR_COULD_FINDSYM, and COM_ERR_MODULE_NOTLOADED.

                                                                         {

#ifndef STATIC_LINK
  if ( _debug) 
    std::cerr << "Roccom: Unloading module " << lname << "..." << std::endl;

  // Obtain the window name corresponding to the library
  int index = _module_map.find(lname).first;
  if ( index<0)
    proc_exception( COM_exception( COM_ERR_MODULE_NOTLOADED, lname),
                    "Roccom_base::unload_module");

  std::set<std::string> &obj = _module_map[index].second;

  // If the module was loaded multiple times but window name is not 
  // specified, then throw exception.
  if ( wname.empty() && obj.size()>1)
    proc_exception( COM_exception( COM_ERR_MODULE_NOTLOADED, lname),
                    "Roccom_base::unload_module");

  std::set<std::string>::iterator it = wname.empty()?obj.begin():obj.find( wname);

  // If wname is not found, throw exception
  if ( it==obj.end())
    proc_exception( COM_exception( COM_ERR_MODULE_NOTLOADED, lname),
                    "Roccom_base::unload_module");

  // Look for the symbol
  std::string fname = lname + "_unload_module";
  std::string wname_str=wname.size()?wname:*obj.begin();

  void *handle = _module_map[index].first;
  void *fptr = dlsym( handle, fname.c_str());
  if ( fptr != NULL) {
    // This is a C/C++ module
    typedef void(*Func1)(const char*);
    (*(Func1)fptr)( wname_str.c_str());
  }
  else {
    if ( _f90_mangling != -1) {
      if ( _f90_mangling & 1 == 1)
        std::transform( fname.begin(), fname.end(), fname.begin(), toupper);
      else
        std::transform( fname.begin(), fname.end(), fname.begin(), tolower);

      if ( _f90_mangling ==2 || _f90_mangling == 3) fname.append( "_");

      fptr = dlsym( handle, fname.c_str());
    }

    if ( fptr != NULL) {
      // This is a Fortran module
      typedef void(*Func2)(const char*,long int);
      (*(Func2)fptr)( wname_str.c_str(), wname_str.size());
    }
    else {
      proc_exception( COM_exception(COM_ERR_COULD_FINDSYM, fname+" in "+lname),
                      "Roccom_base::unload_module");
    }
  }

  obj.erase( wname);

  if ( dodl && obj.size()==0) { // Unload module if all instances removed.
    dlclose( handle);
    _module_map.remove_object( lname);
  }

  if ( _debug) 
    std::cerr << "Rocccom: Module " << lname << " unloaded" << std::endl;
#endif
}

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

Use the subset of panes of another window of which the given pane attribute has value val.

Definition at line 782 of file Roccom_base.C.

References append_frame, COM_ERR_ATTRIBUTE_NOTEXIST, Attribute::empty(), Pane::INHERIT_USE, COM_exception::msg, ni, and s.

{
  try {
    if ( _debug) {
      std::cerr << "Roccom: Using attribute \"" << pwaname 
                << "\" onto \"" << waname << '"' << std::endl;
    }
    std::string pawname, paaname;
    split_name( pwaname, pawname, paaname);

    std::string awname, aaname;
    std::string::size_type ni = waname.find(".");
    if ( ni == std::string::npos) {
      awname = waname; aaname = "";
    }
    else 
      split_name( waname, awname, aaname);

    std::string cawname, caaname;
    if ( cndname && *cndname!=0)
      split_name( cndname, cawname, caaname);
    
    Attribute *cnd=caaname.empty()?NULL:get_window(cawname).attribute(caaname);
    if ( !caaname.empty() && cnd==NULL)
      throw COM_exception( COM_ERR_ATTRIBUTE_NOTEXIST, cndname);

    get_window(awname).inherit( get_window( pawname).attribute(paaname), 
                                aaname, Pane::INHERIT_USE, withghost, cnd, val);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::use_attribute);
    std::string s;
    s = s + "When window " + waname + " uses attribute " + pwaname;
    proc_exception( ex, s);
  }
}

Here is the call graph for this function:

void wait ( int  )

inline

Wait for the completion of a nonblocking call.

Definition at line 369 of file Roccom_base.h.

{}

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

Marks the end of the registration of a window.

Definition at line 424 of file Roccom_base.C.

References append_frame, and COM_exception::msg.

{
  try {
    get_window( wname).init_done(panechanged);
    _errorcode = 0;
  }
  catch ( COM_exception ex) {
    ex.msg = append_frame( ex.msg, Roccom_base::window_init_done);

    std::string msg = std::string("When completing the init of window ")+wname;
    proc_exception( ex, msg);
  }
  if ( _debug) 
    std::cerr << "Roccom: Done creating window \"" << wname 
              << '"' << std::endl;
}

Member Data Documentation

Attribute_map _attr_map

protected

Definition at line 472 of file Roccom_base.h.

MPI_Comm _comm

protected

Default communicator of Roccom.

Definition at line 481 of file Roccom_base.h.

Referenced by get_default_communicator(), set_default_communicator(), and set_profiling_barrier().

int _cppobj_casting

protected

Treatement of C++ objects.

-1: Unknown 0: No casting to COM_Object 1: Casting to COM_Object

Definition at line 494 of file Roccom_base.h.

bool _debug

protected

Indicated whether debug mode is on.

Definition at line 480 of file Roccom_base.h.

Referenced by get_debug(), print_profile(), set_debug(), set_profiling(), and set_profiling_barrier().

int _depth

protected

Depth of procedure calls.

Definition at line 477 of file Roccom_base.h.

int _errorcode

protected

Error code.

Definition at line 483 of file Roccom_base.h.

Referenced by get_error_code().

bool _exception_on

protected

Indicates whether Roccom should throw exception.

Definition at line 484 of file Roccom_base.h.

Referenced by turn_off_exception(), and turn_on_exception().

int _f90_mangling

protected

Encoding name mangling.

-1: Unknown. 0: lower-case without appending 1: upper-case without appending 2: lower-case with appending 3: upper-case with appending

Definition at line 487 of file Roccom_base.h.

int _f90ptr_treat

protected

Treatement of F90 pointers.

Definition at line 493 of file Roccom_base.h.

Referenced by COM_F_FUNC2(), f90ptr_treat(), and get_f90pntoffsets().

Function_map _func_map

protected

Definition at line 473 of file Roccom_base.h.

Referenced by print_profile(), set_profiling(), and set_profiling_barrier().

std::string _libdir

protected

Library directory.

Definition at line 475 of file Roccom_base.h.

Module_map _module_map

protected

Definition at line 470 of file Roccom_base.h.

bool _mpi_initialized

protected

Indicates whether MPI was initialized by Roccom.

Definition at line 482 of file Roccom_base.h.

Referenced by ~Roccom_base().

bool _profile_on

protected

Indicates whether should profile.

Definition at line 485 of file Roccom_base.h.

Referenced by print_profile(), and set_profiling().

std::vector<double> _timer

protected

Timers for function calls.

Definition at line 476 of file Roccom_base.h.

int _verb1

protected

Indicates whether to print detailed information.

Definition at line 479 of file Roccom_base.h.

Referenced by set_verbose().

int _verbose

protected

Indicates whether verbose is on.

Definition at line 478 of file Roccom_base.h.

Referenced by set_verbose().

Window_map _window_map

protected

Definition at line 471 of file Roccom_base.h.

COM_BEGIN_NAME_SPACE Roccom_base * roccom_base =NULL

staticprotected

Definition at line 499 of file Roccom_base.h.

Referenced by get_roccom(), and set_roccom().

---

The documentation for this class was generated from the following files:

• Roccom_base.h
• Roccom_base.C