rres_unused.c

Go to the documentation of this file.

#include "rres_config.h"
#define QOS_DEBUG_LEVEL RRES_MOD_DEBUG_LEVEL
#include "qos_debug.h"

#include "rres.h"
#include "rres_kpi_protected.h"
#include "rres_ready_queue.h"
#include "rres_dispatch.h"
#include "rres_algorithms.h"
#include "kal_timer.h"
#include "qos_func.h"

// * to the default server, then reschedule 
// * @todo remove this function? */
//qos_func_define(qos_rv, rres_move_to_default_srv, server_t *srv, kal_task_t *task) {
//  qos_rv rv;
//  qos_chk_rv(rres_find_by_task(task) == srv, QOS_E_INTERNAL_ERROR);    // Programming error
//  if (is_default_server(srv))
//    rv = QOS_OK;
//  else if (rres_get_default_server() == NULL)
//    rv = rres_detach_task_nosched(srv, task);
//  else
//    rv = rres_move_nosched(default_srv, task);
//  rres_schedule();
//  return rv;
//}

/********************************* FUNCTION TO BE VERIFIED ******************/
#if 0

qos_rv rres_move(server_t * new_srv, kal_task_t *task);

qos_rv rres_move_all(server_t *new_srv, server_t *old_srv) {
  struct list_head *h, *tmp_h;
  kal_task_t *task_tmp;

  old_srv->forbid_reorder = 1;
  rres_sample_time();
  for_each_task_in_server_safe(old_srv, task_tmp, h, tmp_h)
    qos_chk_ok_ret(rres_move_nosched(new_srv, task_tmp));
  qos_chk_ok_ret(rres_check_destroy(old_srv));
  old_srv = NULL; // DO NOT USE 'old_srv' VAR FROM HERE ON
  rres_schedule();
  return QOS_OK;
}

int rres_move_opt(kal_task_t *task, server_t * new_srv)
{
  struct list_head *h, *tmp_h;
  kal_task_t *task_tmp;
  server_t * old_srv = rres_find_by_task(task);

  rres_sample_time();
  for_each_task_in_server_safe(old_srv, task_tmp, h, tmp_h) {
    if(task_tmp == task) {
      list_del(h);
#ifdef CONFIG_RRES_DEFAULT_SRV
      if (is_default_server(new_srv)) {
        qos_free(get_task_entry(h));
        task_tmp->private_data = default_srv;
      } else
#else
      rres_add_simple(new_srv, get_task_entry(h));
#endif
      if (task_running(task)) { 
        rres_deactivate_nosched(old_srv);
        rres_activate_nosched(new_srv);
        sync_task_with_server(new_srv, task); /* maybe this should be optimize since the state 
             of new_srv can be change after call to rres_schedule() */
      }   
      rres_schedule();
      return 0;
    }
  }
  return -1;
}

qos_rv rres_move_all_to_default_srv(server_t * srv)
{
  struct list_head *h, *tmp_h;
  kal_task_t *task_tmp;

  rres_sample_time();
  for_each_task_in_server_safe(srv, task_tmp, h, tmp_h) {
    list_del(h);
    qos_free(get_task_entry(h));
    task_tmp->private_data = default_srv;
    if (task_running(task_tmp)) { 
      qos_chk_ok_ret(rres_deactivate_nosched(srv));
      qos_chk_ok_ret(rres_activate_nosched(default_srv));
      /* Maybe this should be optimized since the state 
         of new_srv can be changed after call to rres_schedule() */
      sync_task_with_server(default_srv, task_tmp);
    }   
  }
  return QOS_OK;
}

int rres_move_all_opt(server_t *old_srv, server_t *new_srv)
{
  struct list_head *h, *tmp_h;
  kal_task_t *task_tmp;
  int call_sched = 0;
  
  rres_sample_time();
#ifdef CONFIG_RRES_DEFAULT_SRV      
  if (is_default_server(new_srv)) { 
    return rres_move_all_to_default_srv(old_srv);
  }
#endif
  for_each_task_in_server_safe(old_srv, task_tmp, h, tmp_h) {
      list_del(h);
      rres_add_simple(new_srv, get_task_entry(h));
      if (task_running(task_tmp)) { 
        call_sched += rres_deactivate_nosched(old_srv);
        call_sched += rres_activate_nosched(new_srv);
        sync_task_with_server(default_srv, task_tmp); /* maybe this should be optimize since the state 
                         of new_srv can be change after call to rres_schedule() */
      }   
  }
  /* this is a possible optimization 
  if (old_srv->activations >= 1) {
    new_srv->activations += (old_srv->activations -1); // -1 is needed since we have to call rres_activate() later 
    old_srv->activations = 0; // is this correct? Do we have to call rres_deactivate_nosched() at least once? 
    call_sched = rres_activate_nosched();
  } 
  */
  if (call_sched)
    return RRES_NEED_RESCHED;
  return 0;
}

int rres_detach_all_tasks_opt(server_t * srv) {}
int rres_attach_all_tasks_opt(list) {}

#endif  // #if 0

---