rres.h

Go to the documentation of this file.

#ifndef __RRES_H__
#define __RRES_H__

#include "rres_config.h"
#include "rres_interface.h"

#include "qos_types.h"
#include "qos_memory.h"
#include "qos_list.h"
//#include "qos_kernel_dep.h"
#include <linux/aquosa/kal_generic.h>
#include <linux/aquosa/rres_time.h>

struct kal_timer_t;

extern spinlock_t generic_scheduler_lock __cacheline_aligned; 
extern struct list_head server_list;    
extern kal_time_t last_update_time;   
#ifdef CONFIG_RRES_DEFAULT_SRV
extern server_t *default_srv;           
#endif

qos_rv rres_init(void);

qos_rv rres_cleanup(void);

qos_rv rres_cleanup_default_server_nosched(server_t *srv);

/* Remove a task from its server and let it be scheduled by the system default scheduling policy (e.g. Linux in a Linux box) */
qos_rv rres_detach_task_nosched(server_t *srv, struct task_struct *task);

qos_rv rres_move_nosched(server_t * new_srv, struct task_struct *task);

//qos_rv rres_activate_nosched(server_t *srv);

//qos_rv rres_deactivate_nosched(server_t *srv);

void rres_schedule(void);

/* @todo (low) add a condition like (if (approved_changed()) {recharge();}).  */
void recharge(server_t *srv);

void recharge_reset_from_now(server_t *srv);

qos_rv rres_on_task_block(struct task_struct *task);

qos_rv rres_on_task_unblock(struct task_struct *task);

#define for_each_srv(srv, head, list_field, pos) \
        for ((pos) = (head)->next, prefetch((pos)->next); \
        (srv) = (list_entry((pos), server_t, list_field)), (pos) != (head); \
                (pos) = (pos)->next, prefetch((pos)->next))

#define for_each_srv_safe(srv, head, list_field, pos, postmp) \
   for (pos = (head)->next, postmp = pos->next; \
         (srv) = (list_entry((pos), server_t, list_field)), pos != (head); \
         pos = postmp, postmp = pos->next)

#define for_each_server(srv, pos)        for_each_srv((srv), &server_list, slist,    (pos))

#define for_each_server_safe(srv, pos, tmppos)        for_each_srv_safe((srv), &server_list, slist,    (pos), (tmppos))

#define get_task_entry(h) list_entry((h), struct task_list, others)

#define for_each_ready_task_in_server(__srv, t, pos) \
        for ((pos) = (__srv)->ready_tasks.next, prefetch((pos)->next); \
        (t) = (list_entry((pos), struct task_list, node))->task, (pos) != &((__srv)->ready_tasks); \
                (pos) = (pos)->next, prefetch((pos)->next))

#define for_each_blocked_task_in_server(__srv, t, pos) \
        for ((pos) = (__srv)->blocked_tasks.next, prefetch((pos)->next); \
        (t) = (list_entry((pos), struct task_list, node))->task, (pos) != &((__srv)->blocked_tasks); \
                (pos) = (pos)->next, prefetch((pos)->next))

#define for_each_ready_task_in_server_safe(__srv, t, __pos, __tmp) \
        for ((__pos) = (__srv)->ready_tasks.next, __tmp = (__pos)->next; \
        (t) = (list_entry((__pos), struct task_list, node))->task, (__pos) != &((__srv)->ready_tasks); \
                (__pos) = (__tmp), __tmp = (__pos)->next)

#define for_each_blocked_task_in_server_safe(__srv, t, __pos, __tmp) \
        for ((__pos) = (__srv)->blocked_tasks.next, __tmp = (__pos)->next; \
        (t) = (list_entry((__pos), struct task_list, node))->task, (__pos) != &((__srv)->blocked_tasks); \
                (__pos) = (__tmp), __tmp = (__pos)->next)

static inline qos_bool_t is_in_default_server(struct task_struct *t) {
#if defined (CONFIG_RRES_DEFAULT_SRV)
  return rres_find_by_task(t) == default_srv;
#else
  return 0;
#endif  
}

static inline qos_bool_t is_default_server(server_t * srv) { 
#if defined (CONFIG_RRES_DEFAULT_SRV)
  return (srv == default_srv); 
#else
  return 0;
#endif  
}

/*********** DISPATCH RELATED ****************/

void rres_stop(server_t * srv);

void rres_dispatch(server_t *srv);

void stop_task_safe(server_t *srv, struct task_struct *task);

void dispatch_task_safe(server_t *srv, struct task_struct *task);

#endif

---