Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.runtime.callsite;
  
 
 public abstract class CachingCallSite extends CallSite {
     protected CacheEntry cache = .;
     public static volatile int totalCallSites;
 //    private AtomicBoolean isPolymorphic = new AtomicBoolean(false);
 
     public CachingCallSite(String methodNameCallType callType) {
         super(methodNamecallType);
         ++;
     }
 
     public CacheEntry getCache() {
         return ;
     }
 
     public boolean isOptimizable() {
         return getCache() != .;// && !isPolymorphic.get();
     }
 
     public int getCachedClassIndex() {
         CacheEntry cacheEntry = getCache();
         if (cacheEntry != .) {
             return cacheEntry.method.getImplementationClass().;
         }
         return .;
     }
 
     public String getMethodName() {
         return ;
     }
 
     public long getCachedMethodSerial() {
         CacheEntry cacheEntry = getCache();
         if (cacheEntry != .) {
             return cacheEntry.method.getSerialNumber();
         }
         return -1;
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selflong fixnum) {
         return call(contextcallerself, RubyFixnum.newFixnum(context.runtimefixnum));
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfdouble flote) {
         return call(contextcallerself, RubyFloat.newFloat(context.runtimeflote));
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject... args) {
         RubyClass selfType = pollAndGetClass(contextself);
         CacheEntry myCache = ;
         if (CacheEntry.typeOk(myCacheselfType)) {
             return myCache.method.call(contextselfselfTypeargs);
         }
         return cacheAndCall(callerselfTypeargscontextself);
     }
 
     private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         RubyClass selfType = pollAndGetClass(contextself);
         CacheEntry myCache = ;
         if (CacheEntry.typeOk(myCacheselfType)) {
             return myCache.method.call(contextselfselfTypeargsblock);
         }
         return cacheAndCall(callerselfTypeblockargscontextself);
     }
 
     public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         return callBlock(contextcallerselfargsblock);
     }
 
     public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
         try {
             return callBlock(contextcallerselfargsblock);
         } catch (JumpException.BreakJump bj) {
             return handleBreakJump(contextbj);
         } catch (JumpException.RetryJump rj) {
             throw retryJumpError(context);
         } finally {
             block.escape();
         }
     }
 
    public IRubyObject callVarargs(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject... args) {
        switch (args.length) {
            case 0: return call(contextcallerself);
            case 1: return call(contextcallerselfargs[0]);
            case 2: return call(contextcallerselfargs[0], args[1]);
            case 3: return call(contextcallerselfargs[0], args[1], args[2]);
            defaultreturn call(contextcallerselfargs);
        }
    }
    public IRubyObject callVarargs(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
        switch (args.length) {
            case 0: return call(contextcallerselfblock);
            case 1: return call(contextcallerselfargs[0], block);
            case 2: return call(contextcallerselfargs[0], args[1], block);
            case 3: return call(contextcallerselfargs[0], args[1], args[2], block);
            defaultreturn call(contextcallerselfargsblock);
        }
    }
    public IRubyObject callVarargsIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject[] argsBlock block) {
        switch (args.length) {
            case 0: return callIter(contextcallerselfblock);
            case 1: return callIter(contextcallerselfargs[0], block);
            case 2: return callIter(contextcallerselfargs[0], args[1], block);
            case 3: return callIter(contextcallerselfargs[0], args[1], args[2], block);
            defaultreturn callIter(contextcallerselfargsblock);
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject self) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfType);
        }
        return cacheAndCall(callerselfTypecontextself);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypeblock);
        }
        return cacheAndCall(callerselfTypeblockcontextself);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        return callBlock(contextcallerselfblock);
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfBlock block) {
        try {
            return callBlock(contextcallerselfblock);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1);
        }
        return cacheAndCall(callerselfTypecontextselfarg1);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfarg1);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        return callBlock(contextcallerselfarg1block);
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1Block block) {
        try {
            return callBlock(contextcallerselfarg1block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1arg2);
        }
        return cacheAndCall(callerselfTypecontextselfarg1arg2);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1arg2block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfarg1arg2);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        return callBlock(contextcallerselfarg1arg2block);
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1arg2arg3);
        }
        return cacheAndCall(callerselfTypecontextselfarg1arg2arg3);
    }
    private IRubyObject callBlock(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        RubyClass selfType = pollAndGetClass(contextself);
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache.method.call(contextselfselfTypearg1arg2arg3block);
        }
        return cacheAndCall(callerselfTypeblockcontextselfarg1arg2arg3);
    }
    public IRubyObject call(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        return callBlock(contextcallerselfarg1arg2arg3block);
    }
    public IRubyObject callIter(ThreadContext contextIRubyObject callerIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3Block block) {
        try {
            return callBlock(contextcallerselfarg1arg2arg3block);
        } catch (JumpException.BreakJump bj) {
            return handleBreakJump(contextbj);
        } catch (JumpException.RetryJump rj) {
            throw retryJumpError(context);
        } finally {
            block.escape();
        }
    }
    public CacheEntry retrieveCache(RubyClass selfTypeString methodName) {
        CacheEntry myCache = ;
        if (CacheEntry.typeOk(myCacheselfType)) {
            return myCache;
        }
        return cacheAndGet(selfTypemethodName);
    }
    private CacheEntry cacheAndGet(RubyClass selfTypeString methodName) {
        CacheEntry entry = selfType.searchWithCache(methodName);
        return  = entry;
    }
    
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockIRubyObject[] argsThreadContext contextIRubyObject self) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodargsblock);
        }
        updateCache(entry);
        return method.call(contextselfselfTypeargsblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeIRubyObject[] argsThreadContext contextIRubyObject self) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodargs);
        }
        updateCache(entry);
        return method.call(contextselfselfTypeargs);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject self) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethod);
        }
        updateCache(entry);
        return method.call(contextselfselfType);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject self) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodblock);
        }
        updateCache(entry);
        return method.call(contextselfselfTypeblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfIRubyObject arg) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodarg);
        }
        updateCache(entry);
        return method.call(contextselfselfTypearg);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfIRubyObject arg) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodargblock);
        }
        updateCache(entry);
        return method.call(contextselfselfTypeargblock);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfIRubyObject arg1IRubyObject arg2) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodarg1arg2);
        }
        updateCache(entry);
        return method.call(contextselfselfTypearg1arg2);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfIRubyObject arg1IRubyObject arg2) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodarg1arg2block);
        }
        updateCache(entry);
        return method.call(contextselfselfTypearg1arg2block);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeThreadContext contextIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodarg1arg2arg3);
        }
        updateCache(entry);
        return method.call(contextselfselfTypearg1arg2arg3);
    }
    protected IRubyObject cacheAndCall(IRubyObject callerRubyClass selfTypeBlock blockThreadContext contextIRubyObject selfIRubyObject arg1IRubyObject arg2IRubyObject arg3) {
        CacheEntry entry = selfType.searchWithCache();
        DynamicMethod method = entry.method;
        if (methodMissing(methodcaller)) {
            return callMethodMissing(contextselfmethodarg1arg2arg3block);
        }
        updateCache(entry);
        return method.call(contextselfselfTypearg1arg2arg3block);
    }
    protected void updateCache(CacheEntry newEntry) {
        // not really working because it flags jitted methods as polymorphic
//        CacheEntry oldCache = cache;
//        if (oldCache != CacheEntry.NULL_CACHE && oldCache.method != newEntry.method) {
//            isPolymorphic.set(true);
//        }
         = newEntry;
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject[] args) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), args.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod method) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), .);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodBlock block) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject[] argsBlock block) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), argsblock);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg0Block block) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg0block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg0IRubyObject arg1) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg0arg1.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg0IRubyObject arg1Block block) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg0arg1block);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg0IRubyObject arg1IRubyObject arg2) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg0arg1arg2.);
    }
    protected IRubyObject callMethodMissing(ThreadContext contextIRubyObject selfDynamicMethod methodIRubyObject arg0IRubyObject arg1IRubyObject arg2Block block) {
        return RuntimeHelpers.selectMethodMissing(contextselfmethod.getVisibility(), ).call(contextselfself.getMetaClass(), arg0arg1arg2block);
    }
    protected abstract boolean methodMissing(DynamicMethod methodIRubyObject caller);
    private static RubyClass pollAndGetClass(ThreadContext contextIRubyObject self) {
        ThreadContext.callThreadPoll(context);
        // the cast in the following line is necessary due to lacking optimizations in Hotspot
        RubyClass selfType = ((RubyBasicObject)self).getMetaClass();
        return selfType;
    }
    private static IRubyObject handleBreakJump(ThreadContext contextBreakJump bjthrows BreakJump {
        if (context.getFrameJumpTarget() == bj.getTarget()) {
            return (IRubyObjectbj.getValue();
        }
        throw bj;
    }
    private static RaiseException retryJumpError(ThreadContext context) {
        return context.runtime.newLocalJumpError(..context.runtime.getNil(), "retry outside of rescue not supported");
    }
New to GrepCode? Check out our FAQ X