static void
initialize_system_counters (void)
{
register_internal ("User Time", SYSCOUNTER_TIME, (gpointer) &user_time, sizeof (gint64));
register_internal ("System Time", SYSCOUNTER_TIME, (gpointer) &system_time, sizeof (gint64));
register_internal ("Total Time", SYSCOUNTER_TIME, (gpointer) &total_time, sizeof (gint64));
register_internal ("Working Set", SYSCOUNTER_BYTES, (gpointer) &working_set, sizeof (gint64));
register_internal ("Private Bytes", SYSCOUNTER_BYTES, (gpointer) &private_bytes, sizeof (gint64));
register_internal ("Virtual Bytes", SYSCOUNTER_BYTES, (gpointer) &virtual_bytes, sizeof (gint64));
register_internal ("Page Faults", SYSCOUNTER_COUNT, (gpointer) &page_faults, sizeof (gint64));
register_internal ("CPU Load Average - 1min", SYSCOUNTER_LOAD, (gpointer) &cpu_load_1min, sizeof (double));
register_internal ("CPU Load Average - 5min", SYSCOUNTER_LOAD, (gpointer) &cpu_load_5min, sizeof (double));
register_internal ("CPU Load Average - 15min", SYSCOUNTER_LOAD, (gpointer) &cpu_load_15min, sizeof (double));
}
/**
* mono_counters_register_with_size:
* @name: The name for this counters.
* @type: One of the possible MONO_COUNTER types, or MONO_COUNTER_CALLBACK for a function pointer.
* @addr: The address to register.
* @size: Max size of the counter data.
*
* Register addr as the address of a counter of type @type.
* Note that @name must be a valid string at all times until
* mono_counters_dump () is called.
*
* It may be a function pointer if MONO_COUNTER_CALLBACK is specified:
* the function should return the value and take no arguments.
*
* The value of @size is ignored for types with fixed size such as int and long.
*
* Use @size for types that can have dynamic size such as string.
*
* If @size is negative, it's silently converted to zero.
*/
void
mono_counters_register_with_size (const char *name, int type, void *addr, int size)
{
if (!initialized)
g_debug ("counters not enabled");
else
register_internal (name, type, addr, size);
}
void ompi_common_verbs_mca_register(mca_base_component_t *component)
{
if (!registered) {
register_internal();
}
/* Make synonym for the common_verbs MCA params. */
mca_base_var_register_synonym(warn_nonexistent_if_index, "ompi", component->mca_type_name,
component->mca_component_name, "warn_nonexistent_if", 0);
}
void ompi_common_verbs_mca_register(mca_base_component_t *component)
{
int ival;
if (!registered) {
register_internal();
}
/* Make synonyms for the common_verbs MCA params. Need to look up
the value again, because a new/different value may have been
set by the new synonym name. */
mca_base_param_reg_syn(warn_nonexistent_if_index, component,
"warn_nonexistent_if", false);
mca_base_param_lookup_int(warn_nonexistent_if_index, &ival);
ompi_common_verbs_warn_nonexistent_if = (bool) ival;
}
/**
* mono_counters_register:
* @name: The name for this counters.
* @type: One of the possible MONO_COUNTER types, or MONO_COUNTER_CALLBACK for a function pointer.
* @addr: The address to register.
*
* Register addr as the address of a counter of type type.
* Note that @name must be a valid string at all times until
* mono_counters_dump () is called.
*
* This function should not be used with counter types that require an explicit size such as string
* as the counter size will be set to zero making them effectively useless.
*
*
* It may be a function pointer if MONO_COUNTER_CALLBACK is specified:
* the function should return the value and take no arguments.
*/
void
mono_counters_register (const char* name, int type, void *addr)
{
int size;
switch (type & MONO_COUNTER_TYPE_MASK) {
case MONO_COUNTER_INT:
size = sizeof (int);
break;
case MONO_COUNTER_UINT:
size = sizeof (guint);
break;
case MONO_COUNTER_LONG:
case MONO_COUNTER_TIME_INTERVAL:
size = sizeof (gint64);
break;
case MONO_COUNTER_ULONG:
size = sizeof (guint64);
break;
case MONO_COUNTER_WORD:
size = sizeof (gssize);
break;
case MONO_COUNTER_DOUBLE:
size = sizeof (double);
break;
case MONO_COUNTER_STRING:
size = 0;
break;
default:
g_assert_not_reached ();
}
if (!initialized)
g_debug ("counters not enabled");
else
register_internal (name, type, addr, size);
}
void
_pbcB_init(struct pbc_env * p) {
register_internal(p,pbc_descriptor,sizeof(pbc_descriptor));
}
void
_pbcB_init(struct pbc_env * p) {
struct pbc_slice slice = { pbc_descriptor,sizeof(pbc_descriptor) };
register_internal(p,&slice);
}
static void
init_internals (filter_t *filter)
{
g_assert(filter->kind == FILTER_MATHMAP);
register_internal(&filter->v.mathmap.internals, "x", CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "y", CONST_X | CONST_T);
register_internal(&filter->v.mathmap.internals, "r", CONST_T);
register_internal(&filter->v.mathmap.internals, "a", CONST_T);
register_internal(&filter->v.mathmap.internals, "t", CONST_X | CONST_Y);
register_internal(&filter->v.mathmap.internals, "R", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "__canvasPixelW", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "__canvasPixelH", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "__renderPixelW", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "__renderPixelH", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "frame", CONST_X | CONST_Y);
/* These are resolved by the compiler as bindings, i.e. calculated
in the filter code */
register_internal(&filter->v.mathmap.internals, "X", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "Y", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "W", CONST_X | CONST_Y | CONST_T);
register_internal(&filter->v.mathmap.internals, "H", CONST_X | CONST_Y | CONST_T);
}
