[GR-48662] Store PolyglotThreadInfo#contextThreadLocals directly in the fast thread locals array.

jchalou · jchalou · commit a22eac89b35b · 2023-10-05T16:03:42.000Z
PullRequest: graal/15594
diff --git a/compiler/mx.compiler/mx_graal_benchmark.py b/compiler/mx.compiler/mx_graal_benchmark.py
@@ -526,7 +526,7 @@ def whitebox_dependency(dist):
     def filter_distribution(self, dist):
         return super(JMHDistWhiteboxBenchmarkSuite, self).filter_distribution(dist) and \
                any(JMHDistWhiteboxBenchmarkSuite.whitebox_dependency(dist)) and \
-               not any(dep.name.startswith('com.oracle.truffle.enterprise.dispatch.jmh') for dep in dist.deps)
+               not any(dep.name.startswith('com.oracle.truffle.enterprise.jmh') for dep in dist.deps)
 
 
     def extraVmArgs(self):
diff --git a/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/impl/AbstractFastThreadLocal.java b/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/impl/AbstractFastThreadLocal.java
@@ -49,6 +49,6 @@ protected AbstractFastThreadLocal() {
 
     public abstract <C> Object[] get();
 
-    public abstract <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull);
+    public abstract <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull, boolean nonNullResult);
 
 }
diff --git a/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/impl/DefaultContextThreadLocal.java b/truffle/src/com.oracle.truffle.api/src/com/oracle/truffle/api/impl/DefaultContextThreadLocal.java
@@ -68,7 +68,7 @@ public <C> Object[] get() {
     @Override
     @SuppressWarnings("unchecked")
     @TruffleBoundary
-    public <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull) {
+    public <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull, boolean nonNullResult) {
         Object[] data = get();
         if (data == null) {
             return null;
diff --git a/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotFastThreadLocals.java b/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotFastThreadLocals.java
@@ -74,9 +74,10 @@ final class PolyglotFastThreadLocals {
     private static final FinalIntMap LANGUAGE_INDEXES = new FinalIntMap();
     private static final int RESERVED_NULL = -1; // never set
     private static final int THREAD_INDEX = 0;
-    static final int CONTEXT_INDEX = 1;
-    private static final int ENCAPSULATING_NODE_REFERENCE_INDEX = 2;
-    private static final int LANGUAGE_START = 3;
+    static final int CONTEXT_THREAD_LOCALS_INDEX = 1;
+    static final int CONTEXT_INDEX = 2;
+    private static final int ENCAPSULATING_NODE_REFERENCE_INDEX = 3;
+    private static final int LANGUAGE_START = 4;
 
     static final int LANGUAGE_CONTEXT_OFFSET = 0;
     static final int LANGUAGE_SPI_OFFSET = 1;
@@ -92,6 +93,7 @@ static Object[] createFastThreadLocals(PolyglotThreadInfo thread) {
         assert Thread.holdsLock(context);
         Object[] data = createEmptyData(thread.context.engine);
         data[THREAD_INDEX] = thread;
+        data[CONTEXT_THREAD_LOCALS_INDEX] = thread.contextThreadLocals;
         data[CONTEXT_INDEX] = thread.context;
         data[ENCAPSULATING_NODE_REFERENCE_INDEX] = EngineAccessor.NODES.createEncapsulatingNodeReference(thread.getThread());
         for (PolyglotLanguageContext languageContext : thread.context.contexts) {
@@ -105,6 +107,7 @@ static Object[] createFastThreadLocals(PolyglotThreadInfo thread) {
     private static Object[] createFastThreadLocalsForLanguage(PolyglotLanguageInstance instance) {
         Object[] data = createEmptyData(instance.language.engine);
         data[THREAD_INDEX] = null; // not available if only engine is entered
+        data[CONTEXT_THREAD_LOCALS_INDEX] = null; // not available if only engine is entered
         data[CONTEXT_INDEX] = null; // not available if only engine is entered
 
         // we take the first language we find. should we fail maybe if there is more than one?
@@ -142,7 +145,7 @@ public static <C> ContextReference<C> createContextReference(Class<? extends Tru
     }
 
     public static boolean needsEnter(PolyglotContextImpl context) {
-        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, false) != context;
+        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, false, false) != context;
     }
 
     public static Object[] enter(PolyglotThreadInfo threadInfo) {
@@ -195,33 +198,33 @@ static EncapsulatingNodeReference getEncapsulatingNodeReference(boolean invalida
          * instead. So we do not bother here and trade a bit smaller code for fewer deoptimizations
          * and less footprint (no assumptions in use).
          */
-        return IMPL.fastGet(ENCAPSULATING_NODE_REFERENCE_INDEX, EncapsulatingNodeReference.class, invalidateOnNull);
+        return IMPL.fastGet(ENCAPSULATING_NODE_REFERENCE_INDEX, EncapsulatingNodeReference.class, invalidateOnNull, false);
     }
 
-    public static PolyglotThreadInfo getCurrentThread(PolyglotSharingLayer layer) {
+    public static Object[] getCurrentThreadContextThreadLocals(PolyglotSharingLayer layer) {
         if (CompilerDirectives.inCompiledCode() && layer != null) {
             PolyglotContextImpl singleContext = layer.getSingleConstantContext();
             if (singleContext != null && CompilerDirectives.isPartialEvaluationConstant(singleContext)) {
                 PolyglotThreadInfo constantThread = singleContext.singleThreadValue.getConstant();
                 if (constantThread != null) {
-                    return constantThread;
+                    return constantThread.getThreadLocals(layer.engine);
                 }
             }
         }
-        return IMPL.fastGet(THREAD_INDEX, PolyglotThreadInfo.class, true);
+        return IMPL.fastGet(CONTEXT_THREAD_LOCALS_INDEX, Object[].class, true, true);
     }
 
-    public static PolyglotThreadInfo getCurrentThreadEngine(PolyglotEngineImpl engine) {
+    public static Object[] getCurrentThreadContextThreadLocalsEngine(PolyglotEngineImpl engine) {
         if (CompilerDirectives.inCompiledCode() && engine != null) {
             PolyglotContextImpl singleContext = engine.singleContextValue.getConstant();
             if (singleContext != null) {
                 PolyglotThreadInfo constantThread = singleContext.singleThreadValue.getConstant();
                 if (constantThread != null) {
-                    return constantThread;
+                    return constantThread.getThreadLocals(engine);
                 }
             }
         }
-        return IMPL.fastGet(THREAD_INDEX, PolyglotThreadInfo.class, true);
+        return IMPL.fastGet(CONTEXT_THREAD_LOCALS_INDEX, Object[].class, true, true);
     }
 
     public static PolyglotContextImpl getContext(PolyglotSharingLayer layer) {
@@ -231,7 +234,7 @@ public static PolyglotContextImpl getContext(PolyglotSharingLayer layer) {
                 return value;
             }
         }
-        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);
+        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);
     }
 
     public static PolyglotContextImpl getContextWithEngine(PolyglotEngineImpl engine) {
@@ -241,7 +244,7 @@ public static PolyglotContextImpl getContextWithEngine(PolyglotEngineImpl engine
                 return context;
             }
         }
-        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);
+        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);
     }
 
     public static PolyglotContextImpl getContextWithNode(Node node) {
@@ -251,7 +254,7 @@ public static PolyglotContextImpl getContextWithNode(Node node) {
                 return layer.getSingleConstantContext();
             }
         }
-        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);
+        return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);
     }
 
     @SuppressWarnings("unchecked")
@@ -263,7 +266,7 @@ public static TruffleLanguage<Object> getLanguage(Node node, int index, Class<?>
                 return instance.spi;
             }
         }
-        return (TruffleLanguage<Object>) IMPL.fastGet(index, languageClass, true);
+        return (TruffleLanguage<Object>) IMPL.fastGet(index, languageClass, true, false);
     }
 
     public static Object getLanguageContext(Node node, int index) {
@@ -279,7 +282,7 @@ public static Object getLanguageContext(Node node, int index) {
             }
             contextClass = findContextClass(node, index);
         }
-        return IMPL.fastGet(index, contextClass, true);
+        return IMPL.fastGet(index, contextClass, true, false);
     }
 
     private static boolean validSharing(Node node) {
diff --git a/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotLocals.java b/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotLocals.java
@@ -366,7 +366,7 @@ void initializeLanguageInstance(PolyglotLanguageInstance instance) {
         @Override
         public T get() {
             assert assertLanguageCreated(PolyglotFastThreadLocals.getContext(null), languageInstance.language);
-            return (T) PolyglotFastThreadLocals.getCurrentThread(sharingLayer).getThreadLocal(location);
+            return (T) location.readLocal(null, PolyglotFastThreadLocals.getCurrentThreadContextThreadLocals(sharingLayer), true);
         }
 
         @SuppressWarnings("unchecked")
@@ -441,7 +441,7 @@ protected InstrumentContextThreadLocal(Object factory) {
         @Override
         public T get() {
             assert assertInstrumentCreated(PolyglotFastThreadLocals.getContext(null), instrument);
-            return (T) PolyglotFastThreadLocals.getCurrentThreadEngine(location.engine).getThreadLocal(location);
+            return (T) location.readLocal(null, PolyglotFastThreadLocals.getCurrentThreadContextThreadLocalsEngine(location.engine), true);
         }
 
         @SuppressWarnings("unchecked")
@@ -515,14 +515,14 @@ final Object invokeFactory(PolyglotContextImpl context, Thread thread) {
         }
 
         final Object readLocal(PolyglotContextImpl context, Object[] locals, boolean threadLocal) {
-            assert locals != null && index < locals.length && locals[index] != null : invalidLocalMessage(context, locals);
+            assert locals != null && index < locals.length && locals[index] != null : invalidLocalMessage(context == null ? PolyglotFastThreadLocals.getContext(null) : context, locals);
             Object result;
             if (CompilerDirectives.inCompiledCode() && CompilerDirectives.isPartialEvaluationConstant(this)) {
                 result = readLocalFast(locals, threadLocal);
             } else {
                 result = locals[index];
             }
-            assert result.getClass() == profiledType : invalidLocalMessage(context, locals);
+            assert result.getClass() == profiledType : invalidLocalMessage(context == null ? PolyglotFastThreadLocals.getContext(null) : context, locals);
             return result;
         }
 
diff --git a/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotThreadInfo.java b/truffle/src/com.oracle.truffle.polyglot/src/com/oracle/truffle/polyglot/PolyglotThreadInfo.java
@@ -54,7 +54,6 @@
 import com.oracle.truffle.api.nodes.EncapsulatingNodeReference;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.utilities.TruffleWeakReference;
-import com.oracle.truffle.polyglot.PolyglotLocals.LocalLocation;
 
 final class PolyglotThreadInfo {
 
@@ -172,6 +171,7 @@ public Object[] getContextThreadLocals() {
     public void setContextThreadLocals(Object[] contextThreadLocals) {
         assert Thread.holdsLock(context);
         this.contextThreadLocals = contextThreadLocals;
+        this.fastThreadLocals[PolyglotFastThreadLocals.CONTEXT_THREAD_LOCALS_INDEX] = contextThreadLocals;
     }
 
     boolean isCurrent() {
@@ -254,12 +254,7 @@ void notifyLeave(PolyglotEngineImpl engine, PolyglotContextImpl profiledContext)
         }
     }
 
-    Object getThreadLocal(LocalLocation l) {
-        // thread id is guaranteed to be unique
-        return l.readLocal(this.context, getThreadLocals(l.engine), true);
-    }
-
-    private Object[] getThreadLocals(PolyglotEngineImpl e) {
+    Object[] getThreadLocals(PolyglotEngineImpl e) {
         CompilerAsserts.partialEvaluationConstant(e);
         Object[] locals = this.contextThreadLocals;
         assert locals != null : "thread local not initialized.";
diff --git a/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedFastThreadLocal.java b/truffle/src/com.oracle.truffle.runtime/src/com/oracle/truffle/runtime/OptimizedFastThreadLocal.java
@@ -61,7 +61,7 @@ protected OptimizedFastThreadLocal() {
 
     @Override
     @SuppressWarnings("unchecked")
-    public final <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull) {
+    public final <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull, boolean nonNullResult) {
         Object[] data;
         if (inCompiledCode()) {
             partialEvaluationConstant(index);
@@ -74,7 +74,7 @@ public final <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNul
                 return null;
             }
             Object v = castArrayFixedLength(array, index + 1)[index];
-            C result = unsafeCast(v, castType, true, false, true);
+            C result = unsafeCast(v, castType, true, nonNullResult, true);
             return result;
         } else {
             data = get();

Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,6 @@ protected AbstractFastThreadLocal() {`
`49`	`49`
`50`	`50`	`public abstract <C> Object[] get();`
`51`	`51`
`52`		`- public abstract <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull);`
	`52`	`+ public abstract <C> C fastGet(int index, Class<C> castType, boolean invalidateOnNull, boolean nonNullResult);`
`53`	`53`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,9 +74,10 @@ final class PolyglotFastThreadLocals {`
`74`	`74`	`private static final FinalIntMap LANGUAGE_INDEXES = new FinalIntMap();`
`75`	`75`	`private static final int RESERVED_NULL = -1; // never set`
`76`	`76`	`private static final int THREAD_INDEX = 0;`
`77`		`- static final int CONTEXT_INDEX = 1;`
`78`		`- private static final int ENCAPSULATING_NODE_REFERENCE_INDEX = 2;`
`79`		`- private static final int LANGUAGE_START = 3;`
	`77`	`+ static final int CONTEXT_THREAD_LOCALS_INDEX = 1;`
	`78`	`+ static final int CONTEXT_INDEX = 2;`
	`79`	`+ private static final int ENCAPSULATING_NODE_REFERENCE_INDEX = 3;`
	`80`	`+ private static final int LANGUAGE_START = 4;`
`80`	`81`
`81`	`82`	`static final int LANGUAGE_CONTEXT_OFFSET = 0;`
`82`	`83`	`static final int LANGUAGE_SPI_OFFSET = 1;`
`@@ -92,6 +93,7 @@ static Object[] createFastThreadLocals(PolyglotThreadInfo thread) {`
`92`	`93`	`assert Thread.holdsLock(context);`
`93`	`94`	`Object[] data = createEmptyData(thread.context.engine);`
`94`	`95`	`data[THREAD_INDEX] = thread;`
	`96`	`+ data[CONTEXT_THREAD_LOCALS_INDEX] = thread.contextThreadLocals;`
`95`	`97`	`data[CONTEXT_INDEX] = thread.context;`
`96`	`98`	`data[ENCAPSULATING_NODE_REFERENCE_INDEX] = EngineAccessor.NODES.createEncapsulatingNodeReference(thread.getThread());`
`97`	`99`	`for (PolyglotLanguageContext languageContext : thread.context.contexts) {`
`@@ -105,6 +107,7 @@ static Object[] createFastThreadLocals(PolyglotThreadInfo thread) {`
`105`	`107`	`private static Object[] createFastThreadLocalsForLanguage(PolyglotLanguageInstance instance) {`
`106`	`108`	`Object[] data = createEmptyData(instance.language.engine);`
`107`	`109`	`data[THREAD_INDEX] = null; // not available if only engine is entered`
	`110`	`+ data[CONTEXT_THREAD_LOCALS_INDEX] = null; // not available if only engine is entered`
`108`	`111`	`data[CONTEXT_INDEX] = null; // not available if only engine is entered`
`109`	`112`
`110`	`113`	`// we take the first language we find. should we fail maybe if there is more than one?`
`@@ -142,7 +145,7 @@ public static <C> ContextReference<C> createContextReference(Class<? extends Tru`
`142`	`145`	`}`
`143`	`146`
`144`	`147`	`public static boolean needsEnter(PolyglotContextImpl context) {`
`145`		`- return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, false) != context;`
	`148`	`+ return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, false, false) != context;`
`146`	`149`	`}`
`147`	`150`
`148`	`151`	`public static Object[] enter(PolyglotThreadInfo threadInfo) {`
`@@ -195,33 +198,33 @@ static EncapsulatingNodeReference getEncapsulatingNodeReference(boolean invalida`
`195`	`198`	`* instead. So we do not bother here and trade a bit smaller code for fewer deoptimizations`
`196`	`199`	`* and less footprint (no assumptions in use).`
`197`	`200`	`*/`
`198`		`- return IMPL.fastGet(ENCAPSULATING_NODE_REFERENCE_INDEX, EncapsulatingNodeReference.class, invalidateOnNull);`
	`201`	`+ return IMPL.fastGet(ENCAPSULATING_NODE_REFERENCE_INDEX, EncapsulatingNodeReference.class, invalidateOnNull, false);`
`199`	`202`	`}`
`200`	`203`
`201`		`- public static PolyglotThreadInfo getCurrentThread(PolyglotSharingLayer layer) {`
	`204`	`+ public static Object[] getCurrentThreadContextThreadLocals(PolyglotSharingLayer layer) {`
`202`	`205`	`if (CompilerDirectives.inCompiledCode() && layer != null) {`
`203`	`206`	`PolyglotContextImpl singleContext = layer.getSingleConstantContext();`
`204`	`207`	`if (singleContext != null && CompilerDirectives.isPartialEvaluationConstant(singleContext)) {`
`205`	`208`	`PolyglotThreadInfo constantThread = singleContext.singleThreadValue.getConstant();`
`206`	`209`	`if (constantThread != null) {`
`207`		`- return constantThread;`
	`210`	`+ return constantThread.getThreadLocals(layer.engine);`
`208`	`211`	`}`
`209`	`212`	`}`
`210`	`213`	`}`
`211`		`- return IMPL.fastGet(THREAD_INDEX, PolyglotThreadInfo.class, true);`
	`214`	`+ return IMPL.fastGet(CONTEXT_THREAD_LOCALS_INDEX, Object[].class, true, true);`
`212`	`215`	`}`
`213`	`216`
`214`		`- public static PolyglotThreadInfo getCurrentThreadEngine(PolyglotEngineImpl engine) {`
	`217`	`+ public static Object[] getCurrentThreadContextThreadLocalsEngine(PolyglotEngineImpl engine) {`
`215`	`218`	`if (CompilerDirectives.inCompiledCode() && engine != null) {`
`216`	`219`	`PolyglotContextImpl singleContext = engine.singleContextValue.getConstant();`
`217`	`220`	`if (singleContext != null) {`
`218`	`221`	`PolyglotThreadInfo constantThread = singleContext.singleThreadValue.getConstant();`
`219`	`222`	`if (constantThread != null) {`
`220`		`- return constantThread;`
	`223`	`+ return constantThread.getThreadLocals(engine);`
`221`	`224`	`}`
`222`	`225`	`}`
`223`	`226`	`}`
`224`		`- return IMPL.fastGet(THREAD_INDEX, PolyglotThreadInfo.class, true);`
	`227`	`+ return IMPL.fastGet(CONTEXT_THREAD_LOCALS_INDEX, Object[].class, true, true);`
`225`	`228`	`}`
`226`	`229`
`227`	`230`	`public static PolyglotContextImpl getContext(PolyglotSharingLayer layer) {`
`@@ -231,7 +234,7 @@ public static PolyglotContextImpl getContext(PolyglotSharingLayer layer) {`
`231`	`234`	`return value;`
`232`	`235`	`}`
`233`	`236`	`}`
`234`		`- return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);`
	`237`	`+ return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);`
`235`	`238`	`}`
`236`	`239`
`237`	`240`	`public static PolyglotContextImpl getContextWithEngine(PolyglotEngineImpl engine) {`
`@@ -241,7 +244,7 @@ public static PolyglotContextImpl getContextWithEngine(PolyglotEngineImpl engine`
`241`	`244`	`return context;`
`242`	`245`	`}`
`243`	`246`	`}`
`244`		`- return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);`
	`247`	`+ return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);`
`245`	`248`	`}`
`246`	`249`
`247`	`250`	`public static PolyglotContextImpl getContextWithNode(Node node) {`
`@@ -251,7 +254,7 @@ public static PolyglotContextImpl getContextWithNode(Node node) {`
`251`	`254`	`return layer.getSingleConstantContext();`
`252`	`255`	`}`
`253`	`256`	`}`
`254`		`- return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true);`
	`257`	`+ return IMPL.fastGet(CONTEXT_INDEX, PolyglotContextImpl.class, true, false);`
`255`	`258`	`}`
`256`	`259`
`257`	`260`	`@SuppressWarnings("unchecked")`
`@@ -263,7 +266,7 @@ public static TruffleLanguage<Object> getLanguage(Node node, int index, Class<?>`
`263`	`266`	`return instance.spi;`
`264`	`267`	`}`
`265`	`268`	`}`
`266`		`- return (TruffleLanguage<Object>) IMPL.fastGet(index, languageClass, true);`
	`269`	`+ return (TruffleLanguage<Object>) IMPL.fastGet(index, languageClass, true, false);`
`267`	`270`	`}`
`268`	`271`
`269`	`272`	`public static Object getLanguageContext(Node node, int index) {`
`@@ -279,7 +282,7 @@ public static Object getLanguageContext(Node node, int index) {`
`279`	`282`	`}`
`280`	`283`	`contextClass = findContextClass(node, index);`
`281`	`284`	`}`
`282`		`- return IMPL.fastGet(index, contextClass, true);`
	`285`	`+ return IMPL.fastGet(index, contextClass, true, false);`
`283`	`286`	`}`
`284`	`287`
`285`	`288`	`private static boolean validSharing(Node node) {`
Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ void initializeLanguageInstance(PolyglotLanguageInstance instance) {`
`366`	`366`	`@Override`
`367`	`367`	`public T get() {`
`368`	`368`	`assert assertLanguageCreated(PolyglotFastThreadLocals.getContext(null), languageInstance.language);`
`369`		`- return (T) PolyglotFastThreadLocals.getCurrentThread(sharingLayer).getThreadLocal(location);`
	`369`	`+ return (T) location.readLocal(null, PolyglotFastThreadLocals.getCurrentThreadContextThreadLocals(sharingLayer), true);`
`370`	`370`	`}`
`371`	`371`
`372`	`372`	`@SuppressWarnings("unchecked")`
`@@ -441,7 +441,7 @@ protected InstrumentContextThreadLocal(Object factory) {`
`441`	`441`	`@Override`
`442`	`442`	`public T get() {`
`443`	`443`	`assert assertInstrumentCreated(PolyglotFastThreadLocals.getContext(null), instrument);`
`444`		`- return (T) PolyglotFastThreadLocals.getCurrentThreadEngine(location.engine).getThreadLocal(location);`
	`444`	`+ return (T) location.readLocal(null, PolyglotFastThreadLocals.getCurrentThreadContextThreadLocalsEngine(location.engine), true);`
`445`	`445`	`}`
`446`	`446`
`447`	`447`	`@SuppressWarnings("unchecked")`
`@@ -515,14 +515,14 @@ final Object invokeFactory(PolyglotContextImpl context, Thread thread) {`
`515`	`515`	`}`
`516`	`516`
`517`	`517`	`final Object readLocal(PolyglotContextImpl context, Object[] locals, boolean threadLocal) {`
`518`		`- assert locals != null && index < locals.length && locals[index] != null : invalidLocalMessage(context, locals);`
	`518`	`+ assert locals != null && index < locals.length && locals[index] != null : invalidLocalMessage(context == null ? PolyglotFastThreadLocals.getContext(null) : context, locals);`
`519`	`519`	`Object result;`
`520`	`520`	`if (CompilerDirectives.inCompiledCode() && CompilerDirectives.isPartialEvaluationConstant(this)) {`
`521`	`521`	`result = readLocalFast(locals, threadLocal);`
`522`	`522`	`} else {`
`523`	`523`	`result = locals[index];`
`524`	`524`	`}`
`525`		`- assert result.getClass() == profiledType : invalidLocalMessage(context, locals);`
	`525`	`+ assert result.getClass() == profiledType : invalidLocalMessage(context == null ? PolyglotFastThreadLocals.getContext(null) : context, locals);`
`526`	`526`	`return result;`
`527`	`527`	`}`
`528`	`528`