gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-1.3.1/gecode/kernel/core.icc

@@ -1,1681 +0,0 @@
-/*
- *  Main authors:
- *     Christian Schulte <schulte@gecode.org>
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Christian Schulte, 2002
- *     Guido Tack, 2003
- *
- *  Bugfixes provided by:
- *     Alexander Samoilov <alexander_samoilov@yahoo.com>
- *
- *  Last modified:
- *     $Date: 2006-10-25 13:51:24 +0200 (Wed, 25 Oct 2006) $ by $Author: schulte $
- *     $Revision: 3787 $
- *
- *  This file is part of Gecode, the generic constraint
- *  development environment:
- *     http://www.gecode.org
- *
- *  See the file "LICENSE" for information on usage and
- *  redistribution of this file, and for a
- *     DISCLAIMER OF ALL WARRANTIES.
- *
- */
-
-namespace Gecode {
-
-  /**
-   * \defgroup TaskVarMEPC Generic modification events and propagation conditions
-   *
-   * Predefined modification events must be taken into account
-   * by variable types.
-   * \ingroup TaskVar
-   */
-  //@{
-  /// Type for modification events
-  typedef int ModEvent;
-
-  /// Generic modification event: failed variable
-  const ModEvent ME_GEN_FAILED   = -1;
-  /// Generic modification event: no modification
-  const ModEvent ME_GEN_NONE     =  0;
-  /// Generic modification event: variable is assigned a value
-  const ModEvent ME_GEN_ASSIGNED =  1;
-  /// Generic modification event: maximal modification event
-  const ModEvent ME_GEN_MAX      = 15;
-
-  /// Type for propagation conditions
-  typedef int PropCond;
-  /// Propagation condition for an assigned variable
-  const PropCond PC_GEN_ASSIGNED = 0;
-  /// Propagation conditions must be between 0 and 15
-  const PropCond PC_GEN_MAX      = 15;
-  //@}
-
-
-  /**
-   * \brief %Variable type identifiers
-   *
-   * Each variable type must have a unique variable type identifier. The
-   * kernel supports at most eight different variable type identifiers.
-   *
-   * If you want to add your own variable type, you have to make sure that
-   * file is created in the subdirectory vti. The names of the file defines
-   * the name of the variable type identifier (for example, if the name of
-   * the file is INT, it defines the identifier VTI_INT).
-   * \ingroup TaskVar
-   */
-  enum VarTypeId {
-#include "gecode/vti.icc"
-    VTI_LAST,     ///< Maximal variable type identifier plus one
-    VTI_NOIDX = 0 ///< Used for variables without indexing structure
-  };
-
-
-  /*
-   * These are the classes of interest
-   *
-   */
-  class Actor;
-  class Propagator;
-  class Space;
-  template <VarTypeId VTI, PropCond PC, class MED> class Variable;
-
-
-  /*
-   * Variables
-   *
-   */
-
-  /**
-   * \brief Base-class for variable implementations
-   *
-   * Serves as base-class that can be used without having to know any
-   * template arguments.
-   * \ingroup TaskVar
-   */
-  class VarBase {};
-
-  /**
-   * \brief Base-class for variable type processor
-   *
-   * Serves as base-class that can be used without having to know any
-   * template arguments.
-   * \ingroup TaskVar
-   */
-  class VarTypeProcessorBase {
-  public:
-    /// Process modified variables linked from \a x
-    virtual void process(Space* home, VarBase* x) = 0;
-    /**
-     * \brief Update copied variables linked from \a x
-     *
-     * The argument \a sub gives the array where subscriptions are
-     * to be stored.
-     */
-    virtual void update(VarBase* x, Propagator**& sub) = 0;
-    /**
-      * \brief Dispose variables
-      *
-      * If needed for the variable type, dispose a list of
-      * variables, with \a x being the first variable on the list.
-      */
-    virtual void dispose(Space* home, VarBase* x) = 0;
-    /// Destructor (not really used)
-    GECODE_KERNEL_EXPORT virtual ~VarTypeProcessorBase(void);
-  };
-
-  /**
-   * \brief %Variable type processor
-   *
-   * Base class for variable type processor for variable type index \a VTI
-   * and maximum propagation condition \a PC.
-   * \ingroup TaskVar
-   */
-  template <VarTypeId VTI, PropCond PC, class MED>
-  class VarTypeProcessor : public VarTypeProcessorBase {
-  public:
-    /// Constructor (registers processor with kernel)
-    VarTypeProcessor(void);
-    /**
-     * \brief Update copied variables linked from \a x
-     *
-     * The argument \a sub gives the array where subscriptions are
-     * to be stored.
-     */
-    virtual void update(VarBase* x, Propagator**& sub);
-    /**
-      * \brief Dispose variables
-      *
-      * If needed for the variable type, dispose a list of
-      * variables, with \a x being the first variable on the list.
-      */
-    virtual void dispose(Space* home, VarBase* x);
-  };
-
-  /**
-   * \brief Propagator modification events
-   *
-   * Propagator modification events are used by propagators. A
-   * propagator stores a modification event for each variable type.
-   * They can be accessed through a variable or a view from a given
-   * propagator. They can be constructed from a given modevent by
-   * a variable or view.
-   * \ingroup TaskActor
-   */
-  typedef int PropModEvent;
-
-
-  /**
-   * \brief Base-class for variable implementations
-   *
-   * Implements variable implementation for variable type identifier
-   * \a VTI and largest possible propagation condition \a PC.
-   * \ingroup TaskVar
-   */
-  template <VarTypeId VTI, PropCond PC, class MED>
-  class Variable : public VarBase {
-    friend class Space;
-    friend class Propagator;
-    friend class VarTypeProcessor<VTI,PC,MED>;
-  private:
-    Variable* _next; ///< Either next modified or copied variable
-    union {
-      /**
-       * \brief Combines the number of free entries with modification events
-       *
-       * The least four bits are reserved for the modification events, the
-       * remaining 28 bits are for the number of free entries.
-       *
-       */
-      unsigned int free_me;
-      /// Store the forwarding pointer during copying
-      Variable* fwd;
-    } u;
-    Propagator** idx[PC+2]; ///< Stores where entries start (idx[pc]}
-
-    /// Manage number of free entries internally
-    unsigned int free(void) const;
-    /// Manage number of free entries internally
-    void free(unsigned int n);
-    /// Manage number of free entries internally
-    void free_inc(void);
-    /// Manage number of free entries internally
-    void free_dec(void);
-
-    /**
-     * \brief Update copied variable \a x
-     *
-     * The argument \a sub gives the array where subscriptions are
-     * to be stored.
-     */
-    void update(Variable* x, Propagator**& sub);
-
-    /// Resize subscription array
-    void resize(Space* home);
-
-  public:
-    /// Creation
-    Variable(Space* home);
-
-    /// \name Dependencies
-    //@{
-    /** \brief Subscribe propagator \a p with propagation condition \a pc to variable
-     *
-     * In case \a process is false, the propagator is just subscribed but
-     * not processed for execution (this must be used when creating
-     * subscriptions during propagation).
-     *
-     * In case the variable is assigned (that is, \a assigned is 
-     * true), the subscribing propagator is processed for execution.
-     * Otherwise, the propagator subscribes and is processed for execution
-     * with modification event \a me provided that \a pc is different
-     * from \a PC_GEN_ASSIGNED.
-     */
-    void subscribe(Space* home, Propagator* p, PropCond pc,
-		   bool assigned, ModEvent me, bool process);
-    /// Cancel subscription of propagator \a p with propagation condition \a pc
-    void cancel(Space* home, Propagator* p, PropCond pc);
-    /// Return degree (number of subscribed propagators)
-    unsigned int degree(void) const;
-    /// Notify that variable implementation has been modified with modification event \a me
-    void notify(Space* home, ModEvent me);
-    /// Notify that variable implementation has been assigned (only if variable has single modification event)
-    void notify(Space* home);
-    //@}
-
-    /// \name Processing modified variables
-    //@{
-    /// Check whether variable has been modified during propagation
-    bool modified(void) const;
-    //@}
-
-    /// \name Cloning variables
-    //@{
-    /// Constructor for cloning
-    Variable(Space* home, bool share, Variable& x);
-    /// Is variable already copied
-    bool copied(void) const;
-    /// Use forward pointer if variable already copied
-    Variable* forward(void) const;
-    //@}
-
-    /// \name Propagator modification events
-    //@{
-    /// Return modification event for variable from propagator \a p
-    static ModEvent     pme(const Propagator* p);
-    /// Translate modification event \a me into propagator modification event
-    static PropModEvent pme(ModEvent me);
-    /// Combine modifications events \a me1 and \a me2
-    static ModEvent     combine(ModEvent me1, ModEvent me2);
-    //@}
-
-    /// \name Processing modified variables
-    //@{
-    /// Return next modified variable and reset (during processing)
-    Variable* next(void);
-    /// Return current modification event of variable
-    ModEvent modevent(void) const;
-    /// Set modification event to \a me
-    void modevent(ModEvent me);
-    /// Process subscribed propagators
-    void process(Space* home, PropCond pc1, PropCond pc2, ModEvent me);
-    /// Process subscribed propagators for assigned variable
-    void process(Space* home);
-    //@}
-
-    /// \name Memory management
-    //@{
-    /// Allocate memory from space
-    static void* operator new(size_t,Space*);
-    /// Return memory to space
-    static void  operator delete(void*,Space*);
-    /// Needed for exceptions
-    static void  operator delete(void*);
-    //@}
-  };
-
-
-
-
-  /**
-   * \brief Status of constraint propagation and branching commit
-   * \ingroup TaskActor
-   */
-  enum ExecStatus {
-    ES_FAILED          = -1, ///< Execution has resulted in failure
-    ES_NOFIX           =  0, ///< Propagation has not computed fixpoint
-    ES_OK              =  0, ///< Execution is okay
-    ES_FIX             =  1, ///< Propagation has computed fixpoint
-    ES_SUBSUMED        =  2, ///< %Propagator is subsumed (entailed)
-    __ES_FIX_PARTIAL   =  3, ///< Internal: do not use
-    __ES_NOFIX_PARTIAL =  4  ///< Internal: do not use
-  };
-
-  /**
-   * \brief Classification of propagation cost
-   * \ingroup TaskActor
-   */
-  enum PropCost {
-    PC_CRAZY_LO     = 0, ///< Exponential complexity, cheap
-    PC_CRAZY_HI     = 0, ///< Exponential complexity, expensive
-    PC_CUBIC_LO     = 1, ///< Cubic complexity, cheap
-    PC_CUBIC_HI     = 1, ///< Cubic complexity, expensive
-    PC_QUADRATIC_LO = 2, ///< Quadratic complexity, cheap
-    PC_QUADRATIC_HI = 2, ///< Quadratic complexity, expensive
-    PC_LINEAR_HI    = 3, ///< Linear complexity, expensive
-    PC_LINEAR_LO    = 4, ///< Linear complexity, cheap
-    PC_TERNARY_HI   = 5, ///< Three variables, expensive
-    PC_BINARY_HI    = 6, ///< Two variables, expensive
-    PC_TERNARY_LO   = 6, ///< Three variables, cheap
-    PC_BINARY_LO    = 7, ///< Two variables, cheap
-    PC_UNARY_LO     = 7, ///< Only single variable, cheap
-    PC_UNARY_HI     = 7, ///< Only single variable, expensive
-    PC_MAX          = 7  ///< Maximal cost value
-  };
-
-  /**
-   * \brief Double-linked list for actors
-   *
-   * Used to maintain which actors belong to a space and also
-   * (for propagators) to organize actors in the queue of
-   * waiting propagators.
-   */
-  class ActorLink {
-    friend class Actor;
-    friend class Space;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class Variable;
-  private:
-    ActorLink* _next; ActorLink* _prev;
-  public:
-    //@{
-    /// Routines for double-linked list
-    ActorLink* prev(void) const; void prev(ActorLink*);
-    ActorLink* next(void) const; void next(ActorLink*);
-    //@}
-
-
-    /// Initialize links (self-linked)
-    void init(void);
-    /// Remove from predecessor and successor
-    void unlink(void);
-    /// Insert \a al directly after this
-    void head(ActorLink* al);
-    /// Insert \a al directly before this
-    void tail(ActorLink* al);
-  };
-
-
-  /**
-   * \brief Double-linked list for deleting actors
-   *
-   * Used for actors that must be deleted (forced deletion) when a space
-   * is deleted (even if the space is failed).
-   *
-   * The reason why it is not conjoined with ActorLink is that the array
-   * of propagator queues just need the normal linkage, but not the linkage
-   * for deletion.
-   */
-  class ActorDeleteLink : public ActorLink {
-    friend class Actor;
-    friend class Space;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class Variable;
-  private:
-    ActorDeleteLink* _next_d; ActorDeleteLink* _prev_d;
-  public:
-    ActorDeleteLink* next_delete(void) const;
-    void next_delete(ActorDeleteLink*);
-    ActorDeleteLink* prev_delete(void) const;
-    void prev_delete(ActorDeleteLink*);
-
-    /// Initialize links (self-linked)
-    void init_delete(void);
-    void unlink_delete(void);
-    void insert_delete(ActorDeleteLink*,bool);
-  };
-
-
-
-  /**
-   * \brief Base-class for both propagators and branchings
-   * \ingroup TaskActor
-   */
-  class Actor : private ActorDeleteLink {
-    friend class Space;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class Variable;
-  public:
-    /// Create copy
-    virtual Actor* copy(Space*,bool) = 0;
-    /// Delete actor and return its size
-    GECODE_KERNEL_EXPORT
-    virtual size_t dispose(Space* home);
-
-    /// \name Memory management
-    //@{
-    /// Flush cache datastructures
-    GECODE_KERNEL_EXPORT virtual void flush(void);
-    /// Report size occupied by cached datastructures
-    GECODE_KERNEL_EXPORT virtual size_t cached(void) const;
-    /// Allocate memory from space
-    static void* operator new(size_t s, Space* home);
-    /// No-op for exceptions
-    static void  operator delete(void* p, Space* home);
-  private:
-#ifndef __GNUC__
-    /// Not used (uses dispose instead)
-    static void  operator delete(void* p, size_t s);
-#endif
-    /// Not used
-    static void* operator new(size_t s);
-    /// Destruct: unlink, dispose, and reclaim memory
-    void destruct(Space* home);
-    //@}
-#ifdef __GNUC__
-  public:
-    /// To avoid warnings from GCC
-    virtual ~Actor(void) {}
-    /// Not used (uses dispose instead)
-    static void  operator delete(void* p, size_t s);
-#endif
-  };
-
-
-
-  /**
-   * \brief Base-class for propagators
-   * \ingroup TaskActor
-   */
-  class Propagator : public Actor {
-    friend class Space;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class Variable;
-  private:
-    PropModEvent pme;
-  protected:
-    /**
-     * \brief Constructor for creation
-     *
-     * Force deletion, if \a fd is true
-     */
-    Propagator(Space* home, bool fd=false);
-    /// Constructor for cloning \a p
-    Propagator(Space* home, bool share, Propagator& p);
-
-    /// \name Partial fixpoints
-    //@{
-    /**
-     * \brief %Propagator has computed partial fixpoint
-     *
-     * %Set propagator modification events after processing of
-     * variables to \a pme.
-     * \warning Has a side-effect on the propagator. Overwrites
-     *          the propagator modification events of a propagator.
-     *          Use only directly with returning from propagation.
-     * \ingroup TaskActor
-     */
-    ExecStatus ES_FIX_PARTIAL(PropModEvent pme);
-    /**
-     * \brief %Propagator has not computed partial fixpoint
-     *
-     * %Set propagator modification events before processing of
-     * variables to \a pme.
-     * \warning Has a side-effect on the propagator. Overwrites
-     *          the propagator modification events of a propagator.
-     *          Use only directly with returning from propagation.
-     * \ingroup TaskActor
-     */
-    ExecStatus ES_NOFIX_PARTIAL(PropModEvent pme);
-    //@}
-  public:
-    /// \name Propagation
-    //@{
-    /// Propagation function
-    virtual ExecStatus propagate(Space*) = 0;
-    /// Cost function
-    virtual PropCost cost(void) const  = 0;
-    //@}
-  };
-
-
-
-  /*
-   * Branchings
-   *
-   */
-
-  class Branching;
-
-  /**
-   * \brief Branch description for batch recomputation
-   *
-   * Must be refined by inheritance such that the information stored
-   * inside a branching description is sufficient to redo a tell
-   * performed by a particular branching.
-   *
-   * \ingroup TaskActor
-   */
-  class BranchingDesc {
-    friend class Space;
-  private:
-    const unsigned int id;  ///< Identity to match creating branching
-    const unsigned int alt; ///< Number of alternatives
-  protected:
-    /// Initialize for particular branching \a b and alternatives \a a
-    BranchingDesc(const Branching* b, const unsigned int a);
-  public:
-    /// Destructor
-    GECODE_KERNEL_EXPORT virtual ~BranchingDesc(void);
-
-    /// Return number of alternatives
-    unsigned int alternatives(void) const;
-
-    /// Report size occupied by branching description
-    virtual size_t size(void) const = 0;
-    /// Allocate memory from heap
-    static void* operator new(size_t);
-    /// Return memory to heap
-    static void  operator delete(void*);
-  };
-
-  /**
-   * \brief Base-class for branchings
-   *
-   * Note that branchings cannot be created inside a propagator
-   * (no idea why one would like to that anyway). If you do that
-   * the system will explode in a truly interesting way.
-   *
-   * \ingroup TaskActor
-   */
-  class Branching : public Actor {
-    friend class Space;
-    friend class BranchingDesc;
-  private:
-    unsigned int id; ///< Unique identity (to match to branching descriptions)
-  protected:
-    /// Constructor for creation, force disposal if \a fd is true
-    Branching(Space* home, bool fd=false);
-    /// Constructor for cloning \a b
-    Branching(Space* home, bool share, Branching& b);
-
-  public:
-    /// \name Branching
-    //@{
-    /**
-     * \brief Check status of branching, return true if alternatives left
-     *
-     * This method is called when Space::status is called, it determines
-     * whether to continue branching with this branching or move on to
-     * the (possibly) next branching.
-     *
-     */
-    virtual bool status(const Space* home) const = 0;
-    /**
-     * \brief Return branching description
-     *
-     * Note that this method can rely on the fact that it is called
-     * immediately after a previous call to status. Hence, it is safe
-     * to remember computation from status in order to speed up
-     * description.
-     *
-     */
-    virtual const BranchingDesc* description(const Space* home) const = 0;
-    /**
-     * \brief Commit for branching description \a d and alternative \a a
-     *
-     * The current branching in the space \a home performs a commit from
-     * the information provided by the branching description \a d
-     * and the alternative \a a.
-     */
-    virtual ExecStatus commit(Space* home, const BranchingDesc* d,
-			      unsigned int a) = 0;
-    //@}
-  };
-
-
-
-  /** 
-   * \brief %Space status
-   * \ingroup TaskSearch
-   */
-  enum SpaceStatus {
-    SS_FAILED, ///< %Space is failed
-    SS_SOLVED, ///< %Space is solved (no branching left)
-    SS_BRANCH  ///< %Space must be branched (at least one branching left)
-  };
-
-  /**
-   * \brief Computation spaces
-   */
-  class Space {
-    friend class Propagator;
-    friend class Branching;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class Variable;
-    template <VarTypeId VTI, PropCond PC, class MED> friend class VarTypeProcessor;
-  private:
-    MemoryManager   mm; ///< Performs memory management for space
-
-    /**
-     * \name Processing variables
-     */
-    //@{
-    /// Registered variable type processors
-    GECODE_KERNEL_EXPORT
-    static VarTypeProcessorBase* vtp[VTI_LAST];
-    /// Array of all modified or copied variables (entry points)
-    VarBase* vars[VTI_LAST];
-    /// Array of lists of variables that need deletion
-    VarBase* vars_dispose[VTI_LAST];
-    /// To keep variables during copying without index structure
-    VarBase* vars_noidx;
-    /// Process all modified variables by delegating to registered processors
-    void process(void);
-    //@}
-
-    /**
-     * \name Pool of waiting propagators
-     */
-    //@{
-    /// Waiting propagators according to cost
-    ActorLink pool[PC_MAX+1];
-    /// Next cost level to check
-    int pool_next;
-    /// Put propagator \a p to pool
-    void pool_put(Propagator* p);
-    /// Get propagator \a p from pool
-    bool pool_get(Propagator*& p);
-    //@}
-
-    /**
-     * \brief Doubly linked list of all actors
-     *
-     * Propagators are stored at the beginning, branchings (if any) at
-     * the end.
-     */
-    ActorDeleteLink a_actors;
-    /**
-     * \brief Points to the first branching to be used for status
-     *
-     * If equal to &a_actors, no branching does exist.
-     *
-     * If it is NULL, the space is failed.
-     *
-     */
-    Branching*      b_status;
-    /**
-     * \brief Points to the first branching to be used for commit
-     *
-     * Note that \a b_commit can point to an earlier branching
-     * than \a b_status. This reflects the fact that the earlier
-     * branching is already done (that is, status on that branching
-     * returns false) but there might be still branching descriptions
-     * referring to the earlier branching.
-     *
-     * If equal to &a_actors, no branching does exist.
-     *
-     */
-    Branching*      b_commit;
-    /// Id of next branching to be created
-    unsigned int    branch_id;
-
-    /**
-     * \brief Number of subscriptions
-     *
-     * This number includes both the number of subscriptions and
-     * one free slot and hence can be considered as a conservative
-     * approximation of the real number of subscriptions. The number
-     * becomes more accurate after cloning a space.
-     *
-     */
-    unsigned int n_sub;
-    /**
-     * \brief Memory area used for storing subscriptions
-     *
-     * This area is only used when a space is created by cloning, otherwise
-     * subscriptions are stored in space-allocated memory.
-     *
-     */
-    Propagator** sub;
-    /// Used for default arguments
-    GECODE_KERNEL_EXPORT static unsigned long int unused_uli;
-
-    /// Perform propagation, return number of propagation steps
-    GECODE_KERNEL_EXPORT unsigned long int propagate(void);
-
-    /// Add new propagator \a p to space (force disposal, if \a fd is true)
-    void propagator(Propagator* p, bool fd);
-    /// Readd propagator \a p (after performing propagation)
-    void propagator(Propagator*);
-    /// Add new branching \a b to space (force disposal, if \a fd is true)
-    void branching(Branching* b, bool fd);
-
-    /**
-     * \name Processing propagators
-     */
-    //@{
-    /// Process propagator \a p with modification event \a me
-    template <VarTypeId VTI, class MED>
-    void process(Propagator* p, ModEvent me);
-    /// Process propagator \a p with modification event ME_GEN_ASSIGNED
-    template <VarTypeId VTI, class MED>
-    void process(Propagator* p);
-    //@}
-
-
-  public:
-    /**
-     * \brief Default constructor
-     * \ingroup TaskIntScript
-     */
-    GECODE_KERNEL_EXPORT Space(void);
-    /**
-     * \brief Destructor
-     * \ingroup TaskIntScript
-     */
-    GECODE_KERNEL_EXPORT virtual ~Space(void);
-    /**
-     * \brief Constructor for cloning
-     *
-     * Must copy and update all data structures (such as variables
-     * and variable arrays) required by the subclass of Space.
-     *
-     * If \a share is true, share all data structures among copies.
-     * Otherwise, make independent copies.
-     * \ingroup TaskIntScript
-     */
-    GECODE_KERNEL_EXPORT Space(bool share, Space& s);
-    /**
-     * \brief Copying member function
-     *
-     * Must create a new object using the constructor for cloning.
-     * \ingroup TaskIntScript
-     */
-    virtual Space* copy(bool share) = 0;
-    /**
-     * \brief Allocate memory from heap for new space
-     * \ingroup TaskIntScript
-     */
-    static void* operator new(size_t);
-    /**
-     * \brief Free memory allocated from heap
-     * \ingroup TaskIntScript
-     */
-    static void  operator delete(void*);
-
-
-
-
-    /*
-     * Member functions for search engines
-     *
-     */
-
-    /**
-     * \brief Query space status
-     *
-     * Propagates the space until fixpoint or failure and
-     * increments \a pn by the number of propagator executions.
-     *  - if the space is failed, SpaceStatus::SS_FAILED is returned.
-     *  - if the space is not failed but the space has no branching left,
-     *    SpaceStatus::SS_SOLVED is returned.
-     *  - otherwise, SpaceStatus::SS_BRANCH is returned.
-     * \ingroup TaskSearch
-     */
-    SpaceStatus status(unsigned long int& pn=unused_uli);
-
-    /**
-     * \brief Create new branching description for current branching
-     *
-     * This member function can only be called after the member function
-     * Space::status on the same space has been called and in between
-     * no non-const member function has been called on this space.
-     *
-     * Note that the above invariant obly pertains to calls of member
-     * functions of the same space. If the invariant is violated, the
-     * system is likely to crash (hopefully it does). In particular, if
-     * applied to a space with no current branching, the system will
-     * crash.
-     *
-     * \ingroup TaskSearch
-     */
-    const BranchingDesc* description(void) const;
-
-    /**
-     * \brief Clone space
-     *
-     * Propagates the space until fixpoint and increments \a pn by the
-     * number of propagator executions. If propagation results in
-     * a failed space, an exception of type SpaceFailed is thrown.
-     *
-     * Otherwise, a clone of the space is returned. If \a shared is true,
-     * sharable datastructures are shared among the clone and the original
-     * space. If \a shared is false, independent copies of the shared
-     * datastructures must be created. This means that a clone with no
-     * sharing can be used in a different thread without any interaction
-     * with the original space.
-     *
-     * \ingroup TaskSearch
-     */
-    GECODE_KERNEL_EXPORT
-    Space* clone(bool share=true, unsigned long int& pn=unused_uli);
-
-    /**
-     * \brief Commit branching description \a d and for alternative \a a
-     *
-     * The current branching in the space performs a commit from
-     * the information provided by the branching description \a d
-     * and the alternative \a a.
-     *
-     * Note that no propagation is perfomed (to support batch
-     * recomputation), in order to perform propagation the member
-     * function status must be used.
-     *
-     * Committing with branching descriptions must be carried
-     * out in the same order as the branch descriptions have been
-     * obtained by the member function Space::description().
-     *
-     * It is perfectly okay to add constraints interleaved with
-     * branching descriptions (provided they are in the right order).
-     * However, if propagation is performed by calling the member
-     * function status and then new branching descriptions are
-     * computed, these branching descriptions are different.
-     *
-     * Committing throws the following exceptions:
-     *  - SpaceNoBranching, if the space has no current branching (it is
-     *    already solved).
-     *  - SpaceIllegalAlternative, if \a a is not smaller than the number
-     *    of alternatives supported by the branching description \a d.
-     *
-     * \ingroup TaskSearch
-     */
-    GECODE_KERNEL_EXPORT
-    void commit(const BranchingDesc* d, unsigned int a);
-
-    /**
-     * \brief Flush cache datastructures in actors
-     *
-     * Flushes caches of actors in the space. This is useful to free
-     * memory (in particular when considering a space to be stored
-     * for later use such as during search). Even better is to make a
-     * clone of the space.
-     *
-     * \ingroup TaskSearch
-     */
-    GECODE_KERNEL_EXPORT
-    void flush(void);
-
-
-    /*
-     * Status checking and failing outside actors
-     *
-     */
-
-    /**
-     * \brief Fail space
-     *
-     * This is useful for failing outside of actors. Never use inside
-     * a propagate or commit member function. The system will crash!
-     * \ingroup TaskActor
-     */
-    void fail(void);
-    /**
-     * \brief Check whether space is failed
-     *
-     * Note that this does not perform propagation. This is useful
-     * for posting actors: only if a space is not yet failed, new
-     * actors are allowed to be created.
-     * \ingroup TaskActor
-     */
-    bool failed(void) const;
-    /**
-     * \brief Return number of propagators
-     *
-     * Note that this function takes linear time in the number of
-     * propagators. The number is only accurate when the space is
-     * stable (that is, at fixpoint and all propagation is done).
-     *
-     * Throws an exception of type SpaceFailed, if the space is failed.
-     */
-    GECODE_KERNEL_EXPORT
-    unsigned int propagators(void) const;
-    /**
-     * \brief Return number of branchings
-     *
-     * Note that this function takes linear time in the number of branchings.
-     *
-     * Throws an exception of type SpaceFailed, if the space is failed.
-     */
-    GECODE_KERNEL_EXPORT
-    unsigned int branchings(void) const;
-
-    /**
-     * \defgroup FuncMemSpace Space-memory management
-     * \ingroup FuncMem
-     */
-    //@{
-    /// Allocate memory on space heap
-    void* alloc(size_t);
-    /// Attempt to reuse memory previously allocated with alloc
-    void  reuse(void*,size_t);
-    /// Allocate from freelist-managed memory
-    template <size_t> void* fl_alloc(void);
-    /**
-     * \brief Return freelist-managed memory to freelist
-     *
-     * The first list element to be retuned is \a f, the last is \a l.
-     */
-    template <size_t> void  fl_dispose(FreeList* f, FreeList* l);
-    /**
-     * \brief Return how much heap memory is allocated by this space
-     *
-     * Note that is excludes the memory for the space object itself.
-     */
-    size_t allocated(void) const;
-    /// Return how much memory is used by caches for actors
-    GECODE_KERNEL_EXPORT size_t cached(void) const;
-    /// Return list of variables that need deletion
-    template <VarTypeId VTI> VarBase* varsDisposeList(void);
-    /// Set list of variables that need deletion
-    template <VarTypeId VTI> void varsDisposeList(VarBase* v);
-    //@}
-  };
-
-
-
-
-  /***
-   *** MEMORY MANAGEMENT
-   ***
-   ***/
-
-  /*
-   * Heap allocated: Space, BranchDesc
-   *
-   */
-
-  forceinline void*
-  Space::operator new(size_t s) {
-    return Memory::malloc(s);
-  }
-  forceinline void
-  Space::operator delete(void* p) {
-    Memory::free(p);
-  }
-
-  forceinline void
-  BranchingDesc::operator delete(void* p) {
-    Memory::free(p);
-  }
-  forceinline void*
-  BranchingDesc::operator new(size_t s) {
-    return Memory::malloc(s);
-  }
-
-  /*
-   * Space allocation: general space heaps and free lists
-   *
-   */
-
-  forceinline void*
-  Space::alloc(size_t s) {
-    return mm.alloc(s);
-  }
-  forceinline void
-  Space::reuse(void* p, size_t s) {
-    return mm.reuse(p,s);
-  }
-
-  template <size_t s>
-  forceinline void*
-  Space::fl_alloc(void) {
-    return mm.template fl_alloc<s>();
-  }
-  template <size_t s>
-  forceinline void
-  Space::fl_dispose(FreeList* f, FreeList* l) {
-    mm.template fl_dispose<s>(f,l);
-  }
-
-  forceinline size_t
-  Space::allocated(void) const {
-    return mm.allocated()+n_sub*sizeof(Propagator**);
-  }
-
-  template <VarTypeId VTI>
-  forceinline VarBase*
-  Space::varsDisposeList(void) {
-    return vars_dispose[VTI];
-  }
-
-  template <VarTypeId VTI>
-  forceinline void
-  Space::varsDisposeList(VarBase* v) {
-    vars_dispose[VTI]=v;
-  }
-
-  /*
-   * Space allocated entities: Actors and Variables
-   *
-   */
-
-  forceinline void
-  Actor::operator delete(void*, size_t) {}
-  forceinline void
-  Actor::operator delete(void*,Space*) {}
-  forceinline void*
-  Actor::operator new(size_t s, Space* home) {
-    return home->alloc(s);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::operator delete(void*) {}
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::operator delete(void*, Space*) {}
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void*
-  Variable<VTI,PC,MED>::operator new(size_t s, Space* home) {
-    return home->alloc(s);
-  }
-
-
-
-  /*
-   * ActorLinks as common subclass for propagators and branchings
-   *
-   */
-
-  forceinline ActorLink*
-  ActorLink::prev(void) const { return _prev; }
-  forceinline ActorLink*
-  ActorLink::next(void) const { return _next; }
-  forceinline void
-  ActorLink::prev(ActorLink* al) { _prev = al; }
-  forceinline void
-  ActorLink::next(ActorLink* al) { _next = al; }
-
-  forceinline void
-  ActorLink::unlink(void) {
-    ActorLink* p = _prev; ActorLink* n = _next;
-    p->_next = n; n->_prev = p;
-  }
-  forceinline void
-  ActorLink::init(void) {
-    _next = this; _prev =this;
-  }
-  forceinline void
-  ActorLink::head(ActorLink* a) {
-    // Inserts al at head of link-chain (that is, after this)
-    ActorLink* n = _next;
-    this->_next = a; a->_prev = this;
-    a->_next = n; n->_prev = a;
-  }
-  forceinline void
-  ActorLink::tail(ActorLink* a) {
-    // Inserts al at tail of link-chain (that is, before this)
-    ActorLink* p = _prev;
-    a->_next = this; this->_prev = a;
-    p->_next = a; a->_prev = p;
-  }
-
-
-
-  forceinline ActorDeleteLink*
-  ActorDeleteLink::next_delete(void) const { return _next_d; }
-  forceinline ActorDeleteLink*
-  ActorDeleteLink::prev_delete(void) const { return _prev_d; }
-  forceinline void
-  ActorDeleteLink::next_delete(ActorDeleteLink* adl) { _next_d = adl; }
-  forceinline void
-  ActorDeleteLink::prev_delete(ActorDeleteLink* adl) { _prev_d = adl; }
-
-  forceinline void
-  ActorDeleteLink::unlink_delete(void) {
-    ActorDeleteLink* p = _prev_d;
-    ActorDeleteLink* n = _next_d;
-    p->_next_d = n; n->_prev_d = p;
-  }
-
-  forceinline void
-  ActorDeleteLink::insert_delete(ActorDeleteLink* a, bool fd) {
-    if (fd) {
-      // Link a after this
-      ActorDeleteLink* n = _next_d;
-      this->_next_d = a; a->_prev_d = this;
-      a->_next_d = n; n->_prev_d = a;
-    } else {
-      // Just link to itself
-      a->_prev_d = a; a->_next_d = a;
-    }
-  }
-
-  forceinline void
-  ActorDeleteLink::init_delete(void) {
-    _next_d = this; _prev_d = this;
-  }
-
-
-
-
-  forceinline size_t
-  Actor::dispose(Space*) {
-    return sizeof(*this);
-  }
-
-  forceinline void
-  Actor::destruct(Space* home) {
-    unlink_delete();
-    size_t s = dispose(home);
-    home->reuse(this,s);
-  }
-
-
-  /*
-   * Spaces
-   *
-   */
-
-  forceinline const BranchingDesc*
-  Space::description(void) const {
-    return b_status->description(this);
-  }
-
-  forceinline bool
-  Space::failed(void) const {
-    return b_status == NULL;
-  }
-
-  /*
-   * Main control for propagation and branching
-   *  - a space only propagates and branches if requested by
-   *    either a status, commit, or clone operation
-   *  - for all of the operations the number of propagation
-   *    steps performed is returned in the last (optional)
-   *    reference argument
-   *
-   */
-  forceinline SpaceStatus
-  Space::status(unsigned long int& pn) {
-    // Perform propagation and do not continue when failed
-    pn += propagate();
-    if (failed())
-      return SS_FAILED;
-    /*
-     * Find the next branching that has still alternatives left
-     *
-     * It is important to note that branchings reporting to have no more
-     * alternatives left can not be deleted. They can not be deleted
-     * as there might be branching descriptions to be used in commit
-     * that refer to one of these branchings.
-     *
-     * A branching reporting that no more alternatives exist will eventually
-     * be deleted in commit. It will be deleted if the first branching
-     * description is used in commit that does not refer to this branching.
-     * As we insist that branching descriptions are used in order of
-     * creation, all further branching descriptions cannot refer to this
-     * branching.
-     *
-     */
-    while (b_status != &a_actors) {
-      if (b_status->status(this))
-	return SS_BRANCH;
-      b_status = static_cast<Branching*>(b_status->next());
-    }
-    // No branching with alternatives left, space is solved
-    return SS_SOLVED;
-  }
-
-
-  /*
-   * Variables
-   *
-   */
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline
-  Variable<VTI,PC,MED>::Variable(Space*) :
-    _next(reinterpret_cast<Variable<VTI,PC,MED>*>(1)) {
-    u.free_me = 0;
-    for (int i=PC+2; i--; )
-      idx[i] = NULL;
-  }
-
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline unsigned int
-  Variable<VTI,PC,MED>::degree(void) const {
-    return static_cast<unsigned int>(idx[PC+1] - idx[0]);
-  }
-
-
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline ModEvent
-  Variable<VTI,PC,MED>::modevent(void) const {
-    return u.free_me & 15;
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::modevent(ModEvent me) {
-    u.free_me = (u.free_me & ~15) | me;
-  }
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline unsigned int
-  Variable<VTI,PC,MED>::free(void) const {
-    return u.free_me >> 4;
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::free(unsigned int n) {
-    u.free_me = (u.free_me & 15) | (n << 4);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::free_inc(void) {
-    u.free_me += (1 << 4);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::free_dec(void) {
-    u.free_me -= (1 << 4);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline bool
-  Variable<VTI,PC,MED>::modified(void) const {
-    return _next != reinterpret_cast<Variable<VTI,PC,MED>*>(1);
-  }
-
-
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline Variable<VTI,PC,MED>*
-  Variable<VTI,PC,MED>::next(void) {
-    Variable<VTI,PC,MED>* n = _next;
-    _next = reinterpret_cast<Variable<VTI,PC,MED>*>(1);
-    return n;
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline bool
-  Variable<VTI,PC,MED>::copied(void) const {
-    return _next != reinterpret_cast<Variable<VTI,PC,MED>*>(1);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline
-  Variable<VTI,PC,MED>::Variable(Space* home, bool, Variable<VTI,PC,MED>& x)
-    : _next(reinterpret_cast<Variable<VTI,PC,MED>*>(1)) {
-    VarBase** reg;
-    if (x.idx[0] == NULL) {
-      // Variable needs no index structure
-      u.free_me = 0;
-      for (int i=PC+2; i--; )
-	idx[i] = NULL;
-      reg = &home->vars_noidx;
-    } else {
-      // Recover original value in copy
-      u.free_me = x.u.free_me;
-      reg = &home->vars[VTI];
-    }
-    // Set forwarding pointer
-    x.u.fwd = this;
-    // Register original
-    x._next = static_cast<Variable<VTI,PC,MED>*>(*reg); *reg = &x;
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline Variable<VTI,PC,MED>*
-  Variable<VTI,PC,MED>::forward(void) const {
-    return u.fwd;
-  }
-
-  /*
-   * Propagator modification events
-   *
-   */
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline ModEvent
-  Variable<VTI,PC,MED>::pme(const Propagator* p) {
-    return static_cast<ModEvent>((p->pme >> (VTI << 2)) & 15);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline PropModEvent
-  Variable<VTI,PC,MED>::pme(ModEvent me) {
-    return static_cast<PropModEvent>(me << (VTI << 2));
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline ModEvent
-  Variable<VTI,PC,MED>::combine(ModEvent me1, ModEvent me2) {
-    MED med;
-    return me2^med(me1,me2);
-  }
-
-  /*
-   * Propagators
-   *
-   */
-
-  forceinline void
-  Space::propagator(Propagator* p, bool fd) {
-    // Propagators are put at the front of the link of actors
-    a_actors.head(p);
-    a_actors.insert_delete(p,fd);
-  }
-
-  forceinline void
-  Space::propagator(Propagator* p) {
-    a_actors.head(p);
-  }
-
-  forceinline void
-  Space::branching(Branching* b, bool fd) {
-    // Propagators are put at the tail of the link of actors
-    b->id = branch_id++;
-    // If no branching available, make it the first one
-    if (b_status == &a_actors) {
-      b_status = b;
-      if (b_commit == &a_actors)
-	b_commit = b;
-    }
-    a_actors.tail(b);
-    a_actors.insert_delete(b,fd);
-  }
-
-
-
-  forceinline
-  Propagator::Propagator(Space* home, bool fd)
-    : pme(0) {
-    home->propagator(this,fd);
-  }
-
-  forceinline
-  Propagator::Propagator(Space*, bool, Propagator&)
-    : pme(0) {}
-
-
-  /*
-   * Branchings
-   *
-   */
-
-  forceinline
-  Branching::Branching(Space* home, bool fd) {
-    home->branching(this,fd);
-  }
-
-  forceinline
-  Branching::Branching(Space*, bool, Branching& b)
-    : id(b.id)  {}
-
-
-
-  /*
-   * Branching descriptions
-   *
-   */
-
-  forceinline
-  BranchingDesc::BranchingDesc(const Branching* b, const unsigned int a)
-    : id(b->id), alt(a) {}
-
-  forceinline unsigned int
-  BranchingDesc::alternatives(void) const {
-    return alt;
-  }
-
-  forceinline
-  BranchingDesc::~BranchingDesc(void) {}
-
-
-
-
-
-  /*
-   * Propagator pools
-   *
-   */
-
-  forceinline void
-  Space::pool_put(Propagator* p) {
-    int c = p->cost();
-    pool[c].tail(p);
-    if (c > pool_next)
-      pool_next = c;
-  }
-
-  forceinline void
-  Space::fail(void) {
-    b_status = NULL;
-  }
-
-  template <VarTypeId VTI, class MED>
-  forceinline void
-  Space::process(Propagator* p) {
-    // The new event is ME_GEN_ASSIGNED
-    PropModEvent old_pme = p->pme;
-    // Compute old modification event
-    ModEvent old_me = old_pme & (ME_GEN_MAX << (VTI << 2));
-    // Check whether old event is already ME_GEN_ASSIGNED
-    if (old_me == (ME_GEN_ASSIGNED << (VTI << 2)))
-      return;
-    // Update event
-    p->pme ^= old_me ^ (ME_GEN_ASSIGNED << (VTI << 2));
-    // Put propagator into right queue
-    p->unlink();
-    pool_put(p);
-  }
-
-  template <VarTypeId VTI, class MED>
-  forceinline void
-  Space::process(Propagator* p, ModEvent new_me) {
-    MED med;
-    PropModEvent old_pme = p->pme;
-    // Compute the old modification event
-    ModEvent old_me = ((old_pme >> (VTI << 2)) & ME_GEN_MAX);
-    // Get the new modification event (xor-ed with the old one)
-    ModEvent com_me = med(new_me,old_me);
-    // Event has not changed, do not nothing
-    if (com_me == 0)
-      return;
-    // Update modification event for propagator (use xor)
-    p->pme ^= (com_me << (VTI << 2));
-    // Put propagator into right queue
-    p->unlink();
-    pool_put(p);
-  }
-
-  forceinline ExecStatus
-  Propagator::ES_FIX_PARTIAL(PropModEvent pme) {
-    this->pme = pme; return __ES_FIX_PARTIAL;
-  }
-
-  forceinline ExecStatus
-  Propagator::ES_NOFIX_PARTIAL(PropModEvent pme) {
-    this->pme = pme; return __ES_NOFIX_PARTIAL;
-  }
-
-
-  /*
-   * Subscribing to a variable
-   *
-   */
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::subscribe(Space* home, Propagator* p, PropCond pc,
-				  bool assigned, ModEvent me, bool process) {
-    if (assigned) {
-      // Do not subscribe, just process the propagator
-      if (process)
-	home->process<VTI,MED>(p);
-    } else {
-      // Count one new subscription
-      home->n_sub += 1;
-      if (free() == 0)
-	resize(home);
-      free_dec();
-      // Enter propagator
-      --idx[0];
-      for (PropCond i = 0; i < pc; i++)
-	*(idx[i]) = *(--idx[i+1]);
-      *idx[pc]=p;
-      // Process propagator
-      if (process && (pc != PC_GEN_ASSIGNED))
-	home->process<VTI,MED>(p,me);
-    }
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  void
-  Variable<VTI,PC,MED>::resize(Space* home) {
-    assert(free() == 0);
-    if (idx[0] == NULL) {
-      // Count the one new free entry
-      home->n_sub += 1;
-      // Create fresh dependency array
-      free(4);
-      Propagator** prop = reinterpret_cast<Propagator**>
-	(home->alloc(4*sizeof(Propagator*))) + 4;
-      for (PropCond i = PC+2; i--; )
-	idx[i] = prop;
-    } else {
-      // Resize dependency array
-      int n = static_cast<int>(idx[PC+1] - idx[0]);
-      Propagator** prop = reinterpret_cast<Propagator**>
-	(home->alloc(2*n*sizeof(Propagator*))) + n;
-      free(n);
-      // Copy entries
-      memcpy(prop, idx[0], n*sizeof(Propagator*));
-      home->reuse(idx[0], n*sizeof(Propagator*));
-      // Update index pointers
-      ptrdiff_t o = prop - idx[0];
-      idx[0] = prop;
-      for (PropCond i = PC+1; i > 0; i--)
-	idx[i] += o;
-    }
-  }
-
-
-  /*
-   * Cancelling a subscription
-   *
-   */
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::cancel(Space* home, Propagator* p, PropCond pc) {
-    if (idx[0] != NULL) {
-      Propagator** f = idx[pc];
-#ifdef GECODE_AUDIT
-      while (f < idx[pc+1])
-	if (*f == p)
-	  goto found;
-	else
-	  f++;
-      GECODE_NEVER;
-    found: ;
-#else
-      while (*f != p) f++;
-#endif
-      *f=*idx[pc];
-      for (PropCond i=pc; i>0; i--)
-	*(idx[i]++)=*(idx[i-1]);
-      idx[0]++;
-      free_inc();
-      home->n_sub -= 1;
-    }
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::notify(Space* home, ModEvent new_me) {
-    if (modified()) {
-      MED med;
-      u.free_me ^= med(new_me,modevent());
-    } else {
-      _next = static_cast<Variable<VTI,PC,MED>*>(home->vars[VTI]);
-      home->vars[VTI] = this;
-      modevent(new_me);
-    }
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::notify(Space* home) {
-    assert(!modified());
-    _next = static_cast<Variable<VTI,PC,MED>*>(home->vars[VTI]);
-    home->vars[VTI] = this;
-    modevent(ME_GEN_ASSIGNED);
-  }
-
-
-  /*
-   * PROCESSING
-   *
-   */
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::update(Variable<VTI,PC,MED>* x, Propagator**& sub) {
-    // this refers to the variable to be updated (clone)
-    // x refers to the original
-    // Recover from copy (also overwrites forwarding pointer)
-    x->u.free_me = u.free_me;
-    Propagator** f = x->idx[0];
-    int n = static_cast<int>(x->idx[PC+1] - f);
-    u.free_me = 1 << 4;
-    Propagator** t = sub + 1;
-    sub += n+1;
-    idx[0] = t;
-    ptrdiff_t o = t - f;
-    for (PropCond i = PC+1; i>0; i--)
-      idx[i] = x->idx[i]+o;
-    while ((n-4) >= 0) {
-      n -= 4;
-      t[0] = static_cast<Propagator*>(f[0]->prev());;
-      t[1] = static_cast<Propagator*>(f[1]->prev());;
-      t[2] = static_cast<Propagator*>(f[2]->prev());;
-      t[3] = static_cast<Propagator*>(f[3]->prev());;
-      t += 4; f += 4;
-    }
-    if ((n-2) >= 0) {
-      n -= 2;
-      t[0] = static_cast<Propagator*>(f[0]->prev());;
-      t[1] = static_cast<Propagator*>(f[1]->prev());;
-      t += 2; f += 2;
-    }
-    if (n > 0) {
-      t[0] = static_cast<Propagator*>(f[0]->prev());;
-    }
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  VarTypeProcessor<VTI,PC,MED>::VarTypeProcessor(void) {
-    Space::vtp[VTI] = this;
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  void
-  VarTypeProcessor<VTI,PC,MED>::update(VarBase* vb, Propagator**& sub) {
-    Variable<VTI,PC,MED>* x = static_cast<Variable<VTI,PC,MED>*>(vb);
-    do {
-      x->forward()->update(x,sub); x = x->next();
-    } while (x != NULL);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  void
-  VarTypeProcessor<VTI,PC,MED>::dispose(Space* home, VarBase* x) {}
-
-  /*
-   * Processing a single modified variable
-   *
-   */
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::process(Space* home,
-				PropCond pc1, PropCond pc2, ModEvent me) {
-    Propagator** b = idx[pc1];
-    Propagator** p = idx[pc2+1];
-    while (p-- > b)
-      home->process<VTI,MED>(*p,me);
-  }
-
-  template <VarTypeId VTI, PropCond PC, class MED>
-  forceinline void
-  Variable<VTI,PC,MED>::process(Space* home) {
-    // Entries in index structure are disabled. However they
-    // must still work for cloning (idx[0]) and degree (idx[PC+1])
-    Propagator** b = idx[0];    idx[0] = NULL;
-    Propagator** p = idx[PC+1]; idx[PC+1] = NULL;
-    /*
-     * Decrement for p-b subscriptions
-     *
-     * Note that one would like to also decrement for the additional
-     * single free slot that was counted initially. However, this
-     * is not possible as there might be no free slot. So the number
-     * of subscriptions is a conservative estimate and will be corrected
-     * upon cloning.
-     */
-    home->n_sub -= p-b;
-    // Information needed to release the dependency array
-    unsigned int n = free() + (p-b);
-    Propagator** s = p-n;
-    while (p-- > b)
-      home->process<VTI,MED>(*p);
-    home->reuse(s,n*sizeof(Propagator*));
-  }
-
-}
-
-// STATISTICS: kernel-core