lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9717 Commits
131 Branches
446 Tags
325 MiB
Tree: e746bbdc2b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e746bbdc2b'
${ noResults }
node/src/smalloc.cc

500 lines
15 KiB
Raw Normal View History

smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto's SlabBuffer, stream's SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "smalloc.h"
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto's SlabBuffer, stream's SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "env.h"
#include "env-inl.h"
smalloc: check if object has external memory Add HasExternalData API to check if Object has externally allocated memory, and accompanying tests.
11 years ago
#include "node.h"
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "node_internals.h"
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto's SlabBuffer, stream's SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
#include "v8-profiler.h"
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "v8.h"
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto's SlabBuffer, stream's SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
#include <string.h>
#include <assert.h>
#define ALLOC_ID (0xA10C)
namespace node {
namespace smalloc {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
using v8::Context;
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
using v8::External;
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
using v8::ExternalArrayType;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::FunctionCallbackInfo;
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
using v8::Handle;
using v8::HandleScope;
using v8::HeapProfiler;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Persistent;
using v8::RetainedObjectInfo;
using v8::Uint32;
using v8::Value;
using v8::kExternalUnsignedByteArray;
struct CallbackInfo {
void* hint;
FreeCallback cb;
smalloc: don&#39;t take address of stack var
12 years ago
Persistent<Object> p_obj;
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
};
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void TargetCallback(Isolate* isolate,
Persistent<Object>* target,
char* arg);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
void TargetFreeCallback(Isolate* isolate,
Persistent<Object>* target,
smalloc: don&#39;t take address of stack var
12 years ago
CallbackInfo* arg);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
// return size of external array type, or 0 if unrecognized
smalloc: expose ExternalArraySize Useful to correctly determine the byte size of the external memory that needs to be allocated for an external array.
12 years ago
size_t ExternalArraySize(enum ExternalArrayType type) {
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
switch (type) {
case v8::kExternalUnsignedByteArray:
return sizeof(uint8_t);
case v8::kExternalByteArray:
return sizeof(int8_t);
case v8::kExternalShortArray:
return sizeof(int16_t);
case v8::kExternalUnsignedShortArray:
return sizeof(uint16_t);
case v8::kExternalIntArray:
return sizeof(int32_t);
case v8::kExternalUnsignedIntArray:
return sizeof(uint32_t);
case v8::kExternalFloatArray:
return sizeof(float); // NOLINT(runtime/sizeof)
case v8::kExternalDoubleArray:
return sizeof(double); // NOLINT(runtime/sizeof)
case v8::kExternalPixelArray:
return sizeof(uint8_t);
}
return 0;
}
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
// copyOnto(source, source_start, dest, dest_start, copy_length)
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void CopyOnto(const FunctionCallbackInfo<Value>& args) {
smalloc: consistent-ify syntax Small syntax fixes of variable renaming and argument alignment.
12 years ago
HandleScope handle_scope(node_isolate);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: cleanup checks/conversions * Moved the ToObject check out of smalloc::Alloc and into JS. Direct usage of that method is for internal use only and so can bypass the possible coercion. * Same has been done with smalloc::SliceOnto. * smalloc::CopyOnto will now throw if passed argument is not an object. * Remove extra TargetFreeCallback function. There was a use for it when it was working with a Local&lt;T&gt;, but that code has been removed making the function superfluous.
12 years ago
if (!args[0]->IsObject())
return ThrowTypeError("source must be an object");
if (!args[2]->IsObject())
return ThrowTypeError("dest must be an object");
Local<Object> source = args[0].As<Object>();
Local<Object> dest = args[2].As<Object>();
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
if (!source->HasIndexedPropertiesInExternalArrayData())
return ThrowError("source has no external array data");
if (!dest->HasIndexedPropertiesInExternalArrayData())
return ThrowError("dest has no external array data");
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
size_t source_start = args[1]->Uint32Value();
size_t dest_start = args[3]->Uint32Value();
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
size_t copy_length = args[4]->Uint32Value();
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
char* source_data = static_cast<char*>(
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
source->GetIndexedPropertiesExternalArrayData());
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
char* dest_data = static_cast<char*>(
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
dest->GetIndexedPropertiesExternalArrayData());
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
size_t source_length = source->GetIndexedPropertiesExternalArrayDataLength();
enum ExternalArrayType source_type =
source->GetIndexedPropertiesExternalArrayDataType();
size_t source_size = ExternalArraySize(source_type);
size_t dest_length = dest->GetIndexedPropertiesExternalArrayDataLength();
enum ExternalArrayType dest_type =
dest->GetIndexedPropertiesExternalArrayDataType();
size_t dest_size = ExternalArraySize(dest_type);
// optimization for Uint8 arrays (i.e. Buffers)
if (source_size != 1 && dest_size != 1) {
if (source_size == 0)
return ThrowTypeError("unknown source external array type");
if (dest_size == 0)
return ThrowTypeError("unknown dest external array type");
if (source_length * source_size < source_length)
return ThrowRangeError("source_length * source_size overflow");
if (copy_length * source_size < copy_length)
return ThrowRangeError("copy_length * source_size overflow");
if (dest_length * dest_size < dest_length)
return ThrowRangeError("dest_length * dest_size overflow");
source_length *= source_size;
copy_length *= source_size;
dest_length *= dest_size;
}
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
// necessary to check in case (source|dest)_start _and_ copy_length overflow
if (copy_length > source_length)
return ThrowRangeError("copy_length > source_length");
if (copy_length > dest_length)
return ThrowRangeError("copy_length > dest_length");
if (source_start > source_length)
return ThrowRangeError("source_start > source_length");
if (dest_start > dest_length)
return ThrowRangeError("dest_start > dest_length");
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
// now we can guarantee these will catch oob access and *_start overflow
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
if (source_start + copy_length > source_length)
return ThrowRangeError("source_start + copy_length > source_length");
if (dest_start + copy_length > dest_length)
return ThrowRangeError("dest_start + copy_length > dest_length");
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
memmove(dest_data + dest_start, source_data + source_start, copy_length);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
// dest will always be same type as source
// for internal use:
// dest._data = sliceOnto(source, dest, start, end);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void SliceOnto(const FunctionCallbackInfo<Value>& args) {
smalloc: consistent-ify syntax Small syntax fixes of variable renaming and argument alignment.
12 years ago
HandleScope handle_scope(node_isolate);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: cleanup checks/conversions * Moved the ToObject check out of smalloc::Alloc and into JS. Direct usage of that method is for internal use only and so can bypass the possible coercion. * Same has been done with smalloc::SliceOnto. * smalloc::CopyOnto will now throw if passed argument is not an object. * Remove extra TargetFreeCallback function. There was a use for it when it was working with a Local&lt;T&gt;, but that code has been removed making the function superfluous.
12 years ago
Local<Object> source = args[0].As<Object>();
Local<Object> dest = args[1].As<Object>();
assert(source->HasIndexedPropertiesInExternalArrayData());
assert(!dest->HasIndexedPropertiesInExternalArrayData());
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
char* source_data = static_cast<char*>(
source->GetIndexedPropertiesExternalArrayData());
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
size_t source_len = source->GetIndexedPropertiesExternalArrayDataLength();
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
enum ExternalArrayType source_type =
source->GetIndexedPropertiesExternalArrayDataType();
size_t source_size = ExternalArraySize(source_type);
assert(source_size != 0);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
size_t start = args[2]->Uint32Value();
size_t end = args[3]->Uint32Value();
buffer: slice on zero length buffer SlowBuffer(0) passes NULL instead of doing malloc(0). So when someone attempted to SlowBuffer(0).slice(0, 1) an assert would fail in smalloc::SliceOnto. It&#39;s important that the check go where it is because the resulting Buffer needs to have external array data allocated. In the case a user tries to slice a zero length Buffer it will also have NULL passed as the data argument. Also fixed where the .parent attribute was set for zero length Buffers. There is no need to track the source of slice if the slice isn&#39;t actually occurring.
12 years ago
size_t length = end - start;
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
if (source_size > 1) {
assert(length * source_size >= length);
length *= source_size;
}
buffer: slice on zero length buffer SlowBuffer(0) passes NULL instead of doing malloc(0). So when someone attempted to SlowBuffer(0).slice(0, 1) an assert would fail in smalloc::SliceOnto. It&#39;s important that the check go where it is because the resulting Buffer needs to have external array data allocated. In the case a user tries to slice a zero length Buffer it will also have NULL passed as the data argument. Also fixed where the .parent attribute was set for zero length Buffers. There is no need to track the source of slice if the slice isn&#39;t actually occurring.
12 years ago
assert(source_data != NULL || length == 0);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
assert(end <= source_len);
assert(start <= end);
dest->SetIndexedPropertiesToExternalArrayData(source_data + start,
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
source_type,
buffer: slice on zero length buffer SlowBuffer(0) passes NULL instead of doing malloc(0). So when someone attempted to SlowBuffer(0).slice(0, 1) an assert would fail in smalloc::SliceOnto. It&#39;s important that the check go where it is because the resulting Buffer needs to have external array data allocated. In the case a user tries to slice a zero length Buffer it will also have NULL passed as the data argument. Also fixed where the .parent attribute was set for zero length Buffers. There is no need to track the source of slice if the slice isn&#39;t actually occurring.
12 years ago
length);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(source);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
// for internal use:
// alloc(obj, n[, type]);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Alloc(const FunctionCallbackInfo<Value>& args) {
smalloc: consistent-ify syntax Small syntax fixes of variable renaming and argument alignment.
12 years ago
HandleScope handle_scope(node_isolate);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: remove double checks Now that values are checks in JS, no need for them to be checked in C++.
12 years ago
Local<Object> obj = args[0].As<Object>();
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: cleanup checks/conversions * Moved the ToObject check out of smalloc::Alloc and into JS. Direct usage of that method is for internal use only and so can bypass the possible coercion. * Same has been done with smalloc::SliceOnto. * smalloc::CopyOnto will now throw if passed argument is not an object. * Remove extra TargetFreeCallback function. There was a use for it when it was working with a Local&lt;T&gt;, but that code has been removed making the function superfluous.
12 years ago
// can't perform this check in JS
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
if (obj->HasIndexedPropertiesInExternalArrayData())
return ThrowTypeError("object already has external array data");
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
size_t length = args[1]->Uint32Value();
enum ExternalArrayType array_type;
// it's faster to not pass the default argument then use Uint32Value
smalloc: length is byte size, not array length The C++ API has been changed so the passed length is the byte size of the data, not the length of the array. This was done so users need to explicitly define how much memory they want allocated.
12 years ago
if (args[2]->IsUndefined()) {
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
array_type = kExternalUnsignedByteArray;
smalloc: length is byte size, not array length The C++ API has been changed so the passed length is the byte size of the data, not the length of the array. This was done so users need to explicitly define how much memory they want allocated.
12 years ago
} else {
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
array_type = static_cast<ExternalArrayType>(args[2]->Uint32Value());
smalloc: length is byte size, not array length The C++ API has been changed so the passed length is the byte size of the data, not the length of the array. This was done so users need to explicitly define how much memory they want allocated.
12 years ago
size_t type_length = ExternalArraySize(array_type);
assert(type_length * length >= length);
length *= type_length;
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
Alloc(obj, length, array_type);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(obj);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
void Alloc(Handle<Object> obj, size_t length, enum ExternalArrayType type) {
size_t type_size = ExternalArraySize(type);
smalloc: length is byte size, not array length The C++ API has been changed so the passed length is the byte size of the data, not the length of the array. This was done so users need to explicitly define how much memory they want allocated.
12 years ago
assert(length <= kMaxLength);
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
assert(type_size > 0);
smalloc: use malloc instead of new To use realloc the implementation had to be changed to use malloc/free.
12 years ago
if (length == 0)
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
return Alloc(obj, NULL, length, type);
smalloc: use malloc instead of new To use realloc the implementation had to be changed to use malloc/free.
12 years ago
char* data = static_cast<char*>(malloc(length));
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
if (data == NULL) {
FatalError("node::smalloc::Alloc(v8::Handle<v8::Object>, size_t,"
smalloc: consistent-ify syntax Small syntax fixes of variable renaming and argument alignment.
12 years ago
" v8::ExternalArrayType)", "Out Of Memory");
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
}
Alloc(obj, data, length, type);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
void Alloc(Handle<Object> obj,
char* data,
size_t length,
enum ExternalArrayType type) {
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
assert(!obj->HasIndexedPropertiesInExternalArrayData());
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
Persistent<Object> p_obj(node_isolate, obj);
node_isolate->AdjustAmountOfExternalAllocatedMemory(length);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
p_obj.MakeWeak(data, TargetCallback);
p_obj.MarkIndependent();
p_obj.SetWrapperClassId(ALLOC_ID);
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
size_t size = length / ExternalArraySize(type);
obj->SetIndexedPropertiesToExternalArrayData(data, type, size);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void TargetCallback(Isolate* isolate,
Persistent<Object>* target,
char* data) {
smalloc: don&#39;t take address of stack var
12 years ago
HandleScope handle_scope(isolate);
src: cast strong persistent handles to locals Avoids the overhead of creating a new Local every time we unwrap a Persistent handle.
12 years ago
Local<Object> obj = PersistentToLocal(isolate, *target);
smalloc: cleanup checks/conversions * Moved the ToObject check out of smalloc::Alloc and into JS. Direct usage of that method is for internal use only and so can bypass the possible coercion. * Same has been done with smalloc::SliceOnto. * smalloc::CopyOnto will now throw if passed argument is not an object. * Remove extra TargetFreeCallback function. There was a use for it when it was working with a Local&lt;T&gt;, but that code has been removed making the function superfluous.
12 years ago
size_t len = obj->GetIndexedPropertiesExternalArrayDataLength();
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
enum ExternalArrayType array_type =
obj->GetIndexedPropertiesExternalArrayDataType();
size_t array_size = ExternalArraySize(array_type);
assert(array_size > 0);
assert(array_size * len >= len);
len *= array_size;
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
if (data != NULL && len > 0) {
isolate->AdjustAmountOfExternalAllocatedMemory(-len);
smalloc: use malloc instead of new To use realloc the implementation had to be changed to use malloc/free.
12 years ago
free(data);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
(*target).Dispose();
}
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
// for internal use: dispose(obj);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void AllocDispose(const FunctionCallbackInfo<Value>& args) {
smalloc: remove double checks Now that values are checks in JS, no need for them to be checked in C++.
12 years ago
AllocDispose(args[0].As<Object>());
smalloc: add api to manually dispose Persistent If the user knows the allocation is no longer needed then the memory can be manually released. Currently this will not ClearWeak the Persistent, so the callback will still run. If the user passed a ClearWeak callback, and then disposed the object, the buffer callback argument will == NULL.
12 years ago
}
void AllocDispose(Handle<Object> obj) {
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
HandleScope handle_scope(node_isolate);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(node_isolate);
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (env->using_smalloc_alloc_cb()) {
Local<Value> ext_v = obj->GetHiddenValue(env->smalloc_p_string());
smalloc: don&#39;t do Has(key), then Get(key) Don&#39;t check for the key first before retrieving it. Just fetch it and check that it has the type we expect.
12 years ago
if (ext_v->IsExternal()) {
Local<External> ext = ext_v.As<External>();
CallbackInfo* cb_info = static_cast<CallbackInfo*>(ext->Value());
TargetFreeCallback(node_isolate, &cb_info->p_obj, cb_info);
return;
}
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
}
smalloc: add api to manually dispose Persistent If the user knows the allocation is no longer needed then the memory can be manually released. Currently this will not ClearWeak the Persistent, so the callback will still run. If the user passed a ClearWeak callback, and then disposed the object, the buffer callback argument will == NULL.
12 years ago
char* data = static_cast<char*>(obj->GetIndexedPropertiesExternalArrayData());
size_t length = obj->GetIndexedPropertiesExternalArrayDataLength();
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
enum ExternalArrayType array_type =
obj->GetIndexedPropertiesExternalArrayDataType();
size_t array_size = ExternalArraySize(array_type);
assert(array_size > 0);
assert(length * array_size >= length);
length *= array_size;
smalloc: add api to manually dispose Persistent If the user knows the allocation is no longer needed then the memory can be manually released. Currently this will not ClearWeak the Persistent, so the callback will still run. If the user passed a ClearWeak callback, and then disposed the object, the buffer callback argument will == NULL.
12 years ago
smalloc: zero size allocs may need to be free&#39;d Zero size allocations don&#39;t necessarily mean that data == NULL. So instead check each value seperately and perform necessary operations.
12 years ago
if (data != NULL) {
obj->SetIndexedPropertiesToExternalArrayData(NULL,
kExternalUnsignedByteArray,
0);
free(data);
}
if (length != 0) {
node_isolate->AdjustAmountOfExternalAllocatedMemory(-length);
}
smalloc: add api to manually dispose Persistent If the user knows the allocation is no longer needed then the memory can be manually released. Currently this will not ClearWeak the Persistent, so the callback will still run. If the user passed a ClearWeak callback, and then disposed the object, the buffer callback argument will == NULL.
12 years ago
}
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
void Alloc(Handle<Object> obj,
size_t length,
FreeCallback fn,
void* hint,
enum ExternalArrayType type) {
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
assert(length <= kMaxLength);
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
size_t type_size = ExternalArraySize(type);
assert(type_size > 0);
assert(length * type_size >= length);
length *= type_size;
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
char* data = new char[length];
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
Alloc(obj, data, length, fn, hint, type);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
void Alloc(Handle<Object> obj,
char* data,
size_t length,
FreeCallback fn,
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
void* hint,
enum ExternalArrayType type) {
smalloc: create separate module It will be confusing if later on we add Buffer#dispose(), and smalloc is its own cpp api anyways. So instead create a new require(&#39;smalloc&#39;) to expose the previous Buffer.alloc/dispose methods, and expose copyOnto and kMaxLength as well. Other changes: * Added documentation and additional tests. * smalloc::CopyOnto has changed from using assert() to throwing errors on bad argument values because it is not exposed to the user. * Minor style fixes.
12 years ago
assert(!obj->HasIndexedPropertiesInExternalArrayData());
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
HandleScope handle_scope(node_isolate);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(node_isolate);
env->set_using_smalloc_alloc_cb(true);
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
CallbackInfo* cb_info = new CallbackInfo;
cb_info->cb = fn;
cb_info->hint = hint;
smalloc: don&#39;t take address of stack var
12 years ago
cb_info->p_obj.Reset(node_isolate, obj);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
obj->SetHiddenValue(env->smalloc_p_string(), External::New(cb_info));
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
node_isolate->AdjustAmountOfExternalAllocatedMemory(length +
sizeof(*cb_info));
smalloc: don&#39;t take address of stack var
12 years ago
cb_info->p_obj.MakeWeak(cb_info, TargetFreeCallback);
cb_info->p_obj.MarkIndependent();
cb_info->p_obj.SetWrapperClassId(ALLOC_ID);
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
size_t size = length / ExternalArraySize(type);
obj->SetIndexedPropertiesToExternalArrayData(data, type, size);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
}
void TargetFreeCallback(Isolate* isolate,
Persistent<Object>* target,
smalloc: don&#39;t take address of stack var
12 years ago
CallbackInfo* cb_info) {
HandleScope handle_scope(isolate);
src: cast strong persistent handles to locals Avoids the overhead of creating a new Local every time we unwrap a Persistent handle.
12 years ago
Local<Object> obj = PersistentToLocal(isolate, *target);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
char* data = static_cast<char*>(obj->GetIndexedPropertiesExternalArrayData());
smalloc: cleanup checks/conversions * Moved the ToObject check out of smalloc::Alloc and into JS. Direct usage of that method is for internal use only and so can bypass the possible coercion. * Same has been done with smalloc::SliceOnto. * smalloc::CopyOnto will now throw if passed argument is not an object. * Remove extra TargetFreeCallback function. There was a use for it when it was working with a Local&lt;T&gt;, but that code has been removed making the function superfluous.
12 years ago
size_t len = obj->GetIndexedPropertiesExternalArrayDataLength();
smalloc: allow different external array types smalloc.alloc now accepts an optional third argument which allows specifying the type of array that should be allocated. All available types are now located on smalloc.Types.
12 years ago
enum ExternalArrayType array_type =
obj->GetIndexedPropertiesExternalArrayDataType();
size_t array_size = ExternalArraySize(array_type);
assert(array_size > 0);
if (array_size > 1) {
assert(len * array_size > len);
len *= array_size;
}
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
isolate->AdjustAmountOfExternalAllocatedMemory(-(len + sizeof(*cb_info)));
smalloc: don&#39;t take address of stack var
12 years ago
cb_info->p_obj.Dispose();
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
cb_info->cb(data, cb_info->hint);
delete cb_info;
}
smalloc: check if object has external memory Add HasExternalData API to check if Object has externally allocated memory, and accompanying tests.
11 years ago
void HasExternalData(const FunctionCallbackInfo<Value>& args) {
args.GetReturnValue().Set(args[0]->IsObject() &&
HasExternalData(args[0].As<Object>()));
}
bool HasExternalData(Local<Object> obj) {
return obj->HasIndexedPropertiesInExternalArrayData();
}
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
class RetainedAllocInfo: public RetainedObjectInfo {
smalloc: fix style, use macro
12 years ago
public:
explicit RetainedAllocInfo(Handle<Value> wrapper);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
virtual void Dispose();
virtual bool IsEquivalent(RetainedObjectInfo* other);
virtual intptr_t GetHash();
virtual const char* GetLabel();
virtual intptr_t GetSizeInBytes();
smalloc: fix style, use macro
12 years ago
private:
smalloc: revert change to use pointer indirection Better to compare fixed addresses than to use pointer indirection.
12 years ago
static const char label_[];
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
char* data_;
int length_;
};
smalloc: revert change to use pointer indirection Better to compare fixed addresses than to use pointer indirection.
12 years ago
const char RetainedAllocInfo::label_[] = "smalloc";
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
RetainedAllocInfo::RetainedAllocInfo(Handle<Value> wrapper) {
Local<Object> obj = wrapper->ToObject();
length_ = obj->GetIndexedPropertiesExternalArrayDataLength();
data_ = static_cast<char*>(obj->GetIndexedPropertiesExternalArrayData());
}
void RetainedAllocInfo::Dispose() {
delete this;
}
bool RetainedAllocInfo::IsEquivalent(RetainedObjectInfo* other) {
return label_ == other->GetLabel() &&
data_ == static_cast<RetainedAllocInfo*>(other)->data_;
}
intptr_t RetainedAllocInfo::GetHash() {
return reinterpret_cast<intptr_t>(data_);
}
const char* RetainedAllocInfo::GetLabel() {
return label_;
}
intptr_t RetainedAllocInfo::GetSizeInBytes() {
return length_;
}
RetainedObjectInfo* WrapperInfo(uint16_t class_id, Handle<Value> wrapper) {
return new RetainedAllocInfo(wrapper);
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void Initialize(Handle<Object> exports,
Handle<Value> unused,
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
smalloc: fix style, use macro
12 years ago
NODE_SET_METHOD(exports, "copyOnto", CopyOnto);
NODE_SET_METHOD(exports, "sliceOnto", SliceOnto);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: fix style, use macro
12 years ago
NODE_SET_METHOD(exports, "alloc", Alloc);
NODE_SET_METHOD(exports, "dispose", AllocDispose);
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
smalloc: check if object has external memory Add HasExternalData API to check if Object has externally allocated memory, and accompanying tests.
11 years ago
NODE_SET_METHOD(exports, "hasExternalData", HasExternalData);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
exports->Set(FIXED_ONE_BYTE_STRING(node_isolate, "kMaxLength"),
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Uint32::NewFromUnsigned(kMaxLength, env->isolate()));
smalloc: call callback if set on AllocDispose Fix bug where if dev passed a callback to Alloc then called AllocDispose it wouldn&#39;t bother to pass the data to the callback and instead would just free it.
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
HeapProfiler* heap_profiler = env->isolate()->GetHeapProfiler();
smalloc: initial implementation smalloc is a simple utility for quickly allocating external memory onto js objects. This will be used to centralize how memory is managed in node, and will become the backer for Buffers. So in the future crypto&#39;s SlabBuffer, stream&#39;s SlabAllocator will be removed. Note on the js API: because no arguments are optional the order of arguments have been placed to match their cc counterparts as closely as possible.
12 years ago
heap_profiler->SetWrapperClassInfoProvider(ALLOC_ID, WrapperInfo);
}
} // namespace smalloc
} // namespace node
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
NODE_MODULE_CONTEXT_AWARE_BUILTIN(smalloc, node::smalloc::Initialize)