scheduler.h

#ifndef _SCHEDULER_H_
#define _SCHEDULER_H_

#include "scheduler.decl.h"

#include "gvtmanager.h" // Temporary for produce/consume
#include "pe_queue.h"
#include "typedefs.h"

extern CkGroupID scheduler_id;

typedef Scheduler* SchedulerPtr;
CpvExtern(SchedulerPtr, g_scheduler);

class Globals;
class LPChare;
class LPToken;
class RemoteEvent;
class Statistics;
class Trigger;

using std::string;

#if CMK_USING_XLC
typedef std::auto_ptr<Trigger> TriggerPtr;
#else
typedef std::unique_ptr<Trigger> TriggerPtr;
#endif

class Scheduler : public CBase_Scheduler {
  protected:
    string scheduler_name;  
    bool   running;         
    double start_time;      
    double end_time;        
    PEQueue next_lps; 
  public:
    // TODO: Globals may not be needed once event handling is moved to scheduler
    Globals* globals;             
    Statistics* stats;            
    Statistics* cumulative_stats; 
    Scheduler();

    virtual void groups_created();

    void start_simulation();  
    void end_simulation();    
    void finalize_complete();
    void finalize(CkReductionMsg *m); 
    void print_progress(Time ts);

    bool schedule_next_lp();

    virtual Time get_min_time() const;

    virtual void execute();

    void register_lp(LPToken* next_token, Time next_ts) {
      next_lps.insert(next_token, next_ts);
    }
    void unregister_lp(LPToken* next_token) {
      next_lps.remove(next_token);
    }
    void update_next(LPToken* token, Time ts) {
      next_lps.update(token, ts);
    }

    // TODO: Move to distributed/optimistic
    virtual void consume(RemoteEvent* e) {}
    virtual void produce(RemoteEvent* e) {}
    virtual void update_min_cancel(Time ts) {}
};

class SequentialScheduler : public CBase_SequentialScheduler {
  public:
    SequentialScheduler();
    void execute();
};

class DistributedScheduler : public CBase_DistributedScheduler {
  protected:
    GVTManager* gvt_manager;  
    TriggerPtr gvt_trigger;   
    TriggerPtr print_trigger; 
#if CMK_TRACE_ENABLED
    TriggerPtr stat_trigger;  
#endif

  public:
    DistributedScheduler();

    void groups_created();

    void iteration_done();
    void next_iteration();

    void start_balancing();
    void balancing_complete();

    virtual void gvt_resume();        
    virtual void gvt_done(Time gvt, bool lb);  
    void consume(RemoteEvent* e) {
      gvt_manager->consume(e);
    }
    void produce(RemoteEvent* e) {
      gvt_manager->produce(e);
    }
};

#endif