---

/root/resourcemonitord/resourcemonitord/ResourceMonitor/ResourceMonitor.h

Go to the documentation of this file.

//
// ResourceMonitor.h
// 
// This file declares the application interface to the resource monitor facility
// ResourceMonitor library is designed to give a "C" consumer application access to the RM features.
//


/*M*
BSD License

Copyright (c) 2002, Intel Corporation
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

  a.. Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
  b.. 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.
  c.. Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR 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.

 *M*/

#ifndef     __ResourceMonitor_h__
#define __ResourceMonitor_h__

#include "ResourceMonitorTypes.h"
#include <stddef.h>

#ifdef __cplusplus

namespace ResourceMonitor
{
extern "C" {
#endif


int rmGetResourceMonitorVersion();

//
// Discovery of subsystems, resources, and statistics:
//
// These `GetAvailable` functions return information in the user's `buffer`about available
// resources that can be monitored. The size parameter indiacted the number of structures
// the buffer can hold. The return value EAGAIN indicates there are
// more information structures available. A larger buffer is needed to retrieve them all.
// 

size_t rmGetSubsystemCount();
int rmGetAvailableSubsystems(rmSubsystemInfo *buffer, const size_t size);
int rmGetActiveResources(const rmUID SubsystemId, rmResourceInfo *buffer, const size_t size);
int rmGetAvailableStatistics(const rmUID SubsystemId, rmStatisticInfo *buffer, const size_t size);
size_t rmGetMonitorCount();
int rmGetMonitors(rmMonitorInfo *buffer, size_t *size);
int rmGetSubsystemInfo(const rmUID SubsystemId, rmSubsystemInfo *buffer);
rmString rmGetSubsystemDescription(const rmUID SubsystemId, const enum rmDescriptions which);
int rmGetResourceInfo(const rmUID SubsystemId, const rmID ResourceId, rmResourceInfo *buffer);
rmString rmGetResourceDescription(const rmUID SubsystemId, const rmID ResourceId, const enum rmDescriptions which);
int rmGetResourceID(const rmUID SubsystemId, const rmString shortdescription, rmID *id);
int rmGetStatisticInfo(const rmUID SubsystemId, const rmID statId, rmStatisticInfo *buffer);
rmString rmGetStatisticDescription(const rmUID SubsystemId, const rmID statId, const enum rmDescriptions which);
int rmGetStatisticID(const rmUID SubsystemId, const rmString shortdescription, rmID *id);

#ifdef RM_Doing_Aliases
// can client applications establish aliases? If so should the RM facility persist them?

int rmGetSubsystemAliases(const rmUID SubsystemId, rmString buffer, size_t *size);

int rmGetResourceAliases(const rmUID SubsystemId, const rmID ResourceId, rmString buffer, size_t *size);

int rmGetStatisticAliases(const rmStatisticKey statisticKey, rmString buffer, size_t* size);
#endif  // RM_Doing_Aliases

//
// query statistic values without creating a monitor
//
int rmGetCurrentValue(const rmStatisticKey id, rmValue *value);
int rmGetUpperBound(const rmStatisticKey id, rmValue *value);

int rmResetCounterStatistic(const rmStatisticKey id, const rmValue *value);

rmHandle rmCreateMonitor(const rmMonitorConfiguration *config, rmMonitorControl *control);
rmHandle rmAccessMonitor(const rmUID MonitorId);
int rmDeleteMonitor(const rmHandle handle);
int rmGetMonitorControl(const rmHandle handle, rmMonitorControl *control);
int rmSetMonitorControl(const rmHandle handle, const rmMonitorControl *control);
int rmGetMonitorConfiguration(const rmHandle handle, rmMonitorConfiguration *config);
int rmSetMonitorConfiguration(const rmHandle handle, const rmMonitorConfiguration *config);
int rmStartMonitor(const rmHandle handle);
int rmStopMonitor(const rmHandle handle);
int rmResetMonitor(const rmHandle handle);
int rmPauseNotification(const rmHandle handle);
int rmResetNotification(const rmHandle handle);
int rmGetMonitorState(const rmHandle handle, rmMonitorState *state);
int rmGetMonitorInfo(const rmHandle handle, rmMonitorInfo *info );
rmString rmGetMonitorDescription(const rmHandle handle, const enum rmDescriptions which);
int rmSetMonitorDescription(const rmHandle handle, const enum rmDescriptions which, const rmString description);

#ifdef RM_Doing_Groups
//
// Statistic groups are for gathering many values in a single call
// ie  rmGetStatisticValues
//
rmHandle rmCreateStatisticGroup();

int rmDeleteStatisticGroup(rmHandle grpHandle);

int rmAddStatisticToGroup( rmHandle grpHandle, rmStatisticKey *stat );

int rmDeleteStatisticFromGroup( rmHandle grpHandle, rmStatisticKey * stat );

size_t rmGetStatisticGroupCount(rmHandle grpHandle);

int rmGetStatisticValues(rmHandle grpHandle, rmStatisticValue *values, size_t count);

int rmGetStatisticsInfo( rmHandle grpHandle, rmStatisticInfo *buffer, size_t count);

//
// Monitor groups are for controlling and gathering state of many monitors in a single call
// ie  rmGetMonitorStates, rmStartMonitors, etc.
//
rmHandle rmCreateMonitorGroup();

int rmDeleteMonitorGroup(rmHandle grpHandle);
// removes user's monitor group and invalidates the monitor's group rmHandle;
// This has no effect on the individual monitors. individual monitors must also
// be deleted if desired.

int rmAddMonitorToGroup( rmHandle grphandle, rmHandle monitorHandle );

int rmDeleteMonitorFromGroup( rmHandle grpHandle, rmHandle monitorHandle );

size_t rmGetMonitorGroupCount(rmHandle grpHandle);

int rmGetMonitorStates( rmHandle grpHandle, rmMonitorState *state, size_t count);

int rmStartMonitors(rmHandle grpHandle);

int rmStopMonitors(rmHandle grpHandle);

int rmPauseNotifications(rmHandle grpHandle);

int rmResetMonitors(rmHandle grpHandle);  // clears current watermark info
#endif  // RM_Doing_Groups

#ifdef __cplusplus
}   // extern "C"

typedef void * rmSessionHandle;

rmSessionHandle rmCreateConsumerSession();

int rmCloseConsumerSession(const rmSessionHandle handle);

class RMsession
{
public:
    RMsession();
    RMsession(rmSessionHandle handle);
    ~RMsession();
    rmSessionHandle getConsumerHandle() const;
    void setSessionHandle(rmSessionHandle a_SessionHandle);
protected:
    rmSessionHandle m_SessionHandle;
};

class RMdiscovery : virtual public RMsession
{
public:
    RMdiscovery();
    RMdiscovery(const rmSessionHandle session);
    ~RMdiscovery();
    size_t GetSubsystemCount() const;
    int GetAvailableSubsystems(rmSubsystemInfo *buffer, const size_t size) const;
    int GetActiveResources( const rmUID &uuid, rmResourceInfo *buffer, const size_t size) const;
    int GetAvailableStatistics( const rmUID &uuid, rmStatisticInfo *buffer, const size_t size) const;
    size_t GetMonitorCount() const;
    int GetMonitors(rmMonitorInfo *buffer, size_t *size) const;
};

class RMsubsystem : virtual public RMsession
{
public:
    RMsubsystem(const rmUID &SubsystemId);
    RMsubsystem(const rmSessionHandle session, const rmUID &SubsystemId);
    ~RMsubsystem();
    void GetSubsystemId(rmUID &uuid) const;
    int GetSubsystemInfo( rmSubsystemInfo *buffer) const;
    rmString GetSubsystemDescription(rmDescriptions which) const;
//  RMresource GetResource(rmid id);
#ifdef RM_Doing_Aliases
    int GetSubsystemAliases( rmString buffer, size_t *size) const;
#endif  // RM_Doing_Aliases

protected:
    RMsubsystem();
    RMsubsystem(const rmSessionHandle session);
    void SetSubsystemId(const rmUID &uuid);
    rmUID m_subsystemId;
};  //RMsubsystem


class RMresource : public RMsubsystem
{
public:
    RMresource(const rmUID &SubsystemId, const rmID ResourceId);
    RMresource(const rmSessionHandle session, const rmUID &SubsystemId, const rmID ResourceId);
    ~RMresource();
    rmID GetResourceId() const;
    int GetResourceInfo( rmResourceInfo *buffer) const;
    rmString GetResourceDescription(rmDescriptions which) const;
//  RMstatistic GetStatistic(rmid id);
#ifdef RM_Doing_Aliases
    int GetResourceAliases( rmString buffer, size_t *size) const;
#endif  // RM_Doing_Aliases
protected:
    RMresource();
    RMresource(const rmSessionHandle session);
    void SetResourceId(const rmID id);
    rmID m_resourceId;
};  //RMresource

class RMstatistic : public RMresource
{
public:
    RMstatistic(const rmStatisticKey &stat);
    RMstatistic(const rmSessionHandle session, const rmStatisticKey &stat);
    ~RMstatistic();
  void GetStatisticId(rmStatisticKey *statisticKey) const;
  rmID GetStatisticId() const;
    int GetValue(rmValue *val) const;
    int GetUpperBound(rmValue *val) const;
    int ResetCounterStatistic(rmValue *val);        // not valid for guages
  int GetStatisticInfo( rmStatisticInfo *buffer) const;
    rmString GetStatisticDescription(const rmDescriptions which) const;
#ifdef RM_Doing_Aliases
    int GetStatisticAliases( rmString buffer, size_t *size) const;
#endif  // RM_Doing_Aliases
protected:
    RMstatistic();
    RMstatistic(const rmSessionHandle session);
  void SetStatisticId(const rmStatisticKey &statisticKey);
  void SetStatisticId(const rmID id);
    rmID     m_statisticId;
};  //    RMstatistic

class RMmonitor : public RMstatistic
{
public:
    RMmonitor(const rmMonitorConfiguration &config, rmMonitorControl *control);
    RMmonitor(const rmUID MonitorId);
    RMmonitor(const rmSessionHandle session, const rmMonitorConfiguration &config, rmMonitorControl *control);
    RMmonitor(const rmSessionHandle session, const rmUID MonitorId);
    ~RMmonitor();
    void OnDestructionDeleteMonitor();
    int GetMonitorControl( rmMonitorControl *control) const;
    int SetMonitorControl( const rmMonitorControl &control);
    int GetMonitorConfiguration( rmMonitorConfiguration *config) const;
    int SetMonitorConfiguration( const rmMonitorConfiguration &config);
    int GetMonitorState( rmMonitorState *state) const;
    int GetMonitorInfo( rmMonitorInfo *buffer ) const;
    rmString GetMonitorDescription(const rmDescriptions which) const;
    int SetMonitorDescription(const rmDescriptions which, const rmString description);
    int StartMonitor();
    int StopMonitor();
    int ResetMonitor();
    int PauseNotification();
    int ResetNotification();
private:
    rmHandle m_MonitorHandle;
    bool m_deleteInDestructor;
};

// END CLASS DEFINITION RMmonitor

#ifdef RM_Doing_Groups
class RMstatisticGroup
{
public:
    RMstatisticGroup();
    ~RMstatisticGroup();
    int AddStatistic( rmStatisticKey& stat );
    int DeleteStatistic( rmStatisticKey &stat );
    size_t GetStatisticCount();
    int GetValues( rmStatisticValue *values, size_t count);
    int GetStatisticInfo( rmStatisticInfo *buffer, size_t count);
private:
    rmHandle m_GroupHandle;
};  //RMstatisticGroup


class RMmonitorGroup
{
public:
    RMmonitorGroup();
    ~RMmonitorGroup();
    int AddMonitor( RMmonitor & monitor );
    int DeleteMonitor( RMmonitor &monitor );
    size_t GetMonitorCount();
    int GetStates( rmMonitorState *state, size_t count) ;
    int StartMonitors();
    int StopMonitors();
    int PauseNotifications();
    int ResetMonitors();
private:
    rmHandle m_GroupHandle;
};  //RMmonitorGroup
#endif  // RM_Doing_Groups

}   //ResourceMonitor
#endif  //  __cplusplus

#endif  //  __ResourceMonitor_h__

---