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

src/spaces.cc

 // 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 346 matching lines @@
 
   ASSERT(top_ == max_nof_chunks_);  // all chunks are free
   top_ = 0;
   capacity_ = 0;
   capacity_executable_ = 0;
   size_ = 0;
   max_nof_chunks_ = 0;
 }
 
 
-void MemoryAllocator::FreeChunkTables(AtomicWord* array, int len, int level) {
+void MemoryAllocator::FreeChunkTables(uintptr_t* array, int len, int level) {
   for (int i = 0; i < len; i++) {
     if (array[i] != kUnusedChunkTableEntry) {
-      AtomicWord* subarray = reinterpret_cast<AtomicWord*>(array[i]);
+      uintptr_t* subarray = reinterpret_cast<uintptr_t*>(array[i]);
       if (level > 1) {
-        Release_Store(&array[i], kUnusedChunkTableEntry);
+        array[i] = kUnusedChunkTableEntry;
         FreeChunkTables(subarray, 1 << kChunkTableBitsPerLevel, level - 1);
       } else {
-        Release_Store(&array[i], kUnusedChunkTableEntry);
+        array[i] = kUnusedChunkTableEntry;
       }
       delete[] subarray;
     }
   }
 }
 
 
 void* MemoryAllocator::AllocateRawMemory(const size_t requested,
                                          size_t* allocated,
                                          Executability executable) {
@@ skipping 429 matching lines @@
 void MemoryAllocator::AddToAllocatedChunks(Address addr, intptr_t size) {
   ASSERT(size == kChunkSize);
   uintptr_t int_address = reinterpret_cast<uintptr_t>(addr);
   AddChunkUsingAddress(int_address, int_address);
   AddChunkUsingAddress(int_address, int_address + size - 1);
 }
 
 
 void MemoryAllocator::AddChunkUsingAddress(uintptr_t chunk_start,
                                            uintptr_t chunk_index_base) {
-  AtomicWord* fine_grained = AllocatedChunksFinder(
+  uintptr_t* fine_grained = AllocatedChunksFinder(
       chunk_table_,
       chunk_index_base,
       kChunkSizeLog2 + (kChunkTableLevels - 1) * kChunkTableBitsPerLevel,
       kCreateTablesAsNeeded);
   int index = FineGrainedIndexForAddress(chunk_index_base);
   if (fine_grained[index] != kUnusedChunkTableEntry) index++;
   ASSERT(fine_grained[index] == kUnusedChunkTableEntry);
-  Release_Store(&fine_grained[index], chunk_start);
+  fine_grained[index] = chunk_start;
 }
 
 
 void MemoryAllocator::RemoveFromAllocatedChunks(Address addr, intptr_t size) {
   ASSERT(size == kChunkSize);
   uintptr_t int_address = reinterpret_cast<uintptr_t>(addr);
   RemoveChunkFoundUsingAddress(int_address, int_address);
   RemoveChunkFoundUsingAddress(int_address, int_address + size - 1);
 }
 
 
 void MemoryAllocator::RemoveChunkFoundUsingAddress(
     uintptr_t chunk_start,
     uintptr_t chunk_index_base) {
-  AtomicWord* fine_grained = AllocatedChunksFinder(
+  uintptr_t* fine_grained = AllocatedChunksFinder(
       chunk_table_,
       chunk_index_base,
       kChunkSizeLog2 + (kChunkTableLevels - 1) * kChunkTableBitsPerLevel,
       kDontCreateTables);
   // Can't remove an entry that's not there.
   ASSERT(fine_grained != kUnusedChunkTableEntry);
   int index = FineGrainedIndexForAddress(chunk_index_base);
   ASSERT(fine_grained[index] != kUnusedChunkTableEntry);
-  if (fine_grained[index] != static_cast<AtomicWord>(chunk_start)) {
+  if (fine_grained[index] != chunk_start) {
     index++;
-    ASSERT(fine_grained[index] == static_cast<AtomicWord>(chunk_start));
-    Release_Store(&fine_grained[index], kUnusedChunkTableEntry);
+    ASSERT(fine_grained[index] == chunk_start);
+    fine_grained[index] = kUnusedChunkTableEntry;
   } else {
-    Release_Store(&fine_grained[index], fine_grained[index + 1]);
-    // Here for a moment the two entries are duplicates, but the reader can
-    // handle that.
-    NoBarrier_Store(&fine_grained[index + 1], kUnusedChunkTableEntry);
+    // If only one of the entries is used it must be the first, since
+    // InAllocatedChunks relies on that.  Move things around so that this is
+    // the case.
+    fine_grained[index] = fine_grained[index + 1];
+    fine_grained[index + 1] = kUnusedChunkTableEntry;
   }
 }
 
 
 bool MemoryAllocator::InAllocatedChunks(Address addr) {
   uintptr_t int_address = reinterpret_cast<uintptr_t>(addr);
-  AtomicWord* fine_grained = AllocatedChunksFinder(
+  uintptr_t* fine_grained = AllocatedChunksFinder(
       chunk_table_,
       int_address,
       kChunkSizeLog2 + (kChunkTableLevels - 1) * kChunkTableBitsPerLevel,
       kDontCreateTables);
   if (fine_grained == NULL) return false;
   int index = FineGrainedIndexForAddress(int_address);
   if (fine_grained[index] == kUnusedChunkTableEntry) return false;
-  uintptr_t entry = static_cast<uintptr_t>(fine_grained[index]);
+  uintptr_t entry = fine_grained[index];
   if (entry <= int_address && entry + kChunkSize > int_address) return true;
   index++;
   if (fine_grained[index] == kUnusedChunkTableEntry) return false;
-  entry = static_cast<uintptr_t>(fine_grained[index]);
-  // At this point it would seem that we must have a hit, but there is a small
-  // window during RemoveChunkFoundUsingAddress where the two entries are
-  // duplicates and we have to handle that.
+  entry = fine_grained[index];
   if (entry <= int_address && entry + kChunkSize > int_address) return true;
   return false;
 }
 
 
-AtomicWord* MemoryAllocator::AllocatedChunksFinder(
-    AtomicWord* table,
+uintptr_t* MemoryAllocator::AllocatedChunksFinder(
+    uintptr_t* table,
     uintptr_t address,
     int bit_position,
     CreateTables create_as_needed) {
   if (bit_position == kChunkSizeLog2) {
     return table;
   }
   ASSERT(bit_position >= kChunkSizeLog2 + kChunkTableBitsPerLevel);
   int index =
       ((address >> bit_position) &
        ((V8_INTPTR_C(1) << kChunkTableBitsPerLevel) - 1));
   uintptr_t more_fine_grained_address =
       address & ((V8_INTPTR_C(1) << bit_position) - 1);
   ASSERT((table == chunk_table_ && index < kChunkTableTopLevelEntries) ||
          (table != chunk_table_ && index < 1 << kChunkTableBitsPerLevel));
-  AtomicWord* more_fine_grained_table =
-      reinterpret_cast<AtomicWord*>(table[index]);
+  uintptr_t* more_fine_grained_table =
+      reinterpret_cast<uintptr_t*>(table[index]);
   if (more_fine_grained_table == kUnusedChunkTableEntry) {
     if (create_as_needed == kDontCreateTables) return NULL;
     int words_needed = 1 << kChunkTableBitsPerLevel;
     if (bit_position == kChunkTableBitsPerLevel + kChunkSizeLog2) {
       words_needed =
           (1 << kChunkTableBitsPerLevel) * kChunkTableFineGrainedWordsPerEntry;
     }
-    more_fine_grained_table = new AtomicWord[words_needed];
+    more_fine_grained_table = new uintptr_t[words_needed];
     for (int i = 0; i < words_needed; i++) {
       more_fine_grained_table[i] = kUnusedChunkTableEntry;
     }
-    Release_Store(&table[index],
-                  reinterpret_cast<AtomicWord>(more_fine_grained_table));
+    table[index] = reinterpret_cast<uintptr_t>(more_fine_grained_table);
   }
   return AllocatedChunksFinder(
       more_fine_grained_table,
       more_fine_grained_address,
       bit_position - kChunkTableBitsPerLevel,
       create_as_needed);
 }
 
 
-AtomicWord MemoryAllocator::chunk_table_[kChunkTableTopLevelEntries];
+uintptr_t MemoryAllocator::chunk_table_[kChunkTableTopLevelEntries];
 
 
 // -----------------------------------------------------------------------------
 // PagedSpace implementation
 
 PagedSpace::PagedSpace(intptr_t max_capacity,
                        AllocationSpace id,
                        Executability executable)
     : Space(id, executable) {
   max_capacity_ = (RoundDown(max_capacity, Page::kPageSize) / Page::kPageSize)
@@ skipping 2301 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal