Skip to content

V
V8
Commit 226c1d25 authored by ulan@chromium.org's avatar ulan@chromium.org
Browse files
Options

Handlify CompilationCache. 

BUG=
R=yangguo@chromium.org

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

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20578 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent c8df5f42
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 167 additions and 277 deletions
src/compilation-cache.cc
View file @ 226c1d25
......@@ -184,7 +184,7 @@ Handle<SharedFunctionInfo> CompilationCacheScript::Lookup(
{ HandleScope scope(isolate());
for (generation = 0; generation < generations(); generation++) {
Handle<CompilationCacheTable> table = GetTable(generation);
Handle<Object> probe(table->Lookup(*source, *context), isolate());
Handle<Object> probe = table->Lookup(source, context);
if (probe->IsSharedFunctionInfo()) {
Handle<SharedFunctionInfo> function_info =
Handle<SharedFunctionInfo>::cast(probe);
......@@ -239,34 +239,17 @@ Handle<SharedFunctionInfo> CompilationCacheScript::Lookup(
}
MaybeObject* CompilationCacheScript::TryTablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info) {
Handle<CompilationCacheTable> table = GetFirstTable();
return table->Put(*source, *context, *function_info);
}
Handle<CompilationCacheTable> CompilationCacheScript::TablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info) {
CALL_HEAP_FUNCTION(isolate(),
TryTablePut(source, context, function_info),
CompilationCacheTable);
}
void CompilationCacheScript::Put(Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info) {
HandleScope scope(isolate());
SetFirstTable(TablePut(source, context, function_info));
Handle<CompilationCacheTable> table = GetFirstTable();
SetFirstTable(
CompilationCacheTable::Put(table, source, context, function_info));
}
Handle<SharedFunctionInfo> CompilationCacheEval::Lookup(
MaybeHandle<SharedFunctionInfo> CompilationCacheEval::Lookup(
Handle<String> source,
Handle<Context> context,
StrictMode strict_mode,
......@@ -274,21 +257,20 @@ Handle<SharedFunctionInfo> CompilationCacheEval::Lookup(
// Make sure not to leak the table into the surrounding handle
// scope. Otherwise, we risk keeping old tables around even after
// having cleared the cache.
Object* result = NULL;
Handle<Object> result = isolate()->factory()->undefined_value();
int generation;
{ HandleScope scope(isolate());
Handle<Object> temp = result;
for (generation = 0; generation < generations(); generation++) {
Handle<CompilationCacheTable> table = GetTable(generation);
result = table->LookupEval(
*source, *context, strict_mode, scope_position);
if (result->IsSharedFunctionInfo()) {
break;
}
temp = table->LookupEval(source, context, strict_mode, scope_position);
if (temp->IsSharedFunctionInfo()) break;
}
if (temp->IsSharedFunctionInfo()) result = scope.CloseAndEscape(temp);
}
if (result->IsSharedFunctionInfo()) {
Handle<SharedFunctionInfo>
function_info(SharedFunctionInfo::cast(result), isolate());
Handle<SharedFunctionInfo> function_info =
Handle<SharedFunctionInfo>::cast(result);
if (generation != 0) {
Put(source, context, function_info, scope_position);
}
......@@ -296,60 +278,44 @@ Handle<SharedFunctionInfo> CompilationCacheEval::Lookup(
return function_info;
} else {
isolate()->counters()->compilation_cache_misses()->Increment();
return Handle<SharedFunctionInfo>::null();
return MaybeHandle<SharedFunctionInfo>();
}
}
MaybeObject* CompilationCacheEval::TryTablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position) {
Handle<CompilationCacheTable> table = GetFirstTable();
return table->PutEval(*source, *context, *function_info, scope_position);
}
Handle<CompilationCacheTable> CompilationCacheEval::TablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position) {
CALL_HEAP_FUNCTION(isolate(),
TryTablePut(
source, context, function_info, scope_position),
CompilationCacheTable);
}
void CompilationCacheEval::Put(Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position) {
HandleScope scope(isolate());
SetFirstTable(TablePut(source, context, function_info, scope_position));
Handle<CompilationCacheTable> table = GetFirstTable();
table = CompilationCacheTable::PutEval(table, source, context,
function_info, scope_position);
SetFirstTable(table);
}
Handle<FixedArray> CompilationCacheRegExp::Lookup(Handle<String> source,
JSRegExp::Flags flags) {
MaybeHandle<FixedArray> CompilationCacheRegExp::Lookup(
Handle<String> source,
JSRegExp::Flags flags) {
// Make sure not to leak the table into the surrounding handle
// scope. Otherwise, we risk keeping old tables around even after
// having cleared the cache.
Object* result = NULL;
Handle<Object> result = isolate()->factory()->undefined_value();
int generation;
{ HandleScope scope(isolate());
Handle<Object> temp = result;
for (generation = 0; generation < generations(); generation++) {
Handle<CompilationCacheTable> table = GetTable(generation);
result = table->LookupRegExp(*source, flags);
if (result->IsFixedArray()) {
temp = table->LookupRegExp(source, flags);
if (temp->IsFixedArray()) {
break;
}
}
if (temp->IsSharedFunctionInfo()) result = scope.CloseAndEscape(temp);
}
if (result->IsFixedArray()) {
Handle<FixedArray> data(FixedArray::cast(result), isolate());
Handle<FixedArray> data = Handle<FixedArray>::cast(result);
if (generation != 0) {
Put(source, flags, data);
}
......@@ -357,35 +323,17 @@ Handle<FixedArray> CompilationCacheRegExp::Lookup(Handle<String> source,
return data;
} else {
isolate()->counters()->compilation_cache_misses()->Increment();
return Handle<FixedArray>::null();
return MaybeHandle<FixedArray>();
}
}
MaybeObject* CompilationCacheRegExp::TryTablePut(
Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data) {
Handle<CompilationCacheTable> table = GetFirstTable();
return table->PutRegExp(*source, flags, *data);
}
Handle<CompilationCacheTable> CompilationCacheRegExp::TablePut(
Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data) {
CALL_HEAP_FUNCTION(isolate(),
TryTablePut(source, flags, data),
CompilationCacheTable);
}
void CompilationCacheRegExp::Put(Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data) {
HandleScope scope(isolate());
SetFirstTable(TablePut(source, flags, data));
Handle<CompilationCacheTable> table = GetFirstTable();
SetFirstTable(CompilationCacheTable::PutRegExp(table, source, flags, data));
}
......@@ -398,36 +346,28 @@ void CompilationCache::Remove(Handle<SharedFunctionInfo> function_info) {
}
Handle<SharedFunctionInfo> CompilationCache::LookupScript(
MaybeHandle<SharedFunctionInfo> CompilationCache::LookupScript(
Handle<String> source,
Handle<Object> name,
int line_offset,
int column_offset,
bool is_shared_cross_origin,
Handle<Context> context) {
if (!IsEnabled()) {
return Handle<SharedFunctionInfo>::null();
}
if (!IsEnabled()) return MaybeHandle<SharedFunctionInfo>();
return script_.Lookup(source,
name,
line_offset,
column_offset,
is_shared_cross_origin,
context);
return script_.Lookup(source, name, line_offset, column_offset,
is_shared_cross_origin, context);
}
Handle<SharedFunctionInfo> CompilationCache::LookupEval(
MaybeHandle<SharedFunctionInfo> CompilationCache::LookupEval(
Handle<String> source,
Handle<Context> context,
StrictMode strict_mode,
int scope_position) {
if (!IsEnabled()) {
return Handle<SharedFunctionInfo>::null();
}
if (!IsEnabled()) return MaybeHandle<SharedFunctionInfo>();
Handle<SharedFunctionInfo> result;
MaybeHandle<SharedFunctionInfo> result;
if (context->IsNativeContext()) {
result = eval_global_.Lookup(
source, context, strict_mode, scope_position);
......@@ -440,11 +380,9 @@ Handle<SharedFunctionInfo> CompilationCache::LookupEval(
}
Handle<FixedArray> CompilationCache::LookupRegExp(Handle<String> source,
MaybeHandle<FixedArray> CompilationCache::LookupRegExp(Handle<String> source,
JSRegExp::Flags flags) {
if (!IsEnabled()) {
return Handle<FixedArray>::null();
}
if (!IsEnabled()) return MaybeHandle<FixedArray>();
return reg_exp_.Lookup(source, flags);
}
......
src/compilation-cache.h
View file @ 226c1d25
......@@ -106,17 +106,6 @@ class CompilationCacheScript : public CompilationSubCache {
Handle<SharedFunctionInfo> function_info);
private:
MUST_USE_RESULT MaybeObject* TryTablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info);
// Note: Returns a new hash table if operation results in expansion.
Handle<CompilationCacheTable> TablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info);
bool HasOrigin(Handle<SharedFunctionInfo> function_info,
Handle<Object> name,
int line_offset,
......@@ -147,10 +136,10 @@ class CompilationCacheEval: public CompilationSubCache {
CompilationCacheEval(Isolate* isolate, int generations)
: CompilationSubCache(isolate, generations) { }
Handle<SharedFunctionInfo> Lookup(Handle<String> source,
Handle<Context> context,
StrictMode strict_mode,
int scope_position);
MaybeHandle<SharedFunctionInfo> Lookup(Handle<String> source,
Handle<Context> context,
StrictMode strict_mode,
int scope_position);
void Put(Handle<String> source,
Handle<Context> context,
......@@ -158,19 +147,6 @@ class CompilationCacheEval: public CompilationSubCache {
int scope_position);
private:
MUST_USE_RESULT MaybeObject* TryTablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position);
// Note: Returns a new hash table if operation results in expansion.
Handle<CompilationCacheTable> TablePut(
Handle<String> source,
Handle<Context> context,
Handle<SharedFunctionInfo> function_info,
int scope_position);
DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheEval);
};
......@@ -181,21 +157,12 @@ class CompilationCacheRegExp: public CompilationSubCache {
CompilationCacheRegExp(Isolate* isolate, int generations)
: CompilationSubCache(isolate, generations) { }
Handle<FixedArray> Lookup(Handle<String> source, JSRegExp::Flags flags);
MaybeHandle<FixedArray> Lookup(Handle<String> source, JSRegExp::Flags flags);
void Put(Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data);
private:
MUST_USE_RESULT MaybeObject* TryTablePut(Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data);
// Note: Returns a new hash table if operation results in expansion.
Handle<CompilationCacheTable> TablePut(Handle<String> source,
JSRegExp::Flags flags,
Handle<FixedArray> data);
DISALLOW_IMPLICIT_CONSTRUCTORS(CompilationCacheRegExp);
};
......@@ -209,25 +176,21 @@ class CompilationCache {
// Finds the script shared function info for a source
// string. Returns an empty handle if the cache doesn't contain a
// script for the given source string with the right origin.
Handle<SharedFunctionInfo> LookupScript(Handle<String> source,
Handle<Object> name,
int line_offset,
int column_offset,
bool is_shared_cross_origin,
Handle<Context> context);
MaybeHandle<SharedFunctionInfo> LookupScript(
Handle<String> source, Handle<Object> name, int line_offset,
int column_offset, bool is_shared_cross_origin, Handle<Context> context);
// Finds the shared function info for a source string for eval in a
// given context. Returns an empty handle if the cache doesn't
// contain a script for the given source string.
Handle<SharedFunctionInfo> LookupEval(Handle<String> source,
Handle<Context> context,
StrictMode strict_mode,
int scope_position);
MaybeHandle<SharedFunctionInfo> LookupEval(
Handle<String> source, Handle<Context> context, StrictMode strict_mode,
int scope_position);
// Returns the regexp data associated with the given regexp if it
// is in cache, otherwise an empty handle.
Handle<FixedArray> LookupRegExp(Handle<String> source,
JSRegExp::Flags flags);
MaybeHandle<FixedArray> LookupRegExp(
Handle<String> source, JSRegExp::Flags flags);
// Associate the (source, kind) pair to the shared function
// info. This may overwrite an existing mapping.
......
src/compiler.cc
View file @ 226c1d25
......@@ -877,10 +877,12 @@ Handle<JSFunction> Compiler::GetFunctionFromEval(Handle<String> source,
isolate->counters()->total_compile_size()->Increment(source_length);
CompilationCache* compilation_cache = isolate->compilation_cache();
Handle<SharedFunctionInfo> shared_info = compilation_cache->LookupEval(
source, context, strict_mode, scope_position);
MaybeHandle<SharedFunctionInfo> maybe_shared_info =
compilation_cache->LookupEval(source, context, strict_mode,
scope_position);
Handle<SharedFunctionInfo> shared_info;
if (shared_info.is_null()) {
if (!maybe_shared_info.ToHandle(&shared_info)) {
Handle<Script> script = isolate->factory()->NewScript(source);
CompilationInfoWithZone info(script);
info.MarkAsEval();
......@@ -945,17 +947,15 @@ Handle<SharedFunctionInfo> Compiler::CompileScript(
CompilationCache* compilation_cache = isolate->compilation_cache();
// Do a lookup in the compilation cache but not for extensions.
MaybeHandle<SharedFunctionInfo> maybe_result;
Handle<SharedFunctionInfo> result;
if (extension == NULL) {
result = compilation_cache->LookupScript(source,
script_name,
line_offset,
column_offset,
is_shared_cross_origin,
context);
maybe_result = compilation_cache->LookupScript(
source, script_name, line_offset, column_offset,
is_shared_cross_origin, context);
}
if (result.is_null()) {
if (!maybe_result.ToHandle(&result)) {
// No cache entry found. Compile the script.
// Create a script object describing the script to be compiled.
......@@ -981,11 +981,10 @@ Handle<SharedFunctionInfo> Compiler::CompileScript(
if (extension == NULL && !result.is_null() && !result->dont_cache()) {
compilation_cache->PutScript(source, context, result);
}
if (result.is_null()) isolate->ReportPendingMessages();
} else if (result->ic_age() != isolate->heap()->global_ic_age()) {
result->ResetForNewContext(isolate->heap()->global_ic_age());
}
if (result.is_null()) isolate->ReportPendingMessages();
return result;
}
......
src/jsregexp.cc
View file @ 226c1d25
......@@ -175,8 +175,10 @@ Handle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
Zone zone(isolate);
JSRegExp::Flags flags = RegExpFlagsFromString(flag_str);
CompilationCache* compilation_cache = isolate->compilation_cache();
Handle<FixedArray> cached = compilation_cache->LookupRegExp(pattern, flags);
bool in_cache = !cached.is_null();
MaybeHandle<FixedArray> maybe_cached =
compilation_cache->LookupRegExp(pattern, flags);
Handle<FixedArray> cached;
bool in_cache = maybe_cached.ToHandle(&cached);
LOG(isolate, RegExpCompileEvent(re, in_cache));
Handle<Object> result;
......
src/objects.cc
View file @ 226c1d25
This diff is collapsed.
src/objects.h
View file @ 226c1d25
......@@ -8200,24 +8200,22 @@ class CompilationCacheTable: public HashTable<CompilationCacheShape,
HashTableKey*> {
public:
// Find cached value for a string key, otherwise return null.
Object* Lookup(String* src, Context* context);
Object* LookupEval(String* src,
Context* context,
StrictMode strict_mode,
int scope_position);
Object* LookupRegExp(String* source, JSRegExp::Flags flags);
MUST_USE_RESULT MaybeObject* Put(String* src,
Context* context,
Object* value);
MUST_USE_RESULT MaybeObject* PutEval(String* src,
Context* context,
SharedFunctionInfo* value,
int scope_position);
MUST_USE_RESULT MaybeObject* PutRegExp(String* src,
JSRegExp::Flags flags,
FixedArray* value);
// Remove given value from cache.
Handle<Object> Lookup(Handle<String> src, Handle<Context> context);
Handle<Object> LookupEval(Handle<String> src, Handle<Context> context,
StrictMode strict_mode, int scope_position);
Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
static Handle<CompilationCacheTable> Put(
Handle<CompilationCacheTable> cache, Handle<String> src,
Handle<Context> context, Handle<Object> value);
static Handle<CompilationCacheTable> PutEval(
Handle<CompilationCacheTable> cache, Handle<String> src,
Handle<Context> context, Handle<SharedFunctionInfo> value,
int scope_position);
static Handle<CompilationCacheTable> PutRegExp(
Handle<CompilationCacheTable> cache, Handle<String> src,
JSRegExp::Flags flags, Handle<FixedArray> value);
static Handle<CompilationCacheTable> EnsureCapacityFor(
Handle<CompilationCacheTable> cache, int n, HashTableKey* key);
void Remove(Object* value);
static inline CompilationCacheTable* cast(Object* obj);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment