32 // Usage:
  33 //   PeriodicTask pf(10);
  34 //   pf.enroll();
  35 //   ...
  36 //   pf.disenroll();
  37 
  38 class PeriodicTask: public CHeapObj<mtInternal> {
  39  public:
  40   // Useful constants.
  41   // The interval constants are used to ensure the declared interval
  42   // is appropriate;  it must be between min_interval and max_interval,
  43   // and have a granularity of interval_gran (all in millis).
  44   enum { max_tasks     = 10,       // Max number of periodic tasks in system
  45          interval_gran = 10,
  46          min_interval  = 10,
  47          max_interval  = 10000 };
  48 
  49   static int num_tasks()   { return _num_tasks; }
  50 
  51  private:
  52   size_t _counter;
  53   const size_t _interval;
  54 
  55   static int _num_tasks;
  56   static PeriodicTask* _tasks[PeriodicTask::max_tasks];
  57   static void real_time_tick(size_t delay_time);
  58 
  59 #ifndef PRODUCT
  60   static elapsedTimer _timer;                      // measures time between ticks
  61   static int _ticks;                               // total number of ticks
  62   static int _intervalHistogram[max_interval];     // to check spacing of timer interrupts
  63  public:
  64   static void print_intervals();
  65 #endif
  66   // Only the WatcherThread can cause us to execute PeriodicTasks
  67   friend class WatcherThread;
  68  public:
  69   PeriodicTask(size_t interval_time); // interval is in milliseconds of elapsed time
  70   ~PeriodicTask();
  71 
  72   // Tells whether is enrolled
  73   bool is_enrolled() const;
  74 
  75   // Make the task active
  76   // NOTE: this may only be called before the WatcherThread has been started

  77   void enroll();
  78 
  79   // Make the task deactive
  80   // NOTE: this may only be called either while the WatcherThread is
  81   // inactive or by a task from within its task() method. One-shot or
  82   // several-shot tasks may be implemented this way.
  83   void disenroll();
  84 
  85   void execute_if_pending(size_t delay_time) {
  86     _counter += delay_time;
  87     if (_counter >= _interval) {


  88       _counter = 0;
  89       task();


  90     }
  91   }
  92 
  93   // Returns how long (time in milliseconds) before the next time we should
  94   // execute this task.
  95   size_t time_to_next_interval() const {
  96     assert(_interval > _counter,  "task counter greater than interval?");
  97     return _interval - _counter;
  98   }
  99 
 100   // Calculate when the next periodic task will fire.
 101   // Called by the WatcherThread's run method.
 102   // This assumes that periodic tasks aren't entering the system
 103   // dynamically, except for during startup.
 104   static size_t time_to_wait() {
 105     if (_num_tasks == 0) {
 106       // Don't wait any more; shut down the thread since we don't
 107       // currently support dynamic enrollment.
 108       return 0;
 109     }
 110 
 111     size_t delay = _tasks[0]->time_to_next_interval();
 112     for (int index = 1; index < _num_tasks; index++) {
 113       delay = MIN2(delay, _tasks[index]->time_to_next_interval());
 114     }
 115     return delay;
 116   }
 117 
 118   // The task to perform at each period
 119   virtual void task() = 0;
 120 };
 121 
 122 #endif // SHARE_VM_RUNTIME_TASK_HPP

  32 // Usage:
  33 //   PeriodicTask pf(10);
  34 //   pf.enroll();
  35 //   ...
  36 //   pf.disenroll();
  37 
  38 class PeriodicTask: public CHeapObj<mtInternal> {
  39  public:
  40   // Useful constants.
  41   // The interval constants are used to ensure the declared interval
  42   // is appropriate;  it must be between min_interval and max_interval,
  43   // and have a granularity of interval_gran (all in millis).
  44   enum { max_tasks     = 10,       // Max number of periodic tasks in system
  45          interval_gran = 10,
  46          min_interval  = 10,
  47          max_interval  = 10000 };
  48 
  49   static int num_tasks()   { return _num_tasks; }
  50 
  51  private:
  52   jint _counter;
  53   const jint _interval;
  54 
  55   static int _num_tasks;
  56   static PeriodicTask* _tasks[PeriodicTask::max_tasks];
  57   static void real_time_tick(jint delay_time);
  58 
  59 #ifndef PRODUCT
  60   static elapsedTimer _timer;                      // measures time between ticks
  61   static int _ticks;                               // total number of ticks
  62   static int _intervalHistogram[max_interval];     // to check spacing of timer interrupts
  63  public:
  64   static void print_intervals();
  65 #endif
  66   // Only the WatcherThread can cause us to execute PeriodicTasks
  67   friend class WatcherThread;
  68  public:
  69   PeriodicTask(jint interval_time); // interval is in milliseconds of elapsed time
  70   ~PeriodicTask();
  71 



  72   // Make the task active
  73   // For dynamic enrollment at the time T, the task will execute somewhere 
  74   // between T and T + interval_time.
  75   void enroll();
  76 
  77   // Make the task deactive



  78   void disenroll();
  79 
  80   void execute_if_pending(jint delay_time) {
  81     // make sure we don't overflow
  82     jlong tmp = (jlong) _counter + (jlong) delay_time;
  83 
  84     if (tmp >= (jlong) _interval) {
  85       _counter = 0;
  86       task();
  87     } else {
  88       _counter += delay_time;
  89     }
  90   }
  91 
  92   // Returns how long (time in milliseconds) before the next time we should
  93   // execute this task.
  94   jint time_to_next_interval() const {
  95     assert(_interval > _counter,  "task counter greater than interval?");
  96     return _interval - _counter;
  97   }
  98 
  99   // Calculate when the next periodic task will fire.
 100   // Called by the WatcherThread's run method.
 101   static jint time_to_wait();














 102 
 103   // The task to perform at each period
 104   virtual void task() = 0;
 105 };
 106 
 107 #endif // SHARE_VM_RUNTIME_TASK_HPP