jdk-sandbox: comparison src/hotspot/cpu/ppc/templateTable_ppc

equal deleted inserted replaced

-:18fb03624696
+:ca9489245872
 // Puts allocated obj ref onto the expression stack.
 void TemplateTable::_new() {
 transition(vtos, atos);
 Label Lslow_case,
-Ldone,
+Ldone;
-Linitialize_header,
-Lallocate_shared,
-Linitialize_object;  // Including clearing the fields.
 const Register RallocatedObject = R17_tos,
 RinstanceKlass   = R9_ARG7,
 Rscratch         = R11_scratch1,
 Roffset          = R8_ARG6,
 Rinstance_size   = Roffset,
 Rcpool           = R4_ARG2,
 Rtags            = R3_ARG1,
 Rindex           = R5_ARG3;
-const bool allow_shared_alloc = Universe::heap()->supports_inline_contig_alloc();
 // --------------------------------------------------------------------------
 // Check if fast case is possible.
 // Load pointers to const pool and const pool's tags array.
 __ get_cpool_and_tags(Rcpool, Rtags);
 // Load index of constant pool entry.
 __ get_2_byte_integer_at_bcp(1, Rindex, InterpreterMacroAssembler::Unsigned);
+// Note: compared to other architectures, PPC's implementation always goes
+// to the slow path if TLAB is used and fails.
 if (UseTLAB) {
 // Make sure the class we're about to instantiate has been resolved
 // This is done before loading instanceKlass to be consistent with the order
 // how Constant Pool is updated (see ConstantPoolCache::klass_at_put).
 __ addi(Rtags, Rtags, Array<u1>::base_offset_in_bytes());
 // --------------------------------------------------------------------------
 // Fast case:
 // Allocate the instance.
 // 1) Try to allocate in the TLAB.
-// 2) If fail, and the TLAB is not full enough to discard, allocate in the shared Eden.
+// 2) If the above fails (or is not applicable), go to a slow case (creates a new TLAB, etc.).
-// 3) If the above fails (or is not applicable), go to a slow case (creates a new TLAB, etc.).
 Register RoldTopValue = RallocatedObject; // Object will be allocated here if it fits.
 Register RnewTopValue = R6_ARG4;
 Register RendValue    = R7_ARG5;
 __ add(RnewTopValue, Rinstance_size, RoldTopValue);
 // If there is enough space, we do not CAS and do not clear.
 __ cmpld(CCR0, RnewTopValue, RendValue);
-__ bgt(CCR0, allow_shared_alloc ? Lallocate_shared : Lslow_case);
+__ bgt(CCR0, Lslow_case);
 __ std(RnewTopValue, in_bytes(JavaThread::tlab_top_offset()), R16_thread);
-if (ZeroTLAB) {
+if (!ZeroTLAB) {
-// The fields have already been cleared.
+// --------------------------------------------------------------------------
-__ b(Linitialize_header);
+// Init1: Zero out newly allocated memory.
-} else {
-// Initialize both the header and fields.
-__ b(Linitialize_object);
-}
-// Fall through: TLAB was too small.
-if (allow_shared_alloc) {
-Register RtlabWasteLimitValue = R10_ARG8;
-Register RfreeValue = RnewTopValue;
-__ bind(Lallocate_shared);
-// Check if tlab should be discarded (refill_waste_limit >= free).
-__ ld(RtlabWasteLimitValue, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), R16_thread);
-__ subf(RfreeValue, RoldTopValue, RendValue);
-__ srdi(RfreeValue, RfreeValue, LogHeapWordSize); // in dwords
-__ cmpld(CCR0, RtlabWasteLimitValue, RfreeValue);
-__ bge(CCR0, Lslow_case);
-// Increment waste limit to prevent getting stuck on this slow path.
-__ add_const_optimized(RtlabWasteLimitValue, RtlabWasteLimitValue, ThreadLocalAllocBuffer::refill_waste_limit_increment());
-__ std(RtlabWasteLimitValue, in_bytes(JavaThread::tlab_refill_waste_limit_offset()), R16_thread);
-}
-// else: No allocation in the shared eden. // fallthru: __ b(Lslow_case);
-}
-// else: Always go the slow path.
-// --------------------------------------------------------------------------
-// slow case
-__ bind(Lslow_case);
-call_VM(R17_tos, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), Rcpool, Rindex);
-if (UseTLAB) {
-__ b(Ldone);
-// --------------------------------------------------------------------------
-// Init1: Zero out newly allocated memory.
-if (!ZeroTLAB || allow_shared_alloc) {
-// Clear object fields.
-__ bind(Linitialize_object);
 // Initialize remaining object fields.
 Register Rbase = Rtags;
 __ addi(Rinstance_size, Rinstance_size, 7 - (int)sizeof(oopDesc));
 __ addi(Rbase, RallocatedObject, sizeof(oopDesc));
 __ srdi(Rinstance_size, Rinstance_size, 3);
 // Clear out object skipping header. Takes also care of the zero length case.
 __ clear_memory_doubleword(Rbase, Rinstance_size);
-// fallthru: __ b(Linitialize_header);
 }
 // --------------------------------------------------------------------------
 // Init2: Initialize the header: mark, klass
-__ bind(Linitialize_header);
 // Init mark.
 if (UseBiasedLocking) {
 __ ld(Rscratch, in_bytes(Klass::prototype_header_offset()), RinstanceKlass);
 } else {
 __ load_const_optimized(Rscratch, markOopDesc::prototype(), R0);
 // Init klass.
 __ store_klass_gap(RallocatedObject);
 __ store_klass(RallocatedObject, RinstanceKlass, Rscratch); // klass (last for cms)
 // Check and trigger dtrace event.
-{
+SkipIfEqualZero::skip_to_label_if_equal_zero(_masm, Rscratch, &DTraceAllocProbes, Ldone);
-SkipIfEqualZero skip_if(_masm, Rscratch, &DTraceAllocProbes);
+__ push(atos);
-__ push(atos);
+__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc));
-__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc));
+__ pop(atos);
-__ pop(atos);
-}
+__ b(Ldone);
 }
+// --------------------------------------------------------------------------
+// slow case
+__ bind(Lslow_case);
+call_VM(R17_tos, CAST_FROM_FN_PTR(address, InterpreterRuntime::_new), Rcpool, Rindex);
 // continue
 __ bind(Ldone);
 // Must prevent reordering of stores for object initialization with stores that publish the new object.

changeset 48476	ca9489245872
parent 48332	651a95f30dfb
child 48608	1dab70e20292
child 56021	864ee22719af