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);
+  AtomicWord value = reinterpret_cast<AtomicWord>(
+      NO_BARRIER_READ_FIELD(this, kInstanceSizeOffset));
+  return (value & 0xff) << kPointerSizeLog2;
+}
+
+
+void Map::nobarrier_set_instance_size(int value) {
+  ASSERT_EQ(0, value & (kPointerSize - 1));
+  value >>= kPointerSizeLog2;
+  ASSERT(0 <= value && value < 256);
+
+  // Our atomics API does not support byte accessors. Hence, we have to manually
+  // read out atomically the whole word, update the last byte and write back the
+  // modified word.
+  ASSERT(kInstanceSizeOffset % kPointerSize == 0);
+  AtomicWord size_field = reinterpret_cast<AtomicWord>(
+      NO_BARRIER_READ_FIELD(this, kInstanceSizeOffset));
+  size_field >>= 8;

[Hannes Payer (out of office), 2014/04/07 12:31:13]

Do you prefer masking ifdef style?

+  size_field <<= 8;
+  size_field |= value;
+  NO_BARRIER_WRITE_FIELD(
+      this, kInstanceSizeOffset, reinterpret_cast<Object*>(size_field));
+}
+
+
 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 2860 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_