Allow race-full access of map instance size when sweeping concurrently.

src/objects-inl.h

 // Copyright 2012 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 3982 matching lines @@
 
 int Map::GetInObjectPropertyOffset(int index) {
   // Adjust for the number of properties stored in the object.
   index -= inobject_properties();
   ASSERT(index < 0);
   return instance_size() + (index * kPointerSize);
 }
 
 
 int HeapObject::SizeFromMap(Map* map) {
-  int instance_size = map->instance_size();
+  int instance_size = map->nobarrier_instance_size();
   if (instance_size != kVariableSizeSentinel) return instance_size;
   // Only inline the most frequent cases.
   int instance_type = static_cast<int>(map->instance_type());
   if (instance_type == FIXED_ARRAY_TYPE) {
     return FixedArray::BodyDescriptor::SizeOf(map, this);
   }
   if (instance_type == ASCII_STRING_TYPE ||
       instance_type == ASCII_INTERNALIZED_STRING_TYPE) {
     return SeqOneByteString::SizeFor(
         reinterpret_cast<SeqOneByteString*>(this)->length());
@@ skipping 30 matching lines @@
 
 
 void Map::set_instance_size(int value) {
   ASSERT_EQ(0, value & (kPointerSize - 1));
   value >>= kPointerSizeLog2;
   ASSERT(0 <= value && value < 256);
   WRITE_BYTE_FIELD(this, kInstanceSizeOffset, static_cast<byte>(value));
 }
 
 
+int Map::nobarrier_instance_size() {
+  // Our atomics API does not support byte accessors. Hence, we have to manually
+  // read out atomically the whole word and mask out the upper bytes.
+  ASSERT(kInstanceSizeOffset % kPointerSize == 0);

[Jarin, 2014/04/08 20:11:11]

STATIC_ASSERT?

+  AtomicWord value = reinterpret_cast<AtomicWord>(
+      NO_BARRIER_READ_FIELD(this, kInstanceSizeOffset));
+  return (value & 0xff) << kPointerSizeLog2;
+}
+
+
 void Map::set_inobject_properties(int value) {
   ASSERT(0 <= value && value < 256);
   WRITE_BYTE_FIELD(this, kInObjectPropertiesOffset, static_cast<byte>(value));
 }
 
 
 void Map::set_pre_allocated_property_fields(int value) {
   ASSERT(0 <= value && value < 256);
   WRITE_BYTE_FIELD(this,
                    kPreAllocatedPropertyFieldsOffset,
@@ skipping 218 matching lines @@
         DependentCode::kPrototypeCheckGroup);
   }
 }
 
 
 bool Map::CanOmitMapChecks() {
   return is_stable() && FLAG_omit_map_checks_for_leaf_maps;
 }
 
 
+void Map::Shrink(int slack) {
+  ASSERT(kInstanceSizeOffset % kPointerSize == 0);

[Jarin, 2014/04/08 20:11:11]

STATIC_ASSERT? Tiny nit - since you are using Atomic32, you only really need
kInstanceSizeOffset % sizeof(Atomic32) == 0.

+  ASSERT(kInstanceSizeOffset + kInObjectPropertiesByte ==
+         kInObjectPropertiesOffset);
+
+  // Our atomics API does not support byte accessors. Hence, we have to manually
+  // read out atomically the whole word, update the instance size and in object
+  // properties byte and write back the modified word.
+  Atomic32 first_word = NoBarrier_Load(reinterpret_cast<Atomic32*>(
+      FIELD_ADDR(this, kInstanceSizeOffset)));
+
+  // The first byte contains the instance size and the second byte (8 bits left)
+  // is the in object properties byte.
+  int difference = (slack << 8) + slack;

[Michael Starzinger, 2014/04/08 11:34:22]

I don't even ... OMG.

[Jarin, 2014/04/08 20:11:11]

Replace 8 with  kInObjectPropertiesByte * kBitsPerByte, also might want
STATIC_ASSERT that kInObjectPropertiesByte < sizeof(Atomic32)

+  first_word -= difference;
+
+  ASSERT(0 <= (first_word & 0xff) && (first_word & 0xff) < 256);
+  ASSERT(0 <= ((first_word & 0xff00) >> 8) &&
+        ((first_word & 0xff00) >> 8) < 256);

[Jarin, 2014/04/08 20:11:11]

The two assertions above do not seem to test any interesting property, this
should hold for any value of first_word, no? 

Maybe we want an assertion testing that slack <= object_size and slack <=
in_object_properties. I was imagining something like this: (inserted before we
do first_word -= difference)

ASSERT(slack <= (first_word & 0xff));
ASSERT(slack <= ((first_word >> kInObjectPropertiesByte * kBitsPerByte) &
0xff));

+
+  NoBarrier_Store(reinterpret_cast<Atomic32*>(
+      FIELD_ADDR(this, kInstanceSizeOffset)), first_word);
+
+  set_unused_property_fields(unused_property_fields() - slack);
+
+  // Visitor id might depend on the instance size, recalculate it.
+  set_visitor_id(StaticVisitorBase::GetVisitorId(this));
+}
+
+
 int DependentCode::number_of_entries(DependencyGroup group) {
   if (length() == 0) return 0;
   return Smi::cast(get(group))->value();
 }
 
 
 void DependentCode::set_number_of_entries(DependencyGroup group, int value) {
   set(group, Smi::FromInt(value));
 }
 
@@ skipping 2622 matching lines @@
 #undef READ_UINT32_FIELD
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_