#include "config.h"
#include "Threading.h"
#include "dtoa.h"
#include "dtoa/cached-powers.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <wtf/DateMath.h>
#include <wtf/PrintStream.h>
#include <wtf/RandomNumberSeed.h>
#include <wtf/ThreadHolder.h>
#include <wtf/ThreadMessage.h>
#include <wtf/ThreadingPrimitives.h>
#include <wtf/WTFThreadData.h>
#include <wtf/text/StringView.h>
#if HAVE(QOS_CLASSES)
#include <bmalloc/bmalloc.h>
#endif
namespace WTF {
struct NewThreadContext {
WTF_MAKE_FAST_ALLOCATED;
public:
const char* name;
Function<void()> entryPoint;
Mutex creationMutex;
};
const char* Thread::normalizeThreadName(const char* threadName)
{
#if HAVE(PTHREAD_SETNAME_NP)
return threadName;
#else
StringView result(threadName);
size_t size = result.reverseFind('.');
if (size != notFound)
result = result.substring(size + 1);
#if OS(WINDOWS)
constexpr const size_t kVisualStudioThreadNameLimit = 32 - 1;
if (result.length() > kVisualStudioThreadNameLimit)
result = result.right(kVisualStudioThreadNameLimit);
#elif OS(LINUX)
constexpr const size_t kLinuxThreadNameLimit = 16 - 1;
if (result.length() > kLinuxThreadNameLimit)
result = result.right(kLinuxThreadNameLimit);
#endif
ASSERT(result.characters8()[result.length()] == '\0');
return reinterpret_cast<const char*>(result.characters8());
#endif
}
static void threadEntryPoint(void* contextData)
{
NewThreadContext* context = static_cast<NewThreadContext*>(contextData);
{
MutexLocker locker(context->creationMutex);
}
Thread::initializeCurrentThreadInternal(context->name);
auto entryPoint = WTFMove(context->entryPoint);
delete context;
entryPoint();
}
RefPtr<Thread> Thread::create(const char* name, Function<void()>&& entryPoint)
{
NewThreadContext* context = new NewThreadContext { name, WTFMove(entryPoint), { } };
MutexLocker locker(context->creationMutex);
return Thread::createInternal(threadEntryPoint, context, name);
}
void Thread::didExit()
{
std::lock_guard<std::mutex> locker(m_mutex);
m_didExit = true;
}
void Thread::setCurrentThreadIsUserInteractive(int relativePriority)
{
#if HAVE(QOS_CLASSES)
ASSERT(relativePriority <= 0);
ASSERT(relativePriority >= QOS_MIN_RELATIVE_PRIORITY);
pthread_set_qos_class_self_np(adjustedQOSClass(QOS_CLASS_USER_INTERACTIVE), relativePriority);
#else
UNUSED_PARAM(relativePriority);
#endif
}
void Thread::setCurrentThreadIsUserInitiated(int relativePriority)
{
#if HAVE(QOS_CLASSES)
ASSERT(relativePriority <= 0);
ASSERT(relativePriority >= QOS_MIN_RELATIVE_PRIORITY);
pthread_set_qos_class_self_np(adjustedQOSClass(QOS_CLASS_USER_INITIATED), relativePriority);
#else
UNUSED_PARAM(relativePriority);
#endif
}
#if HAVE(QOS_CLASSES)
static qos_class_t globalMaxQOSclass { QOS_CLASS_UNSPECIFIED };
void Thread::setGlobalMaxQOSClass(qos_class_t maxClass)
{
bmalloc::api::setScavengerThreadQOSClass(maxClass);
globalMaxQOSclass = maxClass;
}
qos_class_t Thread::adjustedQOSClass(qos_class_t originalClass)
{
if (globalMaxQOSclass != QOS_CLASS_UNSPECIFIED)
return std::min(originalClass, globalMaxQOSclass);
return originalClass;
}
#endif
void Thread::dump(PrintStream& out) const
{
out.print(m_id);
}
void initializeThreading()
{
static std::once_flag initializeKey;
std::call_once(initializeKey, [] {
ThreadHolder::initializeOnce();
StringImpl::empty();
initializeRandomNumberGenerator();
wtfThreadData();
initializeDates();
Thread::initializePlatformThreading();
});
}
}