[Oilpan] Set stack limit using estimated sizes

Source/platform/heap/StackFrameDepth.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/heap/StackFrameDepth.h"
 
 #include "public/platform/Platform.h"
 
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
 #elif defined(__GLIBC__)
 extern "C" void* __libc_stack_end;  // NOLINT
 #endif
 
 namespace blink {
 
+const int StackFrameDepth::kStackRoomSize = 1024;
 static const char* s_avoidOptimization = nullptr;
 
 // NEVER_INLINE ensures that |dummy| array on configureLimit() is not optimized away,
 // and the stack frame base register is adjusted |kSafeStackFrameSize|.
 NEVER_INLINE static uintptr_t currentStackFrameBaseOnCallee(const char* dummy)
 {
     s_avoidOptimization = dummy;
     return StackFrameDepth::currentStackFrame();
 }
 
 void StackFrameDepth::configureLimit()

[haraken, 2015/02/10 08:53:22]

Can we avoid calling getUnderestimatedStackSize() and getStackStart() in each
configureLimit()? (configureLimit() is called at each marking.)

[peria, 2015/02/10 12:05:29]

The instance of StackFrameDepth is globally unique instance, and StackFrames are
different on each thread.
So we have to set limit everytime on calling recursive functions.

To avoid calling configureLimit(), we have to make StackFrameDepth be a member
value of ThreadState. (TODO)

 {
+    size_t stackSize = getUnderestimatedStackSize();

[haraken, 2015/02/10 08:53:22]

Note: You can add RELEASE_ASSERT(stackSize >= 128 * 1024) and run various try
bots. Then you can understand on which platform/tests a reasonable stack size is
not available.

[peria, 2015/02/10 12:05:28]

Acknowledged.

[haraken, 2015/02/10 12:15:09]

Would you try this before landing this CL? We might want to understand on which
platform we can get the stack size and we can make the system workable as
expected.

[peria, 2015/02/12 02:31:58]

Trying in https://codereview.chromium.org/918883003/

+    if (stackSize) {
+        m_stackFrameLimit = reinterpret_cast<uintptr_t>(getStackStart()) - stackSize + kStackRoomSize;
+        return;
+    }
+
+    // Fallback version
     // Allocate a large object in stack and query stack frame pointer after it.
     char dummy[kSafeStackFrameSize];
     m_stackFrameLimit = currentStackFrameBaseOnCallee(dummy);
 
     // Assert that the stack frame can be used.
     dummy[sizeof(dummy) - 1] = 0;
 }
 
 size_t StackFrameDepth::getUnderestimatedStackSize()
 {
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
-    // We cannot get the stack size in these platforms because
-    // pthread_getattr_np() can fail for the main thread.
-    // This is OK because ThreadState::current() doesn't use the stack size
-    // in these platforms.

[haraken, 2015/02/10 08:53:22]

Update this comment instead of removing.

[peria, 2015/02/10 12:05:28]

Done.

+    pthread_attr_t attr;
+    int error;
+#if OS(FREEBSD)
+    pthread_attr_init(&attr);
+    error = pthread_attr_get_np(pthread_self(), &attr);
+#else
+    error = pthread_getattr_np(pthread_self(), &attr);
+#endif
+    if (!error) {
+        void* base;
+        size_t size;
+        error = pthread_attr_getstack(&attr, &base, &size);
+        RELEASE_ASSERT(!error);
+        pthread_attr_destroy(&attr);
+        return size;
+    }
+#if OS(FREEBSD)
+    pthread_attr_destroy(&attr);
+#endif
+
     return 0;
 #elif OS(MACOSX)
     return pthread_get_stacksize_np(pthread_self());
 #elif OS(WIN) && COMPILER(MSVC)
     // On Windows stack limits for the current thread are available in
     // the thread information block (TIB). Its fields can be accessed through
     // FS segment register on x86 and GS segment register on x86_64.
 #ifdef _WIN64
     return __readgsqword(offsetof(NT_TIB64, StackBase)) - __readgsqword(offsetof(NT_TIB64, StackLimit));
 #else
     return __readfsdword(offsetof(NT_TIB, StackBase)) - __readfsdword(offsetof(NT_TIB, StackLimit));
 #endif
 #else
+#error "Stack frame size estimation not supported on this platform."
     return 0;
 #endif
 }
 
 void* StackFrameDepth::getStackStart()
 {
 #if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
     pthread_attr_t attr;
     int error;
 #if OS(FREEBSD)
@@ skipping 33 matching lines @@
     return reinterpret_cast<void*>(__readgsqword(offsetof(NT_TIB64, StackBase)));
 #else
     return reinterpret_cast<void*>(__readfsdword(offsetof(NT_TIB, StackBase)));
 #endif
 #else
 #error Unsupported getStackStart on this platform.
 #endif
 }
 
 } // namespace blink