Add an untagged double to transcendental cache elements. They now contain an...

src/heap.h

 // Copyright 2010 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 1975 matching lines @@
   static void Clear();
 
  private:
   MUST_USE_RESULT inline MaybeObject* 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;
+      if (e.output != NULL) {
+        Counters::transcendental_cache_hit.Increment();
+        return e.output;
+      } else {
+        Object* heap_number;
+        { MaybeObject* maybe_heap_number =
+              Heap::AllocateHeapNumber(e.untagged_output);
+          if (!maybe_heap_number->ToObject(&heap_number))
+            return maybe_heap_number;
+        }
+        elements_[hash].output = heap_number;
+        return heap_number;
+      }
     }
     double answer = Calculate(input);
     Counters::transcendental_cache_miss.Increment();
     Object* heap_number;
     { MaybeObject* maybe_heap_number = Heap::AllocateHeapNumber(answer);
       if (!maybe_heap_number->ToObject(&heap_number)) return maybe_heap_number;
     }
     elements_[hash].in[0] = c.integers[0];
     elements_[hash].in[1] = c.integers[1];
     elements_[hash].output = heap_number;
+    elements_[hash].untagged_output = answer;
     return 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.
     }
   }
   static const int kCacheSize = 512;
   struct Element {
     uint32_t in[2];
     Object* output;
+    double untagged_output;
   };
+  static const int kElementSize = sizeof (Element);

[Erik Corry, 2010/12/13 20:26:13]

There should really be some constants here that you can use in the architecture
dependent files.  All that 3 * kIntSize is rather nasty.  If you put the pointer
last the offsets will be independent of 32 or 64 bit.

   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 ^= static_cast<int32_t>(hash) >> 16;
     hash ^= static_cast<int32_t>(hash) >> 8;
     return (hash & (kCacheSize - 1));
   }
@@ skipping 57 matching lines @@
   // Return whether this object should be retained. If NULL is returned the
   // object has no references. Otherwise the address of the retained object
   // should be returned as in some GC situations the object has been moved.
   virtual Object* RetainAs(Object* object) = 0;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_