com.oracle.truffle.api.CallTarget 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);
        }
    });
}
 

@Specialization(limit = "3")
Object doMap(Object source, Type elementType, CUDARuntime runtime,
                @CachedLibrary("source") InteropLibrary interop,
                @CachedContext(GrCUDALanguage.class) @SuppressWarnings("unused") GrCUDAContext context,
                @Cached(value = "createLoop(source)", uncached = "createUncachedLoop(source, context)") CallTarget loop) {

    if (source instanceof DeviceArray && ((DeviceArray) source).getElementType() == elementType) {
        return source;
    }

    if (!interop.hasArrayElements(source)) {
        CompilerDirectives.transferToInterpreter();
        throw new GrCUDAException("cannot map from non-array to DeviceArray");
    }

    long size;
    try {
        size = interop.getArraySize(source);
    } catch (UnsupportedMessageException e) {
        CompilerDirectives.transferToInterpreter();
        throw new GrCUDAException("cannot read array size");
    }
    DeviceArray result = new DeviceArray(runtime, size, elementType);
    loop.call(size, source, result);
    return result;
}
 

@TruffleBoundary
private static String createStackTrace() {
    final StringBuilder str = new StringBuilder();

    Truffle.getRuntime().iterateFrames(new FrameInstanceVisitor<Integer>() {
        private int skip = 1; // skip stack trace builtin

        @Override
        public Integer visitFrame(FrameInstance frameInstance) {
            if (skip > 0) {
                skip--;
                return null;
            }
            CallTarget callTarget = frameInstance.getCallTarget();
            Frame frame = frameInstance.getFrame(FrameAccess.READ_ONLY);
            RootNode rn = ((RootCallTarget) callTarget).getRootNode();
            // ignore internal or interop stack frames
            if (rn.isInternal() || rn.getLanguageInfo() == null) {
                return 1;
            }
            if (str.length() > 0) {
                str.append(System.getProperty("line.separator"));
            }
            str.append("Frame: ").append(rn.toString());
            FrameDescriptor frameDescriptor = frame.getFrameDescriptor();
            for (FrameSlot s : frameDescriptor.getSlots()) {
                str.append(", ").append(s.getIdentifier()).append("=").append(frame.getValue(s));
            }
            return null;
        }
    });
    return str.toString();
}
 

@Override
protected Object executeDispatch(VirtualFrame frame, CallTarget callTarget,
        Object[] arguments) {
    if (this.cachedCallTarget == callTarget) {
        return this.callCachedTargetNode.call(arguments);
    }
    return this.nextNode.executeDispatch(frame, callTarget, arguments);
}
 

protected CallTarget createUncachedLoop(Object source, GrCUDAContext context) {
    ConcurrentHashMap<Class<?>, CallTarget> uncachedCallTargets = context.getMapCallTargets();
    DynamicDispatchLibrary dispatch = DynamicDispatchLibrary.getFactory().getUncached(source);
    Class<?> clazz = dispatch.dispatch(source);
    if (clazz == null) {
        clazz = source.getClass();
    }
    return uncachedCallTargets.computeIfAbsent(clazz, c -> Truffle.getRuntime().createCallTarget(new LoopRootNode(source, c)));
}
 

static String getDisplayName(CallTarget ct) {
    if (ct instanceof RootCallTarget) {
        RootNode rn = ((RootCallTarget) ct).getRootNode();
        return getMethodName(rn);
    } else {
        //System.err.println("Unexpected CallTarget: "+ct.getClass());
        return ct.toString();
    }
}
 

@Override
protected CallTarget parse(final ParsingRequest request) throws Exception {
    final SqueakImageContext image = getContext();
    final Source source = request.getSource();
    if (source.hasBytes()) {
        image.setImagePath(source.getPath());
        return image.getSqueakImage().asCallTarget();
    } else {
        image.ensureLoaded();
        if (source.isInternal()) {
            image.printToStdOut(MiscUtils.format("Evaluating '%s'...", source.getCharacters().toString()));
        }
        return Truffle.getRuntime().createCallTarget(image.getDoItContextNode(source));
    }
}
 

@Override
protected CallTarget parse(ParsingRequest parsingRequest) throws IOException {
    MumblerContext context = new MumblerContext(this);
    ListSyntax sexp = Reader.read(parsingRequest.getSource());
    Converter converter = new Converter(this, TAIL_CALL_OPTIMIZATION_ENABLED);
    MumblerNode[] nodes = converter.convertSexp(context, sexp);
    MumblerFunction function = MumblerFunction.create(this, new FrameSlot[] {},
            nodes, context.getGlobalFrame().getFrameDescriptor());
    return function.callTarget;
}
 

@Override
protected Object call(VirtualFrame virtualFrame, CallTarget callTarget,
        Object[] arguments) {
    if (this.isTail()) {
        throw new TailCallException(callTarget, arguments);
    }
    while (true) {
        try {
            return super.call(virtualFrame, callTarget, arguments);
        } catch (TailCallException e) {
            callTarget = e.callTarget;
            arguments = e.arguments;
        }
    }
}
 

@Override
protected Object executeDispatch(VirtualFrame virtualFrame,
        CallTarget callTarget, Object[] arguments) {
    CompilerDirectives.transferToInterpreterAndInvalidate();

    Node cur = this;
    int size = 0;
    while (cur.getParent() instanceof DispatchNode) {
        cur = cur.getParent();
        size++;
    }
    InvokeNode invokeNode = (InvokeNode) cur.getParent();

    DispatchNode replacement;
    if (size < INLINE_CACHE_SIZE) {
        // There's still room in the cache. Add a new DirectDispatchNode.
        DispatchNode next = new UninitializedDispatchNode();
        replacement = new DirectDispatchNode(next, callTarget);
        this.replace(replacement);
    } else {
        replacement = new GenericDispatchNode();
        invokeNode.dispatchNode.replace(replacement);
    }

    // Call function with newly created dispatch node.
    return replacement.executeDispatch(virtualFrame, callTarget, arguments);
}
 

@Override
protected Object executeDispatch(VirtualFrame virtualFrame,
        CallTarget callTarget, Object[] argumentValues) {
    return this.callNode.call(callTarget, argumentValues);
}
 

@Override
protected CallTarget parse(ParsingRequest request) throws Exception {
    Source source = request.getSource();
    Map<String, RootCallTarget> functions;
    /*
     * Parse the provided source. At this point, we do not have a SLContext yet. Registration of
     * the functions with the SLContext happens lazily in SLEvalRootNode.
     */
    if (request.getArgumentNames().isEmpty()) {
        functions = HashemLanguageParser.parseHashemiLang(this, source);
    } else {
        Source requestedSource = request.getSource();
        StringBuilder sb = new StringBuilder();
        sb.append("bebin azinja(");
        String sep = "";
        for (String argumentName : request.getArgumentNames()) {
            sb.append(sep);
            sb.append(argumentName);
            sep = ",";
        }
        sb.append(") { return ");
        sb.append(request.getSource().getCharacters());
        sb.append(";}");
        String language = requestedSource.getLanguage() == null ? ID : requestedSource.getLanguage();
        Source decoratedSource = Source.newBuilder(language, sb.toString(), request.getSource().getName()).build();
        functions = HashemLanguageParser.parseHashemiLang(this, decoratedSource);
    }

    RootCallTarget main = functions.get("azinja");
    RootNode evalMain;
    if (main != null) {
        /*
         * We have a main function, so "evaluating" the parsed source means invoking that main
         * function. However, we need to lazily register functions into the SLContext first, so
         * we cannot use the original SLRootNode for the main function. Instead, we create a new
         * SLEvalRootNode that does everything we need.
         */
        evalMain = new HashemEvalRootNode(this, main, functions);
    } else {
        /*
         * Even without a main function, "evaluating" the parsed source needs to register the
         * functions into the SLContext.
         */
        evalMain = new HashemEvalRootNode(this, null, functions);
    }
    return Truffle.getRuntime().createCallTarget(evalMain);
}
 

public DirectDispatchNode(DispatchNode next, CallTarget callTarget) {
    this.cachedCallTarget = callTarget;
    this.callCachedTargetNode = Truffle.getRuntime().createDirectCallNode(
            this.cachedCallTarget);
    this.nextNode = next;
}
 

protected Object call(VirtualFrame virtualFrame, CallTarget callTarget,
        Object[] arguments) {
    return this.dispatchNode.executeDispatch(virtualFrame,
            callTarget, arguments);
}
 

public TailCallException(CallTarget callTarget, Object[] arguments) {
    this.callTarget = callTarget;
    this.arguments = arguments;
}
 

protected abstract Object executeDispatch(VirtualFrame virtualFrame,
CallTarget callTarget, Object[] argumentValues);
 

public CallTarget getCallTarget() {
    return getBlockOrMethod().getResumptionCallTarget(this);
}
 

protected CallTarget createLoop(Object source) {
    return Truffle.getRuntime().createCallTarget(new LoopRootNode(source, null));
}
 

@Override
protected CallTarget parse(ParsingRequest request) {
    ExpressionNode expression = new ParserAntlr().parse(request.getSource());
    GrCUDARootNode newParserRoot = new GrCUDARootNode(this, expression);
    return Truffle.getRuntime().createCallTarget(newParserRoot);
}
 

public ConcurrentHashMap<Class<?>, CallTarget> getMapCallTargets() {
    return uncachedMapCallTargets;
}
 

protected CallTarget parse(String id, String code, HashemContext context) {
    final Source source = Source.newBuilder(id, code, "(eval)").build();
    return context.parse(source);
}