RTOp.h

/*
// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER
*/

/* If the macro RTOp_USE_MPI is defined, then these */
/* declarations will be MPI compatible.  If not then */
/* dummy MPI declarations will be used. */
/* */

#ifndef REDUCT_TRANS_VECTOR_OPERATORS_H
#define REDUCT_TRANS_VECTOR_OPERATORS_H

#include <stddef.h>
#include <stdio.h>
#include <assert.h>

#include "RTOp_MPI_config.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifdef MPIAPI
#define CALL_API MPIAPI
#else
#define CALL_API 
#endif

typedef Teuchos_Ordinal RTOp_index_type;
typedef double RTOp_value_type;
typedef char RTOp_char_type;



typedef void*   RTOp_ReductTarget;     /*< The type for reduction target objects. */
#define         RTOp_REDUCT_OBJ_NULL 0 /*< Value given to a a \c NULL reduction target object */
#define         RTOp_NUM_DATA_TYPES 3  /*< Number of primative data types used in \c RTOp */
/* */
typedef void (CALL_API *RTOp_reduct_op_func_ptr_t) ( void *, void *, int *, RTOp_Datatype * ); 


/* */
#define RTOp_ERR_INVALID_USAGE            -1
/* */
#define RTOp_ERR_INVALID_NUM_VECS         -2
/* */
#define RTOp_ERR_INVALID_NUM_TARG_VECS    -3
/* */
#define RTOp_ERR_INCOMPATIBLE_VECS        -5
/* */
#define RTOp_SERVER_INCOMPATIBLE_OPS      -6
/* */
#define RTOp_SERVER_OP_NAME_TOO_LONG      -7

/* */
struct RTOp_SubVector {
  /* Offset for the sub-vector into the global vector */
  RTOp_index_type                  global_offset;
  /* Dimension of the sub-vector */
  RTOp_index_type                  sub_dim;
  /* Array (size min{|<tt>value_stride*sub_nz</tt>|,1}) for the values in the vector */
  const RTOp_value_type            *values;
  /* Stride between elements in <tt>values[]</tt> */
  ptrdiff_t                        values_stride;
};
/* */
struct RTOp_MutableSubVector {
  /* Offset for the sub-vector into the global vector */
  RTOp_index_type                  global_offset;
  /* Dimension of the sub-vector */
  RTOp_index_type                  sub_dim;
  /* Array (size min{|<tt>value_stride*sub_dim</tt>|,1}) for the values in the vector */
  RTOp_value_type                  *values;
  /* Stride between elements in <tt>values[]</tt> */
  ptrdiff_t                        values_stride;
};
/* */
void RTOp_sub_vector(
  RTOp_index_type global_offset, RTOp_index_type sub_dim
  ,const RTOp_value_type values[], ptrdiff_t values_stride
  ,struct RTOp_SubVector *sub_vec
  );
/* */
void RTOp_sub_vector_null( struct RTOp_SubVector *sub_vec );
/* */
void RTOp_mutable_sub_vector(
  RTOp_index_type global_offset, RTOp_index_type sub_dim
  ,RTOp_value_type values[], ptrdiff_t values_stride
  ,struct RTOp_MutableSubVector *sub_vec
  );
/* */
void RTOp_mutable_sub_vector_null( struct RTOp_MutableSubVector *sub_vec );


struct RTOp_RTOp;

/* */
int RTOp_get_op_name(
  const struct RTOp_RTOp* op
  ,const char** op_name
  );

/* */
int RTOp_get_op_type_num_entries(
  const struct RTOp_RTOp* op
  ,int* num_values
  ,int* num_indexes
  ,int* num_chars
  );

/* */
int RTOp_extract_op_state(
  const struct RTOp_RTOp    *op
  ,int                      num_values
  ,RTOp_value_type          value_data[]
  ,int                      num_indexes
  ,RTOp_index_type          index_data[]
  ,int                      num_chars
  ,RTOp_char_type           char_data[]
  );
/* */
int RTOp_load_op_state(
  int                       num_values
  ,const RTOp_value_type    value_data[]
  ,int                      num_indexes
  ,const RTOp_index_type    index_data[]
  ,int                      num_chars
  ,const RTOp_char_type     char_data[]
  ,struct RTOp_RTOp*        op
  );
/* */
int RTOp_free_op( struct RTOp_RTOp* op );
/* */
int RTOp_get_reduct_type_num_entries(
  const struct RTOp_RTOp     *op
  ,int                       *num_values
  ,int                       *num_indexes
  ,int                       *num_chars
  );
/* */
int RTOp_reduct_obj_create(
  const struct RTOp_RTOp   *op
  ,RTOp_ReductTarget       *reduct_obj
  );
/* */
int RTOp_reduct_obj_reinit(
  const struct RTOp_RTOp    *op
  ,RTOp_ReductTarget        reduct_obj
  );
/* */
int RTOp_reduct_obj_free( const struct RTOp_RTOp* op
  , RTOp_ReductTarget* reduct_obj );
/* */
int RTOp_extract_reduct_obj_state(
  const struct RTOp_RTOp    *op
  ,const RTOp_ReductTarget  reduct_obj
  ,int                      num_values
  ,RTOp_value_type          value_data[]
  ,int                      num_indexes
  ,RTOp_index_type          index_data[]
  ,int                      num_chars
  ,RTOp_char_type           char_data[]
  );
/* */
int RTOp_load_reduct_obj_state(
  const struct RTOp_RTOp   *op
  ,int                     num_values
  ,const RTOp_value_type   value_data[]
  ,int                     num_indexes
  ,const RTOp_index_type   index_data[]
  ,int                     num_chars
  ,const RTOp_char_type    char_data[]
  ,RTOp_ReductTarget       reduct_obj
  );
/* */
int RTOp_coord_invariant(
  const struct RTOp_RTOp   *op
  ,int                     *coord_invariant
  );
/* */
int RTOp_apply_op(
  const struct RTOp_RTOp                  *op
  ,const int                              num_vecs
  ,const struct RTOp_SubVector            sub_vecs[]
  ,const int                              num_targ_vecs
  ,const struct RTOp_MutableSubVector     targ_sub_vecs[]
  ,RTOp_ReductTarget                      reduct_obj
  );
/* */
int RTOp_reduce_reduct_objs(
  const struct RTOp_RTOp     *op
  ,RTOp_ReductTarget         in_reduct_obj
  ,RTOp_ReductTarget         inout_reduct_obj
  );
/* */
int RTOp_get_reduct_op(
  const struct RTOp_RTOp       *op
  ,RTOp_reduct_op_func_ptr_t   *reduct_op_func_ptr
  );


struct RTOp_RTOp_vtbl_t;

/* */
struct RTOp_RTOp {
  /* Pointer to the object data for an instantiation */
  void                           *obj_data;
  /* Pointer to the virtual function table */
  const struct RTOp_RTOp_vtbl_t  *vtbl;
};

/* */
struct RTOp_RTOp_vtbl_t {
  /* Pointer to the virtual function table for the operator object instance data. */
  const struct RTOp_obj_type_vtbl_t  *obj_data_vtbl;
  /* Pointer to the virtual function table for the manipulation of the reduction object. */
  const struct RTOp_obj_type_vtbl_t  *reduct_vtbl;
  /* */
  const char* op_name;
  /* */
  int (*reduct_obj_reinit)(
    const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
    ,RTOp_ReductTarget reduct_obj );
/*  /// Called by <tt>RTOp_coord_invariant()</tt> */
/*  int (*coord_invariant) ( */
/*    const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data */
/*    ,int *coord_invariant ); */
  /* Called by <tt>RTOp_apply_op()</tt> */
  int (*apply_op)(
    const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
    ,const int num_vecs, const struct RTOp_SubVector sub_vecs[]
    ,const int num_targ_vecs, const struct RTOp_MutableSubVector targ_sub_vecs[]
    ,RTOp_ReductTarget reduct_obj );
  /* Called by <tt>RTOp_reduce_reduct_objs()</tt> */
  int (*reduce_reduct_objs)(
    const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
    ,RTOp_ReductTarget in_reduct_obj, RTOp_ReductTarget inout_reduct_obj );
  /* Called by <tt>RTOp_get_reduct_op()</tt> */
  int (*get_reduct_op)(
    const struct RTOp_RTOp_vtbl_t* vtbl, const void* obj_data
    ,RTOp_reduct_op_func_ptr_t* reduct_op_func_ptr );
};

/* */
struct RTOp_obj_type_vtbl_t {
  /* */
  int (*get_obj_type_num_entries)(
    const struct RTOp_obj_type_vtbl_t    *vtbl
    ,const void*                         instance_data
    ,int*                                num_values
    ,int*                                num_indexes
    ,int*                                num_chars
    );
  /* */
  int (*obj_create)(
    const struct RTOp_obj_type_vtbl_t   *vtbl
    ,const void                         *instance_data
    ,void                               ** obj
    );
  /* */
  int (*obj_reinit)(
    const struct RTOp_obj_type_vtbl_t    *vtbl
    ,const void                          *instance_data
    ,void                                *obj
    );
  /* */
  int (*obj_free)(
    const struct RTOp_obj_type_vtbl_t   *vtbl
    ,const void                         *instance_data
    ,void                               **obj
    );
  /* */
  int (*extract_state)(
    const struct RTOp_obj_type_vtbl_t    *vtbl
    ,const void                          *instance_data
    ,void                                *obj
    ,int                                 num_values
    ,RTOp_value_type                     value_data[]
    ,int                                 num_indexes
    ,RTOp_index_type                     index_data[]
    ,int                                 num_chars
    ,RTOp_char_type                      char_data[]
    );
  /* */
  int (*load_state)(
    const struct RTOp_obj_type_vtbl_t    *vtbl
    ,const void                          *instance_data
    ,int                                 num_values
    ,const RTOp_value_type               value_data[]
    ,int                                 num_indexes
    ,const RTOp_index_type               index_data[]
    ,int                                 num_chars
    ,const RTOp_char_type                char_data[]
    ,void                                **obj
    );
};


/* */
int RTOp_Server_add_op_name_vtbl(
  const char                       op_class_name[]
  ,const struct RTOp_RTOp_vtbl_t   *op_class_vtbl
  );

/* */
int RTOp_Server_lookup_op_name(
  const struct RTOp_RTOp_vtbl_t   *op_class_vtbl
  ,char                           op_class_name[]
  );

/* */
int RTOp_Server_construct_op(
  const char               op_class_name[]
  ,int                     num_values
  ,const RTOp_value_type   value_data[]
  ,int                     num_indexes
  ,const RTOp_index_type   index_data[]
  ,int                     num_chars
  ,const RTOp_char_type    char_data[]
  ,struct RTOp_RTOp        *op
  );

/* */
void RTOp_Server_dump( FILE* file );


#ifdef __cplusplus
}
#endif

#endif /* REDUCT_TRANS_VECTOR_OPERATORS_H */