← Back to branch summary

~ljrt-dev/ljrt/ljrt.newjavalib

« back to all changes in this revision

Viewing changes to javalib/java/se/lth/cs/realtime/RTSystem.java

  • Committer: Anders Nilsson
  • Date: 2006-09-06 13:48:19 UTC
  • Revision ID: anders.nilsson@cs.lth.se-20060906134819-52fcde58fec8c840
Ported to AVR. Compiles but does not run

Show diffs side-by-side

added added

removed removed

Lines of Context:
javalib/java/se/lth/cs/realtime/RTSystem.java
58
58
  //----------------------------------- Features for virtual/application time:
59
59
 
60
60
  /** Watchdog thread for application time handling. */
61
 
  private static Thread ticker;
62
 
  static {
63
 
    if (!DEPLOYED)
64
 
//       (ticker = new HiddenThread()).start();
65
 
       ticker = new HiddenThread();
66
 
  }
 
61
//   private static Thread ticker;
 
62
//   static {
 
63
//     if (!DEPLOYED)
 
64
// //       (ticker = new HiddenThread()).start();
 
65
//        ticker = new HiddenThread();
 
66
//   }
67
67
 
68
68
  /** Tick counter for hidden thread below. */
69
69
  static transient volatile int seq;
247
247
  /**
248
248
   * Thread used to detect suspended JVM execution.
249
249
   */
250
 
  private static class HiddenThread extends java.lang.Thread {
 
250
//   private static class HiddenThread extends java.lang.Thread {
251
251
 
252
 
    /**
253
 
     * Increment <code>time</code> (used by
254
 
     * <code>RTSystem.currentTimeMillis()</code>) each tick, keeping
255
 
     * it within the tolerance <code>tol</code> from system time by
256
 
     * adjusting the internal <code>lag</code>.
257
 
     */
258
 
    public void run() {
259
 
      setPriority(MAX_PRIORITY);
260
 
      systime = System.currentTimeMillis();
261
 
      long next = systime + tickMillis; // Next real time for time update.
262
 
      long dt;
263
 
      next = next / tickMillis * tickMillis; // Truncate for nicer values.
264
 
      try {
265
 
        while (!interrupted()) {
266
 
                System.out.println("HiddenThread is running");
267
 
          dt = next - systime;
268
 
          if (dt > 0)
269
 
            Thread.sleep(dt);
270
 
          systime = System.currentTimeMillis();
271
 
          dt = systime - next; // Detected lag increase.
272
 
          if (dt > tol) { // if real time too far ahead.
273
 
            dt = (dt / tickMillis + 1) * tickMillis;
274
 
            next += dt;
275
 
            lag += dt;
276
 
          }
277
 
          else
278
 
            next += tickMillis;
279
 
          seq++;
280
 
        }
281
 
      }
282
 
      catch (InterruptedException exc) {
283
 
        System.out.println("Ticker terminated!");
284
 
        System.exit(1);
285
 
      }
286
 
    }
287
 
  }
 
252
//     /**
 
253
//      * Increment <code>time</code> (used by
 
254
//      * <code>RTSystem.currentTimeMillis()</code>) each tick, keeping
 
255
//      * it within the tolerance <code>tol</code> from system time by
 
256
//      * adjusting the internal <code>lag</code>.
 
257
//      */
 
258
//     public void run() {
 
259
//       setPriority(MAX_PRIORITY);
 
260
//       systime = System.currentTimeMillis();
 
261
//       long next = systime + tickMillis; // Next real time for time update.
 
262
//       long dt;
 
263
//       next = next / tickMillis * tickMillis; // Truncate for nicer values.
 
264
//       try {
 
265
//         while (!interrupted()) {
 
266
//              System.out.println("HiddenThread is running");
 
267
//           dt = next - systime;
 
268
//           if (dt > 0)
 
269
//             Thread.sleep(dt);
 
270
//           systime = System.currentTimeMillis();
 
271
//           dt = systime - next; // Detected lag increase.
 
272
//           if (dt > tol) { // if real time too far ahead.
 
273
//             dt = (dt / tickMillis + 1) * tickMillis;
 
274
//             next += dt;
 
275
//             lag += dt;
 
276
//           }
 
277
//           else
 
278
//             next += tickMillis;
 
279
//           seq++;
 
280
//         }
 
281
//       }
 
282
//       catch (InterruptedException exc) {
 
283
//         System.out.println("Ticker terminated!");
 
284
//         System.exit(1);
 
285
//       }
 
286
//     }
 
287
//   }
288
288
 
289
289
}