mirror of https://github.com/lukechilds/node.git
Browse Source
Pick up the latest branch-head for V8 5.1. This branch brings in improved language support and performance improvements. For full details: http://v8project.blogspot.com/2016/04/v8-release-51.html * Picks up the latest branch head for 5.1 [1] * Edit v8 gitignore to allow trace_event copy * Update V8 DEP trace_event as per deps/v8/DEPS [2] [1] https://chromium.googlesource.com/v8/v8.git/+/dc81244 [2] https://chromium.googlesource.com/chromium/src/base/trace_event/common/+/c8c8665 PR-URL: https://github.com/nodejs/node/pull/7016 Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>v7.x
Michaël Zasso
9 years ago
1487 changed files with 280129 additions and 62497 deletions
@ -0,0 +1,8 @@ |
|||
# V8 Code of Conduct |
|||
|
|||
As part of the Chromium team, the V8 team is committed to preserving and |
|||
fostering a diverse, welcoming community. To this end, the [Chromium Code of |
|||
Conduct](https://chromium.googlesource.com/chromium/src/+/master/CODE_OF_CONDUCT.md) |
|||
applies to our repos and organizations, mailing lists, blog content, and any |
|||
other Chromium-supported communication group, as well as any private |
|||
communication initiated in the context of these spaces. |
|||
File diff suppressed because it is too large
@ -0,0 +1,36 @@ |
|||
#!/usr/bin/env python |
|||
# Copyright 2016 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. |
|||
|
|||
# CC/CXX wrapper script that excludes certain file patterns from coverage |
|||
# instrumentation. |
|||
|
|||
import re |
|||
import subprocess |
|||
import sys |
|||
|
|||
exclusions = [ |
|||
'buildtools', |
|||
'src/third_party', |
|||
'third_party', |
|||
'test', |
|||
'testing', |
|||
] |
|||
|
|||
def remove_if_exists(string_list, item): |
|||
if item in string_list: |
|||
string_list.remove(item) |
|||
|
|||
args = sys.argv[1:] |
|||
text = ' '.join(sys.argv[2:]) |
|||
for exclusion in exclusions: |
|||
if re.search(r'\-o obj/%s[^ ]*\.o' % exclusion, text): |
|||
remove_if_exists(args, '-fprofile-arcs') |
|||
remove_if_exists(args, '-ftest-coverage') |
|||
remove_if_exists(args, '-fsanitize-coverage=func') |
|||
remove_if_exists(args, '-fsanitize-coverage=bb') |
|||
remove_if_exists(args, '-fsanitize-coverage=edge') |
|||
break |
|||
|
|||
sys.exit(subprocess.check_call(args)) |
|||
@ -0,0 +1,31 @@ |
|||
// Copyright 2016 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/api-arguments.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
Handle<Object> FunctionCallbackArguments::Call(FunctionCallback f) { |
|||
Isolate* isolate = this->isolate(); |
|||
VMState<EXTERNAL> state(isolate); |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); |
|||
FunctionCallbackInfo<v8::Value> info(begin(), argv_, argc_, |
|||
is_construct_call_); |
|||
f(info); |
|||
return GetReturnValue<Object>(isolate); |
|||
} |
|||
|
|||
Handle<JSObject> PropertyCallbackArguments::Call( |
|||
IndexedPropertyEnumeratorCallback f) { |
|||
Isolate* isolate = this->isolate(); |
|||
VMState<EXTERNAL> state(isolate); |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); |
|||
PropertyCallbackInfo<v8::Array> info(begin()); |
|||
f(info); |
|||
return GetReturnValue<JSObject>(isolate); |
|||
} |
|||
|
|||
} // namespace internal
|
|||
} // namespace v8
|
|||
@ -0,0 +1,254 @@ |
|||
// Copyright 2016 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_API_ARGUMENTS_H_ |
|||
#define V8_API_ARGUMENTS_H_ |
|||
|
|||
#include "src/api.h" |
|||
#include "src/isolate.h" |
|||
#include "src/tracing/trace-event.h" |
|||
#include "src/vm-state-inl.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Custom arguments replicate a small segment of stack that can be
|
|||
// accessed through an Arguments object the same way the actual stack
|
|||
// can.
|
|||
template <int kArrayLength> |
|||
class CustomArgumentsBase : public Relocatable { |
|||
public: |
|||
virtual inline void IterateInstance(ObjectVisitor* v) { |
|||
v->VisitPointers(values_, values_ + kArrayLength); |
|||
} |
|||
|
|||
protected: |
|||
inline Object** begin() { return values_; } |
|||
explicit inline CustomArgumentsBase(Isolate* isolate) |
|||
: Relocatable(isolate) {} |
|||
Object* values_[kArrayLength]; |
|||
}; |
|||
|
|||
template <typename T> |
|||
class CustomArguments : public CustomArgumentsBase<T::kArgsLength> { |
|||
public: |
|||
static const int kReturnValueOffset = T::kReturnValueIndex; |
|||
|
|||
typedef CustomArgumentsBase<T::kArgsLength> Super; |
|||
~CustomArguments() { |
|||
this->begin()[kReturnValueOffset] = |
|||
reinterpret_cast<Object*>(kHandleZapValue); |
|||
} |
|||
|
|||
protected: |
|||
explicit inline CustomArguments(Isolate* isolate) : Super(isolate) {} |
|||
|
|||
template <typename V> |
|||
Handle<V> GetReturnValue(Isolate* isolate); |
|||
|
|||
inline Isolate* isolate() { |
|||
return reinterpret_cast<Isolate*>(this->begin()[T::kIsolateIndex]); |
|||
} |
|||
}; |
|||
|
|||
template <typename T> |
|||
template <typename V> |
|||
Handle<V> CustomArguments<T>::GetReturnValue(Isolate* isolate) { |
|||
// Check the ReturnValue.
|
|||
Object** handle = &this->begin()[kReturnValueOffset]; |
|||
// Nothing was set, return empty handle as per previous behaviour.
|
|||
if ((*handle)->IsTheHole()) return Handle<V>(); |
|||
Handle<V> result = Handle<V>::cast(Handle<Object>(handle)); |
|||
result->VerifyApiCallResultType(); |
|||
return result; |
|||
} |
|||
|
|||
class PropertyCallbackArguments |
|||
: public CustomArguments<PropertyCallbackInfo<Value> > { |
|||
public: |
|||
typedef PropertyCallbackInfo<Value> T; |
|||
typedef CustomArguments<T> Super; |
|||
static const int kArgsLength = T::kArgsLength; |
|||
static const int kThisIndex = T::kThisIndex; |
|||
static const int kHolderIndex = T::kHolderIndex; |
|||
static const int kDataIndex = T::kDataIndex; |
|||
static const int kReturnValueDefaultValueIndex = |
|||
T::kReturnValueDefaultValueIndex; |
|||
static const int kIsolateIndex = T::kIsolateIndex; |
|||
static const int kShouldThrowOnErrorIndex = T::kShouldThrowOnErrorIndex; |
|||
|
|||
PropertyCallbackArguments(Isolate* isolate, Object* data, Object* self, |
|||
JSObject* holder, Object::ShouldThrow should_throw) |
|||
: Super(isolate) { |
|||
Object** values = this->begin(); |
|||
values[T::kThisIndex] = self; |
|||
values[T::kHolderIndex] = holder; |
|||
values[T::kDataIndex] = data; |
|||
values[T::kIsolateIndex] = reinterpret_cast<Object*>(isolate); |
|||
values[T::kShouldThrowOnErrorIndex] = |
|||
Smi::FromInt(should_throw == Object::THROW_ON_ERROR ? 1 : 0); |
|||
|
|||
// Here the hole is set as default value.
|
|||
// It cannot escape into js as it's remove in Call below.
|
|||
values[T::kReturnValueDefaultValueIndex] = |
|||
isolate->heap()->the_hole_value(); |
|||
values[T::kReturnValueIndex] = isolate->heap()->the_hole_value(); |
|||
DCHECK(values[T::kHolderIndex]->IsHeapObject()); |
|||
DCHECK(values[T::kIsolateIndex]->IsSmi()); |
|||
} |
|||
|
|||
/*
|
|||
* The following Call functions wrap the calling of all callbacks to handle |
|||
* calling either the old or the new style callbacks depending on which one |
|||
* has been registered. |
|||
* For old callbacks which return an empty handle, the ReturnValue is checked |
|||
* and used if it's been set to anything inside the callback. |
|||
* New style callbacks always use the return value. |
|||
*/ |
|||
Handle<JSObject> Call(IndexedPropertyEnumeratorCallback f); |
|||
|
|||
#define FOR_EACH_CALLBACK_TABLE_MAPPING_1_NAME(F) \ |
|||
F(AccessorNameGetterCallback, "get", v8::Value, Object) \ |
|||
F(GenericNamedPropertyQueryCallback, "has", v8::Integer, Object) \ |
|||
F(GenericNamedPropertyDeleterCallback, "delete", v8::Boolean, Object) |
|||
|
|||
#define WRITE_CALL_1_NAME(Function, type, ApiReturn, InternalReturn) \ |
|||
Handle<InternalReturn> Call(Function f, Handle<Name> name) { \ |
|||
Isolate* isolate = this->isolate(); \ |
|||
VMState<EXTERNAL> state(isolate); \ |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \ |
|||
PropertyCallbackInfo<ApiReturn> info(begin()); \ |
|||
LOG(isolate, \ |
|||
ApiNamedPropertyAccess("interceptor-named-" type, holder(), *name)); \ |
|||
f(v8::Utils::ToLocal(name), info); \ |
|||
return GetReturnValue<InternalReturn>(isolate); \ |
|||
} |
|||
|
|||
FOR_EACH_CALLBACK_TABLE_MAPPING_1_NAME(WRITE_CALL_1_NAME) |
|||
|
|||
#undef FOR_EACH_CALLBACK_TABLE_MAPPING_1_NAME |
|||
#undef WRITE_CALL_1_NAME |
|||
|
|||
#define FOR_EACH_CALLBACK_TABLE_MAPPING_1_INDEX(F) \ |
|||
F(IndexedPropertyGetterCallback, "get", v8::Value, Object) \ |
|||
F(IndexedPropertyQueryCallback, "has", v8::Integer, Object) \ |
|||
F(IndexedPropertyDeleterCallback, "delete", v8::Boolean, Object) |
|||
|
|||
#define WRITE_CALL_1_INDEX(Function, type, ApiReturn, InternalReturn) \ |
|||
Handle<InternalReturn> Call(Function f, uint32_t index) { \ |
|||
Isolate* isolate = this->isolate(); \ |
|||
VMState<EXTERNAL> state(isolate); \ |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); \ |
|||
PropertyCallbackInfo<ApiReturn> info(begin()); \ |
|||
LOG(isolate, ApiIndexedPropertyAccess("interceptor-indexed-" type, \ |
|||
holder(), index)); \ |
|||
f(index, info); \ |
|||
return GetReturnValue<InternalReturn>(isolate); \ |
|||
} |
|||
|
|||
FOR_EACH_CALLBACK_TABLE_MAPPING_1_INDEX(WRITE_CALL_1_INDEX) |
|||
|
|||
#undef FOR_EACH_CALLBACK_TABLE_MAPPING_1_INDEX |
|||
#undef WRITE_CALL_1_INDEX |
|||
|
|||
Handle<Object> Call(GenericNamedPropertySetterCallback f, Handle<Name> name, |
|||
Handle<Object> value) { |
|||
Isolate* isolate = this->isolate(); |
|||
VMState<EXTERNAL> state(isolate); |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); |
|||
PropertyCallbackInfo<v8::Value> info(begin()); |
|||
LOG(isolate, |
|||
ApiNamedPropertyAccess("interceptor-named-set", holder(), *name)); |
|||
f(v8::Utils::ToLocal(name), v8::Utils::ToLocal(value), info); |
|||
return GetReturnValue<Object>(isolate); |
|||
} |
|||
|
|||
Handle<Object> Call(IndexedPropertySetterCallback f, uint32_t index, |
|||
Handle<Object> value) { |
|||
Isolate* isolate = this->isolate(); |
|||
VMState<EXTERNAL> state(isolate); |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); |
|||
PropertyCallbackInfo<v8::Value> info(begin()); |
|||
LOG(isolate, |
|||
ApiIndexedPropertyAccess("interceptor-indexed-set", holder(), index)); |
|||
f(index, v8::Utils::ToLocal(value), info); |
|||
return GetReturnValue<Object>(isolate); |
|||
} |
|||
|
|||
void Call(AccessorNameSetterCallback f, Handle<Name> name, |
|||
Handle<Object> value) { |
|||
Isolate* isolate = this->isolate(); |
|||
VMState<EXTERNAL> state(isolate); |
|||
ExternalCallbackScope call_scope(isolate, FUNCTION_ADDR(f)); |
|||
PropertyCallbackInfo<void> info(begin()); |
|||
LOG(isolate, |
|||
ApiNamedPropertyAccess("interceptor-named-set", holder(), *name)); |
|||
f(v8::Utils::ToLocal(name), v8::Utils::ToLocal(value), info); |
|||
} |
|||
|
|||
private: |
|||
inline JSObject* holder() { |
|||
return JSObject::cast(this->begin()[T::kHolderIndex]); |
|||
} |
|||
}; |
|||
|
|||
class FunctionCallbackArguments |
|||
: public CustomArguments<FunctionCallbackInfo<Value> > { |
|||
public: |
|||
typedef FunctionCallbackInfo<Value> T; |
|||
typedef CustomArguments<T> Super; |
|||
static const int kArgsLength = T::kArgsLength; |
|||
static const int kHolderIndex = T::kHolderIndex; |
|||
static const int kDataIndex = T::kDataIndex; |
|||
static const int kReturnValueDefaultValueIndex = |
|||
T::kReturnValueDefaultValueIndex; |
|||
static const int kIsolateIndex = T::kIsolateIndex; |
|||
static const int kCalleeIndex = T::kCalleeIndex; |
|||
static const int kContextSaveIndex = T::kContextSaveIndex; |
|||
|
|||
FunctionCallbackArguments(internal::Isolate* isolate, internal::Object* data, |
|||
internal::HeapObject* callee, |
|||
internal::Object* holder, internal::Object** argv, |
|||
int argc, bool is_construct_call) |
|||
: Super(isolate), |
|||
argv_(argv), |
|||
argc_(argc), |
|||
is_construct_call_(is_construct_call) { |
|||
Object** values = begin(); |
|||
values[T::kDataIndex] = data; |
|||
values[T::kCalleeIndex] = callee; |
|||
values[T::kHolderIndex] = holder; |
|||
values[T::kContextSaveIndex] = isolate->heap()->the_hole_value(); |
|||
values[T::kIsolateIndex] = reinterpret_cast<internal::Object*>(isolate); |
|||
// Here the hole is set as default value.
|
|||
// It cannot escape into js as it's remove in Call below.
|
|||
values[T::kReturnValueDefaultValueIndex] = |
|||
isolate->heap()->the_hole_value(); |
|||
values[T::kReturnValueIndex] = isolate->heap()->the_hole_value(); |
|||
DCHECK(values[T::kCalleeIndex]->IsJSFunction() || |
|||
values[T::kCalleeIndex]->IsFunctionTemplateInfo()); |
|||
DCHECK(values[T::kHolderIndex]->IsHeapObject()); |
|||
DCHECK(values[T::kIsolateIndex]->IsSmi()); |
|||
} |
|||
|
|||
/*
|
|||
* The following Call function wraps the calling of all callbacks to handle |
|||
* calling either the old or the new style callbacks depending on which one |
|||
* has been registered. |
|||
* For old callbacks which return an empty handle, the ReturnValue is checked |
|||
* and used if it's been set to anything inside the callback. |
|||
* New style callbacks always use the return value. |
|||
*/ |
|||
Handle<Object> Call(FunctionCallback f); |
|||
|
|||
private: |
|||
internal::Object** argv_; |
|||
int argc_; |
|||
bool is_construct_call_; |
|||
}; |
|||
|
|||
} // namespace internal
|
|||
} // namespace v8
|
|||
|
|||
#endif // V8_API_ARGUMENTS_H_
|
|||
@ -0,0 +1,33 @@ |
|||
// Copyright 2016 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/base/accounting-allocator.h" |
|||
|
|||
#include <cstdlib> |
|||
|
|||
#if V8_LIBC_BIONIC |
|||
#include <malloc.h> // NOLINT |
|||
#endif |
|||
|
|||
namespace v8 { |
|||
namespace base { |
|||
|
|||
void* AccountingAllocator::Allocate(size_t bytes) { |
|||
void* memory = malloc(bytes); |
|||
if (memory) NoBarrier_AtomicIncrement(¤t_memory_usage_, bytes); |
|||
return memory; |
|||
} |
|||
|
|||
void AccountingAllocator::Free(void* memory, size_t bytes) { |
|||
free(memory); |
|||
NoBarrier_AtomicIncrement(¤t_memory_usage_, |
|||
-static_cast<AtomicWord>(bytes)); |
|||
} |
|||
|
|||
size_t AccountingAllocator::GetCurrentMemoryUsage() const { |
|||
return NoBarrier_Load(¤t_memory_usage_); |
|||
} |
|||
|
|||
} // namespace base
|
|||
} // namespace v8
|
|||
@ -0,0 +1,34 @@ |
|||
// Copyright 2016 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_BASE_ACCOUNTING_ALLOCATOR_H_ |
|||
#define V8_BASE_ACCOUNTING_ALLOCATOR_H_ |
|||
|
|||
#include "src/base/atomicops.h" |
|||
#include "src/base/macros.h" |
|||
|
|||
namespace v8 { |
|||
namespace base { |
|||
|
|||
class AccountingAllocator final { |
|||
public: |
|||
AccountingAllocator() = default; |
|||
~AccountingAllocator() = default; |
|||
|
|||
// Returns nullptr on failed allocation.
|
|||
void* Allocate(size_t bytes); |
|||
void Free(void* memory, size_t bytes); |
|||
|
|||
size_t GetCurrentMemoryUsage() const; |
|||
|
|||
private: |
|||
AtomicWord current_memory_usage_ = 0; |
|||
|
|||
DISALLOW_COPY_AND_ASSIGN(AccountingAllocator); |
|||
}; |
|||
|
|||
} // namespace base
|
|||
} // namespace v8
|
|||
|
|||
#endif // V8_BASE_ACCOUNTING_ALLOCATOR_H_
|
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,247 @@ |
|||
// Copyright 2016 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_COLLECTOR_H_ |
|||
#define V8_COLLECTOR_H_ |
|||
|
|||
#include "src/checks.h" |
|||
#include "src/list.h" |
|||
#include "src/vector.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
/*
|
|||
* A class that collects values into a backing store. |
|||
* Specialized versions of the class can allow access to the backing store |
|||
* in different ways. |
|||
* There is no guarantee that the backing store is contiguous (and, as a |
|||
* consequence, no guarantees that consecutively added elements are adjacent |
|||
* in memory). The collector may move elements unless it has guaranteed not |
|||
* to. |
|||
*/ |
|||
template <typename T, int growth_factor = 2, int max_growth = 1 * MB> |
|||
class Collector { |
|||
public: |
|||
explicit Collector(int initial_capacity = kMinCapacity) |
|||
: index_(0), size_(0) { |
|||
current_chunk_ = Vector<T>::New(initial_capacity); |
|||
} |
|||
|
|||
virtual ~Collector() { |
|||
// Free backing store (in reverse allocation order).
|
|||
current_chunk_.Dispose(); |
|||
for (int i = chunks_.length() - 1; i >= 0; i--) { |
|||
chunks_.at(i).Dispose(); |
|||
} |
|||
} |
|||
|
|||
// Add a single element.
|
|||
inline void Add(T value) { |
|||
if (index_ >= current_chunk_.length()) { |
|||
Grow(1); |
|||
} |
|||
current_chunk_[index_] = value; |
|||
index_++; |
|||
size_++; |
|||
} |
|||
|
|||
// Add a block of contiguous elements and return a Vector backed by the
|
|||
// memory area.
|
|||
// A basic Collector will keep this vector valid as long as the Collector
|
|||
// is alive.
|
|||
inline Vector<T> AddBlock(int size, T initial_value) { |
|||
DCHECK(size > 0); |
|||
if (size > current_chunk_.length() - index_) { |
|||
Grow(size); |
|||
} |
|||
T* position = current_chunk_.start() + index_; |
|||
index_ += size; |
|||
size_ += size; |
|||
for (int i = 0; i < size; i++) { |
|||
position[i] = initial_value; |
|||
} |
|||
return Vector<T>(position, size); |
|||
} |
|||
|
|||
// Add a contiguous block of elements and return a vector backed
|
|||
// by the added block.
|
|||
// A basic Collector will keep this vector valid as long as the Collector
|
|||
// is alive.
|
|||
inline Vector<T> AddBlock(Vector<const T> source) { |
|||
if (source.length() > current_chunk_.length() - index_) { |
|||
Grow(source.length()); |
|||
} |
|||
T* position = current_chunk_.start() + index_; |
|||
index_ += source.length(); |
|||
size_ += source.length(); |
|||
for (int i = 0; i < source.length(); i++) { |
|||
position[i] = source[i]; |
|||
} |
|||
return Vector<T>(position, source.length()); |
|||
} |
|||
|
|||
// Write the contents of the collector into the provided vector.
|
|||
void WriteTo(Vector<T> destination) { |
|||
DCHECK(size_ <= destination.length()); |
|||
int position = 0; |
|||
for (int i = 0; i < chunks_.length(); i++) { |
|||
Vector<T> chunk = chunks_.at(i); |
|||
for (int j = 0; j < chunk.length(); j++) { |
|||
destination[position] = chunk[j]; |
|||
position++; |
|||
} |
|||
} |
|||
for (int i = 0; i < index_; i++) { |
|||
destination[position] = current_chunk_[i]; |
|||
position++; |
|||
} |
|||
} |
|||
|
|||
// Allocate a single contiguous vector, copy all the collected
|
|||
// elements to the vector, and return it.
|
|||
// The caller is responsible for freeing the memory of the returned
|
|||
// vector (e.g., using Vector::Dispose).
|
|||
Vector<T> ToVector() { |
|||
Vector<T> new_store = Vector<T>::New(size_); |
|||
WriteTo(new_store); |
|||
return new_store; |
|||
} |
|||
|
|||
// Resets the collector to be empty.
|
|||
virtual void Reset() { |
|||
for (int i = chunks_.length() - 1; i >= 0; i--) { |
|||
chunks_.at(i).Dispose(); |
|||
} |
|||
chunks_.Rewind(0); |
|||
index_ = 0; |
|||
size_ = 0; |
|||
} |
|||
|
|||
// Total number of elements added to collector so far.
|
|||
inline int size() { return size_; } |
|||
|
|||
protected: |
|||
static const int kMinCapacity = 16; |
|||
List<Vector<T> > chunks_; |
|||
Vector<T> current_chunk_; // Block of memory currently being written into.
|
|||
int index_; // Current index in current chunk.
|
|||
int size_; // Total number of elements in collector.
|
|||
|
|||
// Creates a new current chunk, and stores the old chunk in the chunks_ list.
|
|||
void Grow(int min_capacity) { |
|||
DCHECK(growth_factor > 1); |
|||
int new_capacity; |
|||
int current_length = current_chunk_.length(); |
|||
if (current_length < kMinCapacity) { |
|||
// The collector started out as empty.
|
|||
new_capacity = min_capacity * growth_factor; |
|||
if (new_capacity < kMinCapacity) new_capacity = kMinCapacity; |
|||
} else { |
|||
int growth = current_length * (growth_factor - 1); |
|||
if (growth > max_growth) { |
|||
growth = max_growth; |
|||
} |
|||
new_capacity = current_length + growth; |
|||
if (new_capacity < min_capacity) { |
|||
new_capacity = min_capacity + growth; |
|||
} |
|||
} |
|||
NewChunk(new_capacity); |
|||
DCHECK(index_ + min_capacity <= current_chunk_.length()); |
|||
} |
|||
|
|||
// Before replacing the current chunk, give a subclass the option to move
|
|||
// some of the current data into the new chunk. The function may update
|
|||
// the current index_ value to represent data no longer in the current chunk.
|
|||
// Returns the initial index of the new chunk (after copied data).
|
|||
virtual void NewChunk(int new_capacity) { |
|||
Vector<T> new_chunk = Vector<T>::New(new_capacity); |
|||
if (index_ > 0) { |
|||
chunks_.Add(current_chunk_.SubVector(0, index_)); |
|||
} else { |
|||
current_chunk_.Dispose(); |
|||
} |
|||
current_chunk_ = new_chunk; |
|||
index_ = 0; |
|||
} |
|||
}; |
|||
|
|||
/*
|
|||
* A collector that allows sequences of values to be guaranteed to |
|||
* stay consecutive. |
|||
* If the backing store grows while a sequence is active, the current |
|||
* sequence might be moved, but after the sequence is ended, it will |
|||
* not move again. |
|||
* NOTICE: Blocks allocated using Collector::AddBlock(int) can move |
|||
* as well, if inside an active sequence where another element is added. |
|||
*/ |
|||
template <typename T, int growth_factor = 2, int max_growth = 1 * MB> |
|||
class SequenceCollector : public Collector<T, growth_factor, max_growth> { |
|||
public: |
|||
explicit SequenceCollector(int initial_capacity) |
|||
: Collector<T, growth_factor, max_growth>(initial_capacity), |
|||
sequence_start_(kNoSequence) {} |
|||
|
|||
virtual ~SequenceCollector() {} |
|||
|
|||
void StartSequence() { |
|||
DCHECK(sequence_start_ == kNoSequence); |
|||
sequence_start_ = this->index_; |
|||
} |
|||
|
|||
Vector<T> EndSequence() { |
|||
DCHECK(sequence_start_ != kNoSequence); |
|||
int sequence_start = sequence_start_; |
|||
sequence_start_ = kNoSequence; |
|||
if (sequence_start == this->index_) return Vector<T>(); |
|||
return this->current_chunk_.SubVector(sequence_start, this->index_); |
|||
} |
|||
|
|||
// Drops the currently added sequence, and all collected elements in it.
|
|||
void DropSequence() { |
|||
DCHECK(sequence_start_ != kNoSequence); |
|||
int sequence_length = this->index_ - sequence_start_; |
|||
this->index_ = sequence_start_; |
|||
this->size_ -= sequence_length; |
|||
sequence_start_ = kNoSequence; |
|||
} |
|||
|
|||
virtual void Reset() { |
|||
sequence_start_ = kNoSequence; |
|||
this->Collector<T, growth_factor, max_growth>::Reset(); |
|||
} |
|||
|
|||
private: |
|||
static const int kNoSequence = -1; |
|||
int sequence_start_; |
|||
|
|||
// Move the currently active sequence to the new chunk.
|
|||
virtual void NewChunk(int new_capacity) { |
|||
if (sequence_start_ == kNoSequence) { |
|||
// Fall back on default behavior if no sequence has been started.
|
|||
this->Collector<T, growth_factor, max_growth>::NewChunk(new_capacity); |
|||
return; |
|||
} |
|||
int sequence_length = this->index_ - sequence_start_; |
|||
Vector<T> new_chunk = Vector<T>::New(sequence_length + new_capacity); |
|||
DCHECK(sequence_length < new_chunk.length()); |
|||
for (int i = 0; i < sequence_length; i++) { |
|||
new_chunk[i] = this->current_chunk_[sequence_start_ + i]; |
|||
} |
|||
if (sequence_start_ > 0) { |
|||
this->chunks_.Add(this->current_chunk_.SubVector(0, sequence_start_)); |
|||
} else { |
|||
this->current_chunk_.Dispose(); |
|||
} |
|||
this->current_chunk_ = new_chunk; |
|||
this->index_ = sequence_length; |
|||
sequence_start_ = 0; |
|||
} |
|||
}; |
|||
|
|||
} // namespace internal
|
|||
} // namespace v8
|
|||
|
|||
#endif // V8_COLLECTOR_H_
|
|||
File diff suppressed because it is too large
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue