AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[cleanup] Move ThreadId to separate source file

Browse Source 
and make it Isolate-independent.

Bug: v8:8238
Change-Id: I23faae87c302d24877ef001873f673d4a1cdd327
Reviewed-on: https://chromium-review.googlesource.com/c/1301484
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57066}
This commit is contained in:
Igor Sheludko 2018-10-26 17:32:22 +02:00 committed by Commit Bot
parent 0ccaa2fd4d
commit 72e6c758c3
5 changed files with 125 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.gn
View File

@ -2532,6 +2532,8 @@ v8_source_set("v8_base") {
"src/strtod.cc",
"src/strtod.h",
"src/third_party/utf8-decoder/utf8-decoder.h",
"src/thread-id.cc",
"src/thread-id.h",
"src/torque-assembler.h",
"src/tracing/trace-event.cc",
"src/tracing/trace-event.h",

24
src/isolate.cc
View File

@ -87,8 +87,6 @@ namespace internal {
#define TRACE_ISOLATE(tag)
#endif
base::Atomic32 ThreadId::highest_thread_id_ = 0;
extern const uint8_t* DefaultEmbeddedBlob();
extern uint32_t DefaultEmbeddedBlobSize();
@ -140,21 +138,6 @@ uint32_t Isolate::CurrentEmbeddedBlobSize() {
std::memory_order::memory_order_relaxed);
}
int ThreadId::AllocateThreadId() {
int new_id = base::Relaxed_AtomicIncrement(&highest_thread_id_, 1);
return new_id;
}
int ThreadId::GetCurrentThreadId() {
int thread_id = base::Thread::GetThreadLocalInt(Isolate::thread_id_key_);
if (thread_id == 0) {
thread_id = AllocateThreadId();
base::Thread::SetThreadLocalInt(Isolate::thread_id_key_, thread_id);
}
return thread_id;
}
void ThreadLocalTop::Initialize(Isolate* isolate) {
*this = ThreadLocalTop();
isolate_ = isolate;
@ -173,7 +156,6 @@ void ThreadLocalTop::Free() {
base::Thread::LocalStorageKey Isolate::isolate_key_;
base::Thread::LocalStorageKey Isolate::thread_id_key_;
base::Thread::LocalStorageKey Isolate::per_isolate_thread_data_key_;
base::Atomic32 Isolate::isolate_counter_ = 0;
#if DEBUG
@ -198,9 +180,8 @@ Isolate::PerIsolateThreadData*
void Isolate::DiscardPerThreadDataForThisThread() {
int thread_id_int = base::Thread::GetThreadLocalInt(Isolate::thread_id_key_);
if (thread_id_int) {
ThreadId thread_id = ThreadId(thread_id_int);
ThreadId thread_id = ThreadId::TryGetCurrent();
if (thread_id.IsValid()) {
DCHECK(!thread_manager_->mutex_owner_.Equals(thread_id));
base::MutexGuard lock_guard(&thread_data_table_mutex_);
PerIsolateThreadData* per_thread = thread_data_table_.Lookup(thread_id);
@ -234,7 +215,6 @@ void Isolate::InitializeOncePerProcess() {
#if DEBUG
base::Relaxed_Store(&isolate_key_created_, 1);
#endif
thread_id_key_ = base::Thread::CreateThreadLocalKey();
per_isolate_thread_data_key_ = base::Thread::CreateThreadLocalKey();
}

61
src/isolate.h
View File

@ -32,6 +32,7 @@
#include "src/objects/code.h"
#include "src/objects/debug-objects.h"
#include "src/runtime/runtime.h"
#include "src/thread-id.h"
#include "src/unicode.h"
#ifdef V8_INTL_SUPPORT
@ -331,59 +332,6 @@ class WasmEngine;
} \
} while (false)
// Platform-independent, reliable thread identifier.
class ThreadId {
public:
// Creates an invalid ThreadId.
ThreadId() { base::Relaxed_Store(&id_, kInvalidId); }
ThreadId& operator=(const ThreadId& other) {
base::Relaxed_Store(&id_, base::Relaxed_Load(&other.id_));
return *this;
}
bool operator==(const ThreadId& other) const { return Equals(other); }
// Returns ThreadId for current thread.
static ThreadId Current() { return ThreadId(GetCurrentThreadId()); }
// Returns invalid ThreadId (guaranteed not to be equal to any thread).
static ThreadId Invalid() { return ThreadId(kInvalidId); }
// Compares ThreadIds for equality.
V8_INLINE bool Equals(const ThreadId& other) const {
return base::Relaxed_Load(&id_) == base::Relaxed_Load(&other.id_);
}
// Checks whether this ThreadId refers to any thread.
V8_INLINE bool IsValid() const {
return base::Relaxed_Load(&id_) != kInvalidId;
}
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::GetCurrentThreadId).
int ToInteger() const { return static_cast<int>(base::Relaxed_Load(&id_)); }
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::TerminateExecution).
static ThreadId FromInteger(int id) { return ThreadId(id); }
private:
static const int kInvalidId = -1;
explicit ThreadId(int id) { base::Relaxed_Store(&id_, id); }
static int AllocateThreadId();
V8_EXPORT_PRIVATE static int GetCurrentThreadId();
base::Atomic32 id_;
static base::Atomic32 highest_thread_id_;
friend class Isolate;
};
#define FIELD_ACCESSOR(type, name) \
inline void set_##name(type v) { name##_ = v; } \
inline type name() const { return name##_; }
@ -693,11 +641,6 @@ class Isolate final : private HiddenFactory {
return isolate_key_;
}
// Returns the key used to store process-wide thread IDs.
static base::Thread::LocalStorageKey thread_id_key() {
return thread_id_key_;
}
static base::Thread::LocalStorageKey per_isolate_thread_data_key();
// Mutex for serializing access to break control structures.
@ -1693,7 +1636,6 @@ class Isolate final : private HiddenFactory {
static base::Thread::LocalStorageKey per_isolate_thread_data_key_;
static base::Thread::LocalStorageKey isolate_key_;
static base::Thread::LocalStorageKey thread_id_key_;
// A global counter for all generated Isolates, might overflow.
static base::Atomic32 isolate_counter_;
@ -1962,7 +1904,6 @@ class Isolate final : private HiddenFactory {
friend class Simulator;
friend class StackGuard;
friend class TestSerializer;
friend class ThreadId;
friend class ThreadManager;
DISALLOW_COPY_AND_ASSIGN(Isolate);

47
src/thread-id.cc Normal file
View File

@ -0,0 +1,47 @@
// Copyright 2018 the V8 project 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 "src/thread-id.h"
#include "src/base/lazy-instance.h"
#include "src/base/platform/platform.h"
namespace v8 {
namespace internal {
base::Atomic32 ThreadId::highest_thread_id_ = 0;
namespace {
struct LocalStorageKeyAllocator {
static void Construct(void* storage_ptr_arg) {
auto storage_ptr =
reinterpret_cast<base::Thread::LocalStorageKey*>(storage_ptr_arg);
*storage_ptr = base::Thread::CreateThreadLocalKey();
}
};
static base::LazyInstance<base::Thread::LocalStorageKey,
LocalStorageKeyAllocator>::type thread_id_key =
LAZY_INSTANCE_INITIALIZER;
} // namespace
// static
ThreadId ThreadId::TryGetCurrent() {
int thread_id = base::Thread::GetThreadLocalInt(thread_id_key.Get());
return thread_id == 0 ? Invalid() : ThreadId(thread_id);
}
// static
int ThreadId::GetCurrentThreadId() {
int thread_id = base::Thread::GetThreadLocalInt(thread_id_key.Get());
if (thread_id == 0) {
thread_id = AllocateThreadId();
base::Thread::SetThreadLocalInt(thread_id_key.Get(), thread_id);
}
return thread_id;
}
} // namespace internal
} // namespace v8

73
src/thread-id.h Normal file
View File

@ -0,0 +1,73 @@
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_THREAD_ID_H_
#define V8_THREAD_ID_H_
#include "src/base/atomicops.h"
namespace v8 {
namespace internal {
// Platform-independent, reliable thread identifier.
class ThreadId {
public:
// Creates an invalid ThreadId.
ThreadId() { base::Relaxed_Store(&id_, kInvalidId); }
ThreadId& operator=(const ThreadId& other) {
base::Relaxed_Store(&id_, base::Relaxed_Load(&other.id_));
return *this;
}
bool operator==(const ThreadId& other) const { return Equals(other); }
// Returns ThreadId for current thread if it exists or invalid id.
static ThreadId TryGetCurrent();
// Returns ThreadId for current thread.
static ThreadId Current() { return ThreadId(GetCurrentThreadId()); }
// Returns invalid ThreadId (guaranteed not to be equal to any thread).
static ThreadId Invalid() { return ThreadId(kInvalidId); }
// Compares ThreadIds for equality.
V8_INLINE bool Equals(const ThreadId& other) const {
return base::Relaxed_Load(&id_) == base::Relaxed_Load(&other.id_);
}
// Checks whether this ThreadId refers to any thread.
V8_INLINE bool IsValid() const {
return base::Relaxed_Load(&id_) != kInvalidId;
}
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::GetCurrentThreadId).
int ToInteger() const { return static_cast<int>(base::Relaxed_Load(&id_)); }
// Converts ThreadId to an integer representation
// (required for public API: V8::V8::TerminateExecution).
static ThreadId FromInteger(int id) { return ThreadId(id); }
private:
static const int kInvalidId = -1;
explicit ThreadId(int id) { base::Relaxed_Store(&id_, id); }
static int AllocateThreadId() {
int new_id = base::Relaxed_AtomicIncrement(&highest_thread_id_, 1);
return new_id;
}
static int GetCurrentThreadId();
base::Atomic32 id_;
static base::Atomic32 highest_thread_id_;
};
} // namespace internal
} // namespace v8
#endif // V8_THREAD_ID_H_