[oilpan] Remove ThreadAffinity::MainThreadOnly

Source/heap/ThreadState.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 typedef const uint8_t* ConstAddress;
 
 enum ThreadAffinity {
     AnyThread,
     MainThreadOnly,
 };
 
 // By default all types are considered to be used on the main thread only.
 template<typename T>
 struct ThreadingTrait {
-    static const ThreadAffinity Affinity = MainThreadOnly;
+    static const ThreadAffinity Affinity = AnyThread;
 };
 
 // Marks specified class as requiring thread safe handles which can be used from any thread.
 // Notice that marking base class does not automatically mark its descendants and they
 // have to be explicitly marked.
 #define REQUIRE_THREADSAFE_HANDLES(Class)                 \
     class Class;                                          \
     template<> struct ThreadingTrait<Class> {             \
         static const ThreadAffinity Affinity = AnyThread; \
     }
@@ skipping 152 matching lines @@
         m_endOfStack = endOfStack;
     }
 
     static void visitRoots(Visitor*);
     static void init(intptr_t* startOfStack);
     static void shutdown();
 
     static void attach(intptr_t* startOfStack);
     static void detach();
 
-    static ThreadState* Current() { return **s_threadSpecific; }
+    static ThreadState* Current()
+    {
+        intptr_t dummy;
+        if (LIKELY(s_mainThreadStackTop < &dummy && &dummy <= s_mainThreadStackBottom))

[haraken, 2013/12/12 06:33:47]

Of a couple of approaches I have tried, this is the best approach in terms of
performance.

In Linux, I cannot observe any regression in Dromaeo:

dom-attr: 1056 => 1057 runs/sec
dom-modify: 537 => 526 runs/sec
dom-query: 28458 => 28285 runs/sec
dom-traverse: 649 => 654 runs/sec

We might observe a bit regression in Windows because MSVC doesn't make
optimization for LIKELY.

[Mads Ager (chromium), 2013/12/12 06:51:56]

I find this rather nasty. It is probably true that there is always 64k of stack
space below the initial point but it is a magic number. Also, it means that on
the main thread you all of a sudden start going through thread-local storage if
you recurse very deeply. Can you share the numbers if you always to through
thread-local storage. I would prefer if we can either know precisely that we are
on the main thread or always go through thread-local storage.

+            return MainThreadState();
+        return **s_threadSpecific;
+    }
     static ThreadState* MainThreadState() { return &s_mainThreadState; }
     static bool IsMainThread() { return Current() == MainThreadState(); }
 
     static void stopThreads(StackState);
     static void resumeThreads();
 
     void safePoint();
 
     class SafePointScope {
     public:
@@ skipping 28 matching lines @@
     protected:
         void onInterrupted();
     };
 
     void setInterruptor(Interruptor*);
 
     // Should only be called under protection of threadAttachMutex().
     Interruptor* interruptor() const { return m_interruptor; }
 
 private:
+    static intptr_t* s_mainThreadStackBottom;
+    static intptr_t* s_mainThreadStackTop;
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static ThreadState s_mainThreadState;
     static SafePointBarrier* s_safePointBarrier;
     // This variable is flipped to true after all threads are stoped and outermost GC has started.
     static bool s_inGC;
 
     void create(intptr_t* startOfStack);
     void destroy();
     void trace(Visitor*);
     bool pointersOnStack() const { return m_stackState == HeapPointersOnStack; }
@@ skipping 106 matching lines @@
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Int32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Uint32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Float32Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WTF, Float64Array);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBCallbacksProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBDatabaseBackendProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBDatabaseCallbacksProxy);
 REQUIRE_THREADSAFE_HANDLES_WITH_NAMESPACE(WebKit, IDBFactoryBackendProxy);
 
 #endif