|
MOOCHO (Single Doxygen Collection)
Version of the Day
|
|
MOOCHO (Single Doxygen Collection)
Version of the Day
|
|
Functions | |
| 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) |
Singleton object that aids in the transport and reconstruction of reduction/transformation operators in a distributed environment.
This is a singleton object that must be initialized in every process in a distributed client/server application where reduction/transformation operators are used. This object can be used by a abstract vector implementation to transparently take a reduction/transformation operator object created by the client in one process, and then have this operator object transported over a network and be reconstructed in all of the processes where the operator needs to be applied. This object only supplies the basic functions for setting up the RTOp_Server object with operator class names and vtbl pointers, querying for an operator class name given its vtbl pointer and then reconstructing an operator object given its instance data and the name of its operator class.
This object is implemented as a singleton object since only one of these objects needs to be instantiated in each process.
| int RTOp_Server_add_op_name_vtbl | ( | const char | op_class_name[], |
| const struct RTOp_RTOp_vtbl_t * | op_class_vtbl | ||
| ) |
Function for adding an operator class name and virtual function table pointer.
The user or client of an abstract vector is responsible for calling these functions to setup the RTOp_Server object with the names and vtbl pointers for each of the reduction/transformation operator classes that will be used with the abstract abstract vectors. This initialization must take place in each of the processes where these operators are used.
Several different unrelated clients of abstract vectors can call these functions for the operators they use. For example, an optimization algorithm and a nonlinear equation solver algorithm may both call these functions to initialize the RTOp_Server object for the reduction/transformation operator classes they use. It is very likely that many of these operator classes may be the same and this interface allows the same operator class to be added more than once with no harm. Unrelated client packages may however use the same name for different classes by accident in which case these function will flag the problem when they are added. Therefore, as long as careful names for operator classes are used, then several different client packages can coexist in the same program.
Preconditions:
strlen(op_class_name) <= RTOp_MAX_REDUCT_TRANS_OP_CLASS_NAME op_class_vtbl != NULL | op_class_name | [in] Name (null terminated string) of the operator subclass. Should be unique from all other class names. This name must not be any longer than RTOp_MAX_REDUCT_TRANS_OP_CLASS_NAME. |
| op_class_vtbl | [in] Pointer to the virtual function table for the operator subclass. This should also be unique from all other classes but there is no harm if it is not. |
0 if the operator was successfully added. Returns >0 if the name op_class_name and pointer op_class_vtbl have already been added. Returns <0 if the pair could not be added due to some problem. If this function returns RTOp_SERVER_INCOMPATIBLE_OPS<tt> < 0 then the name op_class_name already exists but the pointer op_class_vtbl is not the same. If this function returns RTOp_SERVER_OP_NAME_TOO_LONG<tt> < 0 then op_class_name was longer than RTOp_MAX_REDUCT_TRANS_OP_CLASS_NAME. | int RTOp_Server_lookup_op_name | ( | const struct RTOp_RTOp_vtbl_t * | op_class_vtbl, |
| char | op_class_name[] | ||
| ) |
Function for lookup up an operator class name given its vtbl pointer.
This function is used by a vector implementation to lookup the name of a reduction/transformation operator class given a pointer to its vtbl. This is needed in order to communicate the class name, along with the object instance data for an operator to other processes so that the operator object can be reconstructed and applied in these processes.
| op_class_vtbl | [in] Pointer to the virtual function table for the operator subclass. This name must have been used in a previous call to RTOp_Server_add_op_name_vtbl(...) |
| op_class_name | [out] Name (null terminated string) of the operator subclass. This array must contain at least RTOp_MAX_REDUCT_TRANS_OP_CLASS_NAME+1 entries that can be set. Note that there may be several names associated with a single op_class_vtbl. Which name is returned is implementation dependent. |
0 if the operator class vtbl was successfully found. Returns <0 if vtbl could not be found. | 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 | ||
| ) |
Function for constructing an operator given its class name and instance data.
This function is used by the vector implementation to reconstruct reduction /transformation operators on remote processors where they need to be applied.
| op_class_name | [in] Name (null terminated string) of the operator subclass. This name must have been used in a previous call to RTOp_Server_add_op_name_vtbl(...). |
| num_values | [in] Returned from RTOp_extract_op_state<tt>(...) |
| value_data | [in] Returned from RTOp_extract_op_state(...) |
| num_indexes | [in] Returned from RTOp_extract_op_state(...) |
| index_data | [in] Returned from RTOp_extract_op_state(...) |
| num_chars | [in] Returned from RTOp_extract_op_state(...) |
| char_data | [in] Returned from RTOp_extract_op_state(...) |
| op | [out] On input, op->obj_data == NULL must be true. Constructed operator object. This object will be constructed using RTOp_load_op_state<tt>(...). To deallocate this object, use RTOp_free_op<tt>(...). |
>=0 if the operator object was successfully initialized. Returns <0 if the name op_class_name was not recognized. 
1.8.6