context.h

Go to the documentation of this file.

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

#ifndef context_h
#define context_h

#include "types.h"
#include "config.h"
#include "fpu_state.h"
#include "sched_context.h"

//
// INTERFACE definition follows 
//


class Entry_frame;
class Space;
class Thread_lock;

class Context
{
  friend class Jdb_thread_list;

public:

  enum Sched_mode {
    Periodic    = 0x1,  
    Nonstrict   = 0x2,  
  };

  enum Helping_mode {
    Helping,
    Not_Helping,
    Ignore_Helping
  };

  static const size_t size = Config::thread_block_size;

  void init_switch_time();

  Cpu_time consumed_time();

  Utcb* utcb() const;

protected:
  void update_consumed_time();

  Mword                 _state;
  Mword   *             _kernel_sp;

private:
  friend class Jdb;
  friend class Jdb_tcb;

  void switchin_context() asm ("switchin_context_label") FIASCO_FASTCALL;

  void switch_fpu (Context *t);

  void switch_cpu (Context *t);

  Space *               _space;
  Context *             _donatee;
  Context *             _helper;

  // Lock state
  // how many locks does this thread hold on other threads
  // incremented in Thread::lock, decremented in Thread::clear
  // Thread::kill needs to know
  int                   _lock_cnt;
  Thread_lock * const   _thread_lock;

  // The scheduling parameters.  We would only need to keep an
  // anonymous reference to them as we do not need them ourselves, but
  // we aggregate them for performance reasons.
  Sched_context         _sched_context;
  Sched_context *       _sched;
  Unsigned64            _period;
  Sched_mode            _mode;
  unsigned short        _mcp;

  // Pointer to floating point register state
  Fpu_state             _fpu_state;

  // Implementation-specific consumed CPU time (TSC ticks or usecs)
  Cpu_time              _consumed_time;

  Context *             _ready_next;
  Context *             _ready_prev;

  static bool           _schedule_in_progress;
  static Sched_context *_current_sched          asm ("CONTEXT_CURRENT_SCHED");
  static Cpu_time       _switch_time            asm ("CONTEXT_SWITCH_TIME");
  static unsigned       _prio_highest           asm ("CONTEXT_PRIO_HIGHEST");
  static Context *      _prio_next[256]         asm ("CONTEXT_PRIO_NEXT");
private:

protected:
  // make sure that there is no virtual function
  void send_activation (unsigned);

public:  
  inline Context(Thread_lock *thread_lock, Space* space, unsigned short prio, unsigned short mcp, Unsigned64 quantum);
  
  virtual ~Context();
  
  inline Mword state() const;
  
  inline Mword exists() const;
  
  inline void state_add(Mword const bits);
  
  inline void state_del(Mword const bits);
  
  inline Mword state_change_safely(Mword const mask, Mword const bits);
  
  inline Mword state_change(Mword const mask, Mword const bits);
  
  inline void state_change_dirty(Mword const mask, Mword const bits);
  
  inline Space * space() const;
  
  inline Thread_lock * const thread_lock() const;
  
  inline unsigned short const mcp() const;
  
  inline Entry_frame * const regs() const;
  
  inline void inc_lock_cnt();
  
  inline void dec_lock_cnt();
  
  inline int const lock_cnt() const;
  
  
  void switch_sched(Sched_context * const next);
  
  void schedule();
  
  static inline bool const schedule_in_progress();
  
  static inline bool const can_preempt_current(Sched_context const * const s);
  
  static inline Sched_context * const current_sched();
  
  inline Sched_context * sched_context(unsigned short const id = 0);
  
  inline Sched_context * sched() const;
  
  inline Unsigned64 const period() const;
  
  inline Context::Sched_mode const mode() const;
  
  inline void set_mode(Context::Sched_mode const mode);
  
  inline Mword const in_ready_list() const;
  
  void ready_enqueue();
  
  inline void ready_dequeue();
  
  inline Context * const helper() const;
  
  inline void set_helper(enum Helping_mode const mode);
  
  inline Context * const donatee() const;
  
  inline void set_donatee(Context * const donatee);
  
  inline Mword * const get_kernel_sp() const;
  
  inline void set_kernel_sp(Mword * const esp);
  
  inline Fpu_state * fpu_state();
  
  inline void consume_time(Cpu_time const quantum);
  
  inline void switch_to(Context *t);
  
  inline void switch_to_locked(Context *t);
  
  inline void switch_exec(Context *t, enum Helping_mode mode);
  
  void switch_exec_locked(Context *t, enum Helping_mode mode);
  
  GThread_num gthread_calculated();
  
  inline LThread_num lthread_calculated();
  
  inline LThread_num task_calculated();
  
  inline void update_kip_switch_time(Context * t);

protected:  
  static void set_current_sched(Sched_context * const sched);
  
  static void invalidate_sched();
  
  inline void set_sched(Sched_context * const sched);
  
  inline void set_period(Unsigned64 const period);
  
  inline void switch_gdt_tls();
  
  inline void load_segments();
  
  inline void store_segments();

private:  
  inline void update_ready_list();
};

inline void update_utcb_ptr();

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

#include "atomic.h"
#include "cpu_lock.h"
#include "entry_frame.h"
#include "std_macros.h"

#include "l4_types.h"

#include <cassert>

#include "cpu.h"
#include "globals.h"            // current()
#include "lock_guard.h"
#include "thread_state.h"
#include "kip.h"

#include "fpu.h"

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



inline Context::Context(Thread_lock *thread_lock,
                  Space* space,
                  unsigned short prio,
                  unsigned short mcp,
                  Unsigned64 quantum)
       : _space     (space),
         _helper            (this),
         _thread_lock       (thread_lock),
         _sched_context     (this, 0, prio, quantum),
         _sched             (&_sched_context),
         _period            (0),
         _mode              (Sched_mode (0)),
         _mcp               (mcp),
         _consumed_time     (0)
{
  // NOTE: We do not have to synchronize the initialization of
  // _space_context because it is constant for all concurrent
  // invocations of this constructor.  When two threads concurrently
  // try to create a new task, they already synchronize in
  // sys_task_new() and avoid calling us twice with different
  // space_context arguments.

  Mword *init_sp = reinterpret_cast<Mword*>
    (reinterpret_cast<Mword>(this) + size - sizeof (Entry_frame));

  // don't care about errors: they just mean someone else has already
  // set up the tcb

  cas (&_kernel_sp, (Mword *) 0, init_sp);
}


inline Mword
Context::state() const
{
  return _state;
}


inline Mword
Context::exists() const
{
  return _state != Thread_invalid;
}


inline void
Context::state_add(Mword const bits)
{
  atomic_or (&_state, bits);
}


inline void
Context::state_del(Mword const bits)
{
  atomic_and (&_state, ~bits);
}


inline Mword
Context::state_change_safely(Mword const mask, Mword const bits)
{
  Mword old;

  do
    {
      old = _state;
      if (old & bits & mask | ~old & ~mask)
        return 0;
    }
  while (!cas (&_state, old, old & mask | bits));

  return 1;
}


inline Mword
Context::state_change(Mword const mask, Mword const bits)
{
  return atomic_change (&_state, mask, bits);
}


inline void
Context::state_change_dirty(Mword const mask, Mword const bits)
{
  _state &= mask;
  _state |= bits;
}


inline Space *
Context::space() const
{
  return _space;
}


inline Thread_lock * const
Context::thread_lock() const
{
  return _thread_lock;
}



inline unsigned short const
Context::mcp() const
{
  return _mcp;
}


inline Entry_frame * const
Context::regs() const
{
  return reinterpret_cast<Entry_frame *>
    (reinterpret_cast<Mword>(this) + size - sizeof(Entry_frame));
}


inline void
Context::inc_lock_cnt()
{
  _lock_cnt++;
}


inline void
Context::dec_lock_cnt()
{
  _lock_cnt--;
}


inline int const
Context::lock_cnt() const
{
  return _lock_cnt;
}


inline bool const
Context::schedule_in_progress()
{
  return _schedule_in_progress;
}


inline bool const
Context::can_preempt_current(Sched_context const * const s)
{
  // XXX: Workaround for missing priority boost implementation
  if (current()->sched()->prio() >= s->prio())
    return false;

  return !current_sched() ||
          current_sched()->prio() < s->prio() ||
          current_sched() == s;
}


inline Sched_context * const
Context::current_sched()
{
  return _current_sched;
}


inline Sched_context *
Context::sched_context(unsigned short const id)
{
  if (EXPECT_TRUE (!id))
    return &_sched_context;

  for (Sched_context *tmp = _sched_context.next();
      tmp != &_sched_context; tmp = tmp->next())
    if (tmp->id() == id)
      return tmp;

  return 0;
}


inline Sched_context *
Context::sched() const
{
  return _sched;
}


inline Unsigned64 const
Context::period() const
{
  return _period;
}


inline Context::Sched_mode const
Context::mode() const
{
  return _mode;
}


inline void
Context::set_mode(Context::Sched_mode const mode)
{
  _mode = mode;
}


inline Mword const
Context::in_ready_list() const
{
  return _ready_next != 0;
}


inline void
Context::ready_dequeue()
{
  Lock_guard <Cpu_lock> guard (&cpu_lock);

  // Don't dequeue threads which aren't enqueued
  if (EXPECT_FALSE (!in_ready_list()))
    return;

  unsigned short prio = sched()->prio();

  if (_prio_next[prio] == this)
    _prio_next[prio] = _ready_next == this ? 0 : _ready_next;

  _ready_prev->_ready_next = _ready_next;
  _ready_next->_ready_prev = _ready_prev;
  _ready_next = 0;                              // Mark dequeued

  while (!_prio_next[_prio_highest] && _prio_highest)
    _prio_highest--;

  send_activation (1); // Send block message
}


inline Context * const
Context::helper() const
{
  return _helper;
}



inline void
Context::set_helper(enum Helping_mode const mode)
{
  switch (mode)
    {
    case Helping:
      _helper = current();
      break;
    case Not_Helping:
      _helper = this;
      break;
    case Ignore_Helping:
      // don't change _helper value
      break;
    }
}


inline Context * const
Context::donatee() const
{
  return _donatee;
}



inline void
Context::set_donatee(Context * const donatee)
{
  _donatee = donatee;
}



inline Mword * const
Context::get_kernel_sp() const
{
  return _kernel_sp;
}



inline void
Context::set_kernel_sp(Mword * const esp)
{
  _kernel_sp = esp;
}



inline Fpu_state *
Context::fpu_state()
{
  return &_fpu_state;
}


inline void
Context::consume_time(Cpu_time const quantum)
{
  _consumed_time += quantum;
}


inline void
Context::switch_to(Context *t)
{
  // Call switch_to_locked if CPU lock is already held
  assert (!cpu_lock.test());

  // Grab the CPU lock
  Lock_guard <Cpu_lock> guard (&cpu_lock);

  switch_to_locked (t);
}


inline void
Context::switch_to_locked(Context *t)
{
  // Must be called with CPU lock held
  assert (cpu_lock.test());

  // Switch to destination thread's scheduling context
  if (current_sched() != t->sched())
    set_current_sched (t->sched());

  // XXX: IPC dependency tracking belongs here.

  // Switch to destination thread's execution context, no helping involved
  if (t != this)
    switch_exec_locked (t, Not_Helping);
}


inline void
Context::switch_exec(Context *t, enum Helping_mode mode)
{
  // Call switch_exec_locked if CPU lock is already held
  assert (!cpu_lock.test());

  // Grab the CPU lock
  Lock_guard <Cpu_lock> guard (&cpu_lock);

  switch_exec_locked (t, mode);
}



inline LThread_num
Context::lthread_calculated()
{
  return gthread_calculated() % L4_uid::threads_per_task();
}



inline LThread_num
Context::task_calculated()
{
  return gthread_calculated() / L4_uid::threads_per_task();
}



inline void
Context::update_kip_switch_time(Context * t)
{
  if (Config::fine_grained_cputime)
    {
      Kip::k()->switch_time = _switch_time;
      Kip::k()->thread_time = t->_consumed_time;
    }
}


inline void
Context::set_sched(Sched_context * const sched)
{
  _sched = sched;
}


inline void
Context::set_period(Unsigned64 const period)
{
  _period = period;
}



inline void
Context::switch_gdt_tls()
{}



inline void
Context::load_segments()
{}



inline void
Context::store_segments()
{}



inline Utcb *
Context::utcb() const
{
  return 0;
}



inline void
Context::send_activation(unsigned)
{}



inline void
Context::init_switch_time()
{
  if (Config::fine_grained_cputime)
    _switch_time = Cpu::rdtsc();
}


inline void
Context::update_consumed_time()
{
  if (Config::fine_grained_cputime)
    {
      Cpu_time tsc = Cpu::rdtsc();
      consume_time (tsc - _switch_time);
      _switch_time = tsc;
    }
}



inline void
Context::switch_cpu(Context *t)
{
  Mword dummy1, dummy2, dummy3;

  update_consumed_time();
  update_kip_switch_time(t);

  store_segments();

  asm volatile
    (
     "   pushl %%ebp                    \n\t"   // save base ptr of old thread
     "   pushl $1f                      \n\t"   // restart addr to old stack
     "   movl  %%esp, (%0)              \n\t"   // save stack pointer
     "   movl  (%1), %%esp              \n\t"   // load new stack pointer
                                                // in new context now (cli'd)
     "   movl  %2, %%eax                \n\t"   // new thread's "this"
     "   call  switchin_context_label   \n\t"   // switch pagetable
     "   popl  %%eax                    \n\t"   // don't do ret here -- we want
     "   jmp   *%%eax                   \n\t"   // to preserve the return stack
                                                // restart code
     "  .p2align 4                      \n\t"   // start code at new cache line
     "1: popl %%ebp                     \n\t"   // restore base ptr

     : "=c" (dummy1), "=S" (dummy2), "=D" (dummy3)
     : "c" (&_kernel_sp), "S" (&t->_kernel_sp), "D" (t)
     : "eax", "ebx", "edx", "memory");
}



inline Cpu_time
Context::consumed_time()
{
  // When using fine-grained CPU time, this is not usecs but TSC ticks
  if (Config::fine_grained_cputime)
    return Cpu::tsc_to_us (_consumed_time);

  return _consumed_time;
}


inline void
Context::switch_fpu(Context *t)
{
  if (Fpu::is_owner(this))
    Fpu::disable();

  else if (Fpu::is_owner(t))
    Fpu::enable();
}



inline void
update_utcb_ptr() 
{}

#endif // context_h

---