Merge branch 'master' into truffle-head

jruby · Sep 22, 2015 · 263ea1d · 263ea1d
2 parents da934a0 + e4834a0
commit 263ea1d
Showing 25 changed files with 270 additions and 580 deletions.
diff --git a/core/src/main/java/org/jruby/util/URLResource.java b/core/src/main/java/org/jruby/util/URLResource.java
@@ -153,7 +153,7 @@ public Channel openChannel( ModeFlags flags, int perm ) throws ResourceException
         return Channels.newChannel(inputStream());
     }
 
-    public static FileResource createClassloaderURI(Ruby runtime, String pathname, boolean isFile) {
+    public static FileResource createClassloaderURI(Ruby runtime, String pathname, boolean asFile) {
         ClassLoader cl = runtime != null ? runtime.getJRubyClassLoader() : RubyInstanceConfig.defaultClassLoader();
         try
         {
@@ -163,7 +163,7 @@ public static FileResource createClassloaderURI(Ruby runtime, String pathname, b
       }
       final URL url = cl.getResource(pathname);
       String[] files = null;
-      if (!isFile) {
+      if (!asFile) {
           files = listClassLoaderFiles(cl, pathname);
           if (files == null) {
               // no .jrubydir found
@@ -238,19 +238,19 @@ private static boolean addDirectoryEntries(Set<String> entries, URL url,
         return isDirectory;
     }
 
-    public static FileResource create(Ruby runtime, String pathname, boolean isFile) {
+    public static FileResource create(Ruby runtime, String pathname, boolean asFile) {
         if (!pathname.startsWith(URI)) {
             return null;
         }
         // GH-2005 needs the replace
         pathname = pathname.substring(URI.length()).replace("\\", "/");
         if (pathname.startsWith(CLASSLOADER)) {
-            return createClassloaderURI(runtime, pathname.substring(CLASSLOADER.length()), isFile);
+            return createClassloaderURI(runtime, pathname.substring(CLASSLOADER.length()), asFile);
         }
-        return createRegularURI(pathname, isFile);
+        return createRegularURI(pathname, asFile);
     }
 
-    private static FileResource createRegularURI(String pathname, boolean isFile) {
+    private static FileResource createRegularURI(String pathname, boolean asFile) {
         URL url;
         try
         {
@@ -270,7 +270,7 @@ private static FileResource createRegularURI(String pathname, boolean isFile) {
             // file does not exists
             return new URLResource(URI + pathname, (URL)null, null);
         }
-        String[] files = isFile ? null : listFiles(pathname);
+        String[] files = asFile ? null : listFiles(pathname);
         if (files != null) {
             return new URLResource(URI + pathname, (URL)null, files);
         }
@@ -324,7 +324,7 @@ private static String[] listFilesFromInputStream(InputStream is) {
     private static String[] listClassLoaderFiles(ClassLoader classloader, String pathname) {
         try
         {
-            String path = pathname + (pathname.equals("") ? ".jrubydir" : "/.jrubydir");
+            String path = pathname + (pathname.equals("") || pathname.endsWith("/") ? ".jrubydir" : "/.jrubydir");
             Enumeration<URL> urls = classloader.getResources(path);
             if (!urls.hasMoreElements()) {
                 return null;

diff --git a/core/src/main/java/org/jruby/util/io/SelectorPool.java b/core/src/main/java/org/jruby/util/io/SelectorPool.java
@@ -31,6 +31,7 @@
 
 import java.io.IOException;
 import java.nio.channels.Selector;
+import java.util.ArrayList;
 import java.util.List;
 
 import java.nio.channels.spi.SelectorProvider;
@@ -52,6 +53,7 @@
  */
 public class SelectorPool {
     private final Map<SelectorProvider, List<Selector>> pool = new HashMap<SelectorProvider, List<Selector>>();
+    private final List<Selector> openSelectors = new ArrayList<Selector>();
 
     /**
      * Get a selector from the pool (or create a new one). Selectors come from
@@ -87,7 +89,8 @@ public synchronized void put(Selector selector) {
     /**
      * Clean up a pool.
      * 
-     * All selectors in a pool are closed and the pool gets empty.
+     * All selectors in a pool or handed out from the pool are closed
+     * and the pool gets emptied.
      * 
      */
     public synchronized void cleanup() {
@@ -103,18 +106,32 @@ public synchronized void cleanup() {
             }
         }
         pool.clear();
+
+        for (Selector selector : openSelectors) {
+            try {
+                selector.close();
+            } catch (IOException ioe) {
+                // ignore IOException at termination.
+            }
+        }
+        openSelectors.clear();
     }
 
     private Selector retrieveFromPool(SelectorProvider provider) throws IOException {
         List<Selector> providerPool = pool.get(provider);
+        Selector selector;
         if (providerPool != null && !providerPool.isEmpty()) {
-            return providerPool.remove(providerPool.size() - 1);
+            selector = providerPool.remove(providerPool.size() - 1);
+        } else {
+            selector = SelectorFactory.openWithRetryFrom(null, provider);
         }
 
-        return SelectorFactory.openWithRetryFrom(null, provider);
+        openSelectors.add(selector);
+        return selector;
     }
 
     private void returnToPool(Selector selector) {
+        openSelectors.remove(selector);
         if (selector.isOpen()) {
             SelectorProvider provider = selector.provider();
             List<Selector> providerPool = pool.get(provider);

diff --git a/core/src/test/java/org/jruby/util/URLResourceTest.java b/core/src/test/java/org/jruby/util/URLResourceTest.java
@@ -17,7 +17,19 @@ public void testDirectory(){
         assertTrue(resource.isDirectory());
         assertTrue(resource.exists());
         assertEquals(Arrays.asList(resource.list()),
-                     Arrays.asList(new String[] {".", "dir_without_listing", "dir_with_listing"}));
+                Arrays.asList(new String[] {".", "dir_without_listing", "dir_with_listing"}));
+    }
+
+    public void testDirectoryWithTrailingSlash(){
+        String uri = Thread.currentThread().getContextClassLoader().getResource( "somedir" ).toExternalForm();
+        FileResource resource = URLResource.create((Ruby) null, "uri:" + uri + "/", false);
+
+        assertNotNull(resource );
+        assertFalse(resource.isFile());
+        assertTrue(resource.isDirectory());
+        assertTrue(resource.exists());
+        assertEquals(Arrays.asList(resource.list()),
+                Arrays.asList(new String[] {".", "dir_without_listing", "dir_with_listing"}));
     }
 
     public void testNoneDirectory(){
@@ -53,18 +65,31 @@ public void testNonExistingFile(){
         assertNull(resource.list());
     }
 
-    public void testDirectoryClassloader()
-    {
+    public void testDirectoryClassloader() {
         FileResource resource = URLResource.create((Ruby) null,
                 "uri:classloader:/somedir", false);
 
+        assertNotNull(resource);
+        assertFalse(resource.isFile());
+        assertTrue(resource.isDirectory());
+        assertTrue(resource.exists());
+        assertEquals(Arrays.asList(resource.list()),
+                Arrays.asList(new String[]{".", "dir_without_listing",
+                        "dir_with_listing"}));
+    }
+
+    public void testDirectoryWithTrailingClassloader()
+    {
+        FileResource resource = URLResource.create((Ruby) null,
+                "uri:classloader:/somedir/", false);
+
         assertNotNull( resource );
         assertFalse( resource.isFile() );
         assertTrue( resource.isDirectory() );
         assertTrue( resource.exists() );
         assertEquals( Arrays.asList( resource.list() ),
-                      Arrays.asList( new String[] { ".", "dir_without_listing",
-                                                   "dir_with_listing" } ) );
+                Arrays.asList( new String[] { ".", "dir_without_listing",
+                        "dir_with_listing" } ) );
     }
 
     public void testNoneDirectoryClassloader()
@@ -83,7 +108,7 @@ public void testNoneDirectoryClassloader()
     public void testFileClassloader()
     {
         FileResource resource = URLResource.create((Ruby) null,
-                "uri:classloader:/somedir/.jrubydir", false );
+                "uri:classloader:/somedir/.jrubydir", true );
 
         assertNotNull( resource );
         assertTrue( resource.isFile() );

diff --git a/maven/jruby-complete/src/it/integrity/pom.xml b/maven/jruby-complete/src/it/integrity/pom.xml
@@ -233,6 +233,28 @@
               </arguments>
             </configuration>
           </execution>
+          <execution>
+            <id>META-INF/jruby.home is not a file - GH-3342</id>
+            <phase>test</phase>
+            <goals>
+              <goal>exec</goal>
+            </goals>
+            <configuration>
+              <workingDirectory>${basedir}</workingDirectory>
+              <executable>java</executable>
+              <arguments>
+                <argument>-classpath</argument>
+                <classpath/>
+                <argument>org.jruby.Main</argument>
+                <argument>-e</argument>
+                <argument>
+                  puts "jruby home is a file: " +
+                  File.file?("uri:classloader:/META-INF/jruby.home").to_s +
+                  File.file?("uri:classloader:/META-INF/jruby.home/").to_s
+                </argument>
+              </arguments>
+            </configuration>
+          </execution>
         </executions>
       </plugin>
     </plugins>

diff --git a/maven/jruby-complete/src/it/integrity/verify.bsh b/maven/jruby-complete/src/it/integrity/verify.bsh
@@ -61,3 +61,6 @@ if ( !file.exists() )
 
 expected = "uri:classloader://META-INF/jruby.home";
 if ( !log.contains( expected ) ) throw new RuntimeException( "log file does not contain '" + expected + "'" );
+
+expected = "jruby home is a file: falsefalse";
+if ( !log.contains( expected ) ) throw new RuntimeException( "log file does not contain '" + expected + "'" );
diff --git a/spec/regression/embedded_runtime_leak_spec.rb b/spec/regression/embedded_runtime_leak_spec.rb
@@ -1,20 +1,48 @@
 describe "embedded runtimes" do
   it "should not leak runtimes after tearing them down" do
-    num_runtimes = 10
+    create_runtimes(10) do |runtime|
+      # nothing to do actually - the runtimes will by default build up
+      # and OOM if they aren't being garbage collected
+    end
+  end
+
+  it "should not leak runtimes blocked on IO" do
+    create_runtimes(10) do |runtime|
+      latch = java.util.concurrent.CountDownLatch.new(1)
+      Thread.new do
+        latch.countDown
+        # we'll get an OOM if the blocking TCPServer#accept call below
+        # doesn't get interrupted during runtime teardown
+        runtime.evalScriptlet <<-EOS
+          require "socket"
+          server = TCPServer.new(0)
+          begin
+            server.accept
+          rescue Exception
+          end
+        EOS
+      end
+      latch.await # spawned thread has started
+      sleep 0.5 # give time for the new runtime to block on accept
+    end
+  end
+
+  def create_runtimes(num_runtimes)
     mbean = java.lang.management.ManagementFactory.getMemoryMXBean
-    lambda do
+    expect do
       num_runtimes.times do
-        instance = org.jruby.Ruby.newInstance
-        instance.evalScriptlet <<-EOS
+        runtime = org.jruby.Ruby.newInstance
+        runtime.evalScriptlet <<-EOS
           # eat up some memory in each runtime
           $arr = 500000.times.map { |i| "foobarbaz\#{i}" }
         EOS
-        instance.tearDown(false)
+        yield runtime if block_given?
+        runtime.tearDown(false)
         # Make sure GC can keep up
         while mbean.getObjectPendingFinalizationCount > 0
           sleep 0.2
         end
       end
-    end.should_not raise_error
+    end.not_to raise_error
   end
 end
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -55,6 +55,7 @@
 import org.jruby.truffle.nodes.methods.LookupMethodNodeGen;
 import org.jruby.truffle.nodes.objects.*;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.nodes.rubinius.ObjectPrimitiveNodes;
 import org.jruby.truffle.nodes.rubinius.ObjectPrimitiveNodesFactory;
 import org.jruby.truffle.pack.parser.FormatParser;
@@ -2116,7 +2117,7 @@ public UntaintNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
             isFrozenNode = IsFrozenNodeGen.create(context, sourceSection, null);
             isTaintedNode = IsTaintedNodeGen.create(context, sourceSection, null);
-            writeTaintNode = new WriteHeadObjectFieldNode(Layouts.TAINTED_IDENTIFIER);
+            writeTaintNode = WriteHeadObjectFieldNodeGen.create(Layouts.TAINTED_IDENTIFIER);
         }
 
         @Specialization

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java
@@ -204,10 +204,9 @@ public GetIndexNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object getIndex(DynamicObject matchData, int index, NotProvided length) {
-            CompilerDirectives.transferToInterpreter();
-
             final Object[] values = Arrays.copyOf(Layouts.MATCH_DATA.getValues(matchData), Layouts.MATCH_DATA.getValues(matchData).length);
             final int normalizedIndex = ArrayOperations.normalizeIndex(values.length, index);
 
@@ -218,20 +217,19 @@ public Object getIndex(DynamicObject matchData, int index, NotProvided length) {
             }
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object getIndex(DynamicObject matchData, int index, int length) {
-            CompilerDirectives.transferToInterpreter();
             // TODO BJF 15-May-2015 Need to handle negative indexes and lengths and out of bounds
             final Object[] values = Arrays.copyOf(Layouts.MATCH_DATA.getValues(matchData), Layouts.MATCH_DATA.getValues(matchData).length);
             final int normalizedIndex = ArrayOperations.normalizeIndex(values.length, index);
             final Object[] store = Arrays.copyOfRange(values, normalizedIndex, normalizedIndex + length);
             return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), store, length);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization(guards = "isRubySymbol(index)")
         public Object getIndexSymbol(DynamicObject matchData, DynamicObject index, NotProvided length) {
-            CompilerDirectives.transferToInterpreter();
-
             try {
                 ByteList value = Layouts.SYMBOL.getByteList(index);
                 final int i = Layouts.REGEXP.getRegex(Layouts.MATCH_DATA.getRegexp(matchData)).nameToBackrefNumber(value.getUnsafeBytes(), value.getBegin(), value.getBegin() + value.getRealSize(), Layouts.MATCH_DATA.getRegion(matchData));
@@ -245,10 +243,9 @@ public Object getIndexSymbol(DynamicObject matchData, DynamicObject index, NotPr
             }
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization(guards = "isRubyString(index)")
         public Object getIndexString(DynamicObject matchData, DynamicObject index, NotProvided length) {
-            CompilerDirectives.transferToInterpreter();
-
             try {
                 ByteList value = Layouts.STRING.getByteList(index);
                 final int i = Layouts.REGEXP.getRegex(Layouts.MATCH_DATA.getRegexp(matchData)).nameToBackrefNumber(value.getUnsafeBytes(), value.getBegin(), value.getBegin() + value.getRealSize(), Layouts.MATCH_DATA.getRegion(matchData));
@@ -275,6 +272,7 @@ public Object getIndex(VirtualFrame frame, DynamicObject matchData, Object index
             return getIndex(matchData, toIntNode.doInt(frame, index), NotProvided.INSTANCE);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization(guards = "isIntegerFixnumRange(range)")
         public Object getIndex(DynamicObject matchData, DynamicObject range, NotProvided len) {
             final Object[] values = Arrays.copyOf(Layouts.MATCH_DATA.getValues(matchData), Layouts.MATCH_DATA.getValues(matchData).length);
@@ -298,13 +296,10 @@ public BeginNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object begin(DynamicObject matchData, int index) {
-            CompilerDirectives.transferToInterpreter();
-
             if (badIndexProfile.profile((index < 0) || (index >= Layouts.MATCH_DATA.getRegion(matchData).numRegs))) {
-                CompilerDirectives.transferToInterpreter();
-
                 throw new RaiseException(
                         getContext().getCoreLibrary().indexError(String.format("index %d out of matches", index), this));
 
@@ -322,10 +317,9 @@ public CapturesNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public DynamicObject toA(DynamicObject matchData) {
-            CompilerDirectives.transferToInterpreter();
-
             Object[] objects = getCaptures(matchData);
             return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), objects, objects.length);
         }
@@ -340,13 +334,10 @@ public EndNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object end(DynamicObject matchData, int index) {
-            CompilerDirectives.transferToInterpreter();
-
             if (badIndexProfile.profile((index < 0) || (index >= Layouts.MATCH_DATA.getRegion(matchData).numRegs))) {
-                CompilerDirectives.transferToInterpreter();
-
                 throw new RaiseException(
                         getContext().getCoreLibrary().indexError(String.format("index %d out of matches", index), this));
 
@@ -395,6 +386,7 @@ public LengthNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public int length(DynamicObject matchData) {
             return Arrays.copyOf(Layouts.MATCH_DATA.getValues(matchData), Layouts.MATCH_DATA.getValues(matchData).length).length;
@@ -412,6 +404,7 @@ public PreMatchNode(RubyContext context, SourceSection sourceSection) {
             taintResultNode = new TaintResultNode(getContext(), getSourceSection());
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object preMatch(DynamicObject matchData) {
             return taintResultNode.maybeTaint(Layouts.MATCH_DATA.getSource(matchData), Layouts.MATCH_DATA.getPre(matchData));
@@ -429,6 +422,7 @@ public PostMatchNode(RubyContext context, SourceSection sourceSection) {
             taintResultNode = new TaintResultNode(getContext(), getSourceSection());
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public Object postMatch(DynamicObject matchData) {
             return taintResultNode.maybeTaint(Layouts.MATCH_DATA.getSource(matchData), Layouts.MATCH_DATA.getPost(matchData));
@@ -443,10 +437,9 @@ public ToANode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public DynamicObject toA(DynamicObject matchData) {
-            CompilerDirectives.transferToInterpreter();
-
             Object[] objects = Arrays.copyOf(Layouts.MATCH_DATA.getValues(matchData), Layouts.MATCH_DATA.getValues(matchData).length);
             return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), objects, objects.length);
         }
@@ -459,10 +452,9 @@ public ToSNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public DynamicObject toS(DynamicObject matchData) {
-            CompilerDirectives.transferToInterpreter();
-
             final ByteList bytes = Layouts.STRING.getByteList(Layouts.MATCH_DATA.getGlobal(matchData)).dup();
             return Layouts.STRING.createString(getContext().getCoreLibrary().getStringFactory(), bytes, StringSupport.CR_UNKNOWN, null);
         }
@@ -475,6 +467,7 @@ public RegexpNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public DynamicObject regexp(DynamicObject matchData) {
             return Layouts.MATCH_DATA.getRegexp(matchData);
@@ -489,6 +482,7 @@ public RubiniusSourceNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
+        @CompilerDirectives.TruffleBoundary
         @Specialization
         public DynamicObject rubiniusSource(DynamicObject matchData) {
             return Layouts.MATCH_DATA.getSource(matchData);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objects/FreezeNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objects/FreezeNode.java
@@ -15,8 +15,10 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.layouts.Layouts;
 
@@ -70,7 +72,7 @@ public Object freezeSymbol(DynamicObject symbol) {
     public Object freeze(DynamicObject object) {
         if (writeFrozenNode == null) {
             CompilerDirectives.transferToInterpreter();
-            writeFrozenNode = insert(new WriteHeadObjectFieldNode(Layouts.FROZEN_IDENTIFIER));
+            writeFrozenNode = insert(WriteHeadObjectFieldNodeGen.create(Layouts.FROZEN_IDENTIFIER));
         }
 
         writeFrozenNode.execute(object, true);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objects/TaintNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objects/TaintNode.java
@@ -14,8 +14,10 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.layouts.Layouts;
@@ -60,7 +62,7 @@ public Object taintSymbol(DynamicObject symbol) {
     public Object taint(DynamicObject object) {
         if (writeTaintNode == null) {
             CompilerDirectives.transferToInterpreter();
-            writeTaintNode = insert(new WriteHeadObjectFieldNode(Layouts.TAINTED_IDENTIFIER));
+            writeTaintNode = insert(WriteHeadObjectFieldNodeGen.create(Layouts.TAINTED_IDENTIFIER));
         }
         writeTaintNode.execute(object, true);
         return object;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objects/WriteInstanceVariableNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objects/WriteInstanceVariableNode.java
@@ -14,10 +14,12 @@
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jcodings.specific.UTF8Encoding;
 import org.jruby.RubyString;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.layouts.Layouts;
@@ -35,7 +37,7 @@ public WriteInstanceVariableNode(RubyContext context, SourceSection sourceSectio
         super(context, sourceSection);
         this.receiver = receiver;
         this.rhs = rhs;
-        writeNode = new WriteHeadObjectFieldNode(name);
+        writeNode = WriteHeadObjectFieldNodeGen.create(name);
         this.isGlobal = isGlobal;
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/MigrateNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/MigrateNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/ReadHeadObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/ReadHeadObjectFieldNode.java
@@ -16,7 +16,9 @@
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
 import com.oracle.truffle.api.object.*;
 import com.oracle.truffle.api.source.SourceSection;
+
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.runtime.Options;
 import org.jruby.truffle.runtime.RubyContext;
 
 @NodeChild("receiver")
@@ -141,7 +143,7 @@ protected DoubleLocation getDoubleLocation(Shape shape) {
     }
 
     protected int getCacheLimit() {
-        return getContext().getOptions().FIELD_LOOKUP_CACHE;
+        return Options.FIELD_LOOKUP_CACHE;
     }
 
 }
diff --git a/...rc/main/java/org/jruby/truffle/nodes/objectstorage/UninitializedWriteObjectFieldNode.java b/...rc/main/java/org/jruby/truffle/nodes/objectstorage/UninitializedWriteObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteBooleanObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteBooleanObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteDoubleObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteDoubleObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteHeadObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteHeadObjectFieldNode.java
@@ -9,37 +9,140 @@
  */
 package org.jruby.truffle.nodes.objectstorage;
 
+import java.util.EnumSet;
+
+import org.jruby.truffle.runtime.Options;
+
+import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.FinalLocationException;
+import com.oracle.truffle.api.object.IncompatibleLocationException;
+import com.oracle.truffle.api.object.Location;
+import com.oracle.truffle.api.object.LocationModifier;
+import com.oracle.truffle.api.object.Property;
+import com.oracle.truffle.api.object.Shape;
 
-public class WriteHeadObjectFieldNode extends Node {
+public abstract class WriteHeadObjectFieldNode extends Node {
 
     private final Object name;
-    @Child private WriteObjectFieldNode first;
 
     public WriteHeadObjectFieldNode(Object name) {
         this.name = name;
-        first = new UninitializedWriteObjectFieldNode(name);
     }
 
-    public void execute(DynamicObject object, int value) {
-        first.execute(object, value);
+    public Object getName() {
+        return name;
+    }
+
+    public abstract void execute(DynamicObject object, Object value);
+
+    @Specialization(
+            guards = {
+                    "location != null",
+                    "object.getShape() == cachedShape",
+                    "location.canSet(object, value)"
+            },
+            assumptions = { "newArray(cachedShape.getValidAssumption(), validLocation)" },
+            limit = "getCacheLimit()")
+    public void writeExistingField(DynamicObject object, Object value,
+            @Cached("object.getShape()") Shape cachedShape,
+            @Cached("getLocation(object, value)") Location location,
+            @Cached("createAssumption()") Assumption validLocation) {
+        try {
+            location.set(object, value, cachedShape);
+        } catch (IncompatibleLocationException e) {
+            // remove this entry
+            validLocation.invalidate();
+            execute(object, value);
+        } catch (FinalLocationException e) {
+            throw new UnsupportedOperationException("write to final location?", e);
+        }
     }
 
-    public void execute(DynamicObject object, long value) {
-        first.execute(object, value);
+    @Specialization(
+            guards = {
+                    "!hasField",
+                    "newShape != null", // workaround for DSL bug
+                    "object.getShape() == oldShape",
+                    "location.canSet(object, value)" },
+            assumptions = { "newArray(oldShape.getValidAssumption(), newShape.getValidAssumption(), validLocation)" },
+            limit = "getCacheLimit()")
+    public void writeNewField(DynamicObject object, Object value,
+            @Cached("hasField(object, value)") boolean hasField,
+            @Cached("object.getShape()") Shape oldShape,
+            @Cached("transitionWithNewField(oldShape, value)") Shape newShape,
+            @Cached("getNewLocation(newShape)") Location location,
+            @Cached("createAssumption()") Assumption validLocation) {
+        try {
+            location.set(object, value, oldShape, newShape);
+        } catch (IncompatibleLocationException e) {
+            // remove this entry
+            validLocation.invalidate();
+            execute(object, value);
+        }
     }
 
-    public void execute(DynamicObject object, double value) {
-        first.execute(object, value);
+    @TruffleBoundary
+    @Specialization
+    public void writeUncached(DynamicObject object, Object value) {
+        object.updateShape();
+        final Shape shape = object.getShape();
+        final Property property = shape.getProperty(name);
+
+        if (property == null) {
+            object.define(name, value, 0);
+        } else {
+            property.setGeneric(object, value, shape);
+        }
     }
 
-    public void execute(DynamicObject object, Object value) {
-        first.execute(object, value);
+    protected Location getLocation(DynamicObject object, Object value) {
+        object.updateShape();
+        final Shape oldShape = object.getShape();
+        final Property property = oldShape.getProperty(name);
+
+        if (property != null && property.getLocation().canSet(object, value)) {
+            return property.getLocation();
+        } else {
+            return null;
+        }
     }
 
-    public Object getName() {
-        return name;
+    protected boolean hasField(DynamicObject object, Object value) {
+        return getLocation(object, value) != null;
+    }
+
+    protected Shape transitionWithNewField(Shape oldShape, Object value) {
+        final Location location = oldShape.allocator().locationForValue(value, EnumSet.of(LocationModifier.NonNull));
+        final Property property = Property.create(name, location, 0);
+        return oldShape.addProperty(property);
+    }
+
+    protected Location getNewLocation(Shape newShape) {
+        return newShape.getProperty(name).getLocation();
+    }
+
+    protected Assumption createAssumption() {
+        return Truffle.getRuntime().createAssumption();
+    }
+
+    protected int getCacheLimit() {
+        return Options.FIELD_LOOKUP_CACHE;
+    }
+
+    // workaround for DSL bug
+    protected Assumption[] newArray(Assumption a1, Assumption a2, Assumption a3) {
+        return new Assumption[] { a1, a2, a3 };
+    }
+
+    // workaround for DSL bug
+    protected Assumption[] newArray(Assumption a1, Assumption a2) {
+        return new Assumption[] { a1, a2 };
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteIntegerObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteIntegerObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteLongObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteLongObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectFieldChainNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectFieldChainNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectObjectFieldNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/objectstorage/WriteObjectObjectFieldNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/ObjectPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/ObjectPrimitiveNodes.java
@@ -24,6 +24,7 @@
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNode;
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNodeGen;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.object.ObjectIDOperations;
@@ -107,7 +108,7 @@ protected ReadHeadObjectFieldNode createReadObjectIDNode() {
         }
 
         protected WriteHeadObjectFieldNode createWriteObjectIDNode() {
-            return new WriteHeadObjectFieldNode(Layouts.OBJECT_ID_IDENTIFIER);
+            return WriteHeadObjectFieldNodeGen.create(Layouts.OBJECT_ID_IDENTIFIER);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StatPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/StatPrimitiveNodes.java
@@ -20,6 +20,7 @@
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNode;
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNodeGen;
 import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNode;
+import org.jruby.truffle.nodes.objectstorage.WriteHeadObjectFieldNodeGen;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.ByteList;
@@ -164,7 +165,7 @@ public static abstract class StatStatPrimitiveNode extends RubiniusPrimitiveNode
 
         public StatStatPrimitiveNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
-            writeStatNode = new WriteHeadObjectFieldNode(STAT_IDENTIFIER);
+            writeStatNode = WriteHeadObjectFieldNodeGen.create(STAT_IDENTIFIER);
         }
 
         @TruffleBoundary
@@ -196,7 +197,7 @@ public static abstract class StatFStatPrimitiveNode extends RubiniusPrimitiveNod
 
         public StatFStatPrimitiveNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
-            writeStatNode = new WriteHeadObjectFieldNode(STAT_IDENTIFIER);
+            writeStatNode = WriteHeadObjectFieldNodeGen.create(STAT_IDENTIFIER);
         }
 
         @TruffleBoundary
@@ -221,7 +222,7 @@ public static abstract class StatLStatPrimitiveNode extends RubiniusPrimitiveNod
 
         public StatLStatPrimitiveNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
-            writeStatNode = new WriteHeadObjectFieldNode(STAT_IDENTIFIER);
+            writeStatNode = WriteHeadObjectFieldNodeGen.create(STAT_IDENTIFIER);
         }
 
         @TruffleBoundary

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/Options.java b/truffle/src/main/java/org/jruby/truffle/runtime/Options.java
@@ -35,7 +35,7 @@ public class Options {
     public final int IS_A_CACHE = org.jruby.util.cli.Options.TRUFFLE_IS_A_CACHE.load();
     public final int BIND_CACHE = org.jruby.util.cli.Options.TRUFFLE_BIND_CACHE.load();
     public final int CONSTANT_LOOKUP_CACHE = org.jruby.util.cli.Options.TRUFFLE_CONSTANT_LOOKUP_CACHE.load();
-    public final int FIELD_LOOKUP_CACHE = org.jruby.util.cli.Options.TRUFFLE_FIELD_LOOKUP_CACHE.load();
+    public static final int FIELD_LOOKUP_CACHE = org.jruby.util.cli.Options.TRUFFLE_FIELD_LOOKUP_CACHE.load();
     public final int BINDING_LOCAL_VARIABLE_CACHE = org.jruby.util.cli.Options.TRUFFLE_BINDING_LOCAL_VARIABLE_CACHE.load();
     public final int SYMBOL_TO_PROC_CACHE = org.jruby.util.cli.Options.TRUFFLE_SYMBOL_TO_PROC_CACHE.load();
     public final int ALLOCATE_CLASS_CACHE = org.jruby.util.cli.Options.TRUFFLE_ALLOCATE_CLASS_CACHE.load();