1/* 2 * Copyright (C) 2008, 2009 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 17 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26#include "config.h" 27#include "Threading.h" 28 29#include <string.h> 30 31namespace WTF { 32 33struct NewThreadContext { 34 WTF_MAKE_FAST_ALLOCATED; 35public: 36 NewThreadContext(ThreadFunction entryPoint, void* data, const char* name) 37 : entryPoint(entryPoint) 38 , data(data) 39 , name(name) 40 { 41 } 42 43 ThreadFunction entryPoint; 44 void* data; 45 const char* name; 46 47 Mutex creationMutex; 48}; 49 50static void threadEntryPoint(void* contextData) 51{ 52 NewThreadContext* context = reinterpret_cast<NewThreadContext*>(contextData); 53 54 // Block until our creating thread has completed any extra setup work, including 55 // establishing ThreadIdentifier. 56 { 57 MutexLocker locker(context->creationMutex); 58 } 59 60 initializeCurrentThreadInternal(context->name); 61 62 // Grab the info that we need out of the context, then deallocate it. 63 ThreadFunction entryPoint = context->entryPoint; 64 void* data = context->data; 65 delete context; 66 67 entryPoint(data); 68} 69 70ThreadIdentifier createThread(ThreadFunction entryPoint, void* data, const char* name) 71{ 72 // Visual Studio has a 31-character limit on thread names. Longer names will 73 // be truncated silently, but we'd like callers to know about the limit. 74#if !LOG_DISABLED && PLATFORM(WIN) 75 if (name && strlen(name) > 31) 76 LOG_ERROR("Thread name \"%s\" is longer than 31 characters and will be truncated by Visual Studio", name); 77#endif 78 79 NewThreadContext* context = new NewThreadContext(entryPoint, data, name); 80 81 // Prevent the thread body from executing until we've established the thread identifier. 82 MutexLocker locker(context->creationMutex); 83 84 return createThreadInternal(threadEntryPoint, context, name); 85} 86 87void setCurrentThreadIsUserInteractive() 88{ 89#if HAVE(QOS_CLASSES) 90 pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0); 91#endif 92} 93 94void setCurrentThreadIsUserInitiated() 95{ 96#if HAVE(QOS_CLASSES) 97 pthread_set_qos_class_self_np(QOS_CLASS_USER_INITIATED, 0); 98#endif 99} 100 101#if PLATFORM(MAC) || PLATFORM(WIN) 102 103// For ABI compatibility with Safari on Mac / Windows: Safari uses the private 104// createThread() and waitForThreadCompletion() functions directly and we need 105// to keep the old ABI compatibility until it's been rebuilt. 106 107typedef void* (*ThreadFunctionWithReturnValue)(void* argument); 108 109WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data, const char* name); 110 111struct ThreadFunctionWithReturnValueInvocation { 112 ThreadFunctionWithReturnValueInvocation(ThreadFunctionWithReturnValue function, void* data) 113 : function(function) 114 , data(data) 115 { 116 } 117 118 ThreadFunctionWithReturnValue function; 119 void* data; 120}; 121 122static void compatEntryPoint(void* param) 123{ 124 // Balanced by .release() in createThread. 125 auto invocation = std::unique_ptr<ThreadFunctionWithReturnValueInvocation>(static_cast<ThreadFunctionWithReturnValueInvocation*>(param)); 126 invocation->function(invocation->data); 127} 128 129ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data, const char* name) 130{ 131 auto invocation = std::make_unique<ThreadFunctionWithReturnValueInvocation>(entryPoint, data); 132 133 // Balanced by std::unique_ptr constructor in compatEntryPoint. 134 return createThread(compatEntryPoint, invocation.release(), name); 135} 136 137WTF_EXPORT_PRIVATE int waitForThreadCompletion(ThreadIdentifier, void**); 138 139int waitForThreadCompletion(ThreadIdentifier threadID, void**) 140{ 141 return waitForThreadCompletion(threadID); 142} 143 144// This function is deprecated but needs to be kept around for backward 145// compatibility. Use the 3-argument version of createThread above. 146 147WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data); 148 149ThreadIdentifier createThread(ThreadFunctionWithReturnValue entryPoint, void* data) 150{ 151 auto invocation = std::make_unique<ThreadFunctionWithReturnValueInvocation>(entryPoint, data); 152 153 // Balanced by adoptPtr() in compatEntryPoint. 154 return createThread(compatEntryPoint, invocation.release(), 0); 155} 156#endif 157 158} // namespace WTF 159