3490 int next_static_oop_offset; |
3490 int next_static_oop_offset; |
3491 int next_static_double_offset; |
3491 int next_static_double_offset; |
3492 int next_static_word_offset; |
3492 int next_static_word_offset; |
3493 int next_static_short_offset; |
3493 int next_static_short_offset; |
3494 int next_static_byte_offset; |
3494 int next_static_byte_offset; |
3495 int next_static_padded_offset; |
|
3496 int next_nonstatic_oop_offset; |
3495 int next_nonstatic_oop_offset; |
3497 int next_nonstatic_double_offset; |
3496 int next_nonstatic_double_offset; |
3498 int next_nonstatic_word_offset; |
3497 int next_nonstatic_word_offset; |
3499 int next_nonstatic_short_offset; |
3498 int next_nonstatic_short_offset; |
3500 int next_nonstatic_byte_offset; |
3499 int next_nonstatic_byte_offset; |
3503 int first_nonstatic_field_offset; |
3502 int first_nonstatic_field_offset; |
3504 int next_nonstatic_field_offset; |
3503 int next_nonstatic_field_offset; |
3505 int next_nonstatic_padded_offset; |
3504 int next_nonstatic_padded_offset; |
3506 |
3505 |
3507 // Count the contended fields by type. |
3506 // Count the contended fields by type. |
3508 int static_contended_count = 0; |
|
3509 int nonstatic_contended_count = 0; |
3507 int nonstatic_contended_count = 0; |
3510 FieldAllocationCount fac_contended; |
3508 FieldAllocationCount fac_contended; |
3511 for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) { |
3509 for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) { |
3512 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type(); |
3510 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type(); |
3513 if (fs.is_contended()) { |
3511 if (fs.is_contended()) { |
3514 fac_contended.count[atype]++; |
3512 fac_contended.count[atype]++; |
3515 if (fs.access_flags().is_static()) { |
3513 if (!fs.access_flags().is_static()) { |
3516 static_contended_count++; |
|
3517 } else { |
|
3518 nonstatic_contended_count++; |
3514 nonstatic_contended_count++; |
3519 } |
3515 } |
3520 } |
3516 } |
3521 } |
3517 } |
3522 int contended_count = static_contended_count + nonstatic_contended_count; |
3518 int contended_count = nonstatic_contended_count; |
3523 |
3519 |
3524 |
3520 |
3525 // Calculate the starting byte offsets |
3521 // Calculate the starting byte offsets |
3526 next_static_oop_offset = InstanceMirrorKlass::offset_of_static_fields(); |
3522 next_static_oop_offset = InstanceMirrorKlass::offset_of_static_fields(); |
3527 |
3523 |
3528 // class is contended, pad before all the fields |
|
3529 if (parsed_annotations.is_contended()) { |
|
3530 next_static_oop_offset += pad_size; |
|
3531 } |
|
3532 |
|
3533 next_static_double_offset = next_static_oop_offset + |
3524 next_static_double_offset = next_static_oop_offset + |
3534 ((fac.count[STATIC_OOP] - fac_contended.count[STATIC_OOP]) * heapOopSize); |
3525 ((fac.count[STATIC_OOP]) * heapOopSize); |
3535 if ( fac.count[STATIC_DOUBLE] && |
3526 if ( fac.count[STATIC_DOUBLE] && |
3536 (Universe::field_type_should_be_aligned(T_DOUBLE) || |
3527 (Universe::field_type_should_be_aligned(T_DOUBLE) || |
3537 Universe::field_type_should_be_aligned(T_LONG)) ) { |
3528 Universe::field_type_should_be_aligned(T_LONG)) ) { |
3538 next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong); |
3529 next_static_double_offset = align_size_up(next_static_double_offset, BytesPerLong); |
3539 } |
3530 } |
3540 |
3531 |
3541 next_static_word_offset = next_static_double_offset + |
3532 next_static_word_offset = next_static_double_offset + |
3542 ((fac.count[STATIC_DOUBLE] - fac_contended.count[STATIC_DOUBLE]) * BytesPerLong); |
3533 ((fac.count[STATIC_DOUBLE]) * BytesPerLong); |
3543 next_static_short_offset = next_static_word_offset + |
3534 next_static_short_offset = next_static_word_offset + |
3544 ((fac.count[STATIC_WORD] - fac_contended.count[STATIC_WORD]) * BytesPerInt); |
3535 ((fac.count[STATIC_WORD]) * BytesPerInt); |
3545 next_static_byte_offset = next_static_short_offset + |
3536 next_static_byte_offset = next_static_short_offset + |
3546 ((fac.count[STATIC_SHORT] - fac_contended.count[STATIC_SHORT]) * BytesPerShort); |
3537 ((fac.count[STATIC_SHORT]) * BytesPerShort); |
3547 next_static_padded_offset = next_static_byte_offset + |
|
3548 ((fac.count[STATIC_BYTE] - fac_contended.count[STATIC_BYTE]) * 1); |
|
3549 |
3538 |
3550 first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() + |
3539 first_nonstatic_field_offset = instanceOopDesc::base_offset_in_bytes() + |
3551 nonstatic_field_size * heapOopSize; |
3540 nonstatic_field_size * heapOopSize; |
3552 |
3541 |
3553 // class is contended, pad before all the fields |
3542 // class is contended, pad before all the fields |
3736 for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) { |
3725 for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) { |
3737 |
3726 |
3738 // skip already laid out fields |
3727 // skip already laid out fields |
3739 if (fs.is_offset_set()) continue; |
3728 if (fs.is_offset_set()) continue; |
3740 |
3729 |
3741 // contended fields are handled below |
3730 // contended instance fields are handled below |
3742 if (fs.is_contended()) continue; |
3731 if (fs.is_contended() && !fs.access_flags().is_static()) continue; |
3743 |
3732 |
3744 int real_offset; |
3733 int real_offset; |
3745 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type(); |
3734 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type(); |
3746 |
3735 |
3747 // pack the rest of the fields |
3736 // pack the rest of the fields |
3941 } |
3930 } |
3942 } |
3931 } |
3943 |
3932 |
3944 // handle static fields |
3933 // handle static fields |
3945 |
3934 |
3946 // if there is at least one contended field, we need to have pre-padding for them |
|
3947 if (static_contended_count > 0) { |
|
3948 next_static_padded_offset += pad_size; |
|
3949 } |
|
3950 |
|
3951 current_group = -1; |
|
3952 while ((current_group = (int)bm.get_next_one_offset(current_group + 1)) != (int)bm.size()) { |
|
3953 |
|
3954 for (AllFieldStream fs(fields, cp); !fs.done(); fs.next()) { |
|
3955 |
|
3956 // skip already laid out fields |
|
3957 if (fs.is_offset_set()) continue; |
|
3958 |
|
3959 // skip non-contended fields and fields from different group |
|
3960 if (!fs.is_contended() || (fs.contended_group() != current_group)) continue; |
|
3961 |
|
3962 // non-statics already handled above |
|
3963 if (!fs.access_flags().is_static()) continue; |
|
3964 |
|
3965 int real_offset; |
|
3966 FieldAllocationType atype = (FieldAllocationType) fs.allocation_type(); |
|
3967 |
|
3968 switch (atype) { |
|
3969 |
|
3970 case STATIC_BYTE: |
|
3971 next_static_padded_offset = align_size_up(next_static_padded_offset, 1); |
|
3972 real_offset = next_static_padded_offset; |
|
3973 next_static_padded_offset += 1; |
|
3974 break; |
|
3975 |
|
3976 case STATIC_SHORT: |
|
3977 next_static_padded_offset = align_size_up(next_static_padded_offset, BytesPerShort); |
|
3978 real_offset = next_static_padded_offset; |
|
3979 next_static_padded_offset += BytesPerShort; |
|
3980 break; |
|
3981 |
|
3982 case STATIC_WORD: |
|
3983 next_static_padded_offset = align_size_up(next_static_padded_offset, BytesPerInt); |
|
3984 real_offset = next_static_padded_offset; |
|
3985 next_static_padded_offset += BytesPerInt; |
|
3986 break; |
|
3987 |
|
3988 case STATIC_DOUBLE: |
|
3989 next_static_padded_offset = align_size_up(next_static_padded_offset, BytesPerLong); |
|
3990 real_offset = next_static_padded_offset; |
|
3991 next_static_padded_offset += BytesPerLong; |
|
3992 break; |
|
3993 |
|
3994 case STATIC_OOP: |
|
3995 next_static_padded_offset = align_size_up(next_static_padded_offset, heapOopSize); |
|
3996 real_offset = next_static_padded_offset; |
|
3997 next_static_padded_offset += heapOopSize; |
|
3998 break; |
|
3999 |
|
4000 default: |
|
4001 ShouldNotReachHere(); |
|
4002 } |
|
4003 |
|
4004 if (fs.contended_group() == 0) { |
|
4005 // Contended group defines the equivalence class over the fields: |
|
4006 // the fields within the same contended group are not inter-padded. |
|
4007 // The only exception is default group, which does not incur the |
|
4008 // equivalence, and so requires intra-padding. |
|
4009 next_static_padded_offset += pad_size; |
|
4010 } |
|
4011 |
|
4012 fs.set_offset(real_offset); |
|
4013 } // for |
|
4014 |
|
4015 // Start laying out the next group. |
|
4016 // Note that this will effectively pad the last group in the back; |
|
4017 // this is expected to alleviate memory contention effects for |
|
4018 // subclass fields and/or adjacent object. |
|
4019 // If this was the default group, the padding is already in place. |
|
4020 if (current_group != 0) { |
|
4021 next_static_padded_offset += pad_size; |
|
4022 } |
|
4023 |
|
4024 } |
|
4025 |
|
4026 } // handle contended |
3935 } // handle contended |
4027 |
3936 |
4028 // Size of instances |
3937 // Size of instances |
4029 int instance_size; |
3938 int instance_size; |
4030 |
3939 |
4033 // Entire class is contended, pad in the back. |
3942 // Entire class is contended, pad in the back. |
4034 // This helps to alleviate memory contention effects for subclass fields |
3943 // This helps to alleviate memory contention effects for subclass fields |
4035 // and/or adjacent object. |
3944 // and/or adjacent object. |
4036 if (parsed_annotations.is_contended()) { |
3945 if (parsed_annotations.is_contended()) { |
4037 notaligned_offset += pad_size; |
3946 notaligned_offset += pad_size; |
4038 next_static_padded_offset += pad_size; |
3947 } |
4039 } |
3948 |
4040 |
3949 int next_static_type_offset = align_size_up(next_static_byte_offset, wordSize); |
4041 int next_static_type_offset = align_size_up(next_static_padded_offset, wordSize); |
|
4042 int static_field_size = (next_static_type_offset - |
3950 int static_field_size = (next_static_type_offset - |
4043 InstanceMirrorKlass::offset_of_static_fields()) / wordSize; |
3951 InstanceMirrorKlass::offset_of_static_fields()) / wordSize; |
4044 |
3952 |
4045 next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize ); |
3953 next_nonstatic_type_offset = align_size_up(notaligned_offset, heapOopSize ); |
4046 nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset |
3954 nonstatic_field_size = nonstatic_field_size + ((next_nonstatic_type_offset |