Resource Monitor

You can monitor various resources in a unified API with resource type, attributes, and some controls.

The basic procedures for getting monitoring data are simple and unified as below:

• At first, set up the environment for resources and attributes that are monitored:

  1. Create a resource instance with the corresponding resource type.

  2. If required, set resource control to specify the target among multi-instantiable resources.

  3. Set interesting attributes for created resource instance.

• Now, it is ready to get monitoring data. Repeat the next two steps when the application wants to get resource attributes:

  1. Request to update the individual resource or all resources at once.

  2. Get the attribute value along with the type of attributes using APIs listed in the table below.

Table: Resource Monitor APIs for getting attribute values

Prerequisites

To enable your application to use the Resource Monitor functionalities, follow these steps:

1. To use the Resource Monitor API, the application has to request permission by adding the following privileges to the tizen-manifest.xml file:

   <privileges>
      <privilege>http://tizen.org/privilege/systemmonitor</privilege>
   </privileges>
   

2. To use the functions and data types of the Resource Monitor API, include the <system/resource-monitor.h> header file in your application:

   #include <system/resource-monitor.h>
   

3. To establish and keep connection with internal monitoring daemon, please get monitor id by resource_monitor_init() during using resource monitor:

   int monitor_id = resource_monitor_init();
   

Get interested attributes from resources

To get the information of various resource attributes in a unified method, follow these steps:

• Get the attributes of singly existing resources without setting controls. For example, the number of possible CPUs of SYSTEM resource:

  void
  func(int monitor_id, int *num_possible_cpu)
  {
      int error = RESOURCE_MONITOR_ERROR_NONE;
      int res_id = resource_monitor_create_resource(monitor_id, RESOURCE_MONITOR_TYPE_SYSTEM);
  
      if (res_id < 0) {
          printf("failed to create resource: %d\n", RESOURCE_MONITOR_TYPE_SYSTEM);
          return res_id;
      }
  
      error = resource_monitor_set_resource_attr(monitor_id, res_id, RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU);
      if (error < 0) {
          printf("failed to set resource atrribute [%d]\n", RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU);
          return error;
      }
  
      error = resource_monitor_update_resource(monitor_id, res_id);
      if (error < 0) {
          printf("failed to update monitoring data\n");
          return error;
      }
  
      error = resource_monitor_get_value_int(monitor_id, res_id, RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU, num_possible_cpu);
      if (error < 0) {
          printf("failed to get attribute data\n");
          return error;
      }
  
      return RESOURCE_MONITOR_ERROR_NONE;
  }
  

• Get the attributes of multi-instantiable resources along with counting and setting controls. For example, the current frequency for all CPUs resource instance:

  void
  func(int monitor_id, int *num_cpu, int *results)
  {
      int error = RESOURCE_MONITOR_ERROR_NONE;
      int *cpu_ids
      int res_count;
      int i;
  
      /* Get the number of available instance */
      error = resource_monitor_get_resource_count(monitor_id, RESOURCE_MONITOR_TYPE_CPU, &res_count);
      if (error < 0) {
          printf("failed to get resource count for res: [%d]\n", RESOURCE_MONITOR_TYPE_CPU);
          return error;
      }
  
      cpu_ids = calloc(res_count, sizeof(int));
      if (!cpu_ids)
          return RESOURCE_MONITOR_ERROR_OUT_OF_MEMORY;
  
      /* Create resources and set attributes and controls */
      for (i = 0; i < res_count; i++) {
          cpu_ids[i] = resource_monitor_create_resource(monitor_id, RESOURCE_MONITOR_TYPE_CPU);
          if (cpu_ids[i] < 0) {
              printf("failed to create resource: %d", RESOURCE_MONITOR_TYPE_CPU);
              goto error_cleanup;
          }
  
          error = resource_monitor_set_resource_attr(monitor_id, cpu_ids[i], RESOURCE_MONITOR_CPU_CUR_FREQ);
          if (error < 0) {
              printf("failed to set resource atrribute [%d]\n", RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU);
              goto error_cleanup;
          }
  
          error = resource_monitor_set_resource_ctrl(monitor_id, cpu_ids[i], RESOURCE_MONITOR_CTRL_CLUSTER_ID, i);
          if (error < 0) {
              printf("failed to set resource control [%d]\n", RESOURCE_MONITOR_SYSTEM_ATTR_POSSIBLE_CPU);
              goto error_cleanup;
          }
      }
  
      /* Update attributes */
      error = resource_monitor_update(monitor_id);
      if (error < 0) {
          printf("failed to update monitoring data\n");
          i--;
          goto error_cleanup;
      }
  
      for (i = 0; i < res_count; i++) {
          error = resource_monitor_get_value_int(monitor_id, res_id, RESOURCE_MONITOR_CPU_CUR_FREQ, &results[i]);
          if (error < 0) {
              printf("failed to get attribute data\n");
              goto error_cleanup;
          }
      }
  
      *num_cpu = res_count;
  
      error = RESOURCE_MONITOR_ERROR_NONE;
  
  error_cleanup:
      for (;i >= 0; i--)
          resource_monitor_delete_resource(monitor_id, cpu_ids[i]);
  
      free(cpu_ids);
  
      return error;
  }
  
  

Resource monitor keys

The following table lists the available resource types, which are part of the resource_monitor_type_e enumeration:

Table: Resource type keys

The following table lists the available attributes for each resource, which are part of the resource_monitor_attr_id_e enumeration:

Table: Resource attribute keys for CPU

Table: Resource attribute keys for BUS

Table: Resource attribute keys for GPU

Table: Resource attribute keys for Memory

Table: Resource attribute keys for Battery

Table: Resource attribute keys for Display

Table: Resource attribute keys for System

Table: Resource attribute keys for Disk

The following table lists the required controls for some resources, which are part of the resource_monitor_ctrl_id_e enumeration:

Table: Resource control keys

Related information

• Dependencies
  • Tizen 7.0 and Higher for Mobile
  • Tizen 7.0 and Higher for Wearable
  • Tizen 7.0 and Higher for TV
  • Tizen 7.0 and Higher for IoT