2 files changed, 85 insertions, 27 deletions

diff --git a/src/java/com/jogamp/common/os/Clock.java b/src/java/com/jogamp/common/os/Clock.java
index 756d1d1..466b3fc 100644
--- a/src/java/com/jogamp/common/os/Clock.java
+++ b/src/java/com/jogamp/common/os/Clock.java
@@ -27,21 +27,35 @@ package com.jogamp.common.os;
 import java.time.Instant;
 
 public class Clock {
-    private static long t0;
+    private static final Instant t0;
     static {
         Platform.initSingleton(); // loads native gluegen_rt library
-        t0 = currentTimeMillis();
+        {
+            final long[/*2*/] val = { 0, 0 };
+            getMonotonicStartupTimeImpl(val);
+            t0 = Instant.ofEpochSecond(val[0], val[1]);
+        }
     }
 
     /**
      * Returns current monotonic time since Unix Epoch `00:00:00 UTC on 1970-01-01`.
-     *
-     * Returned fraction_timespec is passing machine precision and range of the underlying native API.
-     *
+     * <p>
+     * Returned timespec is passing machine precision and range of the underlying native API.
+     * </p>
+     * <p>
      * Monotonic time shall be used for high-performance measurements of durations,
      * since the underlying OS shall support fast calls.
-     *
-     * @see getWallClockTime()
+     * </p>
+     * <p>
+     * Note that {@link #currentTimeNanos()} and {@link #getMonotonicNanos()}
+     * perform much better than this method, since they only return one long nanosecond value
+     * since module startup. <br/>
+     * The implementation of this method needs to write two long values into an array.
+     * </p>
+     * @see #getMonotonicStartupTime()
+     * @see #currentTimeNanos()
+     * @see #getMonotonicNanos()
+     * @see #getWallClockTime()
      */
     public static Instant getMonotonicTime() {
         final long[/*2*/] val = { 0, 0 };
@@ -52,13 +66,17 @@ public class Clock {
 
     /**
      * Returns current wall-clock real-time since Unix Epoch `00:00:00 UTC on 1970-01-01`.
-     *
+     * <p>
      * Returned Instant is passing machine precision and range of the underlying native API.
-     *
+     * </p>
+     * <p>
      * Wall-Clock time shall be used for accurate measurements of the actual time only,
      * since the underlying OS unlikely supports fast calls.
-     *
-     * @see getMonotonicTime()
+     * </p>
+     * @see #getMonotonicStartupTime()
+     * @see #currentTimeNanos()
+     * @see #getMonotonicNanos()
+     * @see #getMonotonicTime()
      */
     public static Instant getWallClockTime() {
         final long[/*2*/] val = { 0, 0 };
@@ -68,29 +86,63 @@ public class Clock {
     private static native void getWallClockTimeImpl(final long[/*2*/] val);
 
     /**
-     * Returns current monotonic time in milliseconds.
+     * Returns the monotonic startup time since module startup as used in {@link #currentTimeNanos()} and {@link #getMonotonicNanos()}.
+     * @see #currentTimeNanos()
+     * @see #getMonotonicNanos()
      */
-    public static native long currentTimeMillis();
+    public static Instant getMonotonicStartupTime() { return t0; }
+    private static native void getMonotonicStartupTimeImpl(final long[/*2*/] val);
 
     /**
-     * Returns current wall-clock system `time of day` in seconds since Unix Epoch
-     * `00:00:00 UTC on 1 January 1970`.
+     * Returns current monotonic time in nanoseconds since start of this application.
+     * <p>
+     * Monotonic time shall be used for high-performance measurements of durations,
+     * since the underlying OS shall support fast calls.
+     * </p>
+     * <p>
+     * Since the returned nanoseconds are counted not from Unix Epoch but start of this application,
+     * it lasts for 9'223'372'036 seconds or 292 years using the 64-bit type `long`.
+     * </p>
+     * @see #getMonotonicStartupTime()
+     * @see #getMonotonicNanos()
      */
-    public static native long wallClockSeconds();
+    public static native long currentTimeNanos();
 
     /**
-     * Returns the startup time in monotonic time in milliseconds of the native module.
+     * Returns the Instant presentation of monotonic {@link #currentTimeNanos()}.
+     * <p>
+     * Monotonic time shall be used for high-performance measurements of durations,
+     * since the underlying OS shall support fast calls.
+     * </p>
+     * <p>
+     * Note that the represented time is not from Unix epoch as claimed,
+     * but monotonic module startup time.
+     * </p>
+     * @see #getMonotonicStartupTime()
+     * @see #currentTimeNanos()
      */
-    public static long startupTimeMillis() { return t0; }
+    public static Instant getMonotonicNanos() {
+        final long nanos = currentTimeNanos();
+        return Instant.ofEpochSecond(nanos/1000000000L, nanos%1000000000L);
+    }
 
     /**
-     * Returns current elapsed monotonic time in milliseconds since module startup, see {@link #startupTimeMillis()}.
+     * Returns current monotonic time in milliseconds.
+     *
+     * @see #getMonotonicStartupTime()
+     * @see #currentTimeNanos()
+     * @see #getMonotonicNanos()
      */
-    public static long elapsedTimeMillis() { return currentTimeMillis() - t0; }
+    public static native long currentTimeMillis();
 
     /**
-     * Returns elapsed monotonic time in milliseconds since module startup comparing against the given timestamp, see {@link #startupTimeMillis()}.
+     * Returns current wall-clock system `time of day` in seconds since Unix Epoch
+     * `00:00:00 UTC on 1 January 1970`.
+     *
+     * @see #getWallClockTime()
+     * @see #getMonotonicTime()
+     * @see #currentTimeNanos()
+     * @see #getMonotonicNanos()
      */
-    public static long elapsedTimeMillis(final long current_ts) { return current_ts - t0; }
-
+    public static native long wallClockSeconds();
 }
diff --git a/src/java/com/jogamp/common/util/PerfCounterCtrl.java b/src/java/com/jogamp/common/util/PerfCounterCtrl.java
index 486c248..30290f8 100644
--- a/src/java/com/jogamp/common/util/PerfCounterCtrl.java
+++ b/src/java/com/jogamp/common/util/PerfCounterCtrl.java
@@ -26,9 +26,15 @@
 package com.jogamp.common.util;
 
 import java.io.PrintStream;
-import java.time.Duration;
+import com.jogamp.common.os.Clock;
 
-/** Simple performance counter controller. */
+/**
+ * Simple performance counter controller.
+ * <p>
+ * Implementation is expected to utilize nanosecond counter since module start,
+ * e.g. {@link Clock#currentTimeNanos()}.
+ * </p>
+ */
 public interface PerfCounterCtrl {
     /** Enable or disable performance counter. */
     void enable(final boolean enable);
@@ -36,8 +42,8 @@ public interface PerfCounterCtrl {
     /** Clear performance counter. */
     void clear();
 
-    /** Return the total duration, covering all sub-counter. */
-    Duration getTotalDuration();
+    /** Return the total duration in nanoseconds, covering all sub-counter. */
+    long getTotalDuration();
 
     /** Print performance counter. */
     void print(final PrintStream out);