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

Parser & internalizing: efficiency fixes.

Browse Source 
1) In ParseLazy, we're already using the heap, so we can also tell
AstValueFactory to internalize immediately. This is more efficient.

2) No need to collect the values in values_ and strings_ if they're already
internalized.

3) No need to collect AstValues which are strings in values_ since they don't
need to be internalized (the underlying strings will be internalized
separately).

BUG=429168
LOG=N
R=rossberg@chromium.org

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

Cr-Commit-Position: refs/heads/master@{#25109}
git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@25109 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
marja@chromium.org 2014-11-04 14:15:57 +00:00
parent 3897182246
commit 94a08565d7
2 changed files with 22 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/ast-value-factory.cc
View File

@ -241,12 +241,11 @@ const AstRawString* AstValueFactory::GetString(Handle<String> literal) {
const AstConsString* AstValueFactory::NewConsString(
const AstString* left, const AstString* right) {
// This Vector will be valid as long as the Collector is alive (meaning that
// the AstRawString will not be moved).
AstConsString* new_string = new (zone_) AstConsString(left, right);
strings_.Add(new_string);
if (isolate_) {
new_string->Internalize(isolate_);
} else {
strings_.Add(new_string);
}
return new_string;
}
@ -273,9 +272,12 @@ const AstValue* AstValueFactory::NewString(const AstRawString* string) {
AstValue* value = new (zone_) AstValue(string);
DCHECK(string != NULL);
if (isolate_) {
value->Internalize(isolate_);
// If we're creating immediately-internalized AstValues, the underlying
// strings must already be internalized at this point.
DCHECK(!string->string_.is_null());
}
values_.Add(value);
// These AstValues don't need to be added to values_, since the AstRawStrings
// will be insternalized separately.
return value;
}
@ -284,8 +286,9 @@ const AstValue* AstValueFactory::NewSymbol(const char* name) {
AstValue* value = new (zone_) AstValue(name);
if (isolate_) {
value->Internalize(isolate_);
} else {
values_.Add(value);
}
values_.Add(value);
return value;
}
@ -294,8 +297,9 @@ const AstValue* AstValueFactory::NewNumber(double number) {
AstValue* value = new (zone_) AstValue(number);
if (isolate_) {
value->Internalize(isolate_);
} else {
values_.Add(value);
}
values_.Add(value);
return value;
}
@ -305,8 +309,9 @@ const AstValue* AstValueFactory::NewSmi(int number) {
new (zone_) AstValue(AstValue::SMI, number);
if (isolate_) {
value->Internalize(isolate_);
} else {
values_.Add(value);
}
values_.Add(value);
return value;
}
@ -316,8 +321,9 @@ const AstValue* AstValueFactory::NewSmi(int number) {
value = new (zone_) AstValue(initializer); \
if (isolate_) { \
value->Internalize(isolate_); \
} else { \
values_.Add(value); \
} \
values_.Add(value); \
} \
return value;
@ -364,9 +370,10 @@ const AstRawString* AstValueFactory::GetString(
AstRawString* new_string = new (zone_) AstRawString(
is_one_byte, Vector<const byte>(new_literal_bytes, length), hash);
entry->key = new_string;
strings_.Add(new_string);
if (isolate_) {
new_string->Internalize(isolate_);
} else {
strings_.Add(new_string);
}
entry->value = reinterpret_cast<void*>(1);
}

5
src/parser.cc
View File

@ -935,6 +935,11 @@ FunctionLiteral* Parser::ParseLazy() {
}
Handle<SharedFunctionInfo> shared_info = info()->shared_info();
// Lazy parsing is only done during runtime, when we're already using the
// heap. So make the AstValueFactory also internalize all values when it
// creates them (this is more efficient).
ast_value_factory()->Internalize(isolate());
// Initialize parser state.
source = String::Flatten(source);
FunctionLiteral* result;