ArrayLayoutImpl.java

package org.jruby.truffle.runtime.layouts;

import java.util.EnumSet;
import com.oracle.truffle.api.object.*;
import org.jruby.truffle.om.dsl.api.UnexpectedLayoutRefusalException;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.CompilerAsserts;
import java.util.concurrent.atomic.*;
import org.jruby.truffle.runtime.layouts.ArrayLayout;
import org.jruby.truffle.runtime.layouts.BasicObjectLayoutImpl;

public class ArrayLayoutImpl extends BasicObjectLayoutImpl implements ArrayLayout {
    
    public static final ArrayLayout INSTANCE = new ArrayLayoutImpl();
    
    protected static class ArrayType extends BasicObjectLayoutImpl.BasicObjectType {
        
        public ArrayType(
                com.oracle.truffle.api.object.DynamicObject logicalClass,
                com.oracle.truffle.api.object.DynamicObject metaClass) {
            super(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ArrayType setLogicalClass(com.oracle.truffle.api.object.DynamicObject logicalClass) {
            return new ArrayType(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ArrayType setMetaClass(com.oracle.truffle.api.object.DynamicObject metaClass) {
            return new ArrayType(
                logicalClass,
                metaClass);
        }
        
    }
    
    protected static final Shape.Allocator ARRAY_ALLOCATOR = LAYOUT.createAllocator();
    
    protected static final HiddenKey STORE_IDENTIFIER = new HiddenKey("store");
    protected static final Property STORE_PROPERTY = Property.create(STORE_IDENTIFIER, ARRAY_ALLOCATOR.locationForType(java.lang.Object.class), 0);
    
    protected static final HiddenKey SIZE_IDENTIFIER = new HiddenKey("size");
    protected static final Property SIZE_PROPERTY = Property.create(SIZE_IDENTIFIER, ARRAY_ALLOCATOR.locationForType(int.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected ArrayLayoutImpl() {
    }
    
    @Override
    public DynamicObjectFactory createArrayShape(
            com.oracle.truffle.api.object.DynamicObject logicalClass,
            com.oracle.truffle.api.object.DynamicObject metaClass) {
        return LAYOUT.createShape(new ArrayType(
                logicalClass,
                metaClass))
            .addProperty(STORE_PROPERTY)
            .addProperty(SIZE_PROPERTY)
            .createFactory();
    }
    
    @Override
    public DynamicObject createArray(
            DynamicObjectFactory factory,
            java.lang.Object store,
            int size) {
        assert factory != null;
        CompilerAsserts.partialEvaluationConstant(factory);
        assert createsArray(factory);
        assert factory.getShape().hasProperty(STORE_IDENTIFIER);
        assert factory.getShape().hasProperty(SIZE_IDENTIFIER);
        return factory.newInstance(
            store,
            size);
    }
    
    @Override
    public boolean isArray(Object object) {
        return (object instanceof DynamicObject) && isArray((DynamicObject) object);
    }
    
    @Override
    public boolean isArray(DynamicObject object) {
        return isArray(object.getShape().getObjectType());
    }
    
    @Override
    public boolean isArray(ObjectType objectType) {
        return objectType instanceof ArrayType;
    }
    
    private boolean createsArray(DynamicObjectFactory factory) {
        return isArray(factory.getShape().getObjectType());
    }
    
    @Override
    public java.lang.Object getStore(DynamicObject object) {
        assert isArray(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        return (java.lang.Object) STORE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setStore(DynamicObject object, java.lang.Object value) {
        assert isArray(object);
        assert object.getShape().hasProperty(STORE_IDENTIFIER);
        
        try {
            STORE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public int getSize(DynamicObject object) {
        assert isArray(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        return (int) SIZE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setSize(DynamicObject object, int value) {
        assert isArray(object);
        assert object.getShape().hasProperty(SIZE_IDENTIFIER);
        
        try {
            SIZE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
}

ThreadLayoutImpl.java

package org.jruby.truffle.runtime.layouts;

import java.util.EnumSet;
import com.oracle.truffle.api.object.*;
import org.jruby.truffle.om.dsl.api.UnexpectedLayoutRefusalException;
import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
import com.oracle.truffle.api.CompilerAsserts;
import java.util.concurrent.atomic.*;
import org.jruby.truffle.runtime.layouts.ThreadLayout;
import org.jruby.truffle.runtime.layouts.BasicObjectLayoutImpl;

public class ThreadLayoutImpl extends BasicObjectLayoutImpl implements ThreadLayout {
    
    public static final ThreadLayout INSTANCE = new ThreadLayoutImpl();
    
    protected static class ThreadType extends BasicObjectLayoutImpl.BasicObjectType {
        
        public ThreadType(
                com.oracle.truffle.api.object.DynamicObject logicalClass,
                com.oracle.truffle.api.object.DynamicObject metaClass) {
            super(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ThreadType setLogicalClass(com.oracle.truffle.api.object.DynamicObject logicalClass) {
            return new ThreadType(
                logicalClass,
                metaClass);
        }
        
        @Override
        public ThreadType setMetaClass(com.oracle.truffle.api.object.DynamicObject metaClass) {
            return new ThreadType(
                logicalClass,
                metaClass);
        }
        
    }
    
    protected static final Shape.Allocator THREAD_ALLOCATOR = LAYOUT.createAllocator();
    
    protected static final HiddenKey FIBER_MANAGER_IDENTIFIER = new HiddenKey("fiberManager");
    protected static final Property FIBER_MANAGER_PROPERTY = Property.create(FIBER_MANAGER_IDENTIFIER, THREAD_ALLOCATOR.locationForType(org.jruby.truffle.runtime.subsystems.FiberManager.class), 0);
    
    protected static final HiddenKey NAME_IDENTIFIER = new HiddenKey("name");
    protected static final Property NAME_PROPERTY = Property.create(NAME_IDENTIFIER, THREAD_ALLOCATOR.locationForType(java.lang.String.class), 0);
    
    protected static final HiddenKey FINISHED_LATCH_IDENTIFIER = new HiddenKey("finishedLatch");
    protected static final Property FINISHED_LATCH_PROPERTY = Property.create(FINISHED_LATCH_IDENTIFIER, THREAD_ALLOCATOR.locationForType(java.util.concurrent.CountDownLatch.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey THREAD_LOCALS_IDENTIFIER = new HiddenKey("threadLocals");
    protected static final Property THREAD_LOCALS_PROPERTY = Property.create(THREAD_LOCALS_IDENTIFIER, THREAD_ALLOCATOR.locationForType(com.oracle.truffle.api.object.DynamicObject.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey OWNED_LOCKS_IDENTIFIER = new HiddenKey("ownedLocks");
    protected static final Property OWNED_LOCKS_PROPERTY = Property.create(OWNED_LOCKS_IDENTIFIER, THREAD_ALLOCATOR.locationForType(java.util.List.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey ABORT_ON_EXCEPTION_IDENTIFIER = new HiddenKey("abortOnException");
    protected static final Property ABORT_ON_EXCEPTION_PROPERTY = Property.create(ABORT_ON_EXCEPTION_IDENTIFIER, THREAD_ALLOCATOR.locationForType(boolean.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey INTERRUPT_MODE_IDENTIFIER = new HiddenKey("interruptMode");
    protected static final Property INTERRUPT_MODE_PROPERTY = Property.create(INTERRUPT_MODE_IDENTIFIER, THREAD_ALLOCATOR.locationForType(org.jruby.truffle.nodes.core.InterruptMode.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey THREAD_IDENTIFIER = new HiddenKey("thread");
    protected static final Property THREAD_PROPERTY = Property.create(THREAD_IDENTIFIER, THREAD_ALLOCATOR.locationForType(AtomicReference.class), 0);
    
    protected static final HiddenKey STATUS_IDENTIFIER = new HiddenKey("status");
    protected static final Property STATUS_PROPERTY = Property.create(STATUS_IDENTIFIER, THREAD_ALLOCATOR.locationForType(AtomicReference.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey EXCEPTION_IDENTIFIER = new HiddenKey("exception");
    protected static final Property EXCEPTION_PROPERTY = Property.create(EXCEPTION_IDENTIFIER, THREAD_ALLOCATOR.locationForType(AtomicReference.class), 0);
    
    protected static final HiddenKey VALUE_IDENTIFIER = new HiddenKey("value");
    protected static final Property VALUE_PROPERTY = Property.create(VALUE_IDENTIFIER, THREAD_ALLOCATOR.locationForType(AtomicReference.class), 0);
    
    protected static final HiddenKey WAKE_UP_IDENTIFIER = new HiddenKey("wakeUp");
    protected static final Property WAKE_UP_PROPERTY = Property.create(WAKE_UP_IDENTIFIER, THREAD_ALLOCATOR.locationForType(java.util.concurrent.atomic.AtomicBoolean.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected static final HiddenKey PRIORITY_IDENTIFIER = new HiddenKey("priority");
    protected static final Property PRIORITY_PROPERTY = Property.create(PRIORITY_IDENTIFIER, THREAD_ALLOCATOR.locationForType(AtomicInteger.class, EnumSet.of(LocationModifier.NonNull)), 0);
    
    protected ThreadLayoutImpl() {
    }
    
    @Override
    public DynamicObjectFactory createThreadShape(
            com.oracle.truffle.api.object.DynamicObject logicalClass,
            com.oracle.truffle.api.object.DynamicObject metaClass) {
        return LAYOUT.createShape(new ThreadType(
                logicalClass,
                metaClass))
            .addProperty(FIBER_MANAGER_PROPERTY)
            .addProperty(NAME_PROPERTY)
            .addProperty(FINISHED_LATCH_PROPERTY)
            .addProperty(THREAD_LOCALS_PROPERTY)
            .addProperty(OWNED_LOCKS_PROPERTY)
            .addProperty(ABORT_ON_EXCEPTION_PROPERTY)
            .addProperty(INTERRUPT_MODE_PROPERTY)
            .addProperty(THREAD_PROPERTY)
            .addProperty(STATUS_PROPERTY)
            .addProperty(EXCEPTION_PROPERTY)
            .addProperty(VALUE_PROPERTY)
            .addProperty(WAKE_UP_PROPERTY)
            .addProperty(PRIORITY_PROPERTY)
            .createFactory();
    }
    
    @Override
    public DynamicObject createThread(
            DynamicObjectFactory factory,
            org.jruby.truffle.runtime.subsystems.FiberManager fiberManager,
            java.lang.String name,
            java.util.concurrent.CountDownLatch finishedLatch,
            com.oracle.truffle.api.object.DynamicObject threadLocals,
            java.util.List<java.util.concurrent.locks.Lock> ownedLocks,
            boolean abortOnException,
            org.jruby.truffle.nodes.core.InterruptMode interruptMode,
            java.lang.Thread thread,
            org.jruby.RubyThread.Status status,
            java.lang.Object exception,
            java.lang.Object value,
            java.util.concurrent.atomic.AtomicBoolean wakeUp,
            int priority) {
        assert factory != null;
        CompilerAsserts.partialEvaluationConstant(factory);
        assert createsThread(factory);
        assert factory.getShape().hasProperty(FIBER_MANAGER_IDENTIFIER);
        assert factory.getShape().hasProperty(NAME_IDENTIFIER);
        assert factory.getShape().hasProperty(FINISHED_LATCH_IDENTIFIER);
        assert factory.getShape().hasProperty(THREAD_LOCALS_IDENTIFIER);
        assert factory.getShape().hasProperty(OWNED_LOCKS_IDENTIFIER);
        assert factory.getShape().hasProperty(ABORT_ON_EXCEPTION_IDENTIFIER);
        assert factory.getShape().hasProperty(INTERRUPT_MODE_IDENTIFIER);
        assert factory.getShape().hasProperty(THREAD_IDENTIFIER);
        assert factory.getShape().hasProperty(STATUS_IDENTIFIER);
        assert factory.getShape().hasProperty(EXCEPTION_IDENTIFIER);
        assert factory.getShape().hasProperty(VALUE_IDENTIFIER);
        assert factory.getShape().hasProperty(WAKE_UP_IDENTIFIER);
        assert factory.getShape().hasProperty(PRIORITY_IDENTIFIER);
        assert finishedLatch != null;
        assert threadLocals != null;
        assert ownedLocks != null;
        assert interruptMode != null;
        assert status != null;
        assert wakeUp != null;
        return factory.newInstance(
            fiberManager,
            name,
            finishedLatch,
            threadLocals,
            ownedLocks,
            abortOnException,
            interruptMode,
            new AtomicReference<java.lang.Thread>(thread),
            new AtomicReference<org.jruby.RubyThread.Status>(status),
            new AtomicReference<java.lang.Object>(exception),
            new AtomicReference<java.lang.Object>(value),
            wakeUp,
            new AtomicInteger(priority));
    }
    
    @Override
    public boolean isThread(DynamicObject object) {
        return isThread(object.getShape().getObjectType());
    }
    
    private boolean isThread(ObjectType objectType) {
        return objectType instanceof ThreadType;
    }
    
    private boolean createsThread(DynamicObjectFactory factory) {
        return isThread(factory.getShape().getObjectType());
    }
    
    @Override
    public org.jruby.truffle.runtime.subsystems.FiberManager getFiberManager(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(FIBER_MANAGER_IDENTIFIER);
        
        return (org.jruby.truffle.runtime.subsystems.FiberManager) FIBER_MANAGER_PROPERTY.get(object, true);
    }
    
    @Override
    public void setFiberManagerUnsafe(DynamicObject object, org.jruby.truffle.runtime.subsystems.FiberManager value) {
        assert isThread(object);
        assert object.getShape().hasProperty(FIBER_MANAGER_IDENTIFIER);
        
        FIBER_MANAGER_PROPERTY.setInternal(object, value);
    }
    
    @Override
    public java.lang.String getName(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(NAME_IDENTIFIER);
        
        return (java.lang.String) NAME_PROPERTY.get(object, true);
    }
    
    @Override
    public void setName(DynamicObject object, java.lang.String value) {
        assert isThread(object);
        assert object.getShape().hasProperty(NAME_IDENTIFIER);
        
        try {
            NAME_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public java.util.concurrent.CountDownLatch getFinishedLatch(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(FINISHED_LATCH_IDENTIFIER);
        
        return (java.util.concurrent.CountDownLatch) FINISHED_LATCH_PROPERTY.get(object, true);
    }
    
    @Override
    public com.oracle.truffle.api.object.DynamicObject getThreadLocals(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(THREAD_LOCALS_IDENTIFIER);
        
        return (com.oracle.truffle.api.object.DynamicObject) THREAD_LOCALS_PROPERTY.get(object, true);
    }
    
    @Override
    public java.util.List<java.util.concurrent.locks.Lock> getOwnedLocks(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(OWNED_LOCKS_IDENTIFIER);
        
        return (java.util.List<java.util.concurrent.locks.Lock>) OWNED_LOCKS_PROPERTY.get(object, true);
    }
    
    @Override
    public boolean getAbortOnException(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(ABORT_ON_EXCEPTION_IDENTIFIER);
        
        return (boolean) ABORT_ON_EXCEPTION_PROPERTY.get(object, true);
    }
    
    @Override
    public void setAbortOnException(DynamicObject object, boolean value) {
        assert isThread(object);
        assert object.getShape().hasProperty(ABORT_ON_EXCEPTION_IDENTIFIER);
        
        try {
            ABORT_ON_EXCEPTION_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public org.jruby.truffle.nodes.core.InterruptMode getInterruptMode(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(INTERRUPT_MODE_IDENTIFIER);
        
        return (org.jruby.truffle.nodes.core.InterruptMode) INTERRUPT_MODE_PROPERTY.get(object, true);
    }
    
    @Override
    public void setInterruptMode(DynamicObject object, org.jruby.truffle.nodes.core.InterruptMode value) {
        assert isThread(object);
        assert object.getShape().hasProperty(INTERRUPT_MODE_IDENTIFIER);
        assert value != null;
        
        try {
            INTERRUPT_MODE_PROPERTY.set(object, value, object.getShape());
        } catch (IncompatibleLocationException | FinalLocationException e) {
            throw new UnexpectedLayoutRefusalException(e);
        }
    }
    
    @Override
    public java.lang.Thread getThread(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(THREAD_IDENTIFIER);
        
        return ((AtomicReference<java.lang.Thread>) THREAD_PROPERTY.get(object, true)).get();
    }
    
    @Override
    public void setThread(DynamicObject object, java.lang.Thread value) {
        assert isThread(object);
        assert object.getShape().hasProperty(THREAD_IDENTIFIER);
        
        ((AtomicReference<java.lang.Thread>) THREAD_PROPERTY.get(object, true)).set(value);
    }
    
    @Override
    public org.jruby.RubyThread.Status getStatus(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(STATUS_IDENTIFIER);
        
        return ((AtomicReference<org.jruby.RubyThread.Status>) STATUS_PROPERTY.get(object, true)).get();
    }
    
    @Override
    public void setStatus(DynamicObject object, org.jruby.RubyThread.Status value) {
        assert isThread(object);
        assert object.getShape().hasProperty(STATUS_IDENTIFIER);
        assert value != null;
        
        ((AtomicReference<org.jruby.RubyThread.Status>) STATUS_PROPERTY.get(object, true)).set(value);
    }
    
    @Override
    public java.lang.Object getException(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(EXCEPTION_IDENTIFIER);
        
        return ((AtomicReference<java.lang.Object>) EXCEPTION_PROPERTY.get(object, true)).get();
    }
    
    @Override
    public void setException(DynamicObject object, java.lang.Object value) {
        assert isThread(object);
        assert object.getShape().hasProperty(EXCEPTION_IDENTIFIER);
        
        ((AtomicReference<java.lang.Object>) EXCEPTION_PROPERTY.get(object, true)).set(value);
    }
    
    @Override
    public java.lang.Object getValue(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(VALUE_IDENTIFIER);
        
        return ((AtomicReference<java.lang.Object>) VALUE_PROPERTY.get(object, true)).get();
    }
    
    @Override
    public void setValue(DynamicObject object, java.lang.Object value) {
        assert isThread(object);
        assert object.getShape().hasProperty(VALUE_IDENTIFIER);
        
        ((AtomicReference<java.lang.Object>) VALUE_PROPERTY.get(object, true)).set(value);
    }
    
    @Override
    public java.util.concurrent.atomic.AtomicBoolean getWakeUp(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(WAKE_UP_IDENTIFIER);
        
        return (java.util.concurrent.atomic.AtomicBoolean) WAKE_UP_PROPERTY.get(object, true);
    }
    
    @Override
    public int getPriority(DynamicObject object) {
        assert isThread(object);
        assert object.getShape().hasProperty(PRIORITY_IDENTIFIER);
        
        return ((AtomicInteger) PRIORITY_PROPERTY.get(object, true)).get();
    }
    
    @Override
    public void setPriority(DynamicObject object, int value) {
        assert isThread(object);
        assert object.getShape().hasProperty(PRIORITY_IDENTIFIER);
        
        ((AtomicInteger) PRIORITY_PROPERTY.get(object, true)).set(value);
    }
    
}