Patch for allowing several V8 instances in process:...

src/runtime.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 74 matching lines @@
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   double name = (obj)->Number();
 
 // Call the specified converter on the object *comand store the result in
 // a variable of the specified type with the given name.  If the
 // object is not a Number call IllegalOperation and return.
 #define CONVERT_NUMBER_CHECKED(type, name, Type, obj)                \
   RUNTIME_ASSERT(obj->IsNumber());                                   \
   type name = NumberTo##Type(obj);
 
-// Non-reentrant string buffer for efficient general use in this file.
-static StaticResource<StringInputBuffer> runtime_string_input_buffer;
-
-
 static Object* DeepCopyBoilerplate(JSObject* boilerplate) {
   StackLimitCheck check;
   if (check.HasOverflowed()) return Top::StackOverflow();
 
   Object* result = Heap::CopyJSObject(boilerplate);
   if (result->IsFailure()) return result;
   JSObject* copy = JSObject::cast(result);
 
   // Deep copy local properties.
   if (copy->HasFastProperties()) {
@@ skipping 1794 matching lines @@
     return biased_good_suffix_shift_[index];
   }
  private:
   int suffixes_[kBMMaxShift + 1];
   int good_suffix_shift_[kBMMaxShift + 1];
   int* biased_suffixes_;
   int* biased_good_suffix_shift_;
   DISALLOW_COPY_AND_ASSIGN(BMGoodSuffixBuffers);
 };
 
-// buffers reused by BoyerMoore
-static int bad_char_occurrence[kBMAlphabetSize];
-static BMGoodSuffixBuffers bmgs_buffers;
+class RuntimeData {
+ public:
+  // Non-reentrant string buffer for efficient general use in this file.
+  StaticResource<StringInputBuffer> runtime_string_input_buffer_;
+  // buffers reused by BoyerMoore
+  int bad_char_occurrence_[kBMAlphabetSize];
+  BMGoodSuffixBuffers bmgs_buffers_;
+  StringInputBuffer buf1_;
+  StringInputBuffer buf2_;
+
+  unibrow::Mapping<unibrow::ToUppercase, 128> to_upper_mapping_;
+  unibrow::Mapping<unibrow::ToLowercase, 128> to_lower_mapping_;
+
+  // Arrays for the individual characters of the two Smis.  Smis are
+  // 31 bit integers and 10 decimal digits are therefore enough.
+  int x_elms_[10];
+  int y_elms_[10];
+
+  StringInputBuffer bufx_;
+  StringInputBuffer bufy_;
+
+  RuntimeData() {}
+  DISALLOW_COPY_AND_ASSIGN(RuntimeData);
+};
 
 // Compute the bad-char table for Boyer-Moore in the static buffer.
 template <typename pchar>
 static void BoyerMoorePopulateBadCharTable(Vector<const pchar> pattern,
                                           int start) {
   // Run forwards to populate bad_char_table, so that *last* instance
   // of character equivalence class is the one registered.
   // Notice: Doesn't include the last character.
   int table_size = (sizeof(pchar) == 1) ? String::kMaxAsciiCharCode + 1
                                         : kBMAlphabetSize;
+  int* const  bad_char_occurrence = v8_context()->runtime_data_->
+    bad_char_occurrence_;
+
   if (start == 0) {  // All patterns less than kBMMaxShift in length.
     memset(bad_char_occurrence, -1, table_size * sizeof(*bad_char_occurrence));
   } else {
     for (int i = 0; i < table_size; i++) {
       bad_char_occurrence[i] = start - 1;
     }
   }
   for (int i = start; i < pattern.length() - 1; i++) {
     pchar c = pattern[i];
     int bucket = (sizeof(pchar) ==1) ? c : c % kBMAlphabetSize;
     bad_char_occurrence[bucket] = i;
   }
 }
 
 template <typename pchar>
 static void BoyerMoorePopulateGoodSuffixTable(Vector<const pchar> pattern,
                                               int start) {
   int m = pattern.length();
   int len = m - start;
   // Compute Good Suffix tables.
+  BMGoodSuffixBuffers& bmgs_buffers =
+    v8_context()->runtime_data_->bmgs_buffers_;
   bmgs_buffers.init(m);
 
   bmgs_buffers.shift(m-1) = 1;
   bmgs_buffers.suffix(m) = m + 1;
   pchar last_char = pattern[m - 1];
   int suffix = m + 1;
   for (int i = m; i > start;) {
     for (pchar c = pattern[i - 1]; suffix <= m && c != pattern[suffix - 1];) {
       if (bmgs_buffers.shift(suffix) == len) {
         bmgs_buffers.shift(suffix) = suffix - i;
@@ skipping 25 matching lines @@
         bmgs_buffers.shift(i) = suffix - start;
       }
       if (i == suffix) {
         suffix = bmgs_buffers.suffix(suffix);
       }
     }
   }
 }
 
 template <typename schar, typename pchar>
-static inline int CharOccurrence(int char_code) {
+static inline int CharOccurrence(int char_code, RuntimeData* data) {
   if (sizeof(schar) == 1) {
-    return bad_char_occurrence[char_code];
+    return data->bad_char_occurrence_[char_code];
   }
   if (sizeof(pchar) == 1) {
     if (char_code > String::kMaxAsciiCharCode) {
       return -1;
     }
-    return bad_char_occurrence[char_code];
+    return data->bad_char_occurrence_[char_code];
   }
-  return bad_char_occurrence[char_code % kBMAlphabetSize];
+  return data->bad_char_occurrence_[char_code % kBMAlphabetSize];
 }
 
 // Restricted simplified Boyer-Moore string matching.
 // Uses only the bad-shift table of Boyer-Moore and only uses it
 // for the character compared to the last character of the needle.
 template <typename schar, typename pchar>
 static int BoyerMooreHorspool(Vector<const schar> subject,
                               Vector<const pchar> pattern,
                               int start_index,
                               bool* complete) {
   int n = subject.length();
   int m = pattern.length();
   // Only preprocess at most kBMMaxShift last characters of pattern.
   int start = m < kBMMaxShift ? 0 : m - kBMMaxShift;
 
   BoyerMoorePopulateBadCharTable(pattern, start);
 
+  RuntimeData* const data = v8_context()->runtime_data_;
   int badness = -m;  // How bad we are doing without a good-suffix table.
   int idx;  // No matches found prior to this index.
   pchar last_char = pattern[m - 1];
-  int last_char_shift = m - 1 - CharOccurrence<schar, pchar>(last_char);
+  int last_char_shift = m - 1 - CharOccurrence<schar, pchar>(last_char, data);
   // Perform search
   for (idx = start_index; idx <= n - m;) {
     int j = m - 1;
     int c;
     while (last_char != (c = subject[idx + j])) {
-      int bc_occ = CharOccurrence<schar, pchar>(c);
+      int bc_occ = CharOccurrence<schar, pchar>(c, data);
       int shift = j - bc_occ;
       idx += shift;
       badness += 1 - shift;  // at most zero, so badness cannot increase.
       if (idx > n - m) {
         *complete = true;
         return -1;
       }
     }
     j--;
     while (j >= 0 && pattern[j] == (subject[idx + j])) j--;
@@ skipping 23 matching lines @@
                              Vector<const pchar> pattern,
                              int idx) {
   int n = subject.length();
   int m = pattern.length();
   // Only preprocess at most kBMMaxShift last characters of pattern.
   int start = m < kBMMaxShift ? 0 : m - kBMMaxShift;
 
   // Build the Good Suffix table and continue searching.
   BoyerMoorePopulateGoodSuffixTable(pattern, start);
   pchar last_char = pattern[m - 1];
+  RuntimeData* runtime_data = v8_context()->runtime_data_;
+  BMGoodSuffixBuffers& bmgs_buffers = runtime_data->bmgs_buffers_;
   // Continue search from i.
   while (idx <= n - m) {
     int j = m - 1;
     schar c;
     while (last_char != (c = subject[idx + j])) {
-      int shift = j - CharOccurrence<schar, pchar>(c);
+      int shift = j - CharOccurrence<schar, pchar>(c, runtime_data);
       idx += shift;
       if (idx > n - m) {
         return -1;
       }
     }
     while (j >= 0 && pattern[j] == (c = subject[idx + j])) j--;
     if (j < 0) {
       return idx;
     } else if (j < start) {
       // we have matched more than our tables allow us to be smart about.
       // Fall back on BMH shift.
-      idx += m - 1 - CharOccurrence<schar, pchar>(last_char);
+      idx += m - 1 - CharOccurrence<schar, pchar>(last_char, runtime_data);
     } else {
       int gs_shift = bmgs_buffers.shift(j + 1);       // Good suffix shift.
-      int bc_occ = CharOccurrence<schar, pchar>(c);
+      int bc_occ = CharOccurrence<schar, pchar>(c, runtime_data);
       int shift = j - bc_occ;                         // Bad-char shift.
       if (gs_shift > shift) {
         shift = gs_shift;
       }
       idx += shift;
     }
   }
 
   return -1;
 }
@@ skipping 249 matching lines @@
 
   // No need to flatten if we are going to find the answer on the first
   // character.  At this point we know there is at least one character
   // in each string, due to the trivial case handling above.
   int d = str1->Get(0) - str2->Get(0);
   if (d != 0) return Smi::FromInt(d);
 
   str1->TryFlattenIfNotFlat();
   str2->TryFlattenIfNotFlat();
 
-  static StringInputBuffer buf1;
-  static StringInputBuffer buf2;
+  RuntimeData* data = v8_context()->runtime_data_;
+  StringInputBuffer& buf1 = data->buf1_;
+  StringInputBuffer& buf2 = data->buf2_;
 
   buf1.Reset(str1);
   buf2.Reset(str2);
 
   for (int i = 0; i < end; i++) {
     uint16_t char1 = buf1.GetNext();
     uint16_t char2 = buf2.GetNext();
     if (char1 != char2) return Smi::FromInt(char1 - char2);
   }
 
@@ skipping 893 matching lines @@
   const char hex_chars[] = "0123456789ABCDEF";
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(String, source, args[0]);
 
   source->TryFlattenIfNotFlat();
 
   int escaped_length = 0;
   int length = source->length();
   {
-    Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+    Access<StringInputBuffer> buffer(
+      &v8_context()->runtime_data_->runtime_string_input_buffer_);
     buffer->Reset(source);
     while (buffer->has_more()) {
       uint16_t character = buffer->GetNext();
       if (character >= 256) {
         escaped_length += 6;
       } else if (IsNotEscaped(character)) {
         escaped_length++;
       } else {
         escaped_length += 3;
       }
       // We don't allow strings that are longer than a maximal length.
       if (escaped_length > String::kMaxLength) {
         Top::context()->mark_out_of_memory();
         return Failure::OutOfMemoryException();
       }
     }
   }
   // No length change implies no change.  Return original string if no change.
   if (escaped_length == length) {
     return source;
   }
   Object* o = Heap::AllocateRawAsciiString(escaped_length);
   if (o->IsFailure()) return o;
   String* destination = String::cast(o);
   int dest_position = 0;
 
-  Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+  Access<StringInputBuffer> buffer(
+    &v8_context()->runtime_data_->runtime_string_input_buffer_);
   buffer->Rewind();
   while (buffer->has_more()) {
     uint16_t chr = buffer->GetNext();
     if (chr >= 256) {
       destination->Set(dest_position, '%');
       destination->Set(dest_position+1, 'u');
       destination->Set(dest_position+2, hex_chars[chr >> 12]);
       destination->Set(dest_position+3, hex_chars[(chr >> 8) & 0xf]);
       destination->Set(dest_position+4, hex_chars[(chr >> 4) & 0xf]);
       destination->Set(dest_position+5, hex_chars[chr & 0xf]);
@@ skipping 105 matching lines @@
 
   CONVERT_CHECKED(String, s, args[0]);
   CONVERT_SMI_CHECKED(radix, args[1]);
 
   s->TryFlattenIfNotFlat();
 
   int len = s->length();
   int i;
 
   // Skip leading white space.
-  for (i = 0; i < len && Scanner::kIsWhiteSpace.get(s->Get(i)); i++) ;
+  unibrow::Predicate<unibrow::WhiteSpace, 128>& kIsWhiteSpace =
+    v8_context()->scanner_data_.kIsWhiteSpace_;
+  for (i = 0; i < len && kIsWhiteSpace.get(s->Get(i)); i++) ;
   if (i == len) return Heap::nan_value();
 
   // Compute the sign (default to +).
   int sign = 1;
   if (s->Get(i) == '-') {
     sign = -1;
     i++;
   } else if (s->Get(i) == '+') {
     i++;
   }
@@ skipping 34 matching lines @@
   CONVERT_CHECKED(String, str, args[0]);
 
   // ECMA-262 section 15.1.2.3, empty string is NaN
   double value = StringToDouble(str, ALLOW_TRAILING_JUNK, OS::nan_value());
 
   // Create a number object from the value.
   return Heap::NumberFromDouble(value);
 }
 
 
-static unibrow::Mapping<unibrow::ToUppercase, 128> to_upper_mapping;
-static unibrow::Mapping<unibrow::ToLowercase, 128> to_lower_mapping;
 
 
 template <class Converter>
 static Object* ConvertCaseHelper(String* s,
                                  int length,
                                  int input_string_length,
                                  unibrow::Mapping<Converter, 128>* mapping) {
   // We try this twice, once with the assumption that the result is no longer
   // than the input and, if that assumption breaks, again with the exact
   // length.  This may not be pretty, but it is nicer than what was here before
   // and I hereby claim my vaffel-is.
   //
   // Allocate the resulting string.
   //
   // NOTE: This assumes that the upper/lower case of an ascii
   // character is also ascii.  This is currently the case, but it
   // might break in the future if we implement more context and locale
   // dependent upper/lower conversions.
   Object* o = s->IsAsciiRepresentation()
       ? Heap::AllocateRawAsciiString(length)
       : Heap::AllocateRawTwoByteString(length);
   if (o->IsFailure()) return o;
   String* result = String::cast(o);
   bool has_changed_character = false;
 
   // Convert all characters to upper case, assuming that they will fit
   // in the buffer
-  Access<StringInputBuffer> buffer(&runtime_string_input_buffer);
+  Access<StringInputBuffer> buffer(&v8_context()->runtime_data_->
+    runtime_string_input_buffer_);
   buffer->Reset(s);
   unibrow::uchar chars[Converter::kMaxWidth];
   // We can assume that the string is not empty
   uc32 current = buffer->GetNext();
   for (int i = 0; i < length;) {
     bool has_next = buffer->has_more();
     uc32 next = has_next ? buffer->GetNext() : 0;
     int char_length = mapping->get(current, next, chars);
     if (char_length == 0) {
       // The case conversion of this character is the character itself.
@@ skipping 76 matching lines @@
   Object* answer = ConvertCaseHelper(s, length, length, mapping);
   if (answer->IsSmi()) {
     // Retry with correct length.
     answer = ConvertCaseHelper(s, Smi::cast(answer)->value(), length, mapping);
   }
   return answer;  // This may be a failure.
 }
 
 
 static Object* Runtime_StringToLowerCase(Arguments args) {
-  return ConvertCase<unibrow::ToLowercase>(args, &to_lower_mapping);
+  return ConvertCase<unibrow::ToLowercase>(
+    args,
+    &v8_context()->runtime_data_->to_lower_mapping_);
 }
 
 
 static Object* Runtime_StringToUpperCase(Arguments args) {
-  return ConvertCase<unibrow::ToUppercase>(args, &to_upper_mapping);
+  return ConvertCase<unibrow::ToUppercase>(
+    args,
+    &v8_context()->runtime_data_->to_upper_mapping_);
 }
 
 static inline bool IsTrimWhiteSpace(unibrow::uchar c) {
   return unibrow::WhiteSpace::Is(c) || c == 0x200b;
 }
 
 static Object* Runtime_StringTrim(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
 
@@ skipping 15 matching lines @@
   if (trimRight) {
     while (right > left && IsTrimWhiteSpace(s->Get(right - 1))) {
       right--;
     }
   }
   return s->SubString(left, right);
 }
 
 bool Runtime::IsUpperCaseChar(uint16_t ch) {
   unibrow::uchar chars[unibrow::ToUppercase::kMaxWidth];
-  int char_length = to_upper_mapping.get(ch, 0, chars);
+  int char_length = v8_context()->runtime_data_->
+    to_upper_mapping_.get(ch, 0, chars);
   return char_length == 0;
 }
 
 
 static Object* Runtime_NumberToString(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   Object* number = args[0];
   RUNTIME_ASSERT(number->IsNumber());
@@ skipping 116 matching lines @@
   // NewNumberFromDouble may return a Smi instead of a Number object
   return Heap::NewNumberFromDouble(x);
 }
 
 
 static Object* Runtime_StringAdd(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(String, str1, args[0]);
   CONVERT_CHECKED(String, str2, args[1]);
-  Counters::string_add_runtime.Increment();
+  INC_COUNTER(string_add_runtime);
   return Heap::AllocateConsString(str1, str2);
 }
 
 
 template<typename sinkchar>
 static inline void StringBuilderConcatHelper(String* special,
                                              sinkchar* sink,
                                              FixedArray* fixed_array,
                                              int array_length) {
   int position = 0;
@@ skipping 248 matching lines @@
   return Smi::FromInt(GREATER);
 }
 
 
 // Compare two Smis as if they were converted to strings and then
 // compared lexicographically.
 static Object* Runtime_SmiLexicographicCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
+  RuntimeData* const data = v8_context()->runtime_data_;
   // Arrays for the individual characters of the two Smis.  Smis are
   // 31 bit integers and 10 decimal digits are therefore enough.
-  static int x_elms[10];
-  static int y_elms[10];
+  int * const x_elms = data->x_elms_;
+  int * const y_elms = data->y_elms_;
 
   // Extract the integer values from the Smis.
   CONVERT_CHECKED(Smi, x, args[0]);
   CONVERT_CHECKED(Smi, y, args[1]);
   int x_value = x->value();
   int y_value = y->value();
 
   // If the integers are equal so are the string representations.
   if (x_value == y_value) return Smi::FromInt(EQUAL);
 
@@ skipping 53 matching lines @@
     return Smi::FromInt(LESS);
   }
 
   int d = x->Get(0) - y->Get(0);
   if (d < 0) return Smi::FromInt(LESS);
   else if (d > 0) return Smi::FromInt(GREATER);
 
   x->TryFlattenIfNotFlat();
   y->TryFlattenIfNotFlat();
 
-  static StringInputBuffer bufx;
-  static StringInputBuffer bufy;
+  RuntimeData* const data = v8_context()->runtime_data_;
+  StringInputBuffer& bufx = data->bufx_;
+  StringInputBuffer& bufy = data->bufy_;
   bufx.Reset(x);
   bufy.Reset(y);
   while (bufx.has_more() && bufy.has_more()) {
     int d = bufx.GetNext() - bufy.GetNext();
     if (d < 0) return Smi::FromInt(LESS);
     else if (d > 0) return Smi::FromInt(GREATER);
   }
 
   // x is (non-trivial) prefix of y:
   if (bufy.has_more()) return Smi::FromInt(LESS);
@@ skipping 351 matching lines @@
 
   bool first_allocation = !function->has_initial_map();
   Handle<JSObject> result = Factory::NewJSObject(function);
   if (first_allocation) {
     Handle<Map> map = Handle<Map>(function->initial_map());
     Handle<Code> stub = Handle<Code>(
         ComputeConstructStub(Handle<SharedFunctionInfo>(function->shared())));
     function->shared()->set_construct_stub(*stub);
   }
 
-  Counters::constructed_objects.Increment();
-  Counters::constructed_objects_runtime.Increment();
+  INC_COUNTER(constructed_objects);
+  INC_COUNTER(constructed_objects_runtime);
 
   return *result;
 }
 
 
 static Object* Runtime_LazyCompile(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
   Handle<JSFunction> function = args.at<JSFunction>(0);
@@ skipping 3435 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   if (failure->IsRetryAfterGC()) {
     // Try to do a garbage collection; ignore it if it fails. The C
     // entry stub will throw an out-of-memory exception in that case.
     Heap::CollectGarbage(failure->requested(), failure->allocation_space());
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
-    Counters::gc_last_resort_from_js.Increment();
+    INC_COUNTER(gc_last_resort_from_js);
     Heap::CollectAllGarbage(false);
   }
 }
 
+void Runtime::PostConstruct() {
+  v8_context()->runtime_data_ = new RuntimeData();
+}
+
+void Runtime::PreDestroy() {
+  delete v8_context()->runtime_data_;
+  v8_context()->runtime_data_ = NULL;
+}
 
 } }  // namespace v8::internal