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

Fix data race with interface caching

Browse Source 
R=bmeurer@chromium.org
BUG=421634
LOG=N

Review URL: https://codereview.chromium.org/667703002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24774 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
rossberg@chromium.org 2014-10-21 12:57:19 +00:00
parent 2147d5a145
commit 5e1cd18d94
2 changed files with 81 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
src/interface.cc
View File

@ -6,23 +6,67 @@
#include "src/interface.h" #include "src/interface.h"
#include "src/base/lazy-instance.h"
namespace v8 { namespace v8 {
namespace internal { namespace internal {
// ---------------------------------------------------------------------------
// Initialization.
struct Interface::ValueCreate {
static void Construct(Interface* ptr) {
::new (ptr) Interface(VALUE + FROZEN);
}
};
struct Interface::ConstCreate {
static void Construct(Interface* ptr) {
::new (ptr) Interface(VALUE + CONST + FROZEN);
}
};
namespace {
base::LazyInstance<Interface, Interface::ValueCreate>::type value_interface =
LAZY_INSTANCE_INITIALIZER;
base::LazyInstance<Interface, Interface::ConstCreate>::type const_interface =
LAZY_INSTANCE_INITIALIZER;
}
Interface* Interface::NewValue() {
return value_interface.Pointer(); // Cached.
}
Interface* Interface::NewConst() {
return const_interface.Pointer(); // Cached.
}
// ---------------------------------------------------------------------------
// Lookup.
Interface* Interface::Lookup(Handle<String> name, Zone* zone) { Interface* Interface::Lookup(Handle<String> name, Zone* zone) {
DCHECK(IsModule()); DCHECK(IsModule());
ZoneHashMap* map = Chase()->exports_; ZoneHashMap* map = Chase()->exports_;
if (map == NULL) return NULL; if (map == nullptr) return nullptr;
ZoneAllocationPolicy allocator(zone); ZoneAllocationPolicy allocator(zone);
ZoneHashMap::Entry* p = map->Lookup(name.location(), name->Hash(), false, ZoneHashMap::Entry* p =
allocator); map->Lookup(name.location(), name->Hash(), false, allocator);
if (p == NULL) return NULL; if (p == nullptr) return nullptr;
DCHECK(*static_cast<String**>(p->key) == *name); DCHECK(*static_cast<String**>(p->key) == *name);
DCHECK(p->value != NULL); DCHECK(p->value != nullptr);
return static_cast<Interface*>(p->value); return static_cast<Interface*>(p->value);
} }
// ---------------------------------------------------------------------------
// Addition.
#ifdef DEBUG #ifdef DEBUG
// Current nesting depth for debug output. // Current nesting depth for debug output.
class Nesting { class Nesting {
@ -48,9 +92,9 @@ void Interface::DoAdd(const void* name, uint32_t hash, Interface* interface,
PrintF("%*s# Adding...\n", Nesting::current(), ""); PrintF("%*s# Adding...\n", Nesting::current(), "");
PrintF("%*sthis = ", Nesting::current(), ""); PrintF("%*sthis = ", Nesting::current(), "");
this->Print(Nesting::current()); this->Print(Nesting::current());
const AstRawString* symbol = static_cast<const AstRawString*>(name); const AstRawString* raw = static_cast<const AstRawString*>(name);
PrintF("%*s%.*s : ", Nesting::current(), "", symbol->length(), PrintF("%*s%.*s : ", Nesting::current(), "",
symbol->raw_data()); raw->length(), raw->raw_data());
interface->Print(Nesting::current()); interface->Print(Nesting::current());
} }
#endif #endif
@ -58,7 +102,7 @@ void Interface::DoAdd(const void* name, uint32_t hash, Interface* interface,
ZoneHashMap** map = &Chase()->exports_; ZoneHashMap** map = &Chase()->exports_;
ZoneAllocationPolicy allocator(zone); ZoneAllocationPolicy allocator(zone);
if (*map == NULL) { if (*map == nullptr) {
*map = new(zone->New(sizeof(ZoneHashMap))) *map = new(zone->New(sizeof(ZoneHashMap)))
ZoneHashMap(ZoneHashMap::PointersMatch, ZoneHashMap(ZoneHashMap::PointersMatch,
ZoneHashMap::kDefaultHashMapCapacity, allocator); ZoneHashMap::kDefaultHashMapCapacity, allocator);
@ -66,10 +110,10 @@ void Interface::DoAdd(const void* name, uint32_t hash, Interface* interface,
ZoneHashMap::Entry* p = ZoneHashMap::Entry* p =
(*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator); (*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator);
if (p == NULL) { if (p == nullptr) {
// This didn't have name but was frozen already, that's an error. // This didn't have name but was frozen already, that's an error.
*ok = false; *ok = false;
} else if (p->value == NULL) { } else if (p->value == nullptr) {
p->value = interface; p->value = interface;
} else { } else {
#ifdef DEBUG #ifdef DEBUG
@ -88,11 +132,14 @@ void Interface::DoAdd(const void* name, uint32_t hash, Interface* interface,
} }
// ---------------------------------------------------------------------------
// Unification.
void Interface::Unify(Interface* that, Zone* zone, bool* ok) { void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
if (this->forward_) return this->Chase()->Unify(that, zone, ok); if (this->forward_) return this->Chase()->Unify(that, zone, ok);
if (that->forward_) return this->Unify(that->Chase(), zone, ok); if (that->forward_) return this->Unify(that->Chase(), zone, ok);
DCHECK(this->forward_ == NULL); DCHECK(this->forward_ == nullptr);
DCHECK(that->forward_ == NULL); DCHECK(that->forward_ == nullptr);
*ok = true; *ok = true;
if (this == that) return; if (this == that) return;
@ -118,7 +165,7 @@ void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
#endif #endif
// Merge the smaller interface into the larger, for performance. // Merge the smaller interface into the larger, for performance.
if (this->exports_ != NULL && (that->exports_ == NULL || if (this->exports_ != nullptr && (that->exports_ == nullptr ||
this->exports_->occupancy() >= that->exports_->occupancy())) { this->exports_->occupancy() >= that->exports_->occupancy())) {
this->DoUnify(that, ok, zone); this->DoUnify(that, ok, zone);
} else { } else {
@ -138,8 +185,8 @@ void Interface::Unify(Interface* that, Zone* zone, bool* ok) {
void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) { void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
DCHECK(this->forward_ == NULL); DCHECK(this->forward_ == nullptr);
DCHECK(that->forward_ == NULL); DCHECK(that->forward_ == nullptr);
DCHECK(!this->IsValue()); DCHECK(!this->IsValue());
DCHECK(!that->IsValue()); DCHECK(!that->IsValue());
DCHECK(this->index_ == -1); DCHECK(this->index_ == -1);
@ -152,8 +199,8 @@ void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
// Try to merge all members from that into this. // Try to merge all members from that into this.
ZoneHashMap* map = that->exports_; ZoneHashMap* map = that->exports_;
if (map != NULL) { if (map != nullptr) {
for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) { for (ZoneHashMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok); this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok);
if (!*ok) return; if (!*ok) return;
} }
@ -161,8 +208,8 @@ void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
// If the new interface is larger than that's, then there were members in // If the new interface is larger than that's, then there were members in
// 'this' which 'that' didn't have. If 'that' was frozen that is an error. // 'this' which 'that' didn't have. If 'that' was frozen that is an error.
int this_size = this->exports_ == NULL ? 0 : this->exports_->occupancy(); int this_size = this->exports_ == nullptr ? 0 : this->exports_->occupancy();
int that_size = map == NULL ? 0 : map->occupancy(); int that_size = map == nullptr ? 0 : map->occupancy();
if (that->IsFrozen() && this_size > that_size) { if (that->IsFrozen() && this_size > that_size) {
*ok = false; *ok = false;
return; return;
@ -174,14 +221,19 @@ void Interface::DoUnify(Interface* that, bool* ok, Zone* zone) {
} }
// ---------------------------------------------------------------------------
// Printing.
#ifdef DEBUG #ifdef DEBUG
void Interface::Print(int n) { void Interface::Print(int n) {
int n0 = n > 0 ? n : 0; int n0 = n > 0 ? n : 0;
if (FLAG_print_interface_details) { if (FLAG_print_interface_details) {
PrintF("%p", static_cast<void*>(this)); PrintF("%p", static_cast<void*>(this));
for (Interface* link = this->forward_; link != NULL; link = link->forward_) for (Interface* link = this->forward_; link != nullptr;
link = link->forward_) {
PrintF("->%p", static_cast<void*>(link)); PrintF("->%p", static_cast<void*>(link));
}
PrintF(" "); PrintF(" ");
} }
@ -194,14 +246,15 @@ void Interface::Print(int n) {
} else if (IsModule()) { } else if (IsModule()) {
PrintF("module %d %s{", Index(), IsFrozen() ? "" : "(unresolved) "); PrintF("module %d %s{", Index(), IsFrozen() ? "" : "(unresolved) ");
ZoneHashMap* map = Chase()->exports_; ZoneHashMap* map = Chase()->exports_;
if (map == NULL || map->occupancy() == 0) { if (map == nullptr || map->occupancy() == 0) {
PrintF("}\n"); PrintF("}\n");
} else if (n < 0 || n0 >= 2 * FLAG_print_interface_depth) { } else if (n < 0 || n0 >= 2 * FLAG_print_interface_depth) {
// Avoid infinite recursion on cyclic types. // Avoid infinite recursion on cyclic types.
PrintF("...}\n"); PrintF("...}\n");
} else { } else {
PrintF("\n"); PrintF("\n");
for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) { for (ZoneHashMap::Entry* p = map->Start();
p != nullptr; p = map->Next(p)) {
String* name = *static_cast<String**>(p->key); String* name = *static_cast<String**>(p->key);
Interface* interface = static_cast<Interface*>(p->value); Interface* interface = static_cast<Interface*>(p->value);
PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray()); PrintF("%*s%s : ", n0 + 2, "", name->ToAsciiArray());

13
src/interface.h
View File

@ -41,15 +41,9 @@ class Interface : public ZoneObject {
return new(zone) Interface(NONE); return new(zone) Interface(NONE);
} }
static Interface* NewValue() { static Interface* NewValue();
static Interface value_interface(VALUE + FROZEN); // Cached.
return &value_interface;
}
static Interface* NewConst() { static Interface* NewConst();
static Interface value_interface(VALUE + CONST + FROZEN); // Cached.
return &value_interface;
}
static Interface* NewModule(Zone* zone) { static Interface* NewModule(Zone* zone) {
return new(zone) Interface(MODULE); return new(zone) Interface(MODULE);
@ -178,6 +172,9 @@ class Interface : public ZoneObject {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// Implementation. // Implementation.
private: private:
struct ValueCreate;
struct ConstCreate;
enum Flags { // All flags are monotonic enum Flags { // All flags are monotonic
NONE = 0, NONE = 0,
VALUE = 1, // This type describes a value VALUE = 1, // This type describes a value