[Isolates] Moving TranscendentalCache to Isolate.

src/heap.h

 // Copyright 2006-2008 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 1799 matching lines @@
   static int alive_after_last_gc_;
 
   static double last_gc_end_timestamp_;
 };
 
 
 class TranscendentalCache {
  public:
   enum Type {ACOS, ASIN, ATAN, COS, EXP, LOG, SIN, TAN, kNumberOfCaches};
 
-  explicit TranscendentalCache(Type t);
-
   // Returns a heap number with f(input), where f is a math function specified
   // by the 'type' argument.
-  static inline Object* Get(Type type, double input) {
-    TranscendentalCache* cache = caches_[type];
-    if (cache == NULL) {
-      caches_[type] = cache = new TranscendentalCache(type);
-    }
-    return cache->Get(input);
-  }
+  inline Object* Get(Type type, double input);
 
   // The cache contains raw Object pointers.  This method disposes of
   // them before a garbage collection.
-  static void Clear();
+  void Clear();
 
  private:
-  inline Object* Get(double input) {
-    Converter c;
-    c.dbl = input;
-    int hash = Hash(c);
-    Element e = elements_[hash];
-    if (e.in[0] == c.integers[0] &&
-        e.in[1] == c.integers[1]) {
-      ASSERT(e.output != NULL);
-      Counters::transcendental_cache_hit.Increment();
-      return e.output;
+  class SubCache {
+    static const int kCacheSize = 512;
+
+    explicit SubCache(Type t);
+
+    inline Object* Get(double input) {
+      Converter c;
+      c.dbl = input;
+      int hash = Hash(c);
+      Element e = elements_[hash];
+      if (e.in[0] == c.integers[0] &&
+          e.in[1] == c.integers[1]) {
+        ASSERT(e.output != NULL);
+        Counters::transcendental_cache_hit.Increment();
+        return e.output;
+      }
+      double answer = Calculate(input);
+      Object* heap_number = heap_->AllocateHeapNumber(answer);
+      if (!heap_number->IsFailure()) {
+        elements_[hash].in[0] = c.integers[0];
+        elements_[hash].in[1] = c.integers[1];
+        elements_[hash].output = heap_number;
+      }
+      Counters::transcendental_cache_miss.Increment();
+      return heap_number;
     }
-    double answer = Calculate(input);
-    Object* heap_number = heap_->AllocateHeapNumber(answer);
-    if (!heap_number->IsFailure()) {
-      elements_[hash].in[0] = c.integers[0];
-      elements_[hash].in[1] = c.integers[1];
-      elements_[hash].output = heap_number;
+
+    inline double Calculate(double input) {
+      switch (type_) {
+        case ACOS:
+          return acos(input);
+        case ASIN:
+          return asin(input);
+        case ATAN:
+          return atan(input);
+        case COS:
+          return cos(input);
+        case EXP:
+          return exp(input);
+        case LOG:
+          return log(input);
+        case SIN:
+          return sin(input);
+        case TAN:
+          return tan(input);
+        default:
+          return 0.0;  // Never happens.
+      }
     }
-    Counters::transcendental_cache_miss.Increment();
-    return heap_number;
+    struct Element {
+      uint32_t in[2];
+      Object* output;
+    };
+    union Converter {
+      double dbl;
+      uint32_t integers[2];
+    };
+    inline static int Hash(const Converter& c) {
+      uint32_t hash = (c.integers[0] ^ c.integers[1]);
+      hash ^= hash >> 16;
+      hash ^= hash >> 8;
+      return (hash & (kCacheSize - 1));
+    }
+
+    // Inline implementation of the caching.
+    friend class TranscendentalCacheStub;
+
+    // For evaluating value.
+    friend class TranscendentalCache;
+
+    Element elements_[kCacheSize];
+    Type type_;
+    Heap* heap_;
+
+    DISALLOW_COPY_AND_ASSIGN(SubCache);
+  };
+
+  TranscendentalCache() {
+    for (int i = 0; i < kNumberOfCaches; ++i) caches_[i] = NULL;
   }
 
-  inline double Calculate(double input) {
-    switch (type_) {
-      case ACOS:
-        return acos(input);
-      case ASIN:
-        return asin(input);
-      case ATAN:
-        return atan(input);
-      case COS:
-        return cos(input);
-      case EXP:
-        return exp(input);
-      case LOG:
-        return log(input);
-      case SIN:
-        return sin(input);
-      case TAN:
-        return tan(input);
-      default:
-        return 0.0;  // Never happens.
-    }
-  }
-  static const int kCacheSize = 512;
-  struct Element {
-    uint32_t in[2];
-    Object* output;
-  };
-  union Converter {
-    double dbl;
-    uint32_t integers[2];
-  };
-  inline static int Hash(const Converter& c) {
-    uint32_t hash = (c.integers[0] ^ c.integers[1]);
-    hash ^= hash >> 16;
-    hash ^= hash >> 8;
-    return (hash & (kCacheSize - 1));
-  }
+  // Used to create an external reference.
+  inline Address cache_array_address();
 
-  static Address cache_array_address() {
-    // Used to create an external reference.
-    return reinterpret_cast<Address>(caches_);
-  }
-
+  // Instantiation
+  friend class Isolate;
+  // Inline implementation of the caching.
+  friend class TranscendentalCacheStub;
   // Allow access to the caches_ array as an ExternalReference.
   friend class ExternalReference;
-  // Inline implementation of the caching.
-  friend class TranscendentalCacheStub;
 
-  static TranscendentalCache* caches_[kNumberOfCaches];
-  Element elements_[kCacheSize];
-  Type type_;
-  Heap* heap_;
+  SubCache* caches_[kNumberOfCaches];
+  DISALLOW_COPY_AND_ASSIGN(TranscendentalCache);
 };
 
 
 // External strings table is a place where all external strings are
 // registered.  We need to keep track of such strings to properly
 // finalize them.
 class ExternalStringTable : public AllStatic {
  public:
   // Registers an external string.
   inline static void AddString(String* string);
@@ skipping 21 matching lines @@
   // separate from old space strings.
   static List<Object*> new_space_strings_;
   static List<Object*> old_space_strings_;
 };
 
 } }  // namespace v8::internal
 
 #undef HEAP
 
 #endif  // V8_HEAP_H_