schedule.h

Go to the documentation of this file.

#ifndef GUM_SCHEDULE_H
#define GUM_SCHEDULE_H

#include <utility>

#include <agrum/agrum.h>

#include <agrum/core/hashTable.h>
#include <agrum/core/set.h>
#include <agrum/graphs/DAG.h>
#include <agrum/graphs/graphElements.h>

#include <agrum/graphicalModels/inference/scheduleCliqueStoreMultiDim.h>
#include <agrum/graphicalModels/inference/scheduleCombine.h>
#include <agrum/graphicalModels/inference/scheduleDeleteMultiDim.h>
#include <agrum/graphicalModels/inference/scheduleOperation.h>
#include <agrum/graphicalModels/inference/scheduleProject.h>
#include <agrum/graphicalModels/inference/scheduleSeparatorStoreMultiDim.h>

namespace gum {

  template < typename GUM_SCALAR >
  class Schedule {
    public:
    using OperationId = Idx;

    using MultiDimId = Idx;

    // ############################################################################
    // ############################################################################

    Schedule();

    Schedule(const Schedule< GUM_SCALAR >&);

    ~Schedule();


    // ############################################################################
    // ############################################################################


    Schedule< GUM_SCALAR >& operator=(const Schedule< GUM_SCALAR >&);


    // ############################################################################
    // ############################################################################


    NodeId insert(const ScheduleOperation< GUM_SCALAR >&);

    void forceAfter(const ScheduleOperation< GUM_SCALAR >& op_to_force,
                    const ScheduleOperation< GUM_SCALAR >& op_before);
    void forceAfter(NodeId op_to_force, NodeId op_before);

    void
         forceAfter(const ScheduleOperation< GUM_SCALAR >&               op_to_force,
                    const Set< const ScheduleOperation< GUM_SCALAR >* >& ops_before);
    void forceAfter(NodeId op_to_force, const NodeSet& ops_before);

    void forceBefore(const ScheduleOperation< GUM_SCALAR >& op_to_force,
                     const ScheduleOperation< GUM_SCALAR >& op_after);
    void forceBefore(NodeId op_to_force, NodeId op_after);

    void
         forceBefore(const ScheduleOperation< GUM_SCALAR >& op_to_force,
                     const Set< const ScheduleOperation< GUM_SCALAR >* >& ops_after);
    void forceBefore(NodeId op_to_force, const NodeSet& ops_after);


    const DAG& scheduling_dag() const;


    const ScheduleOperation< GUM_SCALAR >& operation(NodeId) const;


    NodeId nodeId(const ScheduleOperation< GUM_SCALAR >&) const;

    const NodeProperty< const ScheduleOperation< GUM_SCALAR >* >&
       operations() const;

    const NodeSet&
                   operationsInvolving(const ScheduleMultiDim< GUM_SCALAR >& table) const;
    const NodeSet& operationsInvolving(MultiDimId table_id) const;


    const NodeSet& availableOperations() const;


    void execute(NodeId);
    void execute(const ScheduleOperation< GUM_SCALAR >&);

    float nbOperations(NodeId) const;
    float nbOperations(ScheduleOperation< GUM_SCALAR >&) const;


    std::pair< long, long > memoryUsage(NodeId) const;
    std::pair< long, long > memoryUsage(ScheduleOperation< GUM_SCALAR >&) const;


    private:

    mutable DAG __dag;

    NodeProperty< ScheduleOperation< GUM_SCALAR >* > __node2operation;

    HashTable< OperationId, NodeId > __operation2node;

    HashTable< MultiDimId, NodeId > __created_multidims;


    mutable NodeSet __operations_with_wrong_parents;

    mutable NodeSet __operations_available;

    HashTable< MultiDimId, NodeSet* > __multidim2operations;

    void __updateWrongParents() const;
  };

} /* namespace gum */

// always include the template implementation
#include <agrum/graphicalModels/inference/schedule_tpl.h>

#endif /* GUM_SCHEDULE_H */