com.oracle.truffle.api.TruffleLanguage.Env Java Examples

@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    return Truffle.getRuntime().createCallTarget(new RootNode(this) {

        @CompilationFinal private ContextReference<Env> reference;

        @Override
        public Object execute(VirtualFrame frame) {
            return parseAndEval();
        }

        @TruffleBoundary
        private Object parseAndEval() {
            if (reference == null) {
                CompilerDirectives.transferToInterpreterAndInvalidate();
                this.reference = lookupContextReference(EvalLang.class);
            }
            Source aPlusB = Source.newBuilder("hashemi", "a + b", "plus.hashem").build();
            return reference.get().parsePublic(aPlusB, "a", "b").call(30, 12);
        }
    });
}
 

public CUDARuntime(GrCUDAContext context, Env env) {
    this.context = context;
    try {
        TruffleObject libcudart = (TruffleObject) env.parseInternal(
                        Source.newBuilder("nfi", "load " + "lib" + CUDA_RUNTIME_LIBRARY_NAME + ".so", "cudaruntime").build()).call();
        TruffleObject libcuda = (TruffleObject) env.parseInternal(
                        Source.newBuilder("nfi", "load " + "lib" + CUDA_LIBRARY_NAME + ".so", "cuda").build()).call();
        TruffleObject libnvrtc = (TruffleObject) env.parseInternal(
                        Source.newBuilder("nfi", "load " + "lib" + NVRTC_LIBRARY_NAME + ".so", "nvrtc").build()).call();
        loadedLibraries.put(CUDA_RUNTIME_LIBRARY_NAME, libcudart);
        loadedLibraries.put(CUDA_LIBRARY_NAME, libcuda);
        loadedLibraries.put(NVRTC_LIBRARY_NAME, libnvrtc);
    } catch (UnsatisfiedLinkError e) {
        throw new GrCUDAException(e.getMessage());
    }

    nvrtc = new NVRuntimeCompiler(this);
    context.addDisposable(this::shutdown);
}
 

public HashemContext(HashemLanguage language, TruffleLanguage.Env env, List<NodeFactory<? extends HashemBuiltinNode>> externalBuiltins) {
    this.env = env;
    this.input = new BufferedReader(new InputStreamReader(env.in()));
    this.output = new PrintWriter(env.out(), true);
    this.language = language;
    this.allocationReporter = env.lookup(AllocationReporter.class);
    this.functionRegistry = new HashemBebinRegistry(language);
    this.topScopes = Collections.singleton(Scope.newBuilder("global", functionRegistry.getFunctionsObject()).build());
    installBuiltins();
    for (NodeFactory<? extends HashemBuiltinNode> builtin : externalBuiltins) {
        installBuiltin(builtin);
    }
    this.emptyShape = LAYOUT.createShape(HashemObjectType.SINGLETON);
}
 

public GrCUDAContext(Env env) {
    this.env = env;
    this.cudaRuntime = new CUDARuntime(this, env);

    Namespace namespace = new Namespace(ROOT_NAMESPACE);
    namespace.addNamespace(namespace);
    namespace.addFunction(new BindFunction());
    namespace.addFunction(new BindAllFunction(this));
    namespace.addFunction(new DeviceArrayFunction(cudaRuntime));
    namespace.addFunction(new MapFunction());
    namespace.addFunction(new ShredFunction());
    namespace.addFunction(new BindKernelFunction(cudaRuntime));
    namespace.addFunction(new BuildKernelFunction(cudaRuntime));
    namespace.addFunction(new GetDevicesFunction(cudaRuntime));
    namespace.addFunction(new GetDeviceFunction(cudaRuntime));
    cudaRuntime.registerCUDAFunctions(namespace);
    if (this.getOption(GrCUDAOptions.CuMLEnabled)) {
        Namespace ml = new Namespace(CUMLRegistry.NAMESPACE);
        namespace.addNamespace(ml);
        new CUMLRegistry(this).registerCUMLFunctions(ml);
    }
    if (this.getOption(GrCUDAOptions.CuBLASEnabled)) {
        Namespace blas = new Namespace(CUBLASRegistry.NAMESPACE);
        namespace.addNamespace(blas);
        new CUBLASRegistry(this).registerCUBLASFunctions(blas);
    }
    if (this.getOption(GrCUDAOptions.TensorRTEnabled)) {
        Namespace trt = new Namespace(TensorRTRegistry.NAMESPACE);
        namespace.addNamespace(trt);
        new TensorRTRegistry(this).registerTensorRTFunctions(trt);
    }
    this.rootNamespace = namespace;
}
 

@TruffleBoundary
private static String findLanguageByMimeType(final Env env, final String mimeType) {
    final Map<String, LanguageInfo> languages = env.getPublicLanguages();
    for (final String registeredMimeType : languages.keySet()) {
        if (mimeType.equals(registeredMimeType)) {
            return languages.get(registeredMimeType).getId();
        }
    }
    return null;
}
 

public SqueakContextOptions(final Env env) {
    final OptionValues options = env.getOptions();
    imagePath = options.get(ImagePath);
    imageArguments = options.get(ImageArguments).isEmpty() ? new String[0] : options.get(ImageArguments).split(",");
    isHeadless = options.get(Headless);
    isQuiet = options.get(Quiet);
    disableInterruptHandler = options.get(Interrupts);
    disableStartup = options.get(Startup);
    signalInputSemaphore = options.get(SignalInputSemaphore);
    enableStackDepthProtection = options.get(StackDepthProtection);
    enableStorageStrategies = options.get(StorageStrategies);
    isTesting = options.get(Testing);
}
 

/**
 * Return the current Truffle environment.
 */
public Env getEnv() {
    return env;
}
 

@Override
protected Env createContext(Env env) {
    return env;
}
 

public Env getEnv() {
    return env;
}
 

@TruffleBoundary
private static String systemGetEnv(final Env env, final String key) {
    return env.getEnvironment().get(key);
}