initial blobs

src/node.cc

@@ -10,6 +10,7 @@
 #include <errno.h>
 #include <dlfcn.h> /* dlopen(), dlsym() */
 
+#include <node_blob.h>
 #include <node_events.h>
 #include <node_dns.h>
 #include <node_net.h>
@@ -847,6 +848,7 @@ static Local<Object> Load(int argc, char *argv[]) {
 
 
   // Initialize the C++ modules..................filename of module
+  InitBlob(process);                           // stdio.cc
   Stdio::Initialize(process);                  // stdio.cc
   Timer::Initialize(process);                  // timer.cc
   SignalHandler::Initialize(process);          // signal_handler.cc

src/node_blob.cc

@@ -0,0 +1,294 @@
+#include <assert.h>
+#include <stdlib.h> // malloc, free
+#include <v8.h>
+#include <node.h>
+
+namespace node {
+
+using namespace v8;
+
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+
+#define SLICE_ARGS(start_arg, end_arg)                        \
+  if (!start_arg->IsInt32() || !end_arg->IsInt32()) {           \
+    return ThrowException(Exception::TypeError(               \
+          String::New("Bad argument.")));                     \
+  }                                                           \
+  int32_t start = start_arg->Int32Value();                     \
+  int32_t end = end_arg->Int32Value();                         \
+  if (start < 0 || end < 0) {                                 \
+    return ThrowException(Exception::TypeError(               \
+          String::New("Bad argument.")));                     \
+  }                                   
+
+static Persistent<String> length_symbol;
+static Persistent<FunctionTemplate> constructor_template;
+
+/* A blob is a chunk of memory stored outside the V8 heap mirrored by an
+ * object in javascript. The object is not totally opaque, one can access
+ * individual bytes with [] and one can slice the blob into substrings or
+ * subblobs without copying memory.
+ *
+ * blob.asciiSlide(0, 3) // return an ascii encoded string - no memory iscopied
+ * blob.slice(0, 3)      // returns another blob - no memory is copied
+ *
+ * Interally, each javascript blob object is backed by a "struct blob" object. 
+ * These "struct blob" objects are either the root object (in the case that
+ * blob->root == NULL) or slice objects (in which case blob->root != NULL).
+ * The root blob is only GCed once all it's slices are GCed.
+ */
+
+struct blob {
+  Persistent<Object> handle;  // both
+  bool weak;                  // both
+  struct blob *root;          // both (NULL for root)
+  size_t offset;              // both (0 for root)
+  size_t length;              // both
+  unsigned int refs;          // root only
+  char bytes[1];        // root only
+};
+
+
+static inline struct blob* blob_root(blob *blob) {
+  return blob->root ? blob->root : blob;
+}
+
+/* Determines the absolute position for a relative offset */
+static inline size_t blob_abs_off(blob *blob, size_t off) {
+  struct blob *root = blob_root(blob);
+  off += root->offset;
+  return MIN(root->length, off);
+}
+
+
+static inline void blob_ref(struct blob *blob) {
+  assert(blob->root == NULL);
+  blob->refs++;
+}
+
+
+static inline void blob_unref(struct blob *blob) {
+  assert(blob->root == NULL);
+  assert(blob->refs > 0);
+  blob->refs--;
+  if (blob->refs == 0 && blob->weak) free(blob);
+}
+
+
+static inline struct blob* Unwrap(Handle<Value> val) {
+  assert(val->IsObject());
+  HandleScope scope;
+  Local<Object> obj = val->ToObject();
+  assert(obj->InternalFieldCount() == 1);
+  Local<External> ext = Local<External>::Cast(obj->GetInternalField(0));
+  return static_cast<struct blob*>(ext->Value());
+}
+
+
+static void RootWeakCallback(Persistent<Value> value, void *data)
+{
+  struct blob *blob = static_cast<struct blob*>(data);
+  assert(blob->root == NULL); // this is the root
+  assert(value == blob->handle);
+  blob->handle.Dispose();
+  if (blob->refs) {
+    blob->weak = true;
+  } else {
+    free(blob);
+  }
+}
+
+
+static void SliceWeakCallback(Persistent<Value> value, void *data)
+{
+  struct blob *blob = static_cast<struct blob*>(data);
+  assert(blob->root != NULL); // this is a slice
+  assert(value == blob->handle);
+  blob->handle.Dispose();
+  blob_unref(blob->root);
+}
+
+
+static Handle<Value> Constructor(const Arguments &args) {
+  HandleScope scope;
+
+  size_t length;
+  struct blob *blob;
+
+  if (constructor_template->HasInstance(args[0])) {
+    // slice slice
+    SLICE_ARGS(args[1], args[2])
+
+    struct blob *parent = Unwrap(args[0]);
+
+    size_t start_abs = blob_abs_off(parent, start);
+    size_t end_abs   = blob_abs_off(parent, end);
+    assert(start_abs <= end_abs);
+    length = end_abs - start_abs;
+
+    void *d = malloc(sizeof(struct blob));
+
+    if (!d) {
+      V8::LowMemoryNotification();
+      return ThrowException(Exception::Error(
+            String::New("Could not allocate enough memory")));
+
+    }
+
+    blob = static_cast<struct blob*>(d);
+
+    blob->length = length;
+    blob->offset = start_abs;
+    blob->weak = false;
+    blob->refs = 0;
+    blob->root = blob_root(parent);
+    blob->handle = Persistent<Object>::New(args.This());
+    blob->handle.MakeWeak(blob, SliceWeakCallback);
+
+    blob_ref(blob->root);
+  } else {
+    // Root slice
+
+    length = args[0]->Uint32Value();
+
+    if (length < 1) {
+      return ThrowException(Exception::TypeError(
+            String::New("Bad argument. Length must be positive")));
+    }
+
+    // TODO alignment. modify the length?
+    void *d = malloc(sizeof(struct blob) + length - 1);
+
+    if (!d) {
+      V8::LowMemoryNotification();
+      return ThrowException(Exception::Error(
+            String::New("Could not allocate enough memory")));
+    }
+
+    blob = static_cast<struct blob*>(d);
+
+    blob->offset = 0;
+    blob->length = length;
+    blob->weak = false;
+    blob->refs = 0;
+    blob->root = NULL;
+    blob->handle = Persistent<Object>::New(args.This());
+    blob->handle.MakeWeak(blob, RootWeakCallback);
+  }
+
+  args.This()->SetInternalField(0, v8::External::New(blob));
+
+  struct blob *root = blob_root(blob);
+
+  args.This()->
+    SetIndexedPropertiesToExternalArrayData(&root->bytes + blob->offset,
+                                            kExternalUnsignedByteArray,
+                                            length);
+
+  args.This()->Set(length_symbol, Integer::New(length));
+
+  return args.This();
+}
+
+
+class AsciiSliceExt: public String::ExternalAsciiStringResource {
+ public:
+
+  AsciiSliceExt(struct blob *root, size_t start, size_t end) 
+  {
+    data_ = root->bytes + start;
+    len_ = end - start;
+    root_ = root;
+    blob_ref(root_);
+  }
+
+  ~AsciiSliceExt() {
+    blob_unref(root_);
+  }
+
+  const char* data() const {
+    return data_;
+  }
+
+  size_t length() const {
+    return len_;
+  }
+
+ private:
+  const char *data_;
+  size_t len_;
+  struct blob *root_;
+};
+
+static Handle<Value> AsciiSlice(const Arguments &args) {
+  HandleScope scope;
+
+  SLICE_ARGS(args[0], args[1])
+
+  assert(args.This()->InternalFieldCount() == 1);
+  struct blob *parent = Unwrap(args.This());
+
+  size_t start_abs = blob_abs_off(parent, start);
+  size_t end_abs   = blob_abs_off(parent, end);
+
+  assert(start_abs <= end_abs);
+
+  AsciiSliceExt *s = new AsciiSliceExt(blob_root(parent), start_abs, end_abs);
+  Local<String> string = String::NewExternal(s);
+
+  struct blob *root = blob_root(parent);
+  assert(root->refs > 0);
+  
+  return scope.Close(string);
+}
+
+static Handle<Value> Utf8Slice(const Arguments &args) {
+  HandleScope scope;
+
+  SLICE_ARGS(args[0], args[1])
+
+  struct blob *parent = Unwrap(args.This());
+  size_t start_abs = blob_abs_off(parent, start);
+  size_t end_abs   = blob_abs_off(parent, end);
+  assert(start_abs <= end_abs);
+
+  struct blob *root = blob_root(parent);
+
+  Local<String> string =
+    String::New(reinterpret_cast<const char*>(&root->bytes + start_abs),
+                end_abs - start_abs);
+  return scope.Close(string);
+}
+
+static Handle<Value> Slice(const Arguments &args) {
+  HandleScope scope;
+
+  Local<Value> argv[3] = { args.This(), args[0], args[1] };
+
+  Local<Object> slice =
+    constructor_template->GetFunction()->NewInstance(3, argv);
+
+  return scope.Close(slice);
+}
+
+void InitBlob(Handle<Object> target) {
+  HandleScope scope;
+
+  length_symbol = Persistent<String>::New(String::NewSymbol("length"));
+
+  Local<FunctionTemplate> t = FunctionTemplate::New(Constructor);
+  constructor_template = Persistent<FunctionTemplate>::New(t);
+  constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
+  constructor_template->SetClassName(String::NewSymbol("Blob"));
+
+  // copy free
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "asciiSlice", AsciiSlice);
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "slice", Slice);
+  // TODO NODE_SET_PROTOTYPE_METHOD(t, "utf16Slice", Utf16Slice);
+  // copy 
+  NODE_SET_PROTOTYPE_METHOD(constructor_template, "utf8Slice", Utf8Slice);
+
+  target->Set(String::NewSymbol("Blob"), constructor_template->GetFunction());
+}
+
+}  // namespace node

src/node_blob.h

@@ -0,0 +1,12 @@
+#ifndef NODE_BLOB
+#define NODE_BLOB
+
+#include <v8.h>
+
+namespace node {
+
+void InitBlob(v8::Handle<v8::Object> target);
+
+}
+
+#endif  // NODE_BLOB

wscript

@@ -322,6 +322,7 @@ def build(bld):
   node.target       = "node"
   node.source = """
     src/node.cc
+    src/node_blob.cc
     src/node_child_process.cc
     src/node_constants.cc
     src/node_dns.cc