jruby · Feb 16, 2015 · Feb 16, 2015
Showing with 71 additions and 2 deletions.

+65 −0 truffle/src/main/java/org/jruby/truffle/nodes/core/ProcessNodes.java

+6 −2 truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ProcessNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ProcessNodes.java
@@ -9,10 +9,12 @@
  */
 package org.jruby.truffle.nodes.core;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.source.SourceSection;
 
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.UndefinedPlaceholder;
 import org.jruby.truffle.runtime.core.RubySymbol;
 import org.jruby.truffle.runtime.signal.SignalOperations;
 
@@ -21,6 +23,69 @@
 @CoreClass(name = "Process")
 public abstract class ProcessNodes {
 
+    public static final int CLOCK_MONOTONIC = 1;
+    public static final int CLOCK_REALTIME = 2;
+
+    @CoreMethod(names = "clock_gettime", isModuleFunction = true, required = 1, optional = 1)
+    public abstract static class ClockGetTimeNode extends CoreMethodNode {
+
+        private final RubySymbol floatSecondSymbol;
+        private final RubySymbol nanosecondSymbol;
+
+        public ClockGetTimeNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+            floatSecondSymbol = context.newSymbol("float_second");
+            nanosecondSymbol = context.newSymbol("nanosecond");
+        }
+
+        public ClockGetTimeNode(ClockGetTimeNode prev) {
+            super(prev);
+            floatSecondSymbol = prev.floatSecondSymbol;
+            nanosecondSymbol = prev.nanosecondSymbol;
+        }
+
+        @Specialization(guards = "isMonotonic(arguments[0])")
+        Object clock_gettime_monotonic(int clock_id, UndefinedPlaceholder unit) {
+            return clock_gettime_monotonic(CLOCK_MONOTONIC, floatSecondSymbol);
+        }
+
+        @Specialization(guards = "isRealtime(arguments[0])")
+        Object clock_gettime_realtime(int clock_id, UndefinedPlaceholder unit) {
+            return clock_gettime_realtime(CLOCK_REALTIME, floatSecondSymbol);
+        }
+
+        @Specialization(guards = "isMonotonic(arguments[0])")
+        Object clock_gettime_monotonic(int clock_id, RubySymbol unit) {
+            long time = System.nanoTime();
+            return timeToUnit(time, unit);
+        }
+
+        @Specialization(guards = "isRealtime(arguments[0])")
+        Object clock_gettime_realtime(int clock_id, RubySymbol unit) {
+            long time = System.currentTimeMillis() * 1000000;
+            return timeToUnit(time, unit);
+        }
+
+        Object timeToUnit(long time, RubySymbol unit) {
+            if (unit == nanosecondSymbol) {
+                return time;
+            } else if (unit == floatSecondSymbol) {
+                return time / 1e9;
+            } else {
+                throw new UnsupportedOperationException(unit.toString());
+            }
+        }
+
+        static boolean isMonotonic(int clock_id) {
+            return clock_id == CLOCK_MONOTONIC;
+        }
+
+        static boolean isRealtime(int clock_id) {
+            return clock_id == CLOCK_REALTIME;
+        }
+
+    }
+
     @CoreMethod(names = "kill", isModuleFunction = true, required = 2)
     public abstract static class KillNode extends CoreMethodNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/CoreLibrary.java
@@ -22,6 +22,7 @@
 import org.jruby.runtime.load.LoadServiceResource;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.ArrayNodes;
+import org.jruby.truffle.nodes.core.ProcessNodes;
 import org.jruby.truffle.nodes.methods.SetMethodDeclarationContext;
 import org.jruby.truffle.nodes.objects.Allocator;
 import org.jruby.truffle.runtime.RubyCallStack;
@@ -81,7 +82,7 @@ public class CoreLibrary {
     private final RubyClass numericClass;
     private final RubyClass objectClass;
     private final RubyClass procClass;
-    private final RubyClass processClass;
+    private final RubyModule processModule;
     private final RubyClass rangeClass;
     private final RubyClass rangeErrorClass;
     private final RubyClass rationalClass;
@@ -252,7 +253,7 @@ public CoreLibrary(RubyContext context) {
         defineClass("Mutex", new RubyMutex.MutexAllocator());
         nilClass = defineClass("NilClass");
         procClass = defineClass("Proc", new RubyProc.ProcAllocator());
-        processClass = defineClass("Process");
+        processModule = defineModule("Process");
         rangeClass = defineClass("Range", new RubyRange.RangeAllocator());
         regexpClass = defineClass("Regexp", new RubyRegexp.RegexpAllocator());
         stringClass = defineClass("String", new RubyString.StringAllocator());
@@ -388,6 +389,9 @@ private void initializeConstants() {
 
         fileClass.setConstant(null, "PATH_SEPARATOR", RubyString.fromJavaString(stringClass, File.pathSeparator));
         fileClass.setConstant(null, "FNM_SYSCASE", 0);
+
+        processModule.setConstant(null, "CLOCK_MONOTONIC", ProcessNodes.CLOCK_MONOTONIC);
+        processModule.setConstant(null, "CLOCK_REALTIME", ProcessNodes.CLOCK_REALTIME);
     }
 
     private void initializeSignalConstants() {