sched_context.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef sched_context_h
#define sched_context_h

#include "types.h"

//
// INTERFACE definition follows 
//


class Context;
class slab_cache_anon;

/*
 * Timeslice infrastructure
 */


class Sched_context
{
  friend class Jdb_list_timeouts;

public:
  enum Preemption_type {
    None,
    Timeslice_overrun,
    Deadline_miss
  };

private:
  Context * const       _owner;
  unsigned short const  _id;
  unsigned short        _prio;
  Unsigned64            _quantum;
  Unsigned64            _left;
  Preemption_type       _preemption_type;
  Cpu_time              _preemption_time;
  unsigned              _preemption_count;
  Sched_context *       _prev;
  Sched_context *       _next;

  static slab_cache_anon * _slabs;
  friend void allocator_init();

public:  
  Sched_context(Context * const owner, unsigned short const id, unsigned short prio, Unsigned64 quantum);
  
  inline void * operator new (size_t);
  
  inline void operator delete (void * const ptr);
  
  inline Sched_context * next() const;
  
  inline Sched_context * prev() const;
  
  inline void enqueue_before(Sched_context * const sibling);
  
  inline void dequeue();
  
  inline Context * owner() const;
  
  inline unsigned short id() const;
  
  inline unsigned short prio() const;
  
  inline void set_prio(unsigned short const prio);
  
  inline Unsigned64 quantum() const;
  
  inline void set_quantum(Unsigned64 const quantum);
  
  inline Unsigned64 left() const;
  
  inline void set_left(Unsigned64 const left);
  
  inline Sched_context::Preemption_type preemption_type() const;
  
  inline Cpu_time preemption_time() const;
  
  inline unsigned preemption_count() const;
  
  inline void set_preemption_event(Preemption_type const type, Cpu_time const clock);
  
  inline void clear_preemption_event();
  
  inline Sched_context * find_next_preemption();
};

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include <cassert>
#include "cpu_lock.h"
#include "kdb_ke.h"
#include "lock_guard.h"
#include "slab_cache_anon.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//



inline void *
Sched_context::operator new (size_t)
{
  void *ptr = _slabs->alloc();

  if (!ptr)
    kdb_ke ("Sched_context: Out of slab memory!");

  return ptr;
}


inline void
Sched_context::operator delete (void * const ptr)
{
  _slabs->free (ptr);
}


inline Sched_context *
Sched_context::next() const
{
  return _next;
}


inline Sched_context *
Sched_context::prev() const
{
  return _prev;
}


inline void
Sched_context::enqueue_before(Sched_context * const sibling)
{
  Lock_guard <Cpu_lock> guard (&cpu_lock);

  _next = sibling;
  _prev = sibling->prev();

  assert (_prev);

  _prev->_next = sibling->_prev = this;
}


inline void
Sched_context::dequeue()
{
  Lock_guard <Cpu_lock> guard (&cpu_lock);

  _prev->_next = _next;
  _next->_prev = _prev;
}


inline Context *
Sched_context::owner() const
{
  return _owner;
}


inline unsigned short
Sched_context::id() const
{
  return _id;
}


inline unsigned short
Sched_context::prio() const
{
  return _prio;
}


inline void
Sched_context::set_prio(unsigned short const prio)
{
  _prio = prio;
}


inline Unsigned64
Sched_context::quantum() const
{
  return _quantum;
}


inline void
Sched_context::set_quantum(Unsigned64 const quantum)
{
  _quantum = quantum;
}


inline Unsigned64
Sched_context::left() const
{
  return _left;
}


inline void
Sched_context::set_left(Unsigned64 const left)
{
  _left = left;
}


inline Sched_context::Preemption_type
Sched_context::preemption_type() const
{
  return _preemption_type;
}


inline Cpu_time
Sched_context::preemption_time() const
{
  return _preemption_time;
}


inline unsigned
Sched_context::preemption_count() const
{
  return _preemption_count;
}


inline void
Sched_context::set_preemption_event(Preemption_type const type,
                                     Cpu_time const clock)
{
  _preemption_type = type;
  _preemption_time = clock;
  _preemption_count++;
}



inline void
Sched_context::clear_preemption_event()
{
  _preemption_type  = None;
  _preemption_count = 0;
}


inline Sched_context *
Sched_context::find_next_preemption()
{
  // Clear preemption event for this Sched_context
  clear_preemption_event();

  // Now find the next Sched_context with a pending preemption event
  for (Sched_context *tmp = next(); tmp != this; tmp = tmp->next())
    if (tmp->preemption_type() != None)
      return tmp;

  return 0;
}

#endif // sched_context_h

---