/home/tai/chorist/xian-1.2/src/usei.c

Go to the documentation of this file.

/************************************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "include/usi.h"
#include "include/usei.h"

/*************************************************************************************************************/
unsigned long long
get_node_delta_occupancy(char * macadd,
                         char * dev_name,
                         unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long rx_bytes;
  unsigned long long tx_bytes;
  unsigned long long occupancy;
  unsigned long long delta_occupancy;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  rx_bytes = get_node_rx_bytes(macadd, dev_name, code_err);
  tx_bytes = get_node_tx_bytes(macadd, dev_name, code_err);


  /*
  // FOR TESTING -- BEGINNING
  rx_bytes = 10+3*counter;
  tx_bytes = 20+2*counter;
  // FOR TESTING -- END
  */

  if (!(*code_err))
    {
      occupancy = rx_bytes + tx_bytes;

      /*
      // FOR TESTING -- BEGINNING
      printf("calculated occupancy = %u \n", occupancy);
      printf("counter = %d\n", counter);
      // FOR TESTING -- END
      */

      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev)
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }

      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }

      metric_type = lookup_metric(OCCUPANCY, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(OCCUPANCY);
          add_metric(metric_type, &node->list_metric_log);
        }

      delta_occupancy = occupancy - metric_type->last_values[0];
      set_new_value_metric(occupancy, metric_type->last_values);

      counter = counter + 1;
      return delta_occupancy;
    }
  return 0;
}


/*************************************************************************************************************/
unsigned long long
get_node_avg_delta_occupancy(char * macadd,
                             char * dev_name,
                             unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long rx_bytes;
  unsigned long long tx_bytes;
  unsigned long long occupancy;
  unsigned long long delta_occupancy;
  unsigned long long avg_delta_occupancy;
  int i;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  rx_bytes = get_node_rx_bytes(macadd, dev_name, code_err);
  tx_bytes = get_node_tx_bytes(macadd, dev_name, code_err);

  /*
  // FOR TESTING -- BEGINNING
  rx_bytes = 10+3*counter;
  tx_bytes = 20+2*counter;
  // FOR TESTING -- END
  */
  
  if (!(*code_err))
    {
      occupancy = rx_bytes + tx_bytes;

      /*
      // FOR TESTING -- BEGINNING
      printf("calculated occupancy = %u \n", occupancy);
      printf("counter = %d\n", counter);
      // FOR TESTING -- END
      */
      
      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev) 
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }
           
      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }
        
      metric_type = lookup_metric(OCCUPANCY, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(OCCUPANCY);
          add_metric(metric_type, &node->list_metric_log);
        }
        
      

      delta_occupancy = occupancy - metric_type->last_values[0];
      avg_delta_occupancy = delta_occupancy;
      for (i = 0; i < MAX_METRIC_VALUES - 1; i++)
        {
          delta_occupancy = metric_type->last_values[i] -  metric_type->last_values[i+1];
          avg_delta_occupancy = avg_delta_occupancy + delta_occupancy;
        }

      counter = counter + 1;

      if (counter < MAX_METRIC_VALUES)
        avg_delta_occupancy = (avg_delta_occupancy)/(counter);
      else
        avg_delta_occupancy = (avg_delta_occupancy)/(MAX_METRIC_VALUES);

      set_new_value_metric(occupancy, metric_type->last_values);

      return avg_delta_occupancy;
    }
  return 0;
}


unsigned long long
get_node_avg_rssi(char * macadd,
                  char * dev_name,
                  unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long rssi;
  //  unsigned long long delta_rssi;
  unsigned long long avg_delta_rssi;
  int i;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  rssi = get_node_rssi(macadd, dev_name, code_err);

  if (!(*code_err))
    {
      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev)
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }

      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }

      metric_type = lookup_metric(RSSI, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(RSSI);
          add_metric(metric_type, &node->list_metric_log);
        }

      //      delta_rssi = rssi - metric_type->last_values[0];
      avg_delta_rssi = rssi; //delta_rssi;
      for (i = 0; i < MAX_METRIC_VALUES - 1; i++)
        {
          //              delta_rssi = metric_type->last_values[i] -  metric_type->last_values[i+1];
          //          avg_delta_rssi = avg_delta_rssi + delta_rssi;

          avg_delta_rssi = avg_delta_rssi + metric_type->last_values[i];
        }

      counter = counter + 1;

      if (counter < MAX_METRIC_VALUES)
        avg_delta_rssi = (avg_delta_rssi)/(counter);
      else
        avg_delta_rssi = (avg_delta_rssi)/(MAX_METRIC_VALUES);

      set_new_value_metric(rssi, metric_type->last_values);

      return avg_delta_rssi;
    }
  return 0;
}


/*************************************************************************************************************/
unsigned long long
get_node_avg_delta_tx_frame_with_no_ack(char * macadd, 
                                        char * dev_name, 
                                        unsigned int * code_err)
{  
  static int counter = 0;
  unsigned long long tx_frame_with_no_ack;
  unsigned long long delta_tx_frame_with_no_ack;
  unsigned long long avg_delta_tx_frame_with_no_ack;
  int i;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  tx_frame_with_no_ack = get_node_on_tx_err(macadd, dev_name, code_err);
   
  if (!(*code_err))
    {     
      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev) 
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }
           
      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }
        
      metric_type = lookup_metric(TX_FRAME_WITH_NO_ACK, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(TX_FRAME_WITH_NO_ACK);
          add_metric(metric_type, &node->list_metric_log);
        }
        
      
      delta_tx_frame_with_no_ack = tx_frame_with_no_ack - metric_type->last_values[0];
      avg_delta_tx_frame_with_no_ack = delta_tx_frame_with_no_ack;
      for (i = 0; i < MAX_METRIC_VALUES - 1; i++)
        {
          delta_tx_frame_with_no_ack = metric_type->last_values[i] -  metric_type->last_values[i+1];
          avg_delta_tx_frame_with_no_ack = avg_delta_tx_frame_with_no_ack + delta_tx_frame_with_no_ack;
        }

      counter = counter + 1;

      if (counter < MAX_METRIC_VALUES)
        avg_delta_tx_frame_with_no_ack = (avg_delta_tx_frame_with_no_ack)/(counter);
      else
        avg_delta_tx_frame_with_no_ack = (avg_delta_tx_frame_with_no_ack)/(MAX_METRIC_VALUES);

      set_new_value_metric(tx_frame_with_no_ack, metric_type->last_values);

      return avg_delta_tx_frame_with_no_ack;
    }
  return 0;
}


/*************************************************************************************************************/
unsigned long long
get_node_delta_tx_trial(char * macadd,
                         char * dev_name,
                         unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long tx_trial;
  unsigned long long delta_tx_trial;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  tx_trial = get_node_on_tx_ok(macadd, dev_name, code_err)+get_node_on_tx_err(macadd, dev_name, code_err);

//  printf ("\n>>>>>>>>>>>>>>>>>>>>> TRIAL %u\n", (unsigned) tx_trial);
  
  if (!(*code_err))
    {

      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev)
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }

      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }

      metric_type = lookup_metric(TX_TRIAL, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(TX_TRIAL);
          add_metric(metric_type, &node->list_metric_log);
        }

      delta_tx_trial = tx_trial - metric_type->last_values[0];
      set_new_value_metric(tx_trial, metric_type->last_values);

      counter = counter + 1;

//      printf (">>>>>>>>>>>>>>>>>>>>> DELTA_TX_TRIAL %u\n", (unsigned) delta_tx_trial);
      
      return delta_tx_trial;
    }
  return 0;
}

/*************************************************************************************************************/
unsigned long long
get_node_delta_tx_err(char * macadd,
                         char * dev_name,
                         unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long tx_err;
  unsigned long long delta_tx_err;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  tx_err = get_node_on_tx_err(macadd, dev_name, code_err);

  if (!(*code_err))
    {

      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev)
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }

      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }

      metric_type = lookup_metric(TX_ERR, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(TX_ERR);
          add_metric(metric_type, &node->list_metric_log);
        }

      delta_tx_err = tx_err - metric_type->last_values[0];
      set_new_value_metric(tx_err, metric_type->last_values);

      counter = counter + 1;
      return delta_tx_err;
    }
  return 0;
}


/*************************************************************************************************************/
unsigned long long
get_node_tx_failure_rate(char * macadd,
                           char * dev_name,
                           unsigned int * code_err)
{
  unsigned long long tx_failure_rate;
  unsigned long long tx_trial;
  unsigned long long tx_err;

  tx_trial = get_node_delta_tx_trial(macadd, dev_name, code_err);
  tx_err = get_node_delta_tx_err(macadd, dev_name, code_err);

  if (!(*code_err))
    {
      if (tx_trial==0)
        tx_failure_rate = 0;
        else
        tx_failure_rate = (unsigned long long) (((float)tx_err/(float)tx_trial*10000.0));
        
      return tx_failure_rate;
    }
  return 0;
}

/*************************************************************************************************************/
unsigned long long
get_node_avg_tx_failure_rate(char * macadd,
                  char * dev_name,
                  unsigned int * code_err)
{
  static int counter = 0;
  unsigned long long tx_failure_rate;
  unsigned long long avg_tx_failure_rate;
  int i;

  struct net_dev * dev;
  struct node * node;
  struct metrics_log * metric_type;

  tx_failure_rate = get_node_tx_failure_rate(macadd, dev_name, code_err);

  if (!(*code_err))
    {
      dev = lookup_net_dev(dev_name, net_dev_list);
      if (!dev)
        {
          dev = new_net_dev(dev_name);
          add_net_dev(dev, &net_dev_list);
        }

      node = lookup_node(macadd, dev->list_node);
      if (!node)
        {
          node = new_node(macadd);
          add_node(node, &dev->list_node);
        }

      metric_type = lookup_metric(TX_FAILURE_RATE, node->list_metric_log);
      if (!metric_type)
        {
          metric_type = new_metric(TX_FAILURE_RATE);
          add_metric(metric_type, &node->list_metric_log);
        }

      avg_tx_failure_rate = tx_failure_rate; 
      for (i = 0; i < MAX_METRIC_VALUES - 1; i++)
        {
          avg_tx_failure_rate = avg_tx_failure_rate + metric_type->last_values[i];
        }

      counter = counter + 1;

      if (counter < MAX_METRIC_VALUES)
        avg_tx_failure_rate = (avg_tx_failure_rate)/(counter);
      else
        avg_tx_failure_rate = (avg_tx_failure_rate)/(MAX_METRIC_VALUES);

      set_new_value_metric(tx_failure_rate, metric_type->last_values);

      return avg_tx_failure_rate;
    }
  return 0;
}

---