Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: jruby/jruby
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: 982fa8860119
Choose a base ref
...
head repository: jruby/jruby
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: b2f89475bfba
Choose a head ref
  • 4 commits
  • 5 files changed
  • 1 contributor

Commits on Jul 9, 2016

  1. Copy the full SHA
    fe7a657 View commit details
  2. Copy the full SHA
    b033f01 View commit details
  3. 2
    Copy the full SHA
    8dc5f55 View commit details
  4. Copy the full SHA
    b2f8947 View commit details
Original file line number Diff line number Diff line change
@@ -182,6 +182,7 @@ public class CoreLibrary {
private final DynamicObject notImplementedErrorClass;
private final DynamicObject numericClass;
private final DynamicObject objectClass;
private final DynamicObjectFactory objectFactory;
private final DynamicObject procClass;
private final DynamicObjectFactory procFactory;
private final DynamicObject processModule;
@@ -410,7 +411,8 @@ public CoreLibrary(RubyContext context) {
Layouts.CLASS.setInstanceFactoryUnsafe(basicObjectClass, Layouts.BASIC_OBJECT.createBasicObjectShape(basicObjectClass, basicObjectClass));

objectClass = ClassNodes.createBootClass(context, classClass, basicObjectClass, "Object");
Layouts.CLASS.setInstanceFactoryUnsafe(objectClass, Layouts.BASIC_OBJECT.createBasicObjectShape(objectClass, objectClass));
objectFactory = Layouts.BASIC_OBJECT.createBasicObjectShape(objectClass, objectClass);
Layouts.CLASS.setInstanceFactoryUnsafe(objectClass, objectFactory);

moduleClass = ClassNodes.createBootClass(context, classClass, objectClass, "Module");
Layouts.CLASS.setInstanceFactoryUnsafe(moduleClass, Layouts.MODULE.createModuleShape(moduleClass, moduleClass));
@@ -1268,6 +1270,10 @@ public DynamicObject getObjectClass() {
return objectClass;
}

public DynamicObjectFactory getObjectFactory() {
return objectFactory;
}

public DynamicObject getProcClass() {
return procClass;
}
Original file line number Diff line number Diff line change
@@ -54,14 +54,13 @@ public static DynamicObject createRootFiber(RubyContext context, DynamicObject t

private static DynamicObject createFiber(RubyContext context, DynamicObject thread, DynamicObjectFactory factory, String name, boolean isRootFiber) {
assert RubyGuards.isRubyThread(thread);
final DynamicObjectFactory instanceFactory = Layouts.CLASS.getInstanceFactory(context.getCoreLibrary().getObjectClass());
final DynamicObject fiberLocals = Layouts.BASIC_OBJECT.createBasicObject(instanceFactory);
final DynamicObject fiberLocals = Layouts.BASIC_OBJECT.createBasicObject(context.getCoreLibrary().getObjectFactory());
return Layouts.FIBER.createFiber(
factory,
fiberLocals,
isRootFiber,
new CountDownLatch(1),
new LinkedBlockingQueue<FiberMessage>(2),
new LinkedBlockingQueue<>(2),
thread,
null,
true,
Original file line number Diff line number Diff line change
@@ -53,14 +53,16 @@ public ThreadManager(RubyContext context) {
this.rootThread = createRubyThread(context, context.getCoreLibrary().getThreadClass());
}

public static final InterruptMode DEFAULT_INTERRUPT_MODE = InterruptMode.IMMEDIATE;
public static final Status DEFAULT_STATUS = Status.RUN;

public static DynamicObject createRubyThread(RubyContext context, DynamicObject rubyClass) {
final DynamicObject threadLocals = createThreadLocals(context);
final DynamicObject object = Layouts.THREAD.createThread(
Layouts.CLASS.getInstanceFactory(rubyClass),
threadLocals,
InterruptMode.IMMEDIATE,
Status.RUN,
new ArrayList<Lock>(),
createThreadLocals(context),
DEFAULT_INTERRUPT_MODE,
DEFAULT_STATUS,
new ArrayList<>(),
null,
new CountDownLatch(1),
getGlobalAbortOnException(context),
@@ -69,7 +71,9 @@ public static DynamicObject createRubyThread(RubyContext context, DynamicObject
null,
new AtomicBoolean(false),
0);

Layouts.THREAD.setFiberManagerUnsafe(object, new FiberManager(context, object)); // Because it is cyclic

return object;
}

@@ -78,9 +82,8 @@ public static boolean getGlobalAbortOnException(RubyContext context) {
return (boolean) threadClass.get("@abort_on_exception");
}

private static DynamicObject createThreadLocals(RubyContext context) {
final DynamicObjectFactory instanceFactory = Layouts.CLASS.getInstanceFactory(context.getCoreLibrary().getObjectClass());
final DynamicObject threadLocals = Layouts.BASIC_OBJECT.createBasicObject(instanceFactory);
public static DynamicObject createThreadLocals(RubyContext context) {
final DynamicObject threadLocals = Layouts.BASIC_OBJECT.createBasicObject(context.getCoreLibrary().getObjectFactory());
threadLocals.define("$!", context.getCoreLibrary().getNilObject(), 0);
threadLocals.define("$~", context.getCoreLibrary().getNilObject(), 0);
threadLocals.define("$?", context.getCoreLibrary().getNilObject(), 0);
Original file line number Diff line number Diff line change
@@ -12,6 +12,7 @@
import com.oracle.truffle.api.CompilerDirectives;
import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.dsl.Cached;
import com.oracle.truffle.api.dsl.Specialization;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.Node;
@@ -31,14 +32,27 @@
import org.jruby.truffle.builtins.YieldingCoreMethodNode;
import org.jruby.truffle.core.InterruptMode;
import org.jruby.truffle.core.exception.ExceptionOperations;
import org.jruby.truffle.core.fiber.FiberManager;
import org.jruby.truffle.language.NotProvided;
import org.jruby.truffle.language.RubyNode;
import org.jruby.truffle.language.SafepointAction;
import org.jruby.truffle.language.backtrace.Backtrace;
import org.jruby.truffle.language.control.RaiseException;
import org.jruby.truffle.language.objects.AllocateObjectNode;
import org.jruby.truffle.language.objects.AllocateObjectNodeGen;
import org.jruby.truffle.language.objects.ReadInstanceVariableNode;
import org.jruby.truffle.language.objects.ReadObjectFieldNode;
import org.jruby.truffle.language.objects.ReadObjectFieldNodeGen;
import org.jruby.truffle.platform.UnsafeGroup;
import org.jruby.util.Memo;

import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import static org.jruby.RubyThread.RUBY_MAX_THREAD_PRIORITY;
import static org.jruby.RubyThread.RUBY_MIN_THREAD_PRIORITY;
import static org.jruby.RubyThread.javaPriorityToRubyPriority;
@@ -389,13 +403,41 @@ public DynamicObject setAbortOnException(DynamicObject self, boolean abortOnExce

}

@NonStandard
@CoreMethod(names = "allocate", constructor = true, unsafe = UnsafeGroup.THREADS)
public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {

@Specialization
public DynamicObject allocate(DynamicObject rubyClass) {
// TODO (eregon, 13/10/2015): Thread is not allocatable in MRI but Rubinius's kernel uses it
return ThreadManager.createRubyThread(getContext(), rubyClass);
public DynamicObject allocate(
DynamicObject rubyClass,
@Cached("createAllocateObjectNode()") AllocateObjectNode allocateObjectNode,
@Cached("createReadAbortOnExceptionNode()") ReadObjectFieldNode readAbortOnException ) {
final DynamicObject object = allocateObjectNode.allocate(
rubyClass,
ThreadManager.createThreadLocals(getContext()),
new AtomicReference<>(ThreadManager.DEFAULT_INTERRUPT_MODE),
new AtomicReference<>(ThreadManager.DEFAULT_STATUS),
new ArrayList<>(),
null,
new CountDownLatch(1),
readAbortOnException.execute(getContext().getCoreLibrary().getThreadClass()),
new AtomicReference<>(null),
new AtomicReference<>(null),
new AtomicReference<>(null),
new AtomicBoolean(false),
new AtomicInteger(0));

Layouts.THREAD.setFiberManagerUnsafe(object, new FiberManager(getContext(), object)); // Because it is cyclic

return object;
}

protected AllocateObjectNode createAllocateObjectNode() {
return AllocateObjectNodeGen.create(null, null);
}

protected ReadObjectFieldNode createReadAbortOnExceptionNode() {
return ReadObjectFieldNodeGen.create("@abort_on_exception", false);
}

}
Original file line number Diff line number Diff line change
@@ -41,6 +41,10 @@ public abstract class AllocateObjectNode extends RubyNode {

private final boolean useCallerFrameForTracing;

public AllocateObjectNode() {
this(null, null);
}

public AllocateObjectNode(RubyContext context, SourceSection sourceSection) {
this(context, sourceSection, true);
}