space_index.h

Go to the documentation of this file.

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

#ifndef space_index_h
#define space_index_h

#include "l4_types.h"

//
// INTERFACE definition follows 
//


class Space;
class Space_registry;

class Space_index
{
public:
  enum
  {
    Max_space_number = L4_uid::Max_tasks
  };

private:
  // CLASS DATA
  static Space_registry* spaces;

  // DATA
  unsigned space_id;

public:  
  explicit inline Space_index(unsigned number); // type-conversion cons.:
  // from task number
  
  inline operator unsigned (); // return chief number
  
  inline Space * lookup();
  
  inline bool set_chief(Space_index old_chief, Space_index new_chief);
  
  inline Space_index chief(); // return chief number
  
  static inline bool add(Space *new_space, unsigned new_number);
  
  static inline bool del(Space_index number, Space_index chief);
  
  static inline void aux_del(Space_index /*number*/);
};

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


#include "atomic.h"

#include <cassert>

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




inline Space_index::Space_index(unsigned number) // type-conversion cons.:
                                              // from task number
  : space_id(number)
{ }



inline Space_index::operator unsigned () // return chief number
{ return space_id; }

// 
// Space_registry
// 
struct Space_registry
{
  union {
    Space *space;
    struct {
      unsigned dead : 1;
      unsigned chief : 31;
    } state;
  };

  operator Mword () { return (Mword)space; }


public:  
  // constructor: initialize to "dead = 1"
  inline Space_registry();
};



inline Space *
Space_index::lookup()
{ 
  if (spaces[space_id].state.dead)
    return 0;

  return spaces[space_id].space;
}


// constructor: initialize to "dead = 1"

inline Space_registry::Space_registry()
{ 
  state.chief = 0;
  state.dead = 1; 
} 



inline bool 
Space_index::set_chief(Space_index old_chief, Space_index new_chief)
{
  Space_registry o(spaces[space_id]);

  if (! o.state.dead || o.state.chief != old_chief)
    return false;

  Space_registry n;
  n.state.chief = new_chief;

  return cas (&spaces[space_id], o, n);
}



inline Space_index 
Space_index::chief() // return chief number
{
  assert (spaces[space_id].state.dead); // space does not exist

  return Space_index(spaces[space_id].state.chief);
}



inline bool 
Space_index::add(Space *new_space, unsigned new_number)
{
  Space_registry o(spaces[new_number]);
  assert(o.state.dead);

  Space_registry n;
  n.space = new_space;

  return cas (&spaces[new_number], o, n);
}



inline void
Space_index::aux_del(Space_index /*number*/)
{}



inline bool 
Space_index::del(Space_index number, Space_index chief)
{
  assert(number < Max_space_number);
  assert(! spaces[number].state.dead);

  // when deleting a task, write its owner (chief) into the task register
  spaces[number].state.dead = 1;
  spaces[number].state.chief = chief;

  aux_del(number);

  return true;
}

#endif // space_index_h

---