[GR-20022] Add new time functions with nanosecond resolution.

PullRequest: graalpython/761

Author: ppisl

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/TimeModuleBuiltins.java

@@ -71,6 +71,7 @@
 @CoreFunctions(defineModule = "time")
 public final class TimeModuleBuiltins extends PythonBuiltins {
     private static final int DELAY_NANOS = 10;
+    private static final long PERF_COUNTER_START = TruffleOptions.AOT ? 0 : System.nanoTime();
 
     @Override
     protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFactories() {
@@ -182,6 +183,35 @@ public double time() {
         }
     }
 
+    // time.time_ns()
+    @Builtin(name = "time_ns", minNumOfPositionalArgs = 0, doc = "Similar to time() but returns time as an integer number of nanoseconds since the epoch.")
+    @GenerateNodeFactory
+    public abstract static class PythonTimeNsNode extends PythonBuiltinNode {
+
+        /**
+         * The maximum date, which are systems able to handle is 2262 04 11. This corresponds to the
+         * 64 bit long.
+         * 
+         * @return
+         */
+        @Specialization
+        public long time() {
+            return timeNanoSeconds();
+        }
+
+        @TruffleBoundary
+        private static long timeNanoSeconds() {
+            Instant now = Instant.now();
+            // From java we are not able to obtain the nano seconds resolution. It depends on the
+            // jdk
+            // JKD 1.8 the resolution is usually miliseconds (for example 1576081173486000000)
+            // From JDK 9 including JDK 11 the resolution is usually microseconds (for example
+            // 1576082578022393000)
+            // To obtain really nanosecond resulution we have to fake the nanoseconds
+            return now.getEpochSecond() * 1000000000L + now.getNano();
+        }
+    }
+
     // time.monotonic()
     @Builtin(name = "monotonic", minNumOfPositionalArgs = 0)
     @GenerateNodeFactory
@@ -190,15 +220,44 @@ public abstract static class PythonMonotonicNode extends PythonBuiltinNode {
         @Specialization
         @TruffleBoundary
         public double time() {
+            return System.nanoTime() / 1000000000D;
+        }
+    }
+
+    // time.monotonic_ns()
+    @Builtin(name = "monotonic_ns", minNumOfPositionalArgs = 0, doc = "Similar to monotonic(), but return time as nanoseconds.")
+    @GenerateNodeFactory
+    public abstract static class PythonMonotonicNsNode extends PythonBuiltinNode {
+
+        @Specialization
+        @TruffleBoundary
+        public long time() {
             return System.nanoTime();
         }
     }
 
     @Builtin(name = "perf_counter", minNumOfPositionalArgs = 0)
     @GenerateNodeFactory
-    public abstract static class PythonPerfCounterNode extends PythonClockNode {
+    public abstract static class PythonPerfCounterNode extends PythonBuiltinNode {
+        @Specialization
+        @TruffleBoundary
+        public double counter() {
+            return (System.nanoTime() - PERF_COUNTER_START) / 1000_000_000.0;
+        }
+    }
+
+    @Builtin(name = "perf_counter_ns", minNumOfPositionalArgs = 0)
+    @GenerateNodeFactory
+    public abstract static class PythonPerfCounterNsNode extends PythonBuiltinNode {
+
+        @Specialization
+        @TruffleBoundary
+        public long counter() {
+            return System.nanoTime() - PERF_COUNTER_START;
+        }
     }
 
+    // TODO time.clock in 3.8 is removed in 3.5 is deprecated
     // time.clock()
     @Builtin(name = "clock", minNumOfPositionalArgs = 0)
     @GenerateNodeFactory