Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2017, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* The Universal Permissive License (UPL), Version 1.0
*
* Subject to the condition set forth below, permission is hereby granted to any
* person obtaining a copy of this software, associated documentation and/or
* data (collectively the "Software"), free of charge and under any and all
* copyright rights in the Software, and any and all patent rights owned or
* freely licensable by each licensor hereunder covering either (i) the
* unmodified Software as contributed to or provided by such licensor, or (ii)
* the Larger Works (as defined below), to deal in both
*
* (a) the Software, and
*
* (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
* one is included with the Software each a "Larger Work" to which the Software
* is contributed by such licensors),
*
* without restriction, including without limitation the rights to copy, create
* derivative works of, display, perform, and distribute the Software and make,
* use, sell, offer for sale, import, export, have made, and have sold the
* Software and the Larger Work(s), and to sublicense the foregoing rights on
* either these or other terms.
*
* This license is subject to the following condition:
*
* The above copyright notice and either this complete permission notice or at a
* minimum a reference to the UPL must be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.pkl.thirdparty.truffle.polyglot;
import static org.pkl.thirdparty.truffle.api.CompilerDirectives.shouldNotReachHere;
import static org.pkl.thirdparty.truffle.polyglot.EngineAccessor.LANGUAGE;
import static org.pkl.thirdparty.truffle.polyglot.PolyglotValueDispatch.hostEnter;
import static org.pkl.thirdparty.truffle.polyglot.PolyglotValueDispatch.hostLeave;
import java.io.Closeable;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import java.util.logging.Level;
import org.pkl.thirdparty.graalvm.options.OptionValues;
import org.pkl.thirdparty.graalvm.polyglot.Context;
import org.pkl.thirdparty.graalvm.polyglot.PolyglotException;
import org.pkl.thirdparty.graalvm.polyglot.Value;
import org.pkl.thirdparty.graalvm.polyglot.impl.AbstractPolyglotImpl.AbstractHostLanguageService;
import org.pkl.thirdparty.graalvm.polyglot.io.IOAccess;
import org.pkl.thirdparty.truffle.api.CallTarget;
import org.pkl.thirdparty.truffle.api.CompilerAsserts;
import org.pkl.thirdparty.truffle.api.CompilerDirectives;
import org.pkl.thirdparty.truffle.api.CompilerDirectives.CompilationFinal;
import org.pkl.thirdparty.truffle.api.CompilerDirectives.TruffleBoundary;
import org.pkl.thirdparty.truffle.api.ThreadLocalAction;
import org.pkl.thirdparty.truffle.api.Truffle;
import org.pkl.thirdparty.truffle.api.TruffleContext;
import org.pkl.thirdparty.truffle.api.TruffleLanguage;
import org.pkl.thirdparty.truffle.api.TruffleLogger;
import org.pkl.thirdparty.truffle.api.TruffleOptions;
import org.pkl.thirdparty.truffle.api.TruffleSafepoint;
import org.pkl.thirdparty.truffle.api.exception.AbstractTruffleException;
import org.pkl.thirdparty.truffle.api.impl.DefaultTruffleRuntime;
import org.pkl.thirdparty.truffle.api.impl.JDKAccessor;
import org.pkl.thirdparty.truffle.api.interop.InteropLibrary;
import org.pkl.thirdparty.truffle.api.interop.TruffleObject;
import org.pkl.thirdparty.truffle.api.interop.UnsupportedMessageException;
import org.pkl.thirdparty.truffle.api.nodes.LanguageInfo;
import org.pkl.thirdparty.truffle.api.nodes.Node;
import org.pkl.thirdparty.truffle.api.nodes.RootNode;
import org.pkl.thirdparty.truffle.api.source.Source;
import org.pkl.thirdparty.truffle.api.source.SourceSection;
import org.pkl.thirdparty.truffle.polyglot.FileSystems.PreInitializeContextFileSystem;
import org.pkl.thirdparty.truffle.polyglot.PolyglotContextConfig.FileSystemConfig;
import org.pkl.thirdparty.truffle.polyglot.PolyglotContextConfig.PreinitConfig;
import org.pkl.thirdparty.truffle.polyglot.PolyglotEngineImpl.CancelExecution;
import org.pkl.thirdparty.truffle.polyglot.PolyglotEngineImpl.StableLocalLocations;
import org.pkl.thirdparty.truffle.polyglot.PolyglotLanguageContext.ValueMigrationException;
import org.pkl.thirdparty.truffle.polyglot.PolyglotLocals.LocalLocation;
import org.pkl.thirdparty.truffle.polyglot.PolyglotThreadLocalActions.HandshakeConfig;
import org.pkl.thirdparty.truffle.polyglot.SystemThread.LanguageSystemThread;
final class PolyglotContextImpl implements org.pkl.thirdparty.truffle.polyglot.PolyglotImpl.VMObject {
private static final TruffleLogger LOG = TruffleLogger.getLogger(PolyglotEngineImpl.OPTION_GROUP_ENGINE, PolyglotContextImpl.class);
private static final InteropLibrary UNCACHED = InteropLibrary.getFactory().getUncached();
private static final Object[] DISPOSED_CONTEXT_THREAD_LOCALS = new Object[0];
private static final Map VALID_TRANSITIONS = new EnumMap<>(State.class);
static {
VALID_TRANSITIONS.put(State.DEFAULT, new State[]{
State.CLOSING,
State.INTERRUPTING,
State.PENDING_EXIT,
State.CANCELLING,
State.EXITING, // only for child contexts and local contexts for isolated
// contexts
});
VALID_TRANSITIONS.put(State.CLOSING, new State[]{
State.CLOSING_FINALIZING,
State.CLOSING_INTERRUPTING,
State.CLOSING_CANCELLING,
State.CLOSING_PENDING_EXIT,
State.CLOSING_EXITING, // only for child contexts and local contexts for
// isolated contexts
State.DEFAULT
});
VALID_TRANSITIONS.put(State.CLOSING_FINALIZING, new State[]{
State.CLOSED,
State.CLOSING_INTERRUPTING_FINALIZING,
State.CLOSING_CANCELLING,
State.CLOSING_EXITING, // only for child contexts and local contexts for
// isolated contexts
State.DEFAULT
});
VALID_TRANSITIONS.put(State.INTERRUPTING, new State[]{
State.DEFAULT,
State.CLOSING_INTERRUPTING,
State.CANCELLING,
State.PENDING_EXIT,
State.EXITING, // only for child contexts and local contexts for isolated
// contexts
});
VALID_TRANSITIONS.put(State.PENDING_EXIT, new State[]{
State.EXITING,
State.CANCELLING
});
VALID_TRANSITIONS.put(State.CANCELLING, new State[]{
State.CLOSING_CANCELLING
});
VALID_TRANSITIONS.put(State.CLOSING_INTERRUPTING, new State[]{
State.CLOSING_INTERRUPTING_FINALIZING,
State.CLOSING,
State.CLOSING_PENDING_EXIT,
State.CLOSING_CANCELLING,
State.CLOSING_EXITING, // only for child contexts and local contexts for
// isolate contexts
State.INTERRUPTING
});
VALID_TRANSITIONS.put(State.CLOSING_INTERRUPTING_FINALIZING, new State[]{
State.CLOSED_INTERRUPTED,
State.CLOSING_FINALIZING,
State.CLOSING_CANCELLING,
State.CLOSING_EXITING, // only for child contexts and local contexts for
// isolated contexts
State.INTERRUPTING
});
VALID_TRANSITIONS.put(State.CLOSING_CANCELLING, new State[]{
State.CLOSED_CANCELLED,
State.CANCELLING
});
VALID_TRANSITIONS.put(State.CLOSING_PENDING_EXIT, new State[]{
State.CLOSING_EXITING,
State.CLOSING_CANCELLING,
State.PENDING_EXIT
});
VALID_TRANSITIONS.put(State.CLOSING_EXITING, new State[]{
State.CLOSED_EXITED,
State.EXITING
});
VALID_TRANSITIONS.put(State.EXITING, new State[]{
State.CLOSING_EXITING
});
VALID_TRANSITIONS.put(State.CLOSED,
new State[0]);
VALID_TRANSITIONS.put(State.CLOSED_CANCELLED,
new State[0]);
VALID_TRANSITIONS.put(State.CLOSED_EXITED,
new State[0]);
}
enum State {
/*
* Initial state. Context is valid and ready for use.
*/
DEFAULT,
/*
* Interrupt operation has been started. Threads are being interrupted.
*/
INTERRUPTING,
/*
* Hard exit was called in the DEFAULT or the INTERRUPTING state and exit notifications (see
* TruffleLanguage#exitContext) are about to be executed or are already executing. the
* PENDING_EXIT state overrides the INTERRUPTING state.
*/
PENDING_EXIT,
/*
* Exit operation has been initiated after exit notifications were executed in the
* PENDING_EXIT state. Threads are being stopped.
*/
EXITING,
/*
* Cancel operation has been initiated. Threads are being stopped. The CANCELLING state
* overrides the INTERRUPTING and the PENDING_EXIT state.
*/
CANCELLING,
/*
* Close operation has been initiated in the DEFAULT state, or it has been initiated in the
* INTERRUPTING state and the interrupt operation stopped during closing. The thread that
* initiated the operation is stored in the closingThread field. The close operation either
* finishes successfully and the context goes into one of the closed states, or the close
* operation fails and the context goes back to the DEFAULT state.
*/
CLOSING,
/*
* Hard exit was called in the CLOSING or the CLOSING_INTERRUPTING state and exit
* notifications (see TruffleLanguage#exitContext) are about to be executed or are already
* executing. the CLOSING_PENDING_EXIT state overrides the CLOSING_INTERRUPTING state.
*/
CLOSING_PENDING_EXIT,
/*
* The close operation progressed to the "finalizing" stage where creation of inner contexts
* and caching of thread info is no longer allowed. Also, hard exit is no longer allowed in
* this state. The close operation either finishes successfully and the context goes into
* one of the closed states, or the close operation fails and the context goes back to the
* DEFAULT state.
*/
CLOSING_FINALIZING,
/*
* Close operation has been initiated in the INTERRUPTING state and the interrupt operation
* is still in progress, or it has been initiated in the DEFAULT state and the interrupt
* operation started during closing, i.e., the transition to this state can either be from
* the CLOSING or the INTERRUPTING state. Even if the transition is from the CLOSING state
* the closingThread is still the one that initiated the close operation, not the one that
* initiated the interrupt operation. The close operation either finishes successfully and
* the context goes into one of the closed states, or the close operation fails and the
* context goes back to the INTERRUPTING state.
*/
CLOSING_INTERRUPTING,
/*
* The close operation while interrupting progressed to the "finalizing" stage where
* creation of inner contexts is no longer allowed. Also, hard exit is no longer allowed in
* this state. The close operation either finishes successfully and the context goes into
* one of the closed states, or the close operation fails and the context goes back to the
* INTERRUPTING state.
*/
CLOSING_INTERRUPTING_FINALIZING,
/*
* Close operation has been initiated and at the same time the cancel operation is in
* progress. Transition to this state can either be from the CLOSING, the CANCELLING, or the
* CLOSING_INTERRUPTING state. Even if the transition is from one of the closing states the
* closingThread is still the one that initiated the close operation. The CLOSING_CANCELLING
* state overrides the CLOSING and the CLOSING_INTERRUPTING states. Close operation that
* started in the CLOSING_CANCELLING state must finish successfully, otherwise it is an
* internal error. Close operation that did not start in the CLOSING_CANCELLING state and
* the state was overridden by CLOSING_CANCELLING during the operation can fail in which
* case the state goes back to CANCELLING.
*/
CLOSING_CANCELLING,
/*
* Close operation has been initiated and at the same time exit operation is in progress.
* Transition to this state can be only from the EXITING state. Close operation that started
* in the CLOSING_EXITING state must finish successfully, otherwise it is an internal error.
*/
CLOSING_EXITING,
/*
* Closing operation in the CLOSING state has finished successfully via the
* CLOSING_FINALIZING state.
*/
CLOSED,
/*
* Closing operation in the CLOSING_INTERRUPTING state has finished successfully via the
* CLOSING_INTERRUPTING_FINALIZING state. Essentially the same as the CLOSED state, the only
* difference is that in the CLOSED_INTERRUPTED state, the context leave operations on
* threads that are still entered notify the thread that is waiting for the interrupting
* operation to complete.
*/
CLOSED_INTERRUPTED,
/*
* Closing operation in the CLOSING_CANCELLING state has finished successfully.
*/
CLOSED_CANCELLED,
/*
* Closing operation in the CLOSING_EXITING state has finished successfully.
*/
CLOSED_EXITED;
/*
* The context is not usable and may be in an inconsistent state.
*/
boolean isInvalidOrClosed() {
switch (this) {
case CANCELLING:
case EXITING:
case CLOSING_CANCELLING:
case CLOSING_EXITING:
case CLOSED:
case CLOSED_INTERRUPTED:
case CLOSED_CANCELLED:
case CLOSED_EXITED:
return true;
default:
return false;
}
}
boolean isInterrupting() {
switch (this) {
case INTERRUPTING:
case CLOSING_INTERRUPTING:
case CLOSING_INTERRUPTING_FINALIZING:
return true;
default:
return false;
}
}
boolean isCancelling() {
switch (this) {
case CANCELLING:
case CLOSING_CANCELLING:
return true;
default:
return false;
}
}
boolean isExiting() {
switch (this) {
case EXITING:
case CLOSING_EXITING:
return true;
default:
return false;
}
}
boolean isClosing() {
switch (this) {
case CLOSING:
case CLOSING_FINALIZING:
case CLOSING_INTERRUPTING:
case CLOSING_INTERRUPTING_FINALIZING:
case CLOSING_CANCELLING:
case CLOSING_PENDING_EXIT:
case CLOSING_EXITING:
return true;
default:
return false;
}
}
boolean isClosed() {
switch (this) {
case CLOSED:
case CLOSED_INTERRUPTED:
case CLOSED_CANCELLED:
case CLOSED_EXITED:
return true;
default:
return false;
}
}
private boolean shouldCacheThreadInfo() {
switch (this) {
case DEFAULT:
case PENDING_EXIT:
case CLOSING:
case CLOSING_PENDING_EXIT:
return true;
default:
return false;
}
}
}
volatile State state = State.DEFAULT;
final WeakAssumedValue singleThreadValue = new WeakAssumedValue<>("Single thread");
volatile boolean singleThreaded = true;
private final Map threads = new WeakHashMap<>();
/*
* Do not modify only read. Use setCachedThreadInfo to modify.
*/
private volatile PolyglotThreadInfo cachedThreadInfo = PolyglotThreadInfo.NULL;
volatile Context api;
private ExecutorService cleanupExecutorService;
private Future cleanupFuture;
boolean skipPendingExit;
volatile int exitCode;
private volatile String exitMessage;
volatile Thread closeExitedTriggerThread;
private volatile String invalidMessage;
volatile boolean invalidResourceLimit;
volatile Thread closingThread;
private final ReentrantLock closingLock = new ReentrantLock();
private final ReentrantLock interruptingLock = new ReentrantLock();
private final ReentrantLock initiateCancelOrExitLock = new ReentrantLock();
private List> cancellationOrExitingFutures;
volatile boolean disposing;
final PolyglotEngineImpl engine;
final PolyglotSharingLayer layer;
// contexts by PolyglotLanguage.engineIndex
@CompilationFinal(dimensions = 1) final PolyglotLanguageContext[] contexts;
final TruffleContext creatorTruffleContext;
final TruffleContext currentTruffleContext;
final PolyglotContextImpl parent;
volatile Map polyglotBindings; // for direct legacy access
volatile Value polyglotHostBindings; // for accesses from the polyglot api
private final PolyglotBindings polyglotBindingsObject = new PolyglotBindings(this);
final PolyglotLanguage creator; // creator for internal contexts
final ContextWeakReference weakReference;
final Set subProcesses;
@CompilationFinal PolyglotContextConfig config; // effectively final
// map from class to language index
@CompilationFinal private volatile FinalIntMap languageIndexMap;
private final List childContexts = new ArrayList<>();
List sourcesToInvalidate; // Non null only during content pre-initialization
final AtomicLong volatileStatementCounter = new AtomicLong();
long statementCounter;
final long statementLimit;
private volatile Object contextBoundLoggers;
/*
* Initialized once per context.
*/
@CompilationFinal(dimensions = 1) Object[] contextLocals;
volatile boolean localsCleared;
private ObjectSizeCalculator objectSizeCalculator;
final PolyglotThreadLocalActions threadLocalActions;
private Collection closeables;
private final Set pauseThreadLocalActions = new LinkedHashSet<>();
@CompilationFinal private Object hostContextImpl;
final Node uncachedLocation;
private final Set activeSystemThreads = Collections.newSetFromMap(new HashMap<>());
/* Constructor for testing. */
@SuppressWarnings("unused")
private PolyglotContextImpl() {
this.engine = null;
this.contexts = null;
this.creatorTruffleContext = null;
this.currentTruffleContext = null;
this.layer = null;
this.parent = null;
this.polyglotHostBindings = null;
this.polyglotBindings = null;
this.creator = null;
this.weakReference = null;
this.statementLimit = 0;
this.threadLocalActions = null;
this.subProcesses = new HashSet<>();
this.uncachedLocation = null;
}
/*
* Constructor for outer contexts.
*/
PolyglotContextImpl(PolyglotEngineImpl engine, PolyglotContextConfig config) {
this.parent = null;
this.engine = engine;
this.layer = new PolyglotSharingLayer(engine);
this.config = config;
this.creator = null;
this.uncachedLocation = new UncachedLocationNode(layer);
this.creatorTruffleContext = EngineAccessor.LANGUAGE.createTruffleContext(this, true);
this.currentTruffleContext = EngineAccessor.LANGUAGE.createTruffleContext(this, false);
this.weakReference = new ContextWeakReference(this);
this.contexts = createContextArray();
this.subProcesses = new HashSet<>();
this.statementLimit = config.limits != null && config.limits.statementLimit != 0 ? config.limits.statementLimit : Long.MAX_VALUE - 1;
this.statementCounter = statementLimit;
this.volatileStatementCounter.set(statementLimit);
this.threadLocalActions = new PolyglotThreadLocalActions(this);
PolyglotEngineImpl.ensureInstrumentsCreated(config.getConfiguredInstruments());
/*
* Instruments can add loggers, and so configuration of loggers for this context must be
* done after instruments are created.
*/
if (!config.logLevels.isEmpty()) {
EngineAccessor.LANGUAGE.configureLoggers(this, config.logLevels, getAllLoggers());
}
}
/*
* Constructor for inner contexts.
*/
@SuppressWarnings("hiding")
PolyglotContextImpl(PolyglotLanguageContext creator, PolyglotContextConfig config) {
PolyglotContextImpl parent = creator.context;
this.parent = parent;
this.layer = new PolyglotSharingLayer(parent.engine);
this.config = config;
this.engine = parent.engine;
this.creator = creator.language;
this.uncachedLocation = new UncachedLocationNode(layer);
this.statementLimit = 0; // inner context limit must not be used anyway
this.weakReference = new ContextWeakReference(this);
this.creatorTruffleContext = EngineAccessor.LANGUAGE.createTruffleContext(this, true);
this.currentTruffleContext = EngineAccessor.LANGUAGE.createTruffleContext(this, false);
if (parent.state.isInterrupting()) {
this.state = State.INTERRUPTING;
} else if (parent.state.isCancelling()) {
this.state = State.CANCELLING;
} else if (parent.state.isExiting()) {
this.state = State.EXITING;
}
this.invalidMessage = this.parent.invalidMessage;
this.exitCode = this.parent.exitCode;
this.exitMessage = this.parent.exitMessage;
this.contextBoundLoggers = this.parent.contextBoundLoggers;
this.threadLocalActions = new PolyglotThreadLocalActions(this);
if (!parent.config.logLevels.isEmpty()) {
EngineAccessor.LANGUAGE.configureLoggers(this, parent.config.logLevels, getAllLoggers());
}
this.contexts = createContextArray();
this.subProcesses = new HashSet<>();
// notifyContextCreated() is called after spiContext.impl is set to this.
this.engine.noInnerContexts.invalidate();
}
/*
* Used only in asserts.
*/
private boolean isTransitionAllowed(State fromState, State toState) {
assert Thread.holdsLock(this);
State[] successors = VALID_TRANSITIONS.get(fromState);
for (State successor : successors) {
if (successor == toState) {
return isAdditionalTransitionConditionSatisfied(fromState, toState);
}
}
return false;
}
private boolean isAdditionalTransitionConditionSatisfied(State fromState, State toState) {
assert Thread.holdsLock(this);
if (fromState.isClosing() != toState.isClosing()) {
if (closingThread != Thread.currentThread()) {
return false;
}
}
if (!fromState.isExiting() && toState.isExiting() && fromState != State.PENDING_EXIT && fromState != State.CLOSING_PENDING_EXIT) {
if (parent == null && !skipPendingExit) {
return false;
}
}
return true;
}
private boolean shouldCacheThreadInfo() {
assert Thread.holdsLock(this);
return state.shouldCacheThreadInfo() && !disposing;
}
/**
* Claims a sharing layer for a context. This typically happens at when the first non-host
* language is initialized in a context.
*/
void claimSharingLayer(PolyglotLanguage language) {
PolyglotSharingLayer s = this.layer;
if (!s.isClaimed()) {
synchronized (engine.lock) {
if (!s.isClaimed()) {
assert !language.isHost() : "cannot claim context for a host language";
engine.claimSharingLayer(s, this, language);
assert s.isClaimed();
this.weakReference.layer = s;
}
}
}
}
boolean claimSharingLayer(PolyglotSharingLayer sharableLayer, Set languages) {
PolyglotSharingLayer s = this.layer;
synchronized (engine.lock) {
assert !s.isClaimed() : "sharing layer already claimed";
if (!s.isClaimed()) {
if (!s.claimLayerForContext(sharableLayer, this, languages)) {
return false;
}
assert s.isClaimed();
assert this.layer.equals(sharableLayer);
this.weakReference.layer = s;
}
}
return true;
}
OptionValues getInstrumentContextOptions(PolyglotInstrument instrument) {
return config.getInstrumentOptionValues(instrument);
}
public void resetLimits() {
PolyglotLanguageContext languageContext = this.getHostContext();
Object prev = hostEnter(languageContext);
try {
PolyglotLimits.reset(this);
EngineAccessor.INSTRUMENT.notifyContextResetLimit(engine, creatorTruffleContext);
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(languageContext, e, true);
} finally {
hostLeave(languageContext, prev);
}
}
public void safepoint() {
PolyglotLanguageContext languageContext = this.getHostContext();
Object prev = hostEnter(languageContext);
try {
TruffleSafepoint.poll(this.uncachedLocation);
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(languageContext, e, true);
} finally {
hostLeave(languageContext, prev);
}
}
private PolyglotLanguageContext[] createContextArray() {
Collection languages = engine.idToLanguage.values();
PolyglotLanguageContext[] newContexts = new PolyglotLanguageContext[engine.languageCount];
Iterator languageIterator = languages.iterator();
for (int i = (PolyglotEngineImpl.HOST_LANGUAGE_INDEX + 1); i < engine.languageCount; i++) {
PolyglotLanguage language = languageIterator.next();
newContexts[i] = new PolyglotLanguageContext(this, language);
}
maybeInitializeHostLanguage(newContexts);
return newContexts;
}
private void maybeInitializeHostLanguage(PolyglotLanguageContext[] contextsArray) {
PolyglotLanguage hostLanguage = engine.hostLanguage;
PolyglotLanguageContext hostContext = new PolyglotLanguageContext(this, hostLanguage);
contextsArray[PolyglotEngineImpl.HOST_LANGUAGE_INDEX] = hostContext;
if (PreInitContextHostLanguage.isInstance(hostLanguage)) {
// The host language in the image execution time may differ from host language in the
// image build time. We have to postpone the creation and initialization of the host
// language context until the patching.
assert engine.inEnginePreInitialization : "PreInitContextHostLanguage can be used only during context pre-initialization";
} else {
hostContext.ensureCreated(hostLanguage);
hostContext.ensureInitialized(null);
}
}
PolyglotLanguageContext getContext(PolyglotLanguage language) {
return contexts[language.engineIndex];
}
Object getContextImpl(PolyglotLanguage language) {
return contexts[language.engineIndex].getContextImpl();
}
PolyglotLanguageContext getContextInitialized(PolyglotLanguage language, PolyglotLanguage accessingLanguage) {
PolyglotLanguageContext context = getContext(language);
context.ensureInitialized(accessingLanguage);
return context;
}
void notifyContextCreated() {
EngineAccessor.INSTRUMENT.notifyContextCreated(engine, creatorTruffleContext);
}
void addChildContext(PolyglotContextImpl child) {
assert Thread.holdsLock(this);
assert !state.isClosed();
if (state.isClosing() && !state.shouldCacheThreadInfo()) {
throw PolyglotEngineException.illegalState("Adding child context into a closing context.");
}
childContexts.add(child);
}
/**
* May be used anywhere to lookup the context.
*
* @throws IllegalStateException when there is no current context available.
*/
static PolyglotContextImpl requireContext() {
PolyglotContextImpl context = PolyglotFastThreadLocals.getContext(null);
if (context == null) {
CompilerDirectives.transferToInterpreterAndInvalidate();
throw PolyglotEngineException.illegalState("There is no current context available.");
}
return context;
}
public synchronized void explicitEnter() {
try {
Object[] prev = engine.enter(this);
PolyglotThreadInfo current = getCurrentThreadInfo();
assert current.getThread() == Thread.currentThread();
current.explicitContextStack.addLast(prev);
} catch (Throwable t) {
throw PolyglotImpl.guestToHostException(engine, t);
}
}
public synchronized void explicitLeave() {
if (state.isClosed()) {
/*
* closeImpl leaves automatically for all explicit enters on the closingThread, so
* nothing else needs to be done if context is already closed.
*/
return;
}
try {
PolyglotThreadInfo current = getCurrentThreadInfo();
LinkedList stack = current.explicitContextStack;
if (stack.isEmpty() || current.getThread() == null) {
throw PolyglotEngineException.illegalState("The context is not entered explicity. A context can only be left if it was previously entered.");
}
engine.leave(stack.removeLast(), this);
} catch (Throwable t) {
throw PolyglotImpl.guestToHostException(engine, t);
}
}
synchronized Future pause() {
PauseThreadLocalAction pauseAction = new PauseThreadLocalAction(this);
Future future = threadLocalActions.submit(null, PolyglotEngineImpl.ENGINE_ID, pauseAction, new HandshakeConfig(true, true, false, false));
pauseThreadLocalActions.add(pauseAction);
return new ContextPauseHandle(pauseAction, future);
}
void resume(Future pauseFuture) {
if (pauseFuture instanceof ContextPauseHandle && ((ContextPauseHandle) pauseFuture).pauseThreadLocalAction.context == this) {
ContextPauseHandle pauseHandle = (ContextPauseHandle) pauseFuture;
pauseHandle.resume();
} else {
throw new IllegalArgumentException("Resume method was not passed a valid pause future!");
}
}
/**
* Use to enter context if it's guaranteed to be called rarely and configuration flexibility is
* needed. Otherwise use {@link PolyglotEngineImpl#enter(PolyglotContextImpl)}.
*/
@TruffleBoundary
Object[] enterThreadChanged(boolean notifyEnter, boolean enterReverted, boolean pollSafepoint, boolean deactivateSafepoints, boolean polyglotThreadFirstEnter) {
PolyglotThreadInfo enteredThread = null;
Object[] prev = null;
Thread current = Thread.currentThread();
if (JDKAccessor.isVirtualThread(current) && !(Truffle.getRuntime() instanceof DefaultTruffleRuntime)) {
throw PolyglotEngineException.illegalState(
"Using polyglot contexts on Java virtual threads is currently not supported with an optimizing Truffle runtime. " +
"As a workaround you may add the -Dtruffle.TruffleRuntime=org.pkl.thirdparty.truffle.api.impl.DefaultTruffleRuntime JVM argument to switch to a non-optimizing runtime when using virtual threads. " +
"Please note that performance is severly reduced in this mode. Loom support for optimizing runtimes will be added in a future release.");
}
try {
if (current instanceof SystemThread) {
throw PolyglotEngineException.illegalState("Context cannot be entered on system threads.");
}
boolean needsInitialization = false;
synchronized (this) {
PolyglotThreadInfo threadInfo = getCurrentThreadInfo();
if (enterReverted && threadInfo.getEnteredCount() == 0) {
threadLocalActions.notifyThreadActivation(threadInfo, false);
if ((state.isCancelling() || state.isExiting() || state == State.CLOSED_CANCELLED || state == State.CLOSED_EXITED) && !threadInfo.isActive()) {
notifyThreadClosed(threadInfo);
}
if ((state.isInterrupting() || state == State.CLOSED_INTERRUPTED) && !threadInfo.isActive()) {
Thread.interrupted();
notifyAll();
}
}
if (deactivateSafepoints && threadInfo != PolyglotThreadInfo.NULL) {
threadLocalActions.notifyThreadActivation(threadInfo, false);
}
checkClosedOrDisposing();
assert threadInfo != null;
threadInfo = threads.get(current);
if (threadInfo == null) {
threadInfo = createThreadInfo(current, polyglotThreadFirstEnter);
needsInitialization = true;
}
if (singleThreaded) {
/*
* If this is the only thread, then setting the cached thread info to NULL is no
* performance problem. If there is other thread that is just about to enter, we
* are making sure that it initializes multi-threading if this thread doesn't do
* it.
*/
setCachedThreadInfo(PolyglotThreadInfo.NULL);
}
boolean transitionToMultiThreading = isSingleThreaded() && hasActiveOtherThread(true);
if (transitionToMultiThreading) {
// recheck all thread accesses
checkAllThreadAccesses(Thread.currentThread(), false);
}
if (transitionToMultiThreading) {
/*
* We need to do this early (before initializeMultiThreading) as entering or
* local initialization depends on single thread per context.
*/
engine.singleThreadPerContext.invalidate();
singleThreaded = false;
}
if (needsInitialization) {
threads.put(current, threadInfo);
}
if (needsInitialization) {
/*
* Do not enter the thread before initializing thread locals. Creation of thread
* locals might fail.
*/
initializeThreadLocals(threadInfo);
}
prev = threadInfo.enterInternal();
if (needsInitialization) {
this.threadLocalActions.notifyEnterCreatedThread();
}
if (notifyEnter) {
try {
threadInfo.notifyEnter(engine, this);
} catch (Throwable t) {
threadInfo.leaveInternal(prev);
throw t;
}
}
enteredThread = threadInfo;
// new thread became active so we need to check potential active thread local
// actions and process them.
Set activatedActions = null;
if (enteredThread.getEnteredCount() == 1 && !deactivateSafepoints) {
activatedActions = threadLocalActions.notifyThreadActivation(threadInfo, true);
}
if (transitionToMultiThreading) {
// we need to verify that all languages give access
// to all threads in multi-threaded mode.
transitionToMultiThreaded();
}
if (needsInitialization) {
initializeNewThread(current);
}
if (enteredThread.getEnteredCount() == 1 && !pauseThreadLocalActions.isEmpty()) {
for (Iterator threadLocalActionIterator = pauseThreadLocalActions.iterator(); threadLocalActionIterator.hasNext();) {
PauseThreadLocalAction threadLocalAction = threadLocalActionIterator.next();
if (!threadLocalAction.isPause()) {
threadLocalActionIterator.remove();
} else {
if (activatedActions == null || !activatedActions.contains(threadLocalAction)) {
threadLocalActions.submit(new Thread[]{Thread.currentThread()}, PolyglotEngineImpl.ENGINE_ID, threadLocalAction, new HandshakeConfig(true, true, false, false));
}
}
}
}
// never cache last thread on close or when closingThread
setCachedThreadInfo(threadInfo);
}
if (needsInitialization) {
EngineAccessor.INSTRUMENT.notifyThreadStarted(engine, creatorTruffleContext, current);
}
return prev;
} finally {
/*
* We need to always poll the safepoint here in case we already submitted a thread local
* action for this thread. Not polling here would make dependencies of that event wait
* forever.
*/
if (pollSafepoint) {
try {
TruffleSafepoint.pollHere(this.uncachedLocation);
} catch (Throwable t) {
/*
* Just in case a safepoint makes the enter fail we need to leave the context
* again.
*/
if (enteredThread != null) {
this.leaveThreadChanged(prev, notifyEnter, true, polyglotThreadFirstEnter);
}
throw t;
}
}
}
}
PolyglotThreadInfo getCachedThread() {
PolyglotThreadInfo info;
if (CompilerDirectives.inCompiledCode() && CompilerDirectives.isPartialEvaluationConstant(this)) {
info = singleThreadValue.getConstant();
if (info == null) {
// this branch folds away if the thread info can be resolved as a constant
info = cachedThreadInfo;
}
} else {
info = cachedThreadInfo;
}
return info;
}
PolyglotThreadInfo getCurrentThreadInfo() {
CompilerAsserts.neverPartOfCompilation();
assert Thread.holdsLock(this);
PolyglotThreadInfo info = getCachedThread();
if (info.getThread() != Thread.currentThread()) {
info = threads.get(Thread.currentThread());
if (info == null) {
// closingThread from a thread we have never seen.
info = PolyglotThreadInfo.NULL;
}
}
assert info.getThread() == null || info.getThread() == Thread.currentThread();
return info;
}
void setCachedThreadInfo(PolyglotThreadInfo info) {
if (!shouldCacheThreadInfo() || threadLocalActions.hasActiveEvents()) {
// never set the cached thread when closed closing or invalid
cachedThreadInfo = PolyglotThreadInfo.NULL;
} else {
cachedThreadInfo = info;
}
}
synchronized void checkMultiThreadedAccess(PolyglotThread newThread) {
boolean singleThread = singleThreaded ? !isActiveNotCancelled() : false;
checkAllThreadAccesses(newThread, singleThread);
}
private void checkAllThreadAccesses(Thread enteringThread, boolean singleThread) {
assert Thread.holdsLock(this);
List deniedLanguages = null;
for (PolyglotLanguageContext context : contexts) {
if (!context.isInitialized()) {
continue;
}
boolean accessAllowed = true;
if (!LANGUAGE.isThreadAccessAllowed(context.env, enteringThread, singleThread)) {
accessAllowed = false;
}
if (accessAllowed) {
for (PolyglotThreadInfo seenThread : threads.values()) {
if (!LANGUAGE.isThreadAccessAllowed(context.env, seenThread.getThread(), singleThread)) {
accessAllowed = false;
break;
}
}
}
if (!accessAllowed) {
if (deniedLanguages == null) {
deniedLanguages = new ArrayList<>();
}
deniedLanguages.add(context.language);
}
}
if (deniedLanguages != null) {
throw throwDeniedThreadAccess(enteringThread, singleThread, deniedLanguages);
}
}
/**
* Use to leave a context if its guaranteed to be called rarely and configuration flexibility is
* needed. Otherwise use {@link PolyglotEngineImpl#leave(Object[], PolyglotContextImpl)}.
*/
@TruffleBoundary
void leaveThreadChanged(Object[] prev, boolean notifyLeft, boolean entered, boolean dispose) {
PolyglotThreadInfo info;
Throwable ex = null;
synchronized (this) {
Thread current = Thread.currentThread();
if (dispose) {
info = threads.get(current);
if (info == null) {
// already disposed
return;
}
ex = notifyThreadDisposing(current);
}
setCachedThreadInfo(PolyglotThreadInfo.NULL);
PolyglotThreadInfo threadInfo = threads.get(current);
assert threadInfo != null;
info = threadInfo;
if (entered) {
try {
if (notifyLeft) {
info.notifyLeave(engine, this);
}
} finally {
info.leaveInternal(prev);
}
}
if (threadInfo.getEnteredCount() == 0) {
threadLocalActions.notifyThreadActivation(threadInfo, false);
}
if ((state.isCancelling() || state.isExiting() || state == State.CLOSED_CANCELLED || state == State.CLOSED_EXITED) && !info.isActive()) {
notifyThreadClosed(info);
}
boolean somePauseThreadLocalActionIsActive = false;
if (threadInfo.getEnteredCount() == 0 && !pauseThreadLocalActions.isEmpty()) {
for (Iterator threadLocalActionIterator = pauseThreadLocalActions.iterator(); threadLocalActionIterator.hasNext();) {
PauseThreadLocalAction threadLocalAction = threadLocalActionIterator.next();
if (!threadLocalAction.isPause()) {
threadLocalActionIterator.remove();
} else {
somePauseThreadLocalActionIsActive = true;
}
}
}
if (entered && !somePauseThreadLocalActionIsActive) {
/*
* Must not cache thread info when this synchronized leave was called as a slow-path
* fallback (entered == false). The slow-path fallback does not perform enteredCount
* decrement and so other threads may see this thread as already left before the
* synchronized block is entered. If we cached the thread info in this case, then a
* subsequent fast-path enter would not perform operations that might be necessary,
* e.g. initialize multithreading.
*/
setCachedThreadInfo(threadInfo);
}
if ((state.isInterrupting() || state == State.CLOSED_INTERRUPTED) && !info.isActive()) {
Thread.interrupted();
notifyAll();
}
if (dispose) {
finishThreadDispose(current, info, ex);
}
}
}
private void finishThreadDispose(Thread current, PolyglotThreadInfo info, Throwable ex) {
assert !info.isActive();
if (cachedThreadInfo.getThread() == current) {
setCachedThreadInfo(PolyglotThreadInfo.NULL);
}
info.setContextThreadLocals(DISPOSED_CONTEXT_THREAD_LOCALS);
threads.remove(current);
if (ex != null) {
throw sneakyThrow(ex);
}
}
private Throwable notifyThreadDisposing(Thread current) {
Throwable ex = null;
for (PolyglotLanguageContext languageContext : contexts) {
if (languageContext.isInitialized()) {
try {
LANGUAGE.disposeThread(languageContext.env, current);
} catch (Throwable t) {
if (ex == null) {
ex = t;
} else {
ex.addSuppressed(t);
}
}
}
}
try {
EngineAccessor.INSTRUMENT.notifyThreadFinished(engine, creatorTruffleContext, current);
} catch (Throwable t) {
if (ex == null) {
ex = t;
} else {
ex.addSuppressed(t);
}
}
return ex;
}
private void initializeNewThread(Thread thread) {
for (PolyglotLanguageContext context : contexts) {
if (context.isInitialized()) {
LANGUAGE.initializeThread(context.env, thread);
}
}
}
long getStatementsExecuted() {
long count;
if (engine.singleThreadPerContext.isValid()) {
count = this.statementCounter;
} else {
count = this.volatileStatementCounter.get();
}
return statementLimit - count;
}
private void transitionToMultiThreaded() {
assert Thread.holdsLock(this);
for (PolyglotLanguageContext context : contexts) {
if (context.isInitialized()) {
context.ensureMultiThreadingInitialized();
}
}
singleThreaded = false;
singleThreadValue.invalidate();
long statementsExecuted = statementLimit - statementCounter;
volatileStatementCounter.getAndAdd(-statementsExecuted);
}
private PolyglotThreadInfo createThreadInfo(Thread current, boolean polyglotThreadFirstEnter) {
assert Thread.holdsLock(this);
PolyglotThreadInfo threadInfo = new PolyglotThreadInfo(this, current, polyglotThreadFirstEnter);
boolean singleThread = isSingleThreaded();
List deniedLanguages = null;
for (PolyglotLanguageContext context : contexts) {
if (context.isInitialized()) {
if (!EngineAccessor.LANGUAGE.isThreadAccessAllowed(context.env, current, singleThread)) {
if (deniedLanguages == null) {
deniedLanguages = new ArrayList<>();
}
deniedLanguages.add(context.language);
}
}
}
if (deniedLanguages != null) {
throw throwDeniedThreadAccess(current, singleThread, deniedLanguages);
}
singleThreadValue.update(threadInfo);
return threadInfo;
}
static RuntimeException throwDeniedThreadAccess(Thread current, boolean accessSingleThreaded, List deniedLanguages) {
String message;
StringBuilder languagesString = new StringBuilder("");
for (PolyglotLanguage language : deniedLanguages) {
if (languagesString.length() != 0) {
languagesString.append(", ");
}
languagesString.append(language.getId());
}
if (accessSingleThreaded) {
message = String.format("Single threaded access requested by thread %s but is not allowed for language(s) %s.", current, languagesString);
} else {
message = String.format("Multi threaded access requested by thread %s but is not allowed for language(s) %s.", current, languagesString);
}
throw PolyglotEngineException.illegalState(message);
}
public Value getBindings(String languageId) {
PolyglotLanguageContext languageContext = lookupLanguageContext(languageId);
assert languageContext != null;
Object prev = hostEnter(languageContext);
try {
if (!languageContext.isInitialized()) {
languageContext.ensureInitialized(null);
}
return languageContext.getHostBindings();
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(languageContext, e, true);
} finally {
hostLeave(languageContext, prev);
}
}
public Value getPolyglotBindings() {
try {
checkClosed();
Value bindings = this.polyglotHostBindings;
if (bindings == null) {
initPolyglotBindings();
bindings = this.polyglotHostBindings;
}
return bindings;
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(engine, e);
}
}
public Map getPolyglotGuestBindings() {
Map bindings = this.polyglotBindings;
if (bindings == null) {
initPolyglotBindings();
bindings = this.polyglotBindings;
}
return bindings;
}
private void initPolyglotBindings() {
synchronized (this) {
if (this.polyglotBindings == null) {
this.polyglotBindings = new ConcurrentHashMap<>();
PolyglotLanguageContext hostContext = getHostContext();
PolyglotBindings bindings = new PolyglotBindings(hostContext);
this.polyglotHostBindings = getAPIAccess().newValue(new PolyglotBindingsValue(hostContext, bindings), hostContext, bindings);
}
}
}
public Object getPolyglotBindingsObject() {
return polyglotBindingsObject;
}
void checkClosedOrDisposing() {
checkCancelled();
if (state.isClosed() || disposing) {
throw PolyglotEngineException.closedException("The Context is already closed.");
}
}
void checkClosed() {
checkCancelled();
if (state.isClosed()) {
throw PolyglotEngineException.closedException("The Context is already closed.");
}
}
private void checkCancelled() {
if (state.isInvalidOrClosed() && closingThread != Thread.currentThread() && invalidMessage != null) {
/*
* If invalidMessage == null, then invalid flag was set by close.
*/
if (exitMessage == null) {
throw createCancelException(null);
} else {
throw createExitException(null);
}
}
}
@TruffleBoundary
private RuntimeException failValueSharing() {
throw new ValueMigrationException("A value was tried to be migrated from one context to a different context. " +
"Value migration for the current context was disabled and is therefore disallowed.", this.uncachedLocation);
}
Object migrateValue(Object value, PolyglotContextImpl valueContext) {
if (!config.allowValueSharing) {
throw failValueSharing();
}
Object result = engine.host.migrateValue(this, value, valueContext);
if (result != null) {
// host made sure migration is fine
return result;
}
// guaranteed by migrateValue
assert value instanceof TruffleObject;
if (value instanceof OtherContextGuestObject) {
OtherContextGuestObject otherValue = (OtherContextGuestObject) value;
if (otherValue.receiverContext == this && otherValue.delegateContext == valueContext) {
// reuse wrapper it is already wrapped
return otherValue;
} else if (otherValue.receiverContext == valueContext && otherValue.delegateContext == this) {
// unpack foreign value it belongs to that context
return otherValue.delegate;
} else {
return new OtherContextGuestObject(this, otherValue.delegate, valueContext);
}
}
assert value instanceof TruffleObject;
return new OtherContextGuestObject(this, value, valueContext);
}
Object migrateHostWrapper(PolyglotWrapper wrapper) {
Object wrapped = wrapper.getGuestObject();
PolyglotContextImpl valueContext = wrapper.getContext();
if (valueContext != this) {
// migrate wrapped value to the context
wrapped = migrateValue(wrapped, valueContext);
}
return wrapped;
}
PolyglotLanguageContext getHostContext() {
return contexts[PolyglotEngineImpl.HOST_LANGUAGE_INDEX];
}
Object getHostContextImpl() {
return hostContextImpl;
}
@Override
public PolyglotEngineImpl getEngine() {
return engine;
}
/*
* Special version for getLanguageContext for the fast-path.
*/
PolyglotLanguageContext getLanguageContext(Class> languageClass) {
if (CompilerDirectives.isPartialEvaluationConstant(this)) {
return getLanguageContextImpl(languageClass);
} else {
return getLanguageContextBoundary(languageClass);
}
}
@TruffleBoundary
private PolyglotLanguageContext getLanguageContextBoundary(Class> languageClass) {
return getLanguageContextImpl(languageClass);
}
@SuppressWarnings("rawtypes")
PolyglotLanguageContext findLanguageContext(Class languageClazz) {
PolyglotLanguage directLanguage = engine.getLanguage(languageClazz, false);
if (directLanguage != null) {
return getContext(directLanguage);
}
// slow language lookup - for compatibility
for (PolyglotLanguageContext lang : contexts) {
if (lang.isInitialized()) {
TruffleLanguage language = EngineAccessor.LANGUAGE.getLanguage(lang.env);
if (languageClazz != TruffleLanguage.class && languageClazz.isInstance(language)) {
return lang;
}
}
}
Set languageNames = new HashSet<>();
for (PolyglotLanguageContext lang : contexts) {
if (lang.isInitialized()) {
languageNames.add(lang.language.cache.getClassName());
}
}
throw PolyglotEngineException.illegalState("Cannot find language " + languageClazz + " among " + languageNames);
}
private PolyglotLanguageContext getLanguageContextImpl(Class> languageClass) {
FinalIntMap map = this.languageIndexMap;
int indexValue = map != null ? map.get(languageClass) : -1;
if (indexValue == -1) {
CompilerDirectives.transferToInterpreterAndInvalidate();
synchronized (this) {
if (this.languageIndexMap == null) {
this.languageIndexMap = new FinalIntMap();
}
indexValue = languageIndexMap.get(languageClass);
if (indexValue == -1) {
PolyglotLanguageContext context = findLanguageContext(languageClass);
indexValue = context.language.engineIndex;
this.languageIndexMap.put(languageClass, indexValue);
}
}
}
PolyglotLanguageContext context = contexts[indexValue];
return context;
}
void initializeInnerContextLanguage(String languageId) {
PolyglotLanguage language = engine.idToLanguage.get(languageId);
assert language != null : "language creating the inner context not be found";
Object prev = engine.enterIfNeeded(this, true);
try {
initializeLanguage(language);
} finally {
engine.leaveIfNeeded(prev, this);
}
}
private boolean initializeLanguage(PolyglotLanguage language) {
PolyglotLanguageContext languageContext = getContext(language);
assert languageContext != null;
languageContext.checkAccess(null);
if (!languageContext.isInitialized()) {
return languageContext.ensureInitialized(null);
}
return false;
}
public boolean initializeLanguage(String languageId) {
PolyglotLanguageContext languageContext = lookupLanguageContext(languageId);
Object prev = hostEnter(languageContext);
try {
return initializeLanguage(languageContext.language);
} catch (Throwable t) {
throw PolyglotImpl.guestToHostException(languageContext, t, true);
} finally {
hostLeave(languageContext, prev);
}
}
public Value parse(String languageId, org.pkl.thirdparty.graalvm.polyglot.Source source) {
PolyglotLanguageContext languageContext = lookupLanguageContext(languageId);
assert languageContext != null;
Object prev = hostEnter(languageContext);
try {
Source truffleSource = (Source) getAPIAccess().getReceiver(source);
languageContext.checkAccess(null);
languageContext.ensureInitialized(null);
CallTarget target = languageContext.parseCached(null, truffleSource, null);
return languageContext.asValue(new PolyglotParsedEval(languageContext, truffleSource, target));
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(languageContext, e, true);
} finally {
hostLeave(languageContext, prev);
}
}
private PolyglotLanguageContext lookupLanguageContext(String languageId) {
PolyglotLanguageContext languageContext;
try {
PolyglotLanguage language = requirePublicLanguage(languageId);
languageContext = getContext(language);
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(engine, e);
}
return languageContext;
}
public Value eval(String languageId, org.pkl.thirdparty.graalvm.polyglot.Source source) {
PolyglotLanguageContext languageContext = lookupLanguageContext(languageId);
assert languageContext != null;
Object prev = hostEnter(languageContext);
try {
Source truffleSource = (Source) getAPIAccess().getReceiver(source);
languageContext.checkAccess(null);
languageContext.ensureInitialized(null);
CallTarget target = languageContext.parseCached(null, truffleSource, null);
Object result = target.call(PolyglotImpl.EMPTY_ARGS);
Value hostValue;
try {
hostValue = languageContext.asValue(result);
} catch (NullPointerException | ClassCastException e) {
throw new AssertionError(String.format("Language %s returned an invalid return value %s. Must be an interop value.", languageId, result), e);
}
if (truffleSource.isInteractive()) {
printResult(languageContext, result);
}
return hostValue;
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(languageContext, e, true);
} finally {
hostLeave(languageContext, prev);
}
}
public PolyglotLanguage requirePublicLanguage(String languageId) {
PolyglotLanguage language = engine.idToLanguage.get(languageId);
if (language == null || language.cache.isInternal()) {
engine.requirePublicLanguage(languageId); // will trigger the error
assert false;
return null;
}
return language;
}
@TruffleBoundary
static void printResult(PolyglotLanguageContext languageContext, Object result) {
if (!LANGUAGE.isVisible(languageContext.env, result)) {
return;
}
String stringResult;
try {
stringResult = UNCACHED.asString(UNCACHED.toDisplayString(languageContext.getLanguageView(result), true));
} catch (UnsupportedMessageException e) {
throw shouldNotReachHere(e);
}
try {
OutputStream out = languageContext.context.config.out;
out.write(stringResult.getBytes(StandardCharsets.UTF_8));
out.write(System.getProperty("line.separator").getBytes(StandardCharsets.UTF_8));
} catch (IOException ioex) {
// out stream has problems.
throw new IllegalStateException(ioex);
}
}
/**
* Embedder close.
*/
public void close(boolean cancelIfExecuting) {
try {
clearExplicitContextStack();
if (cancelIfExecuting) {
/*
* Cancel does invalidate. We always need to invalidate before force-closing a
* context that might be active in other threads.
*/
cancel(false, null);
} else {
closeAndMaybeWait(false, null);
checkCancelled();
}
} catch (Throwable t) {
PolyglotException polyglotException = PolyglotImpl.guestToHostException(getHostContext(), t, false);
if (!cancelIfExecuting && state.isInvalidOrClosed() && (polyglotException.isCancelled() || polyglotException.isExit())) {
try {
/*
* The close operation was interrupted by cancelling or exiting, we are now in
* an invalid state. By executing the close operation again, we make sure that
* the close operation is fully completed when we return.
*/
closeAndMaybeWait(false, null);
} catch (Throwable closeFinishError) {
/*
* Close operation started when the context is already invalid should complete
* without an error. This exception indicates a bug, most probably in the
* language implementation.
*/
PolyglotException closeFinishPolyglotException = PolyglotImpl.guestToHostException(getHostContext(), t, false);
polyglotException.addSuppressed(closeFinishPolyglotException);
}
}
throw polyglotException;
}
}
void cancel(boolean resourceLimit, String message) {
String cancelMessage = message == null ? "Context execution was cancelled." : message;
if (parent == null) {
engine.polyglotHostService.notifyContextCancellingOrExiting(this, false, 0, resourceLimit, cancelMessage);
}
List> futures = setCancelling(resourceLimit, cancelMessage);
closeHereOrCancelInCleanupThread(futures);
}
void initiateCancelOrExit(boolean exit, int code, boolean resourceLimit, String message) {
assert parent == null;
initiateCancelOrExitLock.lock();
try {
List> futures;
if (exit) {
futures = setExiting(null, code, message, true);
} else {
futures = setCancelling(resourceLimit, message);
}
if (!futures.isEmpty()) {
/*
* initiateCancelOrExit keeps assigning cancellationOrExitingFutures until one of
* the other setExiting or setCancelling calls takes it and from that point
* cancellationOrExitingFutures == null. If the futures are empty, it means that
* cancelling was not initiated by this method, because it was already initiated
* before, or it is no longer possible.
*/
cancellationOrExitingFutures = futures;
}
} finally {
initiateCancelOrExitLock.unlock();
}
}
void closeAndMaybeWait(boolean force, List> futures) {
if (force) {
PolyglotEngineImpl.cancelOrExit(this, futures);
} else {
boolean closeCompleted = closeImpl(true);
if (!closeCompleted) {
throw PolyglotEngineException.illegalState(String.format("The context is currently executing on another thread. " +
"Set cancelIfExecuting to true to stop the execution on this thread."));
}
}
finishCleanup();
checkSubProcessFinished();
checkSystemThreadsFinished();
if (parent == null) {
engine.polyglotHostService.notifyContextClosed(this, force, invalidResourceLimit, invalidMessage);
}
if (engine.boundEngine && parent == null) {
engine.ensureClosed(force, true);
}
}
private void setState(State targetState) {
assert Thread.holdsLock(this);
assert isTransitionAllowed(state, targetState) : "Transition from " + state.name() + " to " + targetState.name() + " not allowed!";
state = targetState;
notifyAll();
}
private List> setInterrupting() {
assert Thread.holdsLock(this);
State targetState;
List> futures = new ArrayList<>();
if (!state.isInterrupting() && !state.isInvalidOrClosed() && state != State.PENDING_EXIT && state != State.CLOSING_PENDING_EXIT) {
switch (state) {
case CLOSING:
targetState = State.CLOSING_INTERRUPTING;
break;
case CLOSING_FINALIZING:
targetState = State.CLOSING_INTERRUPTING_FINALIZING;
break;
default:
targetState = State.INTERRUPTING;
break;
}
setState(targetState);
setCachedThreadInfo(PolyglotThreadInfo.NULL);
futures.add(threadLocalActions.submit(null, PolyglotEngineImpl.ENGINE_ID, new InterruptThreadLocalAction(), true));
maybeSendInterrupt();
}
return futures;
}
private void unsetInterrupting() {
assert Thread.holdsLock(this);
if (state.isInterrupting()) {
State targetState;
switch (state) {
case CLOSING_INTERRUPTING:
targetState = State.CLOSING;
break;
case CLOSING_INTERRUPTING_FINALIZING:
targetState = State.CLOSING_FINALIZING;
break;
default:
targetState = State.DEFAULT;
break;
}
setState(targetState);
}
}
private void finishInterruptForChildContexts() {
PolyglotContextImpl[] childContextsToInterrupt;
synchronized (this) {
unsetInterrupting();
childContextsToInterrupt = childContexts.toArray(new PolyglotContextImpl[childContexts.size()]);
}
for (PolyglotContextImpl childCtx : childContextsToInterrupt) {
childCtx.finishInterruptForChildContexts();
}
}
private List> interruptChildContexts() {
PolyglotContextImpl[] childContextsToInterrupt = null;
List> futures;
synchronized (this) {
futures = new ArrayList<>(setInterrupting());
if (!futures.isEmpty()) {
childContextsToInterrupt = childContexts.toArray(new PolyglotContextImpl[childContexts.size()]);
}
}
if (childContextsToInterrupt != null) {
for (PolyglotContextImpl childCtx : childContextsToInterrupt) {
futures.addAll(childCtx.interruptChildContexts());
}
}
return futures;
}
private void validateInterruptPrecondition(PolyglotContextImpl operationSource) {
PolyglotContextImpl[] childContextsToInterrupt;
synchronized (this) {
PolyglotThreadInfo info = getCurrentThreadInfo();
if (info != PolyglotThreadInfo.NULL && info.isActive()) {
throw PolyglotEngineException.illegalState(String.format("Cannot interrupt context from a thread where %s context is active.", this == operationSource ? "the" : "its child"));
}
childContextsToInterrupt = childContexts.toArray(new PolyglotContextImpl[childContexts.size()]);
}
for (PolyglotContextImpl childCtx : childContextsToInterrupt) {
childCtx.validateInterruptPrecondition(operationSource);
}
}
public boolean interrupt(Duration timeout) {
try {
if (parent != null) {
throw PolyglotEngineException.illegalState("Cannot interrupt inner context separately.");
}
long startMillis = System.currentTimeMillis();
PolyglotContextImpl[] childContextsToInterrupt = null;
/*
* Two interrupt operations cannot be simultaneously in progress in the whole context
* hierarchy. Inner contexts cannot use interrupt separately and outer context use
* exclusive lock.
*/
interruptingLock.lock();
try {
validateInterruptPrecondition(this);
List> futures;
synchronized (this) {
if (state.isClosed()) {
// already closed
return true;
}
futures = new ArrayList<>(setInterrupting());
if (!futures.isEmpty()) {
childContextsToInterrupt = childContexts.toArray(new PolyglotContextImpl[childContexts.size()]);
}
}
if (childContextsToInterrupt != null) {
for (PolyglotContextImpl childCtx : childContextsToInterrupt) {
futures.addAll(childCtx.interruptChildContexts());
}
}
/*
* No matter whether we successfully transitioned into one of the interrupting
* states, we wait for threads to be completed (which is done as a part of the
* cancel method) as the states that override interrupting states also lead to
* threads being stopped. If that happens before the timeout, the interrupt is
* successful.
*/
return PolyglotEngineImpl.cancelOrExitOrInterrupt(this, futures, startMillis, timeout);
} finally {
try {
if (childContextsToInterrupt != null) {
PolyglotContextImpl[] childContextsToFinishInterrupt;
synchronized (this) {
unsetInterrupting();
childContextsToFinishInterrupt = childContexts.toArray(new PolyglotContextImpl[childContexts.size()]);
}
for (PolyglotContextImpl childCtx : childContextsToFinishInterrupt) {
childCtx.finishInterruptForChildContexts();
}
}
} finally {
interruptingLock.unlock();
}
}
} catch (Throwable thr) {
throw PolyglotImpl.guestToHostException(engine, thr);
}
}
public Value asValue(Object hostValue) {
PolyglotLanguageContext languageContext = this.getHostContext();
Object prev = hostEnter(languageContext);
try {
checkClosed();
PolyglotLanguageContext targetLanguageContext;
if (hostValue instanceof Value) {
// fast path for when no context migration is necessary
PolyglotLanguageContext valueContext = (PolyglotLanguageContext) getAPIAccess().getContext((Value) hostValue);
if (valueContext != null && valueContext.context == this) {
return (Value) hostValue;
}
targetLanguageContext = languageContext;
} else if (PolyglotWrapper.isInstance(hostValue)) {
// host wrappers can nicely reuse the associated context
targetLanguageContext = PolyglotWrapper.asInstance(hostValue).getLanguageContext();
if (this != targetLanguageContext.context) {
// this will fail later in toGuestValue when migrating
// or succeed in case of host languages.
targetLanguageContext = languageContext;
}
} else {
targetLanguageContext = languageContext;
}
return targetLanguageContext.asValue(toGuestValue(null, hostValue, true));
} catch (Throwable e) {
throw PolyglotImpl.guestToHostException(this.getHostContext(), e, true);
} finally {
hostLeave(languageContext, prev);
}
}
static PolyglotEngineImpl getConstantEngine(Node node) {
if (!CompilerDirectives.inCompiledCode() ||
!CompilerDirectives.isPartialEvaluationConstant(node)) {
return null;
}
if (node == null) {
return null;
}
RootNode root = node.getRootNode();
if (root == null) {
return null;
}
PolyglotSharingLayer layer = (PolyglotSharingLayer) EngineAccessor.NODES.getSharingLayer(root);
return layer != null ? layer.engine : null;
}
Object toGuestValue(Node node, Object hostValue, boolean asValue) {
PolyglotEngineImpl localEngine = getConstantEngine(node);
PolyglotContextImpl localContext;
if (localEngine == null) {
localEngine = this.engine;
localContext = this;
} else {
// lookup context as a constant
localContext = localEngine.singleContextValue.getConstant();
if (localContext == null) {
// not a constant use this
localContext = this;
}
}
Object value = PolyglotHostAccess.toGuestValue(localContext, hostValue);
return localEngine.host.toGuestValue(localContext.getHostContextImpl(), value, asValue);
}
boolean waitForThreads(long startMillis, long timeoutMillis) {
synchronized (this) {
long timeElapsed = System.currentTimeMillis() - startMillis;
boolean otherThreadActive;
while ((otherThreadActive = hasActiveOtherThread(true)) && (timeoutMillis == 0 || timeElapsed < timeoutMillis)) {
try {
if (timeoutMillis == 0) {
wait();
} else {
wait(timeoutMillis - timeElapsed);
}
} catch (InterruptedException e) {
}
timeElapsed = System.currentTimeMillis() - startMillis;
}
/*
* hasActiveOtherThread is racy. E.g. one of the threads might be just about to enter
* via fast path and so hasActiveOtherThread might return a different result if we
* executed it again after the while loop. The fast-path enter might not go through in
* the end, especially if this is waiting for cancellation of all threads, so it is not
* a problem that hasActiveOtherThread is racy, but it is important that waitForThreads
* does not return a wrong value. That is why we store the result in a boolean so that
* the returned value corresponds to the reason why the while loop has ended.
*/
return !otherThreadActive;
}
}
boolean isSingleThreaded() {
return singleThreaded;
}
Map getSeenThreads() {
assert Thread.holdsLock(this);
return threads;
}
private boolean isActiveNotCancelled() {
return isActiveNotCancelled(true);
}
synchronized boolean isActiveNotCancelled(boolean includePolyglotThreads) {
for (PolyglotThreadInfo seenTinfo : threads.values()) {
if ((includePolyglotThreads || !seenTinfo.isPolyglotThread(this)) && seenTinfo.isActiveNotCancelled()) {
return true;
}
}
return false;
}
synchronized boolean isActive() {
for (PolyglotThreadInfo seenTinfo : threads.values()) {
if (seenTinfo.isActive()) {
return true;
}
}
return false;
}
synchronized boolean isActive(Thread thread) {
PolyglotThreadInfo info = threads.get(thread);
if (info == null || info == PolyglotThreadInfo.NULL) {
return false;
}
return info.isActive();
}
private PolyglotThreadInfo getFirstActiveOtherThread(boolean includePolyglotThreads) {
assert Thread.holdsLock(this);
// send enters and leaves into a lock by setting the lastThread to null.
for (PolyglotThreadInfo otherInfo : threads.values()) {
if (!includePolyglotThreads && otherInfo.isPolyglotThread(this)) {
continue;
}
if (!otherInfo.isCurrent() && otherInfo.isActive()) {
return otherInfo;
}
}
return null;
}
boolean hasActiveOtherThread(boolean includePolyglotThreads) {
return getFirstActiveOtherThread(includePolyglotThreads) != null;
}
private void notifyThreadClosed(PolyglotThreadInfo info) {
assert Thread.holdsLock(this);
if (!info.cancelled) {
// clear interrupted status after closingThread
// needed because we interrupt when closingThread from another thread.
info.cancelled = true;
Thread.interrupted();
}
notifyAll();
}
long calculateHeapSize(long stopAtBytes, AtomicBoolean calculationCancelled) {
ObjectSizeCalculator localObjectSizeCalculator;
synchronized (this) {
localObjectSizeCalculator = objectSizeCalculator;
if (localObjectSizeCalculator == null) {
localObjectSizeCalculator = new ObjectSizeCalculator();
objectSizeCalculator = localObjectSizeCalculator;
}
}
return localObjectSizeCalculator.calculateObjectSize(getContextHeapRoots(), stopAtBytes, calculationCancelled);
}
private Object[] getContextHeapRoots() {
List
