Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

GATMonitorable.c Go to the documentation of this file. /** @file GATMonitorable.c * Source file for the GATMonitorable_Impl class. * * This implementation of the GATMonitorable interface, which is meant as a * generic helper class, which may be used by other GATObjects to implement * its GATMonitorable interface. * * The GATMonitorable_Impl class is essentially a table of lists, where the * GATMetric is used as the key type for the table and the list contains the * GATMetricListener's for the GATMetric used as the key. * * @date Mon Nov 3 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATMonitorable.c,v 1.16 2004/04/02 12:31:58 hartmutkaiser Exp $ * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATMonitorable.c,v 1.16 2004/04/02 12:31:58 hartmutkaiser Exp $"; /* System Header Files */ #include <stdlib.h> #include <string.h> /* GAT Header Files */ #include "GAT.h" #include "GATTableAnyKey.h" #include "GATInternal.h" #include "GATMonitorable.h" /* * The structure stored for a GATMetric inside the corresponding list */ typedef struct GATMetricListenerData { GATMetricListener listener; /* the GATMetrciListener to call */ void *data; /* the supplied data for this GATMetricListener */ GATuint32 cookie; /* cookie identifying the registered GATMetricListener */ } GATMetricListenerData; /* * Define the type specific interface functions for the GATList_GATMetric and * GATMetricListener lists */ GATLIST_IMPLEMENT(extern, GATMetric, GATList_GATMetric, GATType_GATMetric); GATLIST_DEFINE_QUALIFIED(static, GATMetricListenerData, GATList_GATMetricListenerData, GATType_PlainOldData); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS_QUALIFIED(static, GATList_GATMetricListenerData, GATType_GATList); /* * Define the vtable for this object */ GATOBJECT_DEFINE_VTABLE(GATMonitorable_Impl); GATMONITORABLE_DEFINE_VTABLE(GATMonitorable_Impl); /* Macros */ /* Structures, unions and enums */ /* * The GATMonitorable_Impl_S structure holds the internal representation of a * GATMonitorable_Impl instance. */ struct GATMonitorable_Impl_S { /* the vtable of this structure */ GATMonitorable_Impl_vtable *GATObject__vtable; GATMonitorable_Impl_IMonitorable_vtable *GATMonitorable_Impl__vtable; /* Instance data */ GATTable metrics; /* table of lists containing the GATMetricListener */ }; /* Static function prototypes */ static GATType GATMonitorable_Impl_GetType(GATMonitorable_Impl_const monitorable); static GATResult GATMonitorable_Impl_GetInterface(GATMonitorable_Impl_const monitorable, GATInterface iftype, void const **ifp); /* callback functions for the GATMetric table */ static GATuint32 GATMonitorable_Impl_GetKeySize(GATTable_const monitorable, void const *key); static GATBool GATMonitorable_Impl_EqualKeys(GATTable_const monitorable, void const *key1, void const *key2); static GATResult GATMonitorable_Impl_CloneKey(GATTable_const monitorable, void const *src, void **dest); static unsigned long GATMonitorable_Impl_HashKey(GATTable_const monitorable, void const *key); static void GATMonitorable_Impl_DestroyKey(GATTable_const monitorable, void **key); static GATMetric_const GATMonitorable_Impl_GetMetric(); static GATMetricListener GATMonitorable_Impl_GetMetricListener(); /* File scope variables */ static GATMonitorable_Impl_vtable GATMonitorable_Impl__vtable = { GATMonitorable_Impl_GetType, GATMonitorable_Impl_Destroy, GATMonitorable_Impl_Equals, GATMonitorable_Impl_Clone, GATMonitorable_Impl_GetInterface, NULL }; static GATMonitorable_Impl_IMonitorable_vtable GATMonitorable_Impl_IMonitorable__vtable = { GATMonitorable_Impl_AddMetricListener, GATMonitorable_Impl_RegisterPolling, GATMonitorable_Impl_RemoveRegisteredMetric, GATMonitorable_Impl_GetMetrics }; /* holds the next available cookie used for identifying the registered events */ static GATuint32 cookie_jar = 0; /* External functions */ /** GATMonitorable_Impl_Create * * Create a new instance of the GATMonitorable_Impl class. * * @return The newly constructed instance. */ GATMonitorable_Impl GATMonitorable_Impl_Create(GATList_GATMetric metrics) { GATMonitorable_Impl new_monitorable = (GATMonitorable_Impl) malloc(sizeof(struct GATMonitorable_Impl_S)); if (NULL != new_monitorable) { new_monitorable->GATObject__vtable = &GATMonitorable_Impl__vtable; new_monitorable->GATMonitorable_Impl__vtable = &GATMonitorable_Impl_IMonitorable__vtable; new_monitorable->metrics = GATTable_CreateAnyKey( GATMonitorable_Impl_GetKeySize, GATMonitorable_Impl_EqualKeys, GATMonitorable_Impl_CloneKey, GATMonitorable_Impl_HashKey, GATMonitorable_Impl_DestroyKey); if (NULL == new_monitorable->metrics) { GATMonitorable_Impl_Destroy(&new_monitorable); } else { /* register all GATMetrics, which should be supported here */ GATList_GATMetric_Iterator it = GATList_GATMetric_Begin(metrics); GATList_GATMetric_Iterator end = GATList_GATMetric_End(metrics); GATList_GATMetricListenerData list = GATList_GATMetricListenerData_Create(); if (NULL != list) { for (/**/; it != end; it = GATList_GATMetric_Next(it)) { GATMetric *metric = GATList_GATMetric_Get(it); if (NULL == metric) { break; } /* this clones the empty list into the table */ GATTable_Add_GATObject(new_monitorable->metrics, *metric, GATList_GATMetricListenerData_ToGATObject_const(list)); } } GATList_GATMetricListenerData_Destroy(&list); if (it != end) { /* some error occured */ GATMonitorable_Impl_Destroy(&new_monitorable); } } } return new_monitorable; } /** GATMonitorable_Impl_Destroy * The GATMonitorable_Impl destructor. * This is the destructor for GATMonitorable_Impl objects. * * @param monitorable An old GATMonitorable_Impl */ void GATMonitorable_Impl_Destroy(GATMonitorable_Impl *monitorable) { if (NULL != monitorable && NULL != *monitorable) { GATTable_Destroy(&(*monitorable)->metrics); free(*(monitorable)); *monitorable = NULL; } } /* GATMonitorable API functions */ /** GATMonitorable_Impl_AddMetricListener * * The function GATMonitorable_Impl_AddMetricListener adds the passed instance * of a GATMetricListener to the list of GATMetricListeners which are notified * of fired GATMetricEvents of the type described by the provided GATMetric * instance. * * @param monitorable The GATMonitorable instance to add the GATMetricListener * to. * @param listener The GATMetricListener to call, when the corresponding * GATMetricEvent is fired. * @param listener_data The client supplied data, which will be passed through * to the GATMetricListener. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. This metric instance must be of type * GATMeasurementType_EventLike, otherwise an error is returned. * @param cookie The returned value should be used to remove the * GATMetricListener from this GATMonitorable. * * @return An error code. */ GATResult GATMonitorable_Impl_AddMetricListener(GATMonitorable_Impl monitorable, GATMetricListener listener, void *listener_data, GATMetric metric, GATuint32 *cookie) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != monitorable) { if (NULL == metric || GATMeasurementType_EventLike != GATMetric_GetMeasurementType(metric)) { retval = GAT_INVALID_PARAMETER; } else { GATObject object = NULL; retval = GATTable_internal_Get_GATObjectRef(monitorable->metrics, metric, &object); if (GAT_SUCCESS == retval) { /* insert the listener data into the appropriate list */ GATMetricListenerData data; GATList_GATMetricListenerData list = GATObject_ToGATList_GATMetricListenerData(object); GATList_GATMetricListenerData_Iterator it = GATList_GATMetricListenerData_Begin(list); /* verify, that this listener isn't already registered with this GATMetric */ GATList_GATMetricListenerData_Iterator end = GATList_GATMetricListenerData_End(list); for (/**/; it != end; it = GATList_GATMetricListenerData_Next(it)) { GATMetricListenerData *value = GATList_GATMetricListenerData_Get(it); if (NULL == value) { retval = GAT_FAIL; break; } if (value->listener == listener) { retval = GAT_KEY_ALREADY_EXISTS; break; } } if (GAT_SUCCESS == retval) { if (NULL != cookie) { GATuint32 mycookie = ++cookie_jar; data.listener = listener; data.data = listener_data; data.cookie = mycookie; /* * NOTE: this code directly accesses the list stored inside the * table */ it = GATList_GATMetricListenerData_Insert(list, end, data); if (NULL == it) { retval = GAT_MEMORYFAILURE; } else { *cookie = mycookie; } } else { retval = GAT_INVALID_PARAMETER; } } } } } return retval; } /** GATMonitorable_Impl_RegisterPolling * * The function GATMonitorable_Impl_RegisterPolling registers a continuous * metric with the given GATMonitorable instance. * * @param monitorable The GATMonitorable instance to register the metric * with. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. This metric instance must be of type * GATMeasurementType_Continuous, otherwise an error is returned. * @param event The pointer to a variable, which should receive the resulting * GATMetricEvent (this parameter is ignored for this function). * @param cookie The returned value should be used to remove the * GATMetricListener from this GATMonitorable. * * @return An error code. */ GATResult GATMonitorable_Impl_RegisterPolling(GATMonitorable_Impl monitorable, GATMetric metric, GATMetricEvent *event, GATuint32 *cookie) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != monitorable) { if (NULL == metric || GATMeasurementType_Continuous != GATMetric_GetMeasurementType(metric)) { retval = GAT_INVALID_PARAMETER; } else { GATObject object = NULL; retval = GATTable_internal_Get_GATObjectRef(monitorable->metrics, metric, &object); if (GAT_SUCCESS == retval) { /* insert the listener data into the appropriate list */ GATMetricListenerData data; GATList_GATMetricListenerData list = GATObject_ToGATList_GATMetricListenerData(object); GATList_GATMetricListenerData_Iterator it = GATList_GATMetricListenerData_Begin(list); /* verify, that this listener isn't already registered with this GATMetric */ GATList_GATMetricListenerData_Iterator end = GATList_GATMetricListenerData_End(list); for (/**/; it != end; it = GATList_GATMetricListenerData_Next(it)) { GATMetricListenerData *value = GATList_GATMetricListenerData_Get(it); if (NULL == value) { retval = GAT_FAIL; break; } if (NULL == value->listener && NULL == value->data) { retval = GAT_KEY_ALREADY_EXISTS; break; } } if (GAT_SUCCESS == retval) { if (NULL != cookie) { GATuint32 mycookie = ++cookie_jar; GATList_GATMetricListenerData_Iterator new_it = NULL; data.listener = NULL; /* this is a continuous metric */ data.data = NULL; data.cookie = mycookie; /* * NOTE: this code directly accesses the list stored inside the * table */ new_it = GATList_GATMetricListenerData_Insert(list, end, data); if (NULL == new_it) { retval = GAT_MEMORYFAILURE; } else { *cookie = mycookie; } } else { retval = GAT_INVALID_PARAMETER; } } } } } return retval; } /** GATMonitorable_Impl_RemoveRegisteredMetric * * The function GATMonitorable_Impl_RemoveRegisteredMetric removes a * GATMetricListener, which was previously registered with * GATMonitorable_AddMetricListener. * * @param monitorable The GATMonitorable instance to remove the metric from. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. * @param cookie This value identifies the GATMetricListener to remove, it * was returned from the corresponding GATMonitorable_AddMetricListener * or GATMonitorable_MetricRegisterPolling functions. * * @return An error code. */ GATResult GATMonitorable_Impl_RemoveRegisteredMetric(GATMonitorable_Impl monitorable, GATMetric metric, GATuint32 cookie) { GATResult retval = GAT_FAIL; if (NULL != monitorable) { GATObject_const object = NULL; retval = GATTable_Get_GATObject(monitorable->metrics, metric, &object); if (GAT_SUCCESS == retval) { /* find the listener data inside the appropriate list */ GATList_GATMetricListenerData_const list = GATObject_ToGATList_GATMetricListenerData_const(object); GATList_GATMetricListenerData_Iterator it = GATList_GATMetricListenerData_Begin(list); GATList_GATMetricListenerData_Iterator end = GATList_GATMetricListenerData_End(list); retval = GAT_KEY_NOT_FOUND; for (/**/; it != end; it = GATList_GATMetricListenerData_Next(it)) { GATMetricListenerData *value = GATList_GATMetricListenerData_Get(it); if (NULL == value) { retval = GAT_FAIL; break; } if (value->cookie == cookie) { retval = GAT_SUCCESS; break; } } /* NOTE: this code directly accesses the list stored inside the table */ if (GAT_SUCCESS == retval) { GATList_GATMetricListenerData_Erase( (GATList_GATMetricListenerData) list, it); } } } return retval; } /** GATMonitorable_Impl_GetMetrics * * The function GATMonitorable_Impl_GetMetrics returns a list of metrics * supported by this GATMonitorable. * * @param monitorable The GATMonitorable instance, for which the supported * metrics should be returned. * @param metrics The pointer to the variable, which receives the resulting * list of metrics. * * @return An error code. */ GATResult GATMonitorable_Impl_GetMetrics(GATMonitorable_Impl_const monitorable, GATList_GATMetric *metrics) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != monitorable) { GATList_GATMetric list = GATList_GATMetric_Create(); if (NULL == list) { retval = GAT_MEMORYFAILURE; } else { GATMetric **keys = (GATMetric **) GATTable_GetKeys(monitorable->metrics); if (NULL == keys) { retval = GAT_MEMORYFAILURE; } else { /* copy the metrics into the output list */ GATuint32 i = 0; GATMetric *key = keys[0]; retval = GAT_SUCCESS; /* 'no keys' is valid */ for (/**/; NULL != key; key = keys[++i]) { GATList_GATMetric_Iterator it = GATList_GATMetric_Insert(list, GATList_GATMetric_End(list), *key); if (NULL == it) { retval = GAT_MEMORYFAILURE; break; } } /* free the key list */ for (i = 0, key = keys[0]; NULL != key; key = keys[++i]) { free(*key); } free(keys); } if (GAT_SUCCESS == retval) { if (NULL != metrics) { *metrics = list; } else { retval = GAT_INVALID_PARAMETER; } } else { GATList_GATMetric_Destroy(&list); } } } return retval; } /** GATMonitorable_Impl_FireEvent * * The function GATMonitorable_Impl_FireEvent fires the given event to all * registered metric listeners. * * @param monitorable The GATMonitorable to use for calling the registered * metric listeners. * @param metric The metric, which describes the event fired. * @param event The event to fire. * * @return An error code */ GATResult GATMonitorable_Impl_FireEvent(GATMonitorable_Impl_const monitorable, GATMetric metric, GATMetricEvent event) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != monitorable) { if (NULL == metric || NULL == event) { retval = GAT_INVALID_PARAMETER; } else { GATObject_const object = NULL; retval = GATTable_Get_GATObject(monitorable->metrics, metric, &object); if (GAT_SUCCESS == retval) { /* find the listener data inside the appropriate list */ GATList_GATMetricListenerData_const list = GATObject_ToGATList_GATMetricListenerData_const(object); GATList_GATMetricListenerData_Iterator it = GATList_GATMetricListenerData_Begin(list); GATList_GATMetricListenerData_Iterator end = GATList_GATMetricListenerData_End(list); for (/**/; it != end; it = GATList_GATMetricListenerData_Next(it)) { GATMetricListenerData *data = GATList_GATMetricListenerData_Get(it); if (NULL == data) { retval = GAT_FAIL; /* this is completely unexpected */ break; } if (NULL != data->listener) { /* handle event like metrics only */ retval = data->listener(data->data, event); if (GAT_SUCCESS != retval) { break; } } } } } } return retval; } /** int GATMonitorable_Equals(GATMonitorable_const lhs, GATMonitorable_const rhs, GATBool *isequal) * @brief Compares two GATTable objects * * The function @c GATMonitorable_Equals compares two file objects of type * @c #GATTable. * * @param lhs The first file object to compare * @param rhs The second file object to compare * @param isequal The pointer to the GATBool variable, which should receive * the result if the comparison * * @return An error code. */ GATResult GATMonitorable_Impl_Equals(GATMonitorable_Impl_const lhs, GATMonitorable_Impl_const rhs, GATBool *isequal) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != lhs && NULL != rhs) { /* two GATMonitorable_Impl are equal, if its embedded tables are equal */ retval = GATTable_Equals(lhs->metrics, rhs->metrics, isequal); } return retval; } /** int GATMonitorable_Clone(GATMonitorable_const filehandle, GATTable *new_file) * @brief Clone the given GATTable * * The function @c GATMonitorable_Clone generates a (deep) copy of the given * GATTable. * * @param monitorable The object to clone * @param new_file The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATMonitorable_Impl_Clone(GATMonitorable_Impl_const monitorable, GATMonitorable_Impl *new_object) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != monitorable) { GATMonitorable_Impl new_monitorable = (GATMonitorable_Impl) malloc (sizeof(struct GATMonitorable_Impl_S)); if (NULL == new_monitorable) { retval = GAT_MEMORYFAILURE; } else { new_monitorable->GATObject__vtable = &GATMonitorable_Impl__vtable; new_monitorable->GATMonitorable_Impl__vtable = &GATMonitorable_Impl_IMonitorable__vtable; retval = GATTable_Clone(monitorable->metrics, &new_monitorable->metrics); if (GAT_SUCCESS != retval) { free(new_monitorable); } else { if (NULL != new_object) { *new_object = new_monitorable; } else { retval = GAT_INVALID_PARAMETER; } } } } return retval; } /* Local functions */ /** int GATMonitorable_GetType(GATMonitorable_const file) * @brief Return the type of the GATTable * * The function @c GATMonitorable_GetType always returns GATType_GATTable. * * @param object The object to inspect * * @return returns always @c #GATType_GATTable. */ static GATType GATMonitorable_Impl_GetType(GATMonitorable_Impl_const monitorable) { GAT_UNUSED_PARAMETER(monitorable); return GATType_GATMonitorable_Impl; } /** int GATMonitorable_GetInterface(GATMonitorable_const table, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATList * * The function GATMonitorable_GetInterface allows to get a pointer to an * additional interface supported by this GATList. * * @param monitorable The object to be asked for the new interface. * @param iftype The interface the object is to be asked for. * @param ifp The pointer, through which the result is to be returned. * * @return An error type. */ static GATResult GATMonitorable_Impl_GetInterface(GATMonitorable_Impl_const monitorable, GATInterface iftype, void const **ifp) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != monitorable || NULL != ifp) { *ifp = NULL; if (GATInterface_IMonitorable == iftype) { *ifp = (void const *) &monitorable->GATMonitorable_Impl__vtable; retval = GAT_SUCCESS; } else { retval = GAT_NO_INTERFACE; } } return retval; } static GATuint32 GATMonitorable_Impl_GetKeySize(GATTable_const table, void const *key) { GAT_UNUSED_PARAMETER(table); GAT_UNUSED_PARAMETER(key); return (GATuint32) GATMetric_i_GetTypeSize(); } static GATBool GATMonitorable_Impl_EqualKeys(GATTable_const table, void const *key1, void const *key2) { GATBool retval = GATFalse; GAT_UNUSED_PARAMETER(table); GATMetric_Equals((GATMetric)key1, (GATMetric)key2, &retval); return retval; } static GATResult GATMonitorable_Impl_CloneKey(GATTable_const table, void const *src, void **dest) { GATResult retval = GAT_FAIL; GATMetric new_metric = NULL; GAT_UNUSED_PARAMETER(table); return GATMetric_Clone((GATMetric)src, (GATMetric *)dest); } static void GATMonitorable_Impl_DestroyKey(GATTable_const monitorable, void **key) { GATMetric_Destroy((GATMetric *)key); } static unsigned long GATMonitorable_Impl_HashKey(GATTable_const monitorable, void const *key) { char const *name = GATMetric_GetName((GATMetric)key); /*int c = *((int8_t *) name)++;*/ int8_t* tmp = (int8_t *) name; int8_t c = *tmp++; GATuint32 i = 0; GATuint32 key_size = strlen (name) + 1; unsigned long hash = 0; /* c = *((int8_t *) name)++ */ for (/**/; i < key_size; ++i, tmp = (int8_t *) name, c = *tmp++) { hash = c + (hash << 6) + (hash << 16) - hash; } return hash; }