jdk-sandbox: comparison hotspot/src/share/vm/classfile/classFileParser.cpp

equal deleted inserted replaced

-:5b5a5ad4c222
+:1b6801b0796c
 FieldAllocationCount* fac,
 ClassAnnotationCollector* parsed_annotations,
 FieldLayoutInfo* info,
 TRAPS) {
-// get the padding width from the option
-// TODO: Ask VM about specific CPU we are running on
-int pad_size = ContendedPaddingWidth;
 // Field size and offset computation
 int nonstatic_field_size = _super_klass() == NULL ? 0 : _super_klass()->nonstatic_field_size();
 int next_static_oop_offset;
 int next_static_double_offset;
 int next_static_word_offset;
 int next_nonstatic_oop_offset;
 int next_nonstatic_double_offset;
 int next_nonstatic_word_offset;
 int next_nonstatic_short_offset;
 int next_nonstatic_byte_offset;
-int next_nonstatic_type_offset;
 int first_nonstatic_oop_offset;
-int first_nonstatic_field_offset;
 int next_nonstatic_field_offset;
 int next_nonstatic_padded_offset;
 // Count the contended fields by type.
+//
+// We ignore static fields, because @Contended is not supported for them.
+// The layout code below will also ignore the static fields.
 int nonstatic_contended_count = 0;
 FieldAllocationCount fac_contended;
 for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type();
 if (fs.is_contended()) {
 next_static_short_offset    = next_static_word_offset +
 ((fac->count[STATIC_WORD]) * BytesPerInt);
 next_static_byte_offset     = next_static_short_offset +
 ((fac->count[STATIC_SHORT]) * BytesPerShort);
-first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() +
+int nonstatic_fields_start  = instanceOopDesc::base_offset_in_bytes() +
 nonstatic_field_size * heapOopSize;
-next_nonstatic_field_offset = first_nonstatic_field_offset;
+next_nonstatic_field_offset = nonstatic_fields_start;
-// class is contended, pad before all the fields
+// Class is contended, pad before all the fields
 if (parsed_annotations->is_contended()) {
-next_nonstatic_field_offset += pad_size;
+next_nonstatic_field_offset += ContendedPaddingWidth;
 }
+// Compute the non-contended fields count
 unsigned int nonstatic_double_count = fac->count[NONSTATIC_DOUBLE] - fac_contended.count[NONSTATIC_DOUBLE];
 unsigned int nonstatic_word_count   = fac->count[NONSTATIC_WORD]   - fac_contended.count[NONSTATIC_WORD];
 unsigned int nonstatic_short_count  = fac->count[NONSTATIC_SHORT]  - fac_contended.count[NONSTATIC_SHORT];
 unsigned int nonstatic_byte_count   = fac->count[NONSTATIC_BYTE]   - fac_contended.count[NONSTATIC_BYTE];
 unsigned int nonstatic_oop_count    = fac->count[NONSTATIC_OOP]    - fac_contended.count[NONSTATIC_OOP];
 _class_name == vmSymbols::java_lang_Long())) {
 allocation_style = 0;     // Allocate oops first
 compact_fields   = false; // Don't compact fields
 }
+// Rearrange fields for a given allocation style
 if( allocation_style == 0 ) {
 // Fields order: oops, longs/doubles, ints, shorts/chars, bytes, padded fields
 next_nonstatic_oop_offset    = next_nonstatic_field_offset;
 next_nonstatic_double_offset = next_nonstatic_oop_offset +
 (nonstatic_oop_count * heapOopSize);
 int nonstatic_oop_space_offset;
 int nonstatic_word_space_offset;
 int nonstatic_short_space_offset;
 int nonstatic_byte_space_offset;
+// Try to squeeze some of the fields into the gaps due to
+// long/double alignment.
 if( nonstatic_double_count > 0 ) {
 int offset = next_nonstatic_double_offset;
 next_nonstatic_double_offset = align_size_up(offset, BytesPerLong);
 if( compact_fields && offset != next_nonstatic_double_offset ) {
 // Allocate available fields into the gap before double field.
 // for each field.
 if (contended_count > 0) {
 // if there is at least one contended field, we need to have pre-padding for them
 if (nonstatic_contended_count > 0) {
-next_nonstatic_padded_offset += pad_size;
+next_nonstatic_padded_offset += ContendedPaddingWidth;
 }
 // collect all contended groups
 BitMap bm(_cp->size());
 for (AllFieldStream fs(_fields, _cp); !fs.done(); fs.next()) {
 if (fs.contended_group() == 0) {
 // Contended group defines the equivalence class over the fields:
 // the fields within the same contended group are not inter-padded.
 // The only exception is default group, which does not incur the
 // equivalence, and so requires intra-padding.
-next_nonstatic_padded_offset += pad_size;
+next_nonstatic_padded_offset += ContendedPaddingWidth;
 }
 fs.set_offset(real_offset);
 } // for
 // Note that this will effectively pad the last group in the back;
 // this is expected to alleviate memory contention effects for
 // subclass fields and/or adjacent object.
 // If this was the default group, the padding is already in place.
 if (current_group != 0) {
-next_nonstatic_padded_offset += pad_size;
+next_nonstatic_padded_offset += ContendedPaddingWidth;
 }
 }
 // handle static fields
 }
 // Entire class is contended, pad in the back.
 // This helps to alleviate memory contention effects for subclass fields
 // and/or adjacent object.
 if (parsed_annotations->is_contended()) {
-notaligned_offset += pad_size;
+notaligned_offset += ContendedPaddingWidth;
 }
-int next_static_type_offset     = align_size_up(next_static_byte_offset, wordSize);
+int nonstatic_fields_end      = align_size_up(notaligned_offset, heapOopSize);
-int static_field_size           = (next_static_type_offset -
+int instance_end              = align_size_up(notaligned_offset, wordSize);
-InstanceMirrorKlass::offset_of_static_fields()) / wordSize;
+int static_fields_end         = align_size_up(next_static_byte_offset, wordSize);
-next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize );
+int static_field_size         = (static_fields_end -
-nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset
+InstanceMirrorKlass::offset_of_static_fields()) / wordSize;
-- first_nonstatic_field_offset)/heapOopSize);
+nonstatic_field_size          = nonstatic_field_size +
+(nonstatic_fields_end - nonstatic_fields_start) / heapOopSize;
-next_nonstatic_type_offset = align_size_up(notaligned_offset, wordSize );
-int instance_size = align_object_size(next_nonstatic_type_offset / wordSize);
+int instance_size             = align_object_size(instance_end / wordSize);
 assert(instance_size == align_object_size(align_size_up(
 (instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize),
 wordSize) / wordSize), "consistent layout helper value");
 if (PrintFieldLayout) {
 print_field_layout(_class_name,
 _fields,
 _cp,
 instance_size,
-first_nonstatic_field_offset,
+nonstatic_fields_start,
-next_nonstatic_field_offset,
+nonstatic_fields_end,
-next_static_type_offset);
+static_fields_end);
 }
 #endif
 // Pass back information needed for InstanceKlass creation
 info->nonstatic_oop_offsets = nonstatic_oop_offsets;

changeset 17612	1b6801b0796c
parent 17608	ad5cd8367d40
child 17823	0eeb35991a2e