Java Specialization类代码示例

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = {"function.getArity() < arguments.length"})
public Object doOver(VirtualFrame frame, Function function, Object[] arguments,
                     @Cached("createDispatchNode()") DispatchNode dispatchNode) {
    int argIndex = 0;

    while (function.getArity() < arguments.length-argIndex) {
        Object[] argumentValues = Arrays.copyOfRange(arguments, argIndex, argIndex+function.getArity());

        argIndex += function.getArity();
        function = (Function) call(dispatchNode, frame, function, function.packArguments(argumentValues), false);
    }

    Object[] remainingArguments = Arrays.copyOfRange(arguments, argIndex, arguments.length);

    if (function.getArity() > remainingArguments.length) {
        return function.curry(remainingArguments);
    } else {
        return call(dispatchNode, frame, function, function.packArguments(remainingArguments));
    }
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = {"needsBindings()"})
public Bindings createBindings(
  VirtualFrame frame,
  @Cached("createGetBindingsNode()") GetBindingsNode getBindingsNode,
  @Cached(value = "createFetchers()", dimensions = 1) Fetcher[] fetchers
) {
  Bindings ownBindings = getBindingsNode.executeGetBindings(frame);
  Bindings bindings = new Bindings();
  if (fetchers.length > 0) {
    MaterializedFrame materializedFrame = frame.materialize();
    for (Fetcher fetcher : fetchers) {
      String name = fetcher.getName();
      Binding binding = fetcher.fetch(materializedFrame, ownBindings);
      bindings.add(name, binding);
    }
  }
  return bindings;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization
public SLFunction callUntilCompiled(SLFunction function, boolean checkTarget) {
    OptimizedCallTarget target = ((OptimizedCallTarget) function.getCallTarget());
    for (int i = 0; i < MAX_CALLS; i++) {
        if (isCompiling(target)) {
            break;
        } else {
            indirectCall.call(target, EMPTY_ARGS);
        }
    }

    // call one more in compiled
    indirectCall.call(target, EMPTY_ARGS);

    if (checkTarget) {
        checkTarget(target);
    }

    return function;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = "arr.isDoubleType()")
public final SArray doDoubleArray(final SArray arr, final SBlock block) {
  double[] storage = arr.getDoubleStorage(storageType);
  int length = storage.length;
  try {
    if (SArray.FIRST_IDX < length) {
      execBlock(block, storage[SArray.FIRST_IDX]);
    }
    for (long i = SArray.FIRST_IDX + 1; i < length; i++) {
      execBlock(block, storage[(int) i]);
    }
  } finally {
    if (CompilerDirectives.inInterpreter()) {
      SomLoop.reportLoopCount(length, this);
    }
  }
  return arr;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = {"isResultUsed()", "!isFarRefRcvr(args)", "!isPromiseRcvr(args)"})
public final SPromise toNearRefWithResultPromise(final Object[] args) {
  Actor current = EventualMessage.getActorCurrentMessageIsExecutionOn();

  SPromise result = SPromise.createPromise(current,
      false, promiseResolutionBreakpoint.executeShouldHalt(), source);
  SResolver resolver = SPromise.createResolver(result);

  DirectMessage msg = new DirectMessage(current, selector, args, current,
      resolver, onReceive,
      messageReceiverBreakpoint.executeShouldHalt(),
      promiseResolverBreakpoint.executeShouldHalt());

  if (VmSettings.ACTOR_TRACING) {
    ActorExecutionTrace.sendOperation(SendOp.ACTOR_MSG, msg.getMessageId(),
        current.getId());
  }
  current.send(msg, actorPool);

  return result;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(replaces = "doCachedWithoutArgArr", guards = "argsArr == null")
@TruffleBoundary
public Object doUncached(final Object receiver, final SSymbol selector,
    final Object argsArr,
    @Cached("create()") final IndirectCallNode call) {
  SClass rcvrClass = Types.getClassOf(receiver);
  Dispatchable invokable = rcvrClass.lookupMessage(selector, AccessModifier.PUBLIC);

  Object[] arguments = {receiver};
  if (invokable != null) {
    return invokable.invoke(call, arguments);
  } else {
    return GenericDispatchNode.performDnu(arguments, receiver,
        rcvrClass, selector, call);
  }
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(contains = {"readLong", "readBoolean"})
protected Object readObject(VirtualFrame frame) {
    if (!frame.isObject(getSlot())) {
        CompilerDirectives.transferToInterpreter();
        Object result = frame.getValue(getSlot());
        frame.setObject(getSlot(), result);
        return result;
    }

    return FrameUtil.getObjectSafe(frame, getSlot());
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = "isLongOrIllegal(frame)")
protected long writeLong(VirtualFrame frame, long value) {
    getSlot().setKind(FrameSlotKind.Long);

    frame.setLong(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(guards = "isBooleanOrIllegal(frame)")
protected boolean writeBoolean(VirtualFrame frame, boolean value) {
    getSlot().setKind(FrameSlotKind.Boolean);

    frame.setBoolean(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(contains = {"writeLong", "writeBoolean"})
protected Object write(VirtualFrame frame, Object value) {
    getSlot().setKind(FrameSlotKind.Object);

    frame.setObject(getSlot(), value);
    return value;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(contains = { "readLong", "readDouble", "readObject" })
protected Object read(VirtualFrame virtualFrame) {
    try {
        return this.readUpStack(Frame::getValue, virtualFrame);
    } catch (FrameSlotTypeException e) {
        // FrameSlotTypeException not thrown
    }
    return null;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(limit = "INLINE_CACHE_SIZE",
                guards = "callTarget == cachedCallTarget")
public static Object doDirect(VirtualFrame frame, CallTarget callTarget, Object[] arguments,
                       @Cached("callTarget") CallTarget cachedCallTarget,
                       @Cached("create(cachedCallTarget)") DirectCallNode callNode) {
    return callNode.call(arguments);
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization(rewriteOn = FrameSlotTypeException.class)
@CompilerDirectives.TruffleBoundary
public Closeable open(String path, Symbol direction) throws FrameSlotTypeException {
    File file = new File(path);
    if (!file.isAbsolute()) {
        MaterializedFrame globals = this.getContext().getGlobalFrame();
        FrameSlot homeDirectorySlot = globals.getFrameDescriptor().findFrameSlot("*home-directory*");
        String homeDirectory = (String) globals.getObject(homeDirectorySlot);
        file = new File(homeDirectory, path);
        //throw new RuntimeException("not implemented");
    }

    //System.out.println(file.getAbsoluteFile());

    try {
        switch (direction.getName()) {
            case "in":
                return new BufferedInputStream(new FileInputStream(file));
            case "out":
                return new BufferedOutputStream(new FileOutputStream(file));
        }
    } catch (FileNotFoundException e) {
        throw new RuntimeException("file not found:" + e);
    }

    throw new IllegalArgumentException("invalid direction");
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization
public Object close(Closeable stream) {
    try {
        stream.close();
    } catch (IOException e) {
        throw new RuntimeException("error closing stream:" + e);
    }
    // TODO: empty list?
    return null;
}
 

import com.oracle.truffle.api.dsl.Specialization; //导入依赖的package包/类
@Specialization
public long writeByte(long value, OutputStream stream) {
    try {
        stream.write((int) value);
        stream.flush();
        return value;
    } catch (IOException e) {
        throw new RuntimeException("write-byte: " + e);
    }
}