Re: RFR: 8003246: Add Supplier to ThreadLocal

[Remi Forax]

On 12/06/2012 09:38 PM, Peter Levart wrote:
On 12/06/2012 08:08 PM, Remi Forax wrote:
On 12/06/2012 08:01 PM, Peter Levart wrote:
There's a quick trick that guarantees in-lining of get/set/remove:
    public static class FastThreadLocal<T> extends ThreadLocal<T> {
        @Override
        public final T get() { return super.get(); }

        @Override
        public final void set(T value) { super.set(value); }

        @Override
        public final void remove() { super.remove(); }
    }

....just use static type FastThreadLocal everywhere in code.

I tried it and it works.

No, there is no way to have such guarantee, here, it works either 
because the only class ThreadLocal you load is FastThreadLocal or 
because the VM has profiled the callsite see that you only use 
FastThreadLocal for a specific instruction.

Nothing is certain but death and taxes, I agree.

But think deeper, Remi!

I try, i try, i've trouble to understand what you mean


How do you explain the following test:

public class ThreadLocalTest {

    static class Int { int value; }

    static class TL0 extends ThreadLocal<Int> {}
    static class TL1 extends ThreadLocal<Int> { public Int get() { 
return super.get(); } }
    static class TL2 extends ThreadLocal<Int> { public Int get() { 
return super.get(); } }
    static class TL3 extends ThreadLocal<Int> { public Int get() { 
return super.get(); } }
    static class TL4 extends ThreadLocal<Int> { public Int get() { 
return super.get(); } }

    static long doTest(ThreadLocal<Int> tl) {
        long t0 = System.nanoTime();
        for (int i = 0; i < 100000000; i++)
            tl.get().value++;                                 // 
callsite 1
        return System.nanoTime() - t0;
    }

here, tl.get() (callsite 1) is called with TL0, TL1, TL2, TL3 and TL4, 
do tl.get() is a polymorphic call


    static long doTest(FastThreadLocal<Int> tl) {
        long t0 = System.nanoTime();
        for (int i = 0; i < 100000000; i++)
            tl.get().value++; // callsite 2
        return System.nanoTime() - t0;
    }

if TL0 is defined like as a FastThreadLocal. doTest is called and here 
tl.get() (callsite 2) is only called with a FastThreadLocal, so the call 
is inlined.


    static long test0(ThreadLocal<Int> tl) {
        if (tl instanceof FastThreadLocal)
            return doTest((FastThreadLocal<Int>)tl);
        else
            return doTest(tl);
    }

    static void test(ThreadLocal<Int> tl) {
        tl.set(new Int());
        System.out.print(tl.getClass().getName() + ":");
        for (int i = 0; i < 8; i++)
            System.out.print(" " + test0(tl));
        System.out.println();
    }

    public static void main(String[] args) {
        TL0 tl0 = new TL0();
        test(tl0);
        test(new TL1());
        test(new TL2());
        test(new TL3());
        test(new TL4());
        test(tl0);
    }
}


Which prints the following (demonstrating almost 2x slowdown of TL0 - 
last line compared to first):

test.ThreadLocalTest$TL0: 342716421 326105315 300744544 300654890 
300726346 300752009 300700781 300735651
test.ThreadLocalTest$TL1: 321424139 312128166 312173383 312125203 
312142144 312150949 316760957 313393554
test.ThreadLocalTest$TL2: 525661886 524169413 524184405 524215685 
524162050 524400364 524174966 454370228
test.ThreadLocalTest$TL3: 472042229 471071328 464387909 468047355 
464795171 464466481 464449567 464365974
test.ThreadLocalTest$TL4: 459651686 454142365 454129481 454180718 
454217277 454109611 454119988 456978405
test.ThreadLocalTest$TL0: 582252322 582773455 582612509 582753610 
582626360 582852195 582805654 582598285

Now with a simple change of:

    static class TL0 extends FastThreadLocal<Int> {}

...the same test prints:

test.ThreadLocalTest$TL0: 330722181 325823711 301171182 309992192 
321868979 308111417 303806979 300612033
test.ThreadLocalTest$TL1: 330263857 326448062 300607081 300575641 
307442821 300616794 300548457 303462898
test.ThreadLocalTest$TL2: 319627165 311309477 311465815 311279612 
311294427 311315803 311470291 311293823
test.ThreadLocalTest$TL3: 526849874 524209792 524421574 524166747 
524396011 524163313 524395641 524165429
test.ThreadLocalTest$TL4: 464963126 455172216 455466304 455245487 
455368318 455093735 455125038 455317375
test.ThreadLocalTest$TL0: 300472239 300695398 300480230 303459397 
300451419 300679904 300445717 300451166


And that's very repeatable! Try it for yourself (on JDK8 of course).

Regards, Peter

so to summarize, the tl.get() in doTest(ThreadLocal) is polymorphic and 
the one in doTest(FastThreadLocal) is monomorphic thus inlinable.
It has nothing to do with the fact that FastThreadLocal override get, 
set and remove.
You can comment the methods inside FastThreadLocal to see that it change 
nothing.

regards,
Rémi