Add card table test.

Tests some of the functionality supported by the card table.

Removed some logcat spam from monitor_pool.

Change-Id: I1423816a72572f78aca44552effa2b4c6aac46c8

5 files changed, 163 insertions, 14 deletions

diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index 6e27190..9ee3b69 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -91,6 +91,7 @@ RUNTIME_GTEST_COMMON_SRC_FILES := \
   runtime/entrypoints/quick/quick_trampoline_entrypoints_test.cc \
   runtime/entrypoints_order_test.cc \
   runtime/exception_test.cc \
+  runtime/gc/accounting/card_table_test.cc \
   runtime/gc/accounting/space_bitmap_test.cc \
   runtime/gc/heap_test.cc \
   runtime/gc/space/dlmalloc_space_base_test.cc \
diff --git a/runtime/gc/accounting/card_table.cc b/runtime/gc/accounting/card_table.cc
index ceb42e5..0498550 100644
--- a/runtime/gc/accounting/card_table.cc
+++ b/runtime/gc/accounting/card_table.cc
@@ -28,6 +28,11 @@ namespace art {
 namespace gc {
 namespace accounting {
 
+constexpr size_t CardTable::kCardShift;
+constexpr size_t CardTable::kCardSize;
+constexpr uint8_t CardTable::kCardClean;
+constexpr uint8_t CardTable::kCardDirty;
+
 /*
  * Maintain a card table from the write barrier. All writes of
  * non-NULL values to heap addresses should go through an entry in
@@ -55,9 +60,9 @@ CardTable* CardTable::Create(const byte* heap_begin, size_t heap_capacity) {
   size_t capacity = heap_capacity / kCardSize;
   /* Allocate an extra 256 bytes to allow fixed low-byte of base */
   std::string error_msg;
-  std::unique_ptr<MemMap> mem_map(MemMap::MapAnonymous("card table", NULL,
-                                                 capacity + 256, PROT_READ | PROT_WRITE,
-                                                 false, &error_msg));
+  std::unique_ptr<MemMap> mem_map(
+      MemMap::MapAnonymous("card table", nullptr, capacity + 256, PROT_READ | PROT_WRITE,
+                           false, &error_msg));
   CHECK(mem_map.get() != NULL) << "couldn't allocate card table: " << error_msg;
   // All zeros is the correct initial value; all clean. Anonymous mmaps are initialized to zero, we
   // don't clear the card table to avoid unnecessary pages being allocated
@@ -67,17 +72,17 @@ CardTable* CardTable::Create(const byte* heap_begin, size_t heap_capacity) {
   CHECK(cardtable_begin != NULL);
 
   // We allocated up to a bytes worth of extra space to allow biased_begin's byte value to equal
-  // GC_CARD_DIRTY, compute a offset value to make this the case
+  // kCardDirty, compute a offset value to make this the case
   size_t offset = 0;
   byte* biased_begin = reinterpret_cast<byte*>(reinterpret_cast<uintptr_t>(cardtable_begin) -
       (reinterpret_cast<uintptr_t>(heap_begin) >> kCardShift));
-  if (((uintptr_t)biased_begin & 0xff) != kCardDirty) {
-    int delta = kCardDirty - (reinterpret_cast<uintptr_t>(biased_begin) & 0xff);
+  uintptr_t biased_byte = reinterpret_cast<uintptr_t>(biased_begin) & 0xff;
+  if (biased_byte != kCardDirty) {
+    int delta = kCardDirty - biased_byte;
     offset = delta + (delta < 0 ? 0x100 : 0);
     biased_begin += offset;
   }
   CHECK_EQ(reinterpret_cast<uintptr_t>(biased_begin) & 0xff, kCardDirty);
-
   return new CardTable(mem_map.release(), biased_begin, offset);
 }
 
diff --git a/runtime/gc/accounting/card_table.h b/runtime/gc/accounting/card_table.h
index 7934974..fbeea85 100644
--- a/runtime/gc/accounting/card_table.h
+++ b/runtime/gc/accounting/card_table.h
@@ -46,10 +46,10 @@ template<size_t kAlignment> class SpaceBitmap;
 // WriteBarrier, and from there to here.
 class CardTable {
  public:
-  static const size_t kCardShift = 7;
-  static const size_t kCardSize = (1 << kCardShift);
-  static const uint8_t kCardClean = 0x0;
-  static const uint8_t kCardDirty = 0x70;
+  static constexpr size_t kCardShift = 7;
+  static constexpr size_t kCardSize = 1 << kCardShift;
+  static constexpr uint8_t kCardClean = 0x0;
+  static constexpr uint8_t kCardDirty = 0x70;
 
   static CardTable* Create(const byte* heap_begin, size_t heap_capacity);
 
diff --git a/runtime/gc/accounting/card_table_test.cc b/runtime/gc/accounting/card_table_test.cc
new file mode 100644
index 0000000..a88b2c9
--- /dev/null
+++ b/runtime/gc/accounting/card_table_test.cc
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "card_table-inl.h"
+
+#include <string>
+
+#include "atomic.h"
+#include "common_runtime_test.h"
+#include "handle_scope-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/string-inl.h"  // Strings are easiest to allocate
+#include "scoped_thread_state_change.h"
+#include "thread_pool.h"
+#include "utils.h"
+
+namespace art {
+
+namespace mirror {
+  class Object;
+}  // namespace mirror
+
+class CardTableTest : public CommonRuntimeTest {
+ public:
+  std::unique_ptr<gc::accounting::CardTable> card_table_;
+  static constexpr size_t kCardSize = gc::accounting::CardTable::kCardSize;
+
+  void CommonSetup() {
+    if (card_table_.get() == nullptr) {
+      card_table_.reset(gc::accounting::CardTable::Create(heap_begin_, heap_size_));
+      EXPECT_TRUE(card_table_.get() != nullptr);
+    } else {
+      ClearCardTable();
+    }
+  }
+  // Default values for the test, not random to avoid undeterministic behaviour.
+  CardTableTest() : heap_begin_(reinterpret_cast<byte*>(0x2000000)), heap_size_(2 * MB) {
+  }
+  void ClearCardTable() {
+    card_table_->ClearCardTable();
+  }
+  byte* HeapBegin() const {
+    return heap_begin_;
+  }
+  byte* HeapLimit() const {
+    return HeapBegin() + heap_size_;
+  }
+  byte PRandCard(const byte* addr) const {
+    size_t offset = RoundDown(addr - heap_begin_, kCardSize);
+    return 1 + offset % 254;
+  }
+  void FillRandom() {
+    for (const byte* addr = HeapBegin(); addr != HeapLimit(); addr += kCardSize) {
+      EXPECT_TRUE(card_table_->AddrIsInCardTable(addr));
+      byte* card = card_table_->CardFromAddr(addr);
+      *card = PRandCard(addr);
+    }
+  }
+
+ private:
+  byte* const heap_begin_;
+  const size_t heap_size_;
+};
+
+TEST_F(CardTableTest, TestMarkCard) {
+  CommonSetup();
+  for (const byte* addr = HeapBegin(); addr < HeapLimit(); addr += kObjectAlignment) {
+    auto obj = reinterpret_cast<const mirror::Object*>(addr);
+    EXPECT_EQ(card_table_->GetCard(obj), gc::accounting::CardTable::kCardClean);
+    EXPECT_TRUE(!card_table_->IsDirty(obj));
+    card_table_->MarkCard(addr);
+    EXPECT_TRUE(card_table_->IsDirty(obj));
+    EXPECT_EQ(card_table_->GetCard(obj), gc::accounting::CardTable::kCardDirty);
+    byte* card_addr = card_table_->CardFromAddr(addr);
+    EXPECT_EQ(*card_addr, gc::accounting::CardTable::kCardDirty);
+    *card_addr = gc::accounting::CardTable::kCardClean;
+    EXPECT_EQ(*card_addr, gc::accounting::CardTable::kCardClean);
+  }
+}
+
+class UpdateVisitor {
+ public:
+  byte operator()(byte c) const {
+    return c * 93 + 123;
+  }
+  void operator()(byte* /*card*/, byte /*expected_value*/, byte /*new_value*/) const {
+  }
+};
+
+TEST_F(CardTableTest, TestModifyCardsAtomic) {
+  CommonSetup();
+  FillRandom();
+  const size_t delta = std::min(static_cast<size_t>(HeapLimit() - HeapBegin()), 8U * kCardSize);
+  UpdateVisitor visitor;
+  size_t start_offset = 0;
+  for (byte* cstart = HeapBegin(); cstart < HeapBegin() + delta; cstart += kCardSize) {
+    start_offset = (start_offset + kObjectAlignment) % kCardSize;
+    size_t end_offset = 0;
+    for (byte* cend = HeapLimit() - delta; cend < HeapLimit(); cend += kCardSize) {
+      // Don't always start at a card boundary.
+      byte* start = cstart + start_offset;
+      byte* end = cend - end_offset;
+      end_offset = (end_offset + kObjectAlignment) % kCardSize;
+      // Modify cards.
+      card_table_->ModifyCardsAtomic(start, end, visitor, visitor);
+      // Check adjacent cards not modified.
+      for (byte* cur = start - kCardSize; cur >= HeapBegin(); cur -= kCardSize) {
+        EXPECT_EQ(card_table_->GetCard(reinterpret_cast<mirror::Object*>(cur)), PRandCard(cur));
+      }
+      for (byte* cur = end + kCardSize; cur < HeapLimit(); cur += kCardSize) {
+        EXPECT_EQ(card_table_->GetCard(reinterpret_cast<mirror::Object*>(cur)), PRandCard(cur));
+      }
+      // Verify Range.
+      for (byte* cur = start; cur < AlignUp(end, kCardSize); cur += kCardSize) {
+        byte* card = card_table_->CardFromAddr(cur);
+        byte value = PRandCard(cur);
+        if (visitor(value) != *card) {
+          LOG(ERROR) << reinterpret_cast<void*>(start) << " " << reinterpret_cast<void*>(cur) << " " << reinterpret_cast<void*>(end);
+        }
+        EXPECT_EQ(visitor(value), *card);
+        // Restore for next iteration.
+        *card = value;
+      }
+    }
+  }
+}
+
+// TODO: Add test for CardTable::Scan.
+
+}  // namespace art
diff --git a/runtime/monitor_pool.cc b/runtime/monitor_pool.cc
index 440a6be..4964aa0 100644
--- a/runtime/monitor_pool.cc
+++ b/runtime/monitor_pool.cc
@@ -52,7 +52,7 @@ void MonitorPool::AllocateChunk() {
       monitor_chunks_.StoreRelaxed(new_backing);
       capacity_ = new_capacity;
       old_chunk_arrays_.push_back(old_backing);
-      LOG(INFO) << "Resizing to capacity " << capacity_;
+      VLOG(monitor) << "Resizing to capacity " << capacity_;
     }
   }
 
@@ -64,7 +64,7 @@ void MonitorPool::AllocateChunk() {
   CHECK_EQ(0U, reinterpret_cast<uintptr_t>(chunk) % kMonitorAlignment);
 
   // Add the chunk.
-  *(monitor_chunks_.LoadRelaxed()+num_chunks_) = reinterpret_cast<uintptr_t>(chunk);
+  *(monitor_chunks_.LoadRelaxed() + num_chunks_) = reinterpret_cast<uintptr_t>(chunk);
   num_chunks_++;
 
   // Set up the free list
@@ -96,7 +96,7 @@ Monitor* MonitorPool::CreateMonitorInPool(Thread* self, Thread* owner, mirror::O
 
   // Enough space, or need to resize?
   if (first_free_ == nullptr) {
-    LOG(INFO) << "Allocating a new chunk.";
+    VLOG(monitor) << "Allocating a new chunk.";
     AllocateChunk();
   }