scheduler.h

Go to the documentation of this file.

#ifndef SCHEDULER_CLASS
#define SCHEDULER_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : scheduler                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "scheduling_common.h"

// forward.
class actor_mapper;
class int_averager;
class mailbox;
class memory_limiter;
class schedulable;
class schedule_actor;
class schedule_driver;
class schedule_iterator;
class scheduling_id;

namespace nodes {
  class safe_list;
  class safe_list_write_iterator;
}


class SCHEDULING_CLASS_STYLE scheduler : public scheduling_common
{
public:
  scheduler(actor_mapper &mapper, int time_per_activation,
          int maximum_weight, int max_actor_weight,
          int snooze_interval = 64);

  virtual ~scheduler();

  IMPLEMENT_CLASS_NAME("scheduler");

  // the following are metrics that describe how this scheduler is operating.

  const int_averager &processing_durations() const;

  const int_averager &activation_durations() const;

  const int_averager &item_durations() const;

  const int_averager &bandwidths() const;

  int snooze_interval() const { return _snooze_interval; }

  void reset_stats();



  // the main service routines below (until private:) are all thread safe.

  outcome add(schedulable *to_schedule, bool single_file);



  // the background thread is managed by these two functions.
  void start_scheduling();
  void stop_scheduling();


  // NOTE: neither type of remove operation calls any of the removed items'
  // postprocessing function.

  outcome remove_by_id(scheduling_id id);

  outcome remove_by_actor(int actor_id);

  outcome mark_dead(scheduling_id to_mark);

  void filter_missing_actors(const int_set &valid_actors);


  void schedule_text_form(string_array &info, int indent = 0);

  void pending_text_form(istring &info, int indent = 0);

  void memory_text_form(istring &info, int indent = 2);


  schedule_iterator *open_iterator(common::list_positions where = common::HEAD);

  schedule_iterator *find(scheduling_id to_find);

  void close_iterator(schedule_iterator * &to_close);

  const schedulable *active_item(schedule_iterator &to_use) const;

  bool items_scheduled(schedule_iterator &to_use, int actor);

  void zap(schedule_iterator &to_use);

private:
  actor_mapper &_mapper;  
  int _time_per_item;  
  nodes::safe_list *_schedule;  
  int_averager *_processing_durations;  
  int_averager *_activation_durations;  
  int_averager *_item_durations;  
  int_averager *_bandwidths;  
  schedulable *_active_item;  
  memory_limiter *_weight_tracker;  
  mailbox *_pending_sends;  
  int_set *_timely_to_run;  
  int_set *_queued_actors;  
  int _snooze_interval;  

  friend class schedule_driver;  
  schedule_driver *_driver;

  outcome process_schedule(int schedulings_allowed);

  bool time_to_schedule(schedulable &to_check);

  outcome check_expiration(schedulable &to_check, schedule_actor &actor);

  outcome do_preprocess(schedulable &to_preprocess);

  void promote_queued_items();

  void promote_actor(int actor_id);

  bool find_timely_items(int_set &timely);

  outcome schedule_item(int &hits, schedulable &to_process);

  void crunch_on_timely_items(int &hits, int hits_allowed, int_set &timely);

  // forbidden.
  scheduler(const scheduler &to_copy);
  scheduler &operator =(const scheduler &to_copy);
};



class SCHEDULING_CLASS_STYLE schedule_iterator
{
public:
  ~schedule_iterator();

  void next();  
  void previous();  

  schedulable *access();  

  bool is_head();  
  bool is_tail();  

  void jump_head();  
  void jump_tail();  

private:
  friend class scheduler;
  const scheduler &_manager;  
  nodes::safe_list_write_iterator *_hidden_iterator;  

  schedule_iterator(const scheduler &mgr);

  // disallowed functions.
  schedule_iterator(const schedule_iterator &to_copy);
  schedule_iterator &operator =(const schedule_iterator &to_copy);
};

#endif

---