Remove the atomic/thread safe stuff from the chunk table, since we don't...

src/spaces.h

 // Copyright 2006-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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_SPACES_H_
 #define V8_SPACES_H_
 
-#include "atomicops.h"
 #include "list-inl.h"
 #include "log.h"
 
 namespace v8 {
 namespace internal {
 
 // -----------------------------------------------------------------------------
 // Heap structures:
 //
 // A JS heap consists of a young generation, an old generation, and a large
@@ skipping 639 matching lines @@
  private:
   static const int kChunkSize = kPagesPerChunk * Page::kPageSize;
   static const int kChunkSizeLog2 = kPagesPerChunkLog2 + kPageSizeBits;
   static const int kChunkTableTopLevelEntries =
       1 << (sizeof(intptr_t) * kBitsPerByte - kChunkSizeLog2 -
           (kChunkTableLevels - 1) * kChunkTableBitsPerLevel);
 
   // The chunks are not chunk-size aligned so for a given chunk-sized area of
   // memory there can be two chunks that cover it.
   static const int kChunkTableFineGrainedWordsPerEntry = 2;
-  static const AtomicWord kUnusedChunkTableEntry = 0;
+  static const uintptr_t kUnusedChunkTableEntry = 0;
 
   // Maximum space size in bytes.
   static intptr_t capacity_;
   // Maximum subset of capacity_ that can be executable
   static intptr_t capacity_executable_;
 
   // Top level table to track whether memory is part of a chunk or not.
-  static AtomicWord chunk_table_[kChunkTableTopLevelEntries];
+  static uintptr_t chunk_table_[kChunkTableTopLevelEntries];
 
   // Allocated space size in bytes.
   static intptr_t size_;
   // Allocated executable space size in bytes.
   static intptr_t size_executable_;
 
   struct MemoryAllocationCallbackRegistration {
     MemoryAllocationCallbackRegistration(MemoryAllocationCallback callback,
                                          ObjectSpace space,
                                          AllocationAction action)
@@ skipping 49 matching lines @@
   // Helpers to maintain and query the chunk tables.
   static void AddChunkUsingAddress(
       uintptr_t chunk_start,        // Where the chunk starts.
       uintptr_t chunk_index_base);  // Used to place the chunk in the tables.
   static void RemoveChunkFoundUsingAddress(
       uintptr_t chunk_start,        // Where the chunk starts.
       uintptr_t chunk_index_base);  // Used to locate the entry in the tables.
   // Controls whether the lookup creates intermediate levels of tables as
   // needed.
   enum CreateTables { kDontCreateTables, kCreateTablesAsNeeded };
-  static AtomicWord* AllocatedChunksFinder(AtomicWord* table,
-                                           uintptr_t address,
-                                           int bit_position,
-                                           CreateTables create_as_needed);
-  static void FreeChunkTables(AtomicWord* array, int length, int level);
+  static uintptr_t* AllocatedChunksFinder(uintptr_t* table,
+                                          uintptr_t address,
+                                          int bit_position,
+                                          CreateTables create_as_needed);
+  static void FreeChunkTables(uintptr_t* array, int length, int level);
   static int FineGrainedIndexForAddress(uintptr_t address) {
     int index = ((address >> kChunkSizeLog2) &
         ((1 << kChunkTableBitsPerLevel) - 1));
     return index * kChunkTableFineGrainedWordsPerEntry;
   }
 
 
   // Basic check whether a chunk id is in the valid range.
   static inline bool IsValidChunkId(int chunk_id);
 
@@ skipping 1564 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_