--- a/hotspot/make/hotspot_version Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/make/hotspot_version Fri Jun 21 00:51:56 2013 -0700
@@ -35,7 +35,7 @@
HS_MAJOR_VER=25
HS_MINOR_VER=0
-HS_BUILD_NUMBER=37
+HS_BUILD_NUMBER=38
JDK_MAJOR_VER=1
JDK_MINOR_VER=8
--- a/hotspot/make/linux/makefiles/gcc.make Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/make/linux/makefiles/gcc.make Fri Jun 21 00:51:56 2013 -0700
@@ -214,7 +214,7 @@
WARNINGS_ARE_ERRORS += -Wno-return-type -Wno-empty-body
endif
-WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef -Wunused-function
+WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef -Wunused-function -Wunused-value
ifeq ($(USE_CLANG),)
# Since GCC 4.3, -Wconversion has changed its meanings to warn these implicit
--- a/hotspot/src/cpu/sparc/vm/assembler_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/assembler_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -57,7 +57,6 @@
fbp_op2 = 5,
br_op2 = 2,
bp_op2 = 1,
- cb_op2 = 7, // V8
sethi_op2 = 4
};
@@ -145,7 +144,6 @@
ldsh_op3 = 0x0a,
ldx_op3 = 0x0b,
- ldstub_op3 = 0x0d,
stx_op3 = 0x0e,
swap_op3 = 0x0f,
@@ -163,15 +161,6 @@
prefetch_op3 = 0x2d,
-
- ldc_op3 = 0x30,
- ldcsr_op3 = 0x31,
- lddc_op3 = 0x33,
- stc_op3 = 0x34,
- stcsr_op3 = 0x35,
- stdcq_op3 = 0x36,
- stdc_op3 = 0x37,
-
casa_op3 = 0x3c,
casxa_op3 = 0x3e,
@@ -574,17 +563,11 @@
static void vis3_only() { assert( VM_Version::has_vis3(), "This instruction only works on SPARC with VIS3"); }
// instruction only in v9
- static void v9_only() { assert( VM_Version::v9_instructions_work(), "This instruction only works on SPARC V9"); }
-
- // instruction only in v8
- static void v8_only() { assert( VM_Version::v8_instructions_work(), "This instruction only works on SPARC V8"); }
+ static void v9_only() { } // do nothing
// instruction deprecated in v9
static void v9_dep() { } // do nothing for now
- // some float instructions only exist for single prec. on v8
- static void v8_s_only(FloatRegisterImpl::Width w) { if (w != FloatRegisterImpl::S) v9_only(); }
-
// v8 has no CC field
static void v8_no_cc(CC cc) { if (cc) v9_only(); }
@@ -730,11 +713,6 @@
inline void bp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt = relocInfo::none );
inline void bp( Condition c, bool a, CC cc, Predict p, Label& L );
- // pp 121 (V8)
-
- inline void cb( Condition c, bool a, address d, relocInfo::relocType rt = relocInfo::none );
- inline void cb( Condition c, bool a, Label& L );
-
// pp 149
inline void call( address d, relocInfo::relocType rt = relocInfo::runtime_call_type );
@@ -775,8 +753,8 @@
// pp 157
- void fcmp( FloatRegisterImpl::Width w, CC cc, FloatRegister s1, FloatRegister s2) { v8_no_cc(cc); emit_int32( op(arith_op) | cmpcc(cc) | op3(fpop2_op3) | fs1(s1, w) | opf(0x50 + w) | fs2(s2, w)); }
- void fcmpe( FloatRegisterImpl::Width w, CC cc, FloatRegister s1, FloatRegister s2) { v8_no_cc(cc); emit_int32( op(arith_op) | cmpcc(cc) | op3(fpop2_op3) | fs1(s1, w) | opf(0x54 + w) | fs2(s2, w)); }
+ void fcmp( FloatRegisterImpl::Width w, CC cc, FloatRegister s1, FloatRegister s2) { emit_int32( op(arith_op) | cmpcc(cc) | op3(fpop2_op3) | fs1(s1, w) | opf(0x50 + w) | fs2(s2, w)); }
+ void fcmpe( FloatRegisterImpl::Width w, CC cc, FloatRegister s1, FloatRegister s2) { emit_int32( op(arith_op) | cmpcc(cc) | op3(fpop2_op3) | fs1(s1, w) | opf(0x54 + w) | fs2(s2, w)); }
// pp 159
@@ -794,21 +772,11 @@
// pp 162
- void fmov( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { v8_s_only(w); emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x00 + w) | fs2(s, w)); }
-
- void fneg( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { v8_s_only(w); emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x04 + w) | fs2(s, w)); }
-
- // page 144 sparc v8 architecture (double prec works on v8 if the source and destination registers are the same). fnegs is the only instruction available
- // on v8 to do negation of single, double and quad precision floats.
+ void fmov( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x00 + w) | fs2(s, w)); }
- void fneg( FloatRegisterImpl::Width w, FloatRegister sd ) { if (VM_Version::v9_instructions_work()) emit_int32( op(arith_op) | fd(sd, w) | op3(fpop1_op3) | opf(0x04 + w) | fs2(sd, w)); else emit_int32( op(arith_op) | fd(sd, w) | op3(fpop1_op3) | opf(0x05) | fs2(sd, w)); }
-
- void fabs( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { v8_s_only(w); emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x08 + w) | fs2(s, w)); }
+ void fneg( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x04 + w) | fs2(s, w)); }
- // page 144 sparc v8 architecture (double prec works on v8 if the source and destination registers are the same). fabss is the only instruction available
- // on v8 to do abs operation on single/double/quad precision floats.
-
- void fabs( FloatRegisterImpl::Width w, FloatRegister sd ) { if (VM_Version::v9_instructions_work()) emit_int32( op(arith_op) | fd(sd, w) | op3(fpop1_op3) | opf(0x08 + w) | fs2(sd, w)); else emit_int32( op(arith_op) | fd(sd, w) | op3(fpop1_op3) | opf(0x09) | fs2(sd, w)); }
+ void fabs( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d ) { emit_int32( op(arith_op) | fd(d, w) | op3(fpop1_op3) | opf(0x08 + w) | fs2(s, w)); }
// pp 163
@@ -839,11 +807,6 @@
void impdep1( int id1, int const19a ) { v9_only(); emit_int32( op(arith_op) | fcn(id1) | op3(impdep1_op3) | u_field(const19a, 18, 0)); }
void impdep2( int id1, int const19a ) { v9_only(); emit_int32( op(arith_op) | fcn(id1) | op3(impdep2_op3) | u_field(const19a, 18, 0)); }
- // pp 149 (v8)
-
- void cpop1( int opc, int cr1, int cr2, int crd ) { v8_only(); emit_int32( op(arith_op) | fcn(crd) | op3(impdep1_op3) | u_field(cr1, 18, 14) | opf(opc) | u_field(cr2, 4, 0)); }
- void cpop2( int opc, int cr1, int cr2, int crd ) { v8_only(); emit_int32( op(arith_op) | fcn(crd) | op3(impdep2_op3) | u_field(cr1, 18, 14) | opf(opc) | u_field(cr2, 4, 0)); }
-
// pp 170
void jmpl( Register s1, Register s2, Register d );
@@ -860,16 +823,6 @@
inline void ldxfsr( Register s1, Register s2 );
inline void ldxfsr( Register s1, int simm13a);
- // pp 94 (v8)
-
- inline void ldc( Register s1, Register s2, int crd );
- inline void ldc( Register s1, int simm13a, int crd);
- inline void lddc( Register s1, Register s2, int crd );
- inline void lddc( Register s1, int simm13a, int crd);
- inline void ldcsr( Register s1, Register s2, int crd );
- inline void ldcsr( Register s1, int simm13a, int crd);
-
-
// 173
void ldfa( FloatRegisterImpl::Width w, Register s1, Register s2, int ia, FloatRegister d ) { v9_only(); emit_int32( op(ldst_op) | fd(d, w) | alt_op3(ldf_op3 | alt_bit_op3, w) | rs1(s1) | imm_asi(ia) | rs2(s2) ); }
@@ -910,18 +863,6 @@
void lduwa( Register s1, int simm13a, Register d ) { emit_int32( op(ldst_op) | rd(d) | op3(lduw_op3 | alt_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
void ldxa( Register s1, Register s2, int ia, Register d ) { v9_only(); emit_int32( op(ldst_op) | rd(d) | op3(ldx_op3 | alt_bit_op3) | rs1(s1) | imm_asi(ia) | rs2(s2) ); }
void ldxa( Register s1, int simm13a, Register d ) { v9_only(); emit_int32( op(ldst_op) | rd(d) | op3(ldx_op3 | alt_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
- void ldda( Register s1, Register s2, int ia, Register d ) { v9_dep(); emit_int32( op(ldst_op) | rd(d) | op3(ldd_op3 | alt_bit_op3) | rs1(s1) | imm_asi(ia) | rs2(s2) ); }
- void ldda( Register s1, int simm13a, Register d ) { v9_dep(); emit_int32( op(ldst_op) | rd(d) | op3(ldd_op3 | alt_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
-
- // pp 179
-
- inline void ldstub( Register s1, Register s2, Register d );
- inline void ldstub( Register s1, int simm13a, Register d);
-
- // pp 180
-
- void ldstuba( Register s1, Register s2, int ia, Register d ) { emit_int32( op(ldst_op) | rd(d) | op3(ldstub_op3 | alt_bit_op3) | rs1(s1) | imm_asi(ia) | rs2(s2) ); }
- void ldstuba( Register s1, int simm13a, Register d ) { emit_int32( op(ldst_op) | rd(d) | op3(ldstub_op3 | alt_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
// pp 181
@@ -992,11 +933,6 @@
void smulcc( Register s1, Register s2, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(smul_op3 | cc_bit_op3) | rs1(s1) | rs2(s2) ); }
void smulcc( Register s1, int simm13a, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(smul_op3 | cc_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
- // pp 199
-
- void mulscc( Register s1, Register s2, Register d ) { v9_dep(); emit_int32( op(arith_op) | rd(d) | op3(mulscc_op3) | rs1(s1) | rs2(s2) ); }
- void mulscc( Register s1, int simm13a, Register d ) { v9_dep(); emit_int32( op(arith_op) | rd(d) | op3(mulscc_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
-
// pp 201
void nop() { emit_int32( op(branch_op) | op2(sethi_op2) ); }
@@ -1116,17 +1052,6 @@
void stda( Register d, Register s1, Register s2, int ia ) { emit_int32( op(ldst_op) | rd(d) | op3(std_op3 | alt_bit_op3) | rs1(s1) | imm_asi(ia) | rs2(s2) ); }
void stda( Register d, Register s1, int simm13a ) { emit_int32( op(ldst_op) | rd(d) | op3(std_op3 | alt_bit_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
- // pp 97 (v8)
-
- inline void stc( int crd, Register s1, Register s2 );
- inline void stc( int crd, Register s1, int simm13a);
- inline void stdc( int crd, Register s1, Register s2 );
- inline void stdc( int crd, Register s1, int simm13a);
- inline void stcsr( int crd, Register s1, Register s2 );
- inline void stcsr( int crd, Register s1, int simm13a);
- inline void stdcq( int crd, Register s1, Register s2 );
- inline void stdcq( int crd, Register s1, int simm13a);
-
// pp 230
void sub( Register s1, Register s2, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(sub_op3 ) | rs1(s1) | rs2(s2) ); }
@@ -1153,20 +1078,16 @@
void taddcc( Register s1, Register s2, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(taddcc_op3 ) | rs1(s1) | rs2(s2) ); }
void taddcc( Register s1, int simm13a, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(taddcc_op3 ) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
- void taddcctv( Register s1, Register s2, Register d ) { v9_dep(); emit_int32( op(arith_op) | rd(d) | op3(taddcctv_op3) | rs1(s1) | rs2(s2) ); }
- void taddcctv( Register s1, int simm13a, Register d ) { v9_dep(); emit_int32( op(arith_op) | rd(d) | op3(taddcctv_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
// pp 235
void tsubcc( Register s1, Register s2, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(tsubcc_op3 ) | rs1(s1) | rs2(s2) ); }
void tsubcc( Register s1, int simm13a, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(tsubcc_op3 ) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
- void tsubcctv( Register s1, Register s2, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(tsubcctv_op3) | rs1(s1) | rs2(s2) ); }
- void tsubcctv( Register s1, int simm13a, Register d ) { emit_int32( op(arith_op) | rd(d) | op3(tsubcctv_op3) | rs1(s1) | immed(true) | simm(simm13a, 13) ); }
// pp 237
- void trap( Condition c, CC cc, Register s1, Register s2 ) { v8_no_cc(cc); emit_int32( op(arith_op) | cond(c) | op3(trap_op3) | rs1(s1) | trapcc(cc) | rs2(s2)); }
- void trap( Condition c, CC cc, Register s1, int trapa ) { v8_no_cc(cc); emit_int32( op(arith_op) | cond(c) | op3(trap_op3) | rs1(s1) | trapcc(cc) | immed(true) | u_field(trapa, 6, 0)); }
+ void trap( Condition c, CC cc, Register s1, Register s2 ) { emit_int32( op(arith_op) | cond(c) | op3(trap_op3) | rs1(s1) | trapcc(cc) | rs2(s2)); }
+ void trap( Condition c, CC cc, Register s1, int trapa ) { emit_int32( op(arith_op) | cond(c) | op3(trap_op3) | rs1(s1) | trapcc(cc) | immed(true) | u_field(trapa, 6, 0)); }
// simple uncond. trap
void trap( int trapa ) { trap( always, icc, G0, trapa ); }
--- a/hotspot/src/cpu/sparc/vm/assembler_sparc.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/assembler_sparc.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -63,9 +63,6 @@
inline void Assembler::fbp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt ) { v9_only(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(fbp_op2) | branchcc(cc) | predict(p) | wdisp(intptr_t(d), intptr_t(pc()), 19), rt); has_delay_slot(); }
inline void Assembler::fbp( Condition c, bool a, CC cc, Predict p, Label& L ) { fbp(c, a, cc, p, target(L)); }
-inline void Assembler::cb( Condition c, bool a, address d, relocInfo::relocType rt ) { v8_only(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(cb_op2) | wdisp(intptr_t(d), intptr_t(pc()), 22), rt); has_delay_slot(); }
-inline void Assembler::cb( Condition c, bool a, Label& L ) { cb(c, a, target(L)); }
-
inline void Assembler::br( Condition c, bool a, address d, relocInfo::relocType rt ) { v9_dep(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(br_op2) | wdisp(intptr_t(d), intptr_t(pc()), 22), rt); has_delay_slot(); }
inline void Assembler::br( Condition c, bool a, Label& L ) { br(c, a, target(L)); }
@@ -88,18 +85,9 @@
inline void Assembler::ldf(FloatRegisterImpl::Width w, Register s1, Register s2, FloatRegister d) { emit_int32( op(ldst_op) | fd(d, w) | alt_op3(ldf_op3, w) | rs1(s1) | rs2(s2) ); }
inline void Assembler::ldf(FloatRegisterImpl::Width w, Register s1, int simm13a, FloatRegister d, RelocationHolder const& rspec) { emit_data( op(ldst_op) | fd(d, w) | alt_op3(ldf_op3, w) | rs1(s1) | immed(true) | simm(simm13a, 13), rspec); }
-inline void Assembler::ldfsr( Register s1, Register s2) { v9_dep(); emit_int32( op(ldst_op) | op3(ldfsr_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::ldfsr( Register s1, int simm13a) { v9_dep(); emit_data( op(ldst_op) | op3(ldfsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
inline void Assembler::ldxfsr( Register s1, Register s2) { v9_only(); emit_int32( op(ldst_op) | rd(G1) | op3(ldfsr_op3) | rs1(s1) | rs2(s2) ); }
inline void Assembler::ldxfsr( Register s1, int simm13a) { v9_only(); emit_data( op(ldst_op) | rd(G1) | op3(ldfsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::ldc( Register s1, Register s2, int crd) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(ldc_op3 ) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::ldc( Register s1, int simm13a, int crd) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(ldc_op3 ) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::lddc( Register s1, Register s2, int crd) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(lddc_op3 ) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::lddc( Register s1, int simm13a, int crd) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(lddc_op3 ) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::ldcsr( Register s1, Register s2, int crd) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(ldcsr_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::ldcsr( Register s1, int simm13a, int crd) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(ldcsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-
inline void Assembler::ldsb( Register s1, Register s2, Register d) { emit_int32( op(ldst_op) | rd(d) | op3(ldsb_op3) | rs1(s1) | rs2(s2) ); }
inline void Assembler::ldsb( Register s1, int simm13a, Register d) { emit_data( op(ldst_op) | rd(d) | op3(ldsb_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
@@ -119,9 +107,6 @@
inline void Assembler::ldd( Register s1, Register s2, Register d) { v9_dep(); assert(d->is_even(), "not even"); emit_int32( op(ldst_op) | rd(d) | op3(ldd_op3) | rs1(s1) | rs2(s2) ); }
inline void Assembler::ldd( Register s1, int simm13a, Register d) { v9_dep(); assert(d->is_even(), "not even"); emit_data( op(ldst_op) | rd(d) | op3(ldd_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::ldstub( Register s1, Register s2, Register d) { emit_int32( op(ldst_op) | rd(d) | op3(ldstub_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::ldstub( Register s1, int simm13a, Register d) { emit_data( op(ldst_op) | rd(d) | op3(ldstub_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-
inline void Assembler::rett( Register s1, Register s2 ) { cti(); emit_int32( op(arith_op) | op3(rett_op3) | rs1(s1) | rs2(s2)); has_delay_slot(); }
inline void Assembler::rett( Register s1, int simm13a, relocInfo::relocType rt) { cti(); emit_data( op(arith_op) | op3(rett_op3) | rs1(s1) | immed(true) | simm(simm13a, 13), rt); has_delay_slot(); }
@@ -132,8 +117,6 @@
inline void Assembler::stf( FloatRegisterImpl::Width w, FloatRegister d, Register s1, Register s2) { emit_int32( op(ldst_op) | fd(d, w) | alt_op3(stf_op3, w) | rs1(s1) | rs2(s2) ); }
inline void Assembler::stf( FloatRegisterImpl::Width w, FloatRegister d, Register s1, int simm13a) { emit_data( op(ldst_op) | fd(d, w) | alt_op3(stf_op3, w) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::stfsr( Register s1, Register s2) { v9_dep(); emit_int32( op(ldst_op) | op3(stfsr_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::stfsr( Register s1, int simm13a) { v9_dep(); emit_data( op(ldst_op) | op3(stfsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
inline void Assembler::stxfsr( Register s1, Register s2) { v9_only(); emit_int32( op(ldst_op) | rd(G1) | op3(stfsr_op3) | rs1(s1) | rs2(s2) ); }
inline void Assembler::stxfsr( Register s1, int simm13a) { v9_only(); emit_data( op(ldst_op) | rd(G1) | op3(stfsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
@@ -152,17 +135,6 @@
inline void Assembler::std( Register d, Register s1, Register s2) { v9_dep(); assert(d->is_even(), "not even"); emit_int32( op(ldst_op) | rd(d) | op3(std_op3) | rs1(s1) | rs2(s2) ); }
inline void Assembler::std( Register d, Register s1, int simm13a) { v9_dep(); assert(d->is_even(), "not even"); emit_data( op(ldst_op) | rd(d) | op3(std_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-// v8 p 99
-
-inline void Assembler::stc( int crd, Register s1, Register s2) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(stc_op3 ) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::stc( int crd, Register s1, int simm13a) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(stc_op3 ) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::stdc( int crd, Register s1, Register s2) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(stdc_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::stdc( int crd, Register s1, int simm13a) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(stdc_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::stcsr( int crd, Register s1, Register s2) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(stcsr_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::stcsr( int crd, Register s1, int simm13a) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(stcsr_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-inline void Assembler::stdcq( int crd, Register s1, Register s2) { v8_only(); emit_int32( op(ldst_op) | fcn(crd) | op3(stdcq_op3) | rs1(s1) | rs2(s2) ); }
-inline void Assembler::stdcq( int crd, Register s1, int simm13a) { v8_only(); emit_data( op(ldst_op) | fcn(crd) | op3(stdcq_op3) | rs1(s1) | immed(true) | simm(simm13a, 13)); }
-
// pp 231
inline void Assembler::swap( Register s1, Register s2, Register d) { v9_dep(); emit_int32( op(ldst_op) | rd(d) | op3(swap_op3) | rs1(s1) | rs2(s2) ); }
--- a/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -597,13 +597,6 @@
__ sra(Rdividend, 31, Rscratch);
__ wry(Rscratch);
- if (!VM_Version::v9_instructions_work()) {
- // v9 doesn't require these nops
- __ nop();
- __ nop();
- __ nop();
- __ nop();
- }
add_debug_info_for_div0_here(op->info());
@@ -652,10 +645,6 @@
case lir_cond_lessEqual: acond = (is_unordered ? Assembler::f_unorderedOrLessOrEqual : Assembler::f_lessOrEqual); break;
case lir_cond_greaterEqual: acond = (is_unordered ? Assembler::f_unorderedOrGreaterOrEqual: Assembler::f_greaterOrEqual); break;
default : ShouldNotReachHere();
- };
-
- if (!VM_Version::v9_instructions_work()) {
- __ nop();
}
__ fb( acond, false, Assembler::pn, *(op->label()));
} else {
@@ -725,9 +714,6 @@
Label L;
// result must be 0 if value is NaN; test by comparing value to itself
__ fcmp(FloatRegisterImpl::S, Assembler::fcc0, rsrc, rsrc);
- if (!VM_Version::v9_instructions_work()) {
- __ nop();
- }
__ fb(Assembler::f_unordered, true, Assembler::pn, L);
__ delayed()->st(G0, addr); // annuled if contents of rsrc is not NaN
__ ftoi(FloatRegisterImpl::S, rsrc, rsrc);
@@ -1909,7 +1895,7 @@
switch (code) {
case lir_add: __ add (lreg, rreg, res); break;
case lir_sub: __ sub (lreg, rreg, res); break;
- case lir_mul: __ mult (lreg, rreg, res); break;
+ case lir_mul: __ mulx (lreg, rreg, res); break;
default: ShouldNotReachHere();
}
}
@@ -1924,7 +1910,7 @@
switch (code) {
case lir_add: __ add (lreg, simm13, res); break;
case lir_sub: __ sub (lreg, simm13, res); break;
- case lir_mul: __ mult (lreg, simm13, res); break;
+ case lir_mul: __ mulx (lreg, simm13, res); break;
default: ShouldNotReachHere();
}
} else {
@@ -1936,7 +1922,7 @@
switch (code) {
case lir_add: __ add (lreg, (int)con, res); break;
case lir_sub: __ sub (lreg, (int)con, res); break;
- case lir_mul: __ mult (lreg, (int)con, res); break;
+ case lir_mul: __ mulx (lreg, (int)con, res); break;
default: ShouldNotReachHere();
}
}
@@ -3234,48 +3220,26 @@
Register base = mem_addr->base()->as_register();
if (src->is_register() && dest->is_address()) {
// G4 is high half, G5 is low half
- if (VM_Version::v9_instructions_work()) {
- // clear the top bits of G5, and scale up G4
- __ srl (src->as_register_lo(), 0, G5);
- __ sllx(src->as_register_hi(), 32, G4);
- // combine the two halves into the 64 bits of G4
- __ or3(G4, G5, G4);
- null_check_offset = __ offset();
- if (idx == noreg) {
- __ stx(G4, base, disp);
- } else {
- __ stx(G4, base, idx);
- }
+ // clear the top bits of G5, and scale up G4
+ __ srl (src->as_register_lo(), 0, G5);
+ __ sllx(src->as_register_hi(), 32, G4);
+ // combine the two halves into the 64 bits of G4
+ __ or3(G4, G5, G4);
+ null_check_offset = __ offset();
+ if (idx == noreg) {
+ __ stx(G4, base, disp);
} else {
- __ mov (src->as_register_hi(), G4);
- __ mov (src->as_register_lo(), G5);
- null_check_offset = __ offset();
- if (idx == noreg) {
- __ std(G4, base, disp);
- } else {
- __ std(G4, base, idx);
- }
+ __ stx(G4, base, idx);
}
} else if (src->is_address() && dest->is_register()) {
null_check_offset = __ offset();
- if (VM_Version::v9_instructions_work()) {
- if (idx == noreg) {
- __ ldx(base, disp, G5);
- } else {
- __ ldx(base, idx, G5);
- }
- __ srax(G5, 32, dest->as_register_hi()); // fetch the high half into hi
- __ mov (G5, dest->as_register_lo()); // copy low half into lo
+ if (idx == noreg) {
+ __ ldx(base, disp, G5);
} else {
- if (idx == noreg) {
- __ ldd(base, disp, G4);
- } else {
- __ ldd(base, idx, G4);
- }
- // G4 is high half, G5 is low half
- __ mov (G4, dest->as_register_hi());
- __ mov (G5, dest->as_register_lo());
+ __ ldx(base, idx, G5);
}
+ __ srax(G5, 32, dest->as_register_hi()); // fetch the high half into hi
+ __ mov (G5, dest->as_register_lo()); // copy low half into lo
} else {
Unimplemented();
}
--- a/hotspot/src/cpu/sparc/vm/c1_MacroAssembler_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_MacroAssembler_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -108,7 +108,7 @@
// compare object markOop with Rmark and if equal exchange Rscratch with object markOop
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casx_under_lock(mark_addr.base(), Rmark, Rscratch, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), Rmark, Rscratch);
// if compare/exchange succeeded we found an unlocked object and we now have locked it
// hence we are done
cmp(Rmark, Rscratch);
@@ -149,7 +149,7 @@
// Check if it is still a light weight lock, this is is true if we see
// the stack address of the basicLock in the markOop of the object
- casx_under_lock(mark_addr.base(), Rbox, Rmark, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), Rbox, Rmark);
cmp(Rbox, Rmark);
brx(Assembler::notEqual, false, Assembler::pn, slow_case);
@@ -276,7 +276,7 @@
sub(var_size_in_bytes, hdr_size_in_bytes, t2); // compute size of body
initialize_body(t1, t2);
#ifndef _LP64
- } else if (VM_Version::v9_instructions_work() && con_size_in_bytes < threshold * 2) {
+ } else if (con_size_in_bytes < threshold * 2) {
// on v9 we can do double word stores to fill twice as much space.
assert(hdr_size_in_bytes % 8 == 0, "double word aligned");
assert(con_size_in_bytes % 8 == 0, "double word aligned");
--- a/hotspot/src/cpu/sparc/vm/c2_init_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/c2_init_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -30,5 +30,4 @@
void Compile::pd_compiler2_init() {
guarantee(CodeEntryAlignment >= InteriorEntryAlignment, "" );
- guarantee( VM_Version::v9_instructions_work(), "Server compiler does not run on V8 systems" );
}
--- a/hotspot/src/cpu/sparc/vm/disassembler_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/disassembler_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -30,8 +30,7 @@
}
static const char* pd_cpu_opts() {
- return (VM_Version::v9_instructions_work()?
- (VM_Version::v8_instructions_work()? "" : "v9only") : "v8only");
+ return "v9only";
}
#endif // CPU_SPARC_VM_DISASSEMBLER_SPARC_HPP
--- a/hotspot/src/cpu/sparc/vm/globals_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/globals_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -110,8 +110,5 @@
\
product(uintx, ArraycopyDstPrefetchDistance, 0, \
"Distance to prefetch destination array in arracopy") \
- \
- develop(intx, V8AtomicOperationUnderLockSpinCount, 50, \
- "Number of times to spin wait on a v8 atomic operation lock") \
#endif // CPU_SPARC_VM_GLOBALS_SPARC_HPP
--- a/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1210,8 +1210,7 @@
st_ptr(mark_reg, lock_addr, BasicLock::displaced_header_offset_in_bytes());
// compare and exchange object_addr, markOop | 1, stack address of basicLock
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casx_under_lock(mark_addr.base(), mark_reg, temp_reg,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), mark_reg, temp_reg);
// if the compare and exchange succeeded we are done (we saw an unlocked object)
cmp_and_brx_short(mark_reg, temp_reg, Assembler::equal, Assembler::pt, done);
@@ -1291,8 +1290,7 @@
// we expect to see the stack address of the basicLock in case the
// lock is still a light weight lock (lock_reg)
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casx_under_lock(mark_addr.base(), lock_reg, displaced_header_reg,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), lock_reg, displaced_header_reg);
cmp(lock_reg, displaced_header_reg);
brx(Assembler::equal, true, Assembler::pn, done);
delayed()->st_ptr(G0, lockobj_addr); // free entry
--- a/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -118,7 +118,6 @@
case bp_op2: m = wdisp( word_aligned_ones, 0, 19); v = wdisp( dest_pos, inst_pos, 19); break;
case fb_op2: m = wdisp( word_aligned_ones, 0, 22); v = wdisp( dest_pos, inst_pos, 22); break;
case br_op2: m = wdisp( word_aligned_ones, 0, 22); v = wdisp( dest_pos, inst_pos, 22); break;
- case cb_op2: m = wdisp( word_aligned_ones, 0, 22); v = wdisp( dest_pos, inst_pos, 22); break;
case bpr_op2: {
if (is_cbcond(inst)) {
m = wdisp10(word_aligned_ones, 0);
@@ -149,7 +148,6 @@
case bp_op2: r = inv_wdisp( inst, pos, 19); break;
case fb_op2: r = inv_wdisp( inst, pos, 22); break;
case br_op2: r = inv_wdisp( inst, pos, 22); break;
- case cb_op2: r = inv_wdisp( inst, pos, 22); break;
case bpr_op2: {
if (is_cbcond(inst)) {
r = inv_wdisp10(inst, pos);
@@ -325,12 +323,6 @@
trap(ST_RESERVED_FOR_USER_0);
}
-// flush windows (except current) using flushw instruction if avail.
-void MacroAssembler::flush_windows() {
- if (VM_Version::v9_instructions_work()) flushw();
- else flush_windows_trap();
-}
-
// Write serialization page so VM thread can do a pseudo remote membar
// We use the current thread pointer to calculate a thread specific
// offset to write to within the page. This minimizes bus traffic
@@ -358,88 +350,6 @@
Unimplemented();
}
-void MacroAssembler::mult(Register s1, Register s2, Register d) {
- if(VM_Version::v9_instructions_work()) {
- mulx (s1, s2, d);
- } else {
- smul (s1, s2, d);
- }
-}
-
-void MacroAssembler::mult(Register s1, int simm13a, Register d) {
- if(VM_Version::v9_instructions_work()) {
- mulx (s1, simm13a, d);
- } else {
- smul (s1, simm13a, d);
- }
-}
-
-
-#ifdef ASSERT
-void MacroAssembler::read_ccr_v8_assert(Register ccr_save) {
- const Register s1 = G3_scratch;
- const Register s2 = G4_scratch;
- Label get_psr_test;
- // Get the condition codes the V8 way.
- read_ccr_trap(s1);
- mov(ccr_save, s2);
- // This is a test of V8 which has icc but not xcc
- // so mask off the xcc bits
- and3(s2, 0xf, s2);
- // Compare condition codes from the V8 and V9 ways.
- subcc(s2, s1, G0);
- br(Assembler::notEqual, true, Assembler::pt, get_psr_test);
- delayed()->breakpoint_trap();
- bind(get_psr_test);
-}
-
-void MacroAssembler::write_ccr_v8_assert(Register ccr_save) {
- const Register s1 = G3_scratch;
- const Register s2 = G4_scratch;
- Label set_psr_test;
- // Write out the saved condition codes the V8 way
- write_ccr_trap(ccr_save, s1, s2);
- // Read back the condition codes using the V9 instruction
- rdccr(s1);
- mov(ccr_save, s2);
- // This is a test of V8 which has icc but not xcc
- // so mask off the xcc bits
- and3(s2, 0xf, s2);
- and3(s1, 0xf, s1);
- // Compare the V8 way with the V9 way.
- subcc(s2, s1, G0);
- br(Assembler::notEqual, true, Assembler::pt, set_psr_test);
- delayed()->breakpoint_trap();
- bind(set_psr_test);
-}
-#else
-#define read_ccr_v8_assert(x)
-#define write_ccr_v8_assert(x)
-#endif // ASSERT
-
-void MacroAssembler::read_ccr(Register ccr_save) {
- if (VM_Version::v9_instructions_work()) {
- rdccr(ccr_save);
- // Test code sequence used on V8. Do not move above rdccr.
- read_ccr_v8_assert(ccr_save);
- } else {
- read_ccr_trap(ccr_save);
- }
-}
-
-void MacroAssembler::write_ccr(Register ccr_save) {
- if (VM_Version::v9_instructions_work()) {
- // Test code sequence used on V8. Do not move below wrccr.
- write_ccr_v8_assert(ccr_save);
- wrccr(ccr_save);
- } else {
- const Register temp_reg1 = G3_scratch;
- const Register temp_reg2 = G4_scratch;
- write_ccr_trap(ccr_save, temp_reg1, temp_reg2);
- }
-}
-
-
// Calls to C land
#ifdef ASSERT
@@ -465,8 +375,8 @@
#ifdef ASSERT
AddressLiteral last_get_thread_addrlit(&last_get_thread);
set(last_get_thread_addrlit, L3);
- inc(L4, get_pc(L4) + 2 * BytesPerInstWord); // skip getpc() code + inc + st_ptr to point L4 at call
- st_ptr(L4, L3, 0);
+ rdpc(L4);
+ inc(L4, 3 * BytesPerInstWord); // skip rdpc + inc + st_ptr to point L4 at call st_ptr(L4, L3, 0);
#endif
call(CAST_FROM_FN_PTR(address, reinitialize_thread), relocInfo::runtime_call_type);
delayed()->nop();
@@ -1327,7 +1237,7 @@
void RegistersForDebugging::save_registers(MacroAssembler* a) {
a->sub(FP, round_to(sizeof(RegistersForDebugging), sizeof(jdouble)) - STACK_BIAS, O0);
- a->flush_windows();
+ a->flushw();
int i;
for (i = 0; i < 8; ++i) {
a->ld_ptr(as_iRegister(i)->address_in_saved_window().after_save(), L1); a->st_ptr( L1, O0, i_offset(i));
@@ -1338,7 +1248,7 @@
for (i = 0; i < 32; ++i) {
a->stf(FloatRegisterImpl::S, as_FloatRegister(i), O0, f_offset(i));
}
- for (i = 0; i < (VM_Version::v9_instructions_work() ? 64 : 32); i += 2) {
+ for (i = 0; i < 64; i += 2) {
a->stf(FloatRegisterImpl::D, as_FloatRegister(i), O0, d_offset(i));
}
}
@@ -1350,7 +1260,7 @@
for (int j = 0; j < 32; ++j) {
a->ldf(FloatRegisterImpl::S, O0, f_offset(j), as_FloatRegister(j));
}
- for (int k = 0; k < (VM_Version::v9_instructions_work() ? 64 : 32); k += 2) {
+ for (int k = 0; k < 64; k += 2) {
a->ldf(FloatRegisterImpl::D, O0, d_offset(k), as_FloatRegister(k));
}
}
@@ -1465,8 +1375,6 @@
// the high bits of the O-regs if they contain Long values. Acts as a 'leaf'
// call.
void MacroAssembler::verify_oop_subroutine() {
- assert( VM_Version::v9_instructions_work(), "VerifyOops not supported for V8" );
-
// Leaf call; no frame.
Label succeed, fail, null_or_fail;
@@ -1870,26 +1778,17 @@
// And the equals case for the high part does not need testing,
// since that triplet is reached only after finding the high halves differ.
- if (VM_Version::v9_instructions_work()) {
- mov(-1, Rresult);
- ba(done); delayed()-> movcc(greater, false, icc, 1, Rresult);
- } else {
- br(less, true, pt, done); delayed()-> set(-1, Rresult);
- br(greater, true, pt, done); delayed()-> set( 1, Rresult);
- }
-
- bind( check_low_parts );
-
- if (VM_Version::v9_instructions_work()) {
- mov( -1, Rresult);
- movcc(equal, false, icc, 0, Rresult);
- movcc(greaterUnsigned, false, icc, 1, Rresult);
- } else {
- set(-1, Rresult);
- br(equal, true, pt, done); delayed()->set( 0, Rresult);
- br(greaterUnsigned, true, pt, done); delayed()->set( 1, Rresult);
- }
- bind( done );
+ mov(-1, Rresult);
+ ba(done);
+ delayed()->movcc(greater, false, icc, 1, Rresult);
+
+ bind(check_low_parts);
+
+ mov( -1, Rresult);
+ movcc(equal, false, icc, 0, Rresult);
+ movcc(greaterUnsigned, false, icc, 1, Rresult);
+
+ bind(done);
}
void MacroAssembler::lneg( Register Rhi, Register Rlow ) {
@@ -2117,118 +2016,23 @@
void MacroAssembler::float_cmp( bool is_float, int unordered_result,
FloatRegister Fa, FloatRegister Fb,
Register Rresult) {
-
- fcmp(is_float ? FloatRegisterImpl::S : FloatRegisterImpl::D, fcc0, Fa, Fb);
-
- Condition lt = unordered_result == -1 ? f_unorderedOrLess : f_less;
- Condition eq = f_equal;
- Condition gt = unordered_result == 1 ? f_unorderedOrGreater : f_greater;
-
- if (VM_Version::v9_instructions_work()) {
-
- mov(-1, Rresult);
- movcc(eq, true, fcc0, 0, Rresult);
- movcc(gt, true, fcc0, 1, Rresult);
-
+ if (is_float) {
+ fcmp(FloatRegisterImpl::S, fcc0, Fa, Fb);
} else {
- Label done;
-
- set( -1, Rresult );
- //fb(lt, true, pn, done); delayed()->set( -1, Rresult );
- fb( eq, true, pn, done); delayed()->set( 0, Rresult );
- fb( gt, true, pn, done); delayed()->set( 1, Rresult );
-
- bind (done);
+ fcmp(FloatRegisterImpl::D, fcc0, Fa, Fb);
}
-}
-
-
-void MacroAssembler::fneg( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
-{
- if (VM_Version::v9_instructions_work()) {
- Assembler::fneg(w, s, d);
+
+ if (unordered_result == 1) {
+ mov( -1, Rresult);
+ movcc(f_equal, true, fcc0, 0, Rresult);
+ movcc(f_unorderedOrGreater, true, fcc0, 1, Rresult);
} else {
- if (w == FloatRegisterImpl::S) {
- Assembler::fneg(w, s, d);
- } else if (w == FloatRegisterImpl::D) {
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
-
- Assembler::fneg(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- } else {
- assert(w == FloatRegisterImpl::Q, "Invalid float register width");
-
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
-
- Assembler::fneg(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
- }
+ mov( -1, Rresult);
+ movcc(f_equal, true, fcc0, 0, Rresult);
+ movcc(f_greater, true, fcc0, 1, Rresult);
}
}
-void MacroAssembler::fmov( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
-{
- if (VM_Version::v9_instructions_work()) {
- Assembler::fmov(w, s, d);
- } else {
- if (w == FloatRegisterImpl::S) {
- Assembler::fmov(w, s, d);
- } else if (w == FloatRegisterImpl::D) {
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
-
- Assembler::fmov(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- } else {
- assert(w == FloatRegisterImpl::Q, "Invalid float register width");
-
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
-
- Assembler::fmov(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
- }
- }
-}
-
-void MacroAssembler::fabs( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d)
-{
- if (VM_Version::v9_instructions_work()) {
- Assembler::fabs(w, s, d);
- } else {
- if (w == FloatRegisterImpl::S) {
- Assembler::fabs(w, s, d);
- } else if (w == FloatRegisterImpl::D) {
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 1) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 1) == 0), "float register alignment check");
-
- Assembler::fabs(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- } else {
- assert(w == FloatRegisterImpl::Q, "Invalid float register width");
-
- // number() does a sanity check on the alignment.
- assert(((s->encoding(FloatRegisterImpl::D) & 3) == 0) &&
- ((d->encoding(FloatRegisterImpl::D) & 3) == 0), "float register alignment check");
-
- Assembler::fabs(FloatRegisterImpl::S, s, d);
- Assembler::fmov(FloatRegisterImpl::S, s->successor(), d->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor(), d->successor()->successor());
- Assembler::fmov(FloatRegisterImpl::S, s->successor()->successor()->successor(), d->successor()->successor()->successor());
- }
- }
-}
void MacroAssembler::save_all_globals_into_locals() {
mov(G1,L1);
@@ -2250,135 +2054,6 @@
mov(L7,G7);
}
-// Use for 64 bit operation.
-void MacroAssembler::casx_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg, address lock_addr, bool use_call_vm)
-{
- // store ptr_reg as the new top value
-#ifdef _LP64
- casx(top_ptr_reg, top_reg, ptr_reg);
-#else
- cas_under_lock(top_ptr_reg, top_reg, ptr_reg, lock_addr, use_call_vm);
-#endif // _LP64
-}
-
-// [RGV] This routine does not handle 64 bit operations.
-// use casx_under_lock() or casx directly!!!
-void MacroAssembler::cas_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg, address lock_addr, bool use_call_vm)
-{
- // store ptr_reg as the new top value
- if (VM_Version::v9_instructions_work()) {
- cas(top_ptr_reg, top_reg, ptr_reg);
- } else {
-
- // If the register is not an out nor global, it is not visible
- // after the save. Allocate a register for it, save its
- // value in the register save area (the save may not flush
- // registers to the save area).
-
- Register top_ptr_reg_after_save;
- Register top_reg_after_save;
- Register ptr_reg_after_save;
-
- if (top_ptr_reg->is_out() || top_ptr_reg->is_global()) {
- top_ptr_reg_after_save = top_ptr_reg->after_save();
- } else {
- Address reg_save_addr = top_ptr_reg->address_in_saved_window();
- top_ptr_reg_after_save = L0;
- st(top_ptr_reg, reg_save_addr);
- }
-
- if (top_reg->is_out() || top_reg->is_global()) {
- top_reg_after_save = top_reg->after_save();
- } else {
- Address reg_save_addr = top_reg->address_in_saved_window();
- top_reg_after_save = L1;
- st(top_reg, reg_save_addr);
- }
-
- if (ptr_reg->is_out() || ptr_reg->is_global()) {
- ptr_reg_after_save = ptr_reg->after_save();
- } else {
- Address reg_save_addr = ptr_reg->address_in_saved_window();
- ptr_reg_after_save = L2;
- st(ptr_reg, reg_save_addr);
- }
-
- const Register& lock_reg = L3;
- const Register& lock_ptr_reg = L4;
- const Register& value_reg = L5;
- const Register& yield_reg = L6;
- const Register& yieldall_reg = L7;
-
- save_frame();
-
- if (top_ptr_reg_after_save == L0) {
- ld(top_ptr_reg->address_in_saved_window().after_save(), top_ptr_reg_after_save);
- }
-
- if (top_reg_after_save == L1) {
- ld(top_reg->address_in_saved_window().after_save(), top_reg_after_save);
- }
-
- if (ptr_reg_after_save == L2) {
- ld(ptr_reg->address_in_saved_window().after_save(), ptr_reg_after_save);
- }
-
- Label(retry_get_lock);
- Label(not_same);
- Label(dont_yield);
-
- assert(lock_addr, "lock_address should be non null for v8");
- set((intptr_t)lock_addr, lock_ptr_reg);
- // Initialize yield counter
- mov(G0,yield_reg);
- mov(G0, yieldall_reg);
- set(StubRoutines::Sparc::locked, lock_reg);
-
- bind(retry_get_lock);
- cmp_and_br_short(yield_reg, V8AtomicOperationUnderLockSpinCount, Assembler::less, Assembler::pt, dont_yield);
-
- if(use_call_vm) {
- Untested("Need to verify global reg consistancy");
- call_VM(noreg, CAST_FROM_FN_PTR(address, SharedRuntime::yield_all), yieldall_reg);
- } else {
- // Save the regs and make space for a C call
- save(SP, -96, SP);
- save_all_globals_into_locals();
- call(CAST_FROM_FN_PTR(address,os::yield_all));
- delayed()->mov(yieldall_reg, O0);
- restore_globals_from_locals();
- restore();
- }
-
- // reset the counter
- mov(G0,yield_reg);
- add(yieldall_reg, 1, yieldall_reg);
-
- bind(dont_yield);
- // try to get lock
- Assembler::swap(lock_ptr_reg, 0, lock_reg);
-
- // did we get the lock?
- cmp(lock_reg, StubRoutines::Sparc::unlocked);
- br(Assembler::notEqual, true, Assembler::pn, retry_get_lock);
- delayed()->add(yield_reg,1,yield_reg);
-
- // yes, got lock. do we have the same top?
- ld(top_ptr_reg_after_save, 0, value_reg);
- cmp_and_br_short(value_reg, top_reg_after_save, Assembler::notEqual, Assembler::pn, not_same);
-
- // yes, same top.
- st(ptr_reg_after_save, top_ptr_reg_after_save, 0);
- membar(Assembler::StoreStore);
-
- bind(not_same);
- mov(value_reg, ptr_reg_after_save);
- st(lock_reg, lock_ptr_reg, 0); // unlock
-
- restore();
- }
-}
-
RegisterOrConstant MacroAssembler::delayed_value_impl(intptr_t* delayed_value_addr,
Register tmp,
int offset) {
@@ -2970,7 +2645,7 @@
markOopDesc::biased_lock_mask_in_place | markOopDesc::age_mask_in_place | markOopDesc::epoch_mask_in_place,
mark_reg);
or3(G2_thread, mark_reg, temp_reg);
- casn(mark_addr.base(), mark_reg, temp_reg);
+ cas_ptr(mark_addr.base(), mark_reg, temp_reg);
// If the biasing toward our thread failed, this means that
// another thread succeeded in biasing it toward itself and we
// need to revoke that bias. The revocation will occur in the
@@ -2998,7 +2673,7 @@
load_klass(obj_reg, temp_reg);
ld_ptr(Address(temp_reg, Klass::prototype_header_offset()), temp_reg);
or3(G2_thread, temp_reg, temp_reg);
- casn(mark_addr.base(), mark_reg, temp_reg);
+ cas_ptr(mark_addr.base(), mark_reg, temp_reg);
// If the biasing toward our thread failed, this means that
// another thread succeeded in biasing it toward itself and we
// need to revoke that bias. The revocation will occur in the
@@ -3027,7 +2702,7 @@
// bits in this situation. Should attempt to preserve them.
load_klass(obj_reg, temp_reg);
ld_ptr(Address(temp_reg, Klass::prototype_header_offset()), temp_reg);
- casn(mark_addr.base(), mark_reg, temp_reg);
+ cas_ptr(mark_addr.base(), mark_reg, temp_reg);
// Fall through to the normal CAS-based lock, because no matter what
// the result of the above CAS, some thread must have succeeded in
// removing the bias bit from the object's header.
@@ -3058,15 +2733,6 @@
}
-// CASN -- 32-64 bit switch hitter similar to the synthetic CASN provided by
-// Solaris/SPARC's "as". Another apt name would be cas_ptr()
-
-void MacroAssembler::casn (Register addr_reg, Register cmp_reg, Register set_reg ) {
- casx_under_lock (addr_reg, cmp_reg, set_reg, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
-}
-
-
-
// compiler_lock_object() and compiler_unlock_object() are direct transliterations
// of i486.ad fast_lock() and fast_unlock(). See those methods for detailed comments.
// The code could be tightened up considerably.
@@ -3129,8 +2795,7 @@
// compare object markOop with Rmark and if equal exchange Rscratch with object markOop
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casx_under_lock(mark_addr.base(), Rmark, Rscratch,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), Rmark, Rscratch);
// if compare/exchange succeeded we found an unlocked object and we now have locked it
// hence we are done
@@ -3176,7 +2841,7 @@
mov(Rbox, Rscratch);
or3(Rmark, markOopDesc::unlocked_value, Rmark);
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casn(mark_addr.base(), Rmark, Rscratch);
+ cas_ptr(mark_addr.base(), Rmark, Rscratch);
cmp(Rmark, Rscratch);
brx(Assembler::equal, false, Assembler::pt, done);
delayed()->sub(Rscratch, SP, Rscratch);
@@ -3207,7 +2872,7 @@
// Invariant: if we acquire the lock then _recursions should be 0.
add(Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark);
mov(G2_thread, Rscratch);
- casn(Rmark, G0, Rscratch);
+ cas_ptr(Rmark, G0, Rscratch);
cmp(Rscratch, G0);
// Intentional fall-through into done
} else {
@@ -3240,7 +2905,7 @@
mov(0, Rscratch);
or3(Rmark, markOopDesc::unlocked_value, Rmark);
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casn(mark_addr.base(), Rmark, Rscratch);
+ cas_ptr(mark_addr.base(), Rmark, Rscratch);
// prefetch (mark_addr, Assembler::severalWritesAndPossiblyReads);
cmp(Rscratch, Rmark);
brx(Assembler::notZero, false, Assembler::pn, Recursive);
@@ -3266,7 +2931,7 @@
// the fast-path stack-lock code from the interpreter and always passed
// control to the "slow" operators in synchronizer.cpp.
- // RScratch contains the fetched obj->mark value from the failed CASN.
+ // RScratch contains the fetched obj->mark value from the failed CAS.
#ifdef _LP64
sub(Rscratch, STACK_BIAS, Rscratch);
#endif
@@ -3300,7 +2965,7 @@
// Invariant: if we acquire the lock then _recursions should be 0.
add(Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark);
mov(G2_thread, Rscratch);
- casn(Rmark, G0, Rscratch);
+ cas_ptr(Rmark, G0, Rscratch);
cmp(Rscratch, G0);
// ST box->displaced_header = NonZero.
// Any non-zero value suffices:
@@ -3336,8 +3001,7 @@
// Check if it is still a light weight lock, this is is true if we see
// the stack address of the basicLock in the markOop of the object
assert(mark_addr.disp() == 0, "cas must take a zero displacement");
- casx_under_lock(mark_addr.base(), Rbox, Rmark,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(mark_addr.base(), Rbox, Rmark);
ba(done);
delayed()->cmp(Rbox, Rmark);
bind(done);
@@ -3398,7 +3062,7 @@
delayed()->andcc(G0, G0, G0);
add(Rmark, ObjectMonitor::owner_offset_in_bytes()-2, Rmark);
mov(G2_thread, Rscratch);
- casn(Rmark, G0, Rscratch);
+ cas_ptr(Rmark, G0, Rscratch);
// invert icc.zf and goto done
br_notnull(Rscratch, false, Assembler::pt, done);
delayed()->cmp(G0, G0);
@@ -3440,7 +3104,7 @@
// A prototype implementation showed excellent results, although
// the scavenger and timeout code was rather involved.
- casn(mark_addr.base(), Rbox, Rscratch);
+ cas_ptr(mark_addr.base(), Rbox, Rscratch);
cmp(Rbox, Rscratch);
// Intentional fall through into done ...
@@ -3540,7 +3204,8 @@
if (CMSIncrementalMode || !Universe::heap()->supports_inline_contig_alloc()) {
// No allocation in the shared eden.
- ba_short(slow_case);
+ ba(slow_case);
+ delayed()->nop();
} else {
// get eden boundaries
// note: we need both top & top_addr!
@@ -3583,7 +3248,7 @@
// Compare obj with the value at top_addr; if still equal, swap the value of
// end with the value at top_addr. If not equal, read the value at top_addr
// into end.
- casx_under_lock(top_addr, obj, end, (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ cas_ptr(top_addr, obj, end);
// if someone beat us on the allocation, try again, otherwise continue
cmp(obj, end);
brx(Assembler::notEqual, false, Assembler::pn, retry);
--- a/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -963,7 +963,7 @@
inline void sub(Register s1, RegisterOrConstant s2, Register d, int offset = 0);
using Assembler::swap;
- inline void swap(Address& a, Register d, int offset = 0);
+ inline void swap(const Address& a, Register d, int offset = 0);
// address pseudos: make these names unlike instruction names to avoid confusion
inline intptr_t load_pc_address( Register reg, int bytes_to_skip );
@@ -1056,13 +1056,6 @@
void breakpoint_trap();
void breakpoint_trap(Condition c, CC cc);
- void flush_windows_trap();
- void clean_windows_trap();
- void get_psr_trap();
- void set_psr_trap();
-
- // V8/V9 flush_windows
- void flush_windows();
// Support for serializing memory accesses between threads
void serialize_memory(Register thread, Register tmp1, Register tmp2);
@@ -1071,14 +1064,6 @@
void enter();
void leave();
- // V8/V9 integer multiply
- void mult(Register s1, Register s2, Register d);
- void mult(Register s1, int simm13a, Register d);
-
- // V8/V9 read and write of condition codes.
- void read_ccr(Register d);
- void write_ccr(Register s);
-
// Manipulation of C++ bools
// These are idioms to flag the need for care with accessing bools but on
// this platform we assume byte size
@@ -1162,21 +1147,6 @@
// check_and_forward_exception to handle exceptions when it is safe
void check_and_forward_exception(Register scratch_reg);
- private:
- // For V8
- void read_ccr_trap(Register ccr_save);
- void write_ccr_trap(Register ccr_save1, Register scratch1, Register scratch2);
-
-#ifdef ASSERT
- // For V8 debugging. Uses V8 instruction sequence and checks
- // result with V9 insturctions rdccr and wrccr.
- // Uses Gscatch and Gscatch2
- void read_ccr_v8_assert(Register ccr_save);
- void write_ccr_v8_assert(Register ccr_save);
-#endif // ASSERT
-
- public:
-
// Write to card table for - register is destroyed afterwards.
void card_table_write(jbyte* byte_map_base, Register tmp, Register obj);
@@ -1314,20 +1284,9 @@
FloatRegister Fa, FloatRegister Fb,
Register Rresult);
- void fneg( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d);
- void fneg( FloatRegisterImpl::Width w, FloatRegister sd ) { Assembler::fneg(w, sd); }
- void fmov( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d);
- void fabs( FloatRegisterImpl::Width w, FloatRegister s, FloatRegister d);
-
void save_all_globals_into_locals();
void restore_globals_from_locals();
- void casx_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg,
- address lock_addr=0, bool use_call_vm=false);
- void cas_under_lock(Register top_ptr_reg, Register top_reg, Register ptr_reg,
- address lock_addr=0, bool use_call_vm=false);
- void casn (Register addr_reg, Register cmp_reg, Register set_reg) ;
-
// These set the icc condition code to equal if the lock succeeded
// and notEqual if it failed and requires a slow case
void compiler_lock_object(Register Roop, Register Rmark, Register Rbox,
--- a/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -229,10 +229,7 @@
// Use the right branch for the platform
inline void MacroAssembler::br( Condition c, bool a, Predict p, address d, relocInfo::relocType rt ) {
- if (VM_Version::v9_instructions_work())
- Assembler::bp(c, a, icc, p, d, rt);
- else
- Assembler::br(c, a, d, rt);
+ Assembler::bp(c, a, icc, p, d, rt);
}
inline void MacroAssembler::br( Condition c, bool a, Predict p, Label& L ) {
@@ -268,10 +265,7 @@
}
inline void MacroAssembler::fb( Condition c, bool a, Predict p, address d, relocInfo::relocType rt ) {
- if (VM_Version::v9_instructions_work())
- fbp(c, a, fcc0, p, d, rt);
- else
- Assembler::fb(c, a, d, rt);
+ fbp(c, a, fcc0, p, d, rt);
}
inline void MacroAssembler::fb( Condition c, bool a, Predict p, Label& L ) {
@@ -334,7 +328,7 @@
// prefetch instruction
inline void MacroAssembler::iprefetch( address d, relocInfo::relocType rt ) {
- if (VM_Version::v9_instructions_work())
+ Assembler::bp( never, true, xcc, pt, d, rt );
Assembler::bp( never, true, xcc, pt, d, rt );
}
inline void MacroAssembler::iprefetch( Label& L) { iprefetch( target(L) ); }
@@ -344,15 +338,7 @@
// returns delta from gotten pc to addr after
inline int MacroAssembler::get_pc( Register d ) {
int x = offset();
- if (VM_Version::v9_instructions_work())
- rdpc(d);
- else {
- Label lbl;
- Assembler::call(lbl, relocInfo::none); // No relocation as this is call to pc+0x8
- if (d == O7) delayed()->nop();
- else delayed()->mov(O7, d);
- bind(lbl);
- }
+ rdpc(d);
return offset() - x;
}
@@ -646,41 +632,26 @@
// returns if membar generates anything, obviously this code should mirror
// membar below.
inline bool MacroAssembler::membar_has_effect( Membar_mask_bits const7a ) {
- if( !os::is_MP() ) return false; // Not needed on single CPU
- if( VM_Version::v9_instructions_work() ) {
- const Membar_mask_bits effective_mask =
- Membar_mask_bits(const7a & ~(LoadLoad | LoadStore | StoreStore));
- return (effective_mask != 0);
- } else {
- return true;
- }
+ if (!os::is_MP())
+ return false; // Not needed on single CPU
+ const Membar_mask_bits effective_mask =
+ Membar_mask_bits(const7a & ~(LoadLoad | LoadStore | StoreStore));
+ return (effective_mask != 0);
}
inline void MacroAssembler::membar( Membar_mask_bits const7a ) {
// Uniprocessors do not need memory barriers
- if (!os::is_MP()) return;
+ if (!os::is_MP())
+ return;
// Weakened for current Sparcs and TSO. See the v9 manual, sections 8.4.3,
// 8.4.4.3, a.31 and a.50.
- if( VM_Version::v9_instructions_work() ) {
- // Under TSO, setting bit 3, 2, or 0 is redundant, so the only value
- // of the mmask subfield of const7a that does anything that isn't done
- // implicitly is StoreLoad.
- const Membar_mask_bits effective_mask =
- Membar_mask_bits(const7a & ~(LoadLoad | LoadStore | StoreStore));
- if ( effective_mask != 0 ) {
- Assembler::membar( effective_mask );
- }
- } else {
- // stbar is the closest there is on v8. Equivalent to membar(StoreStore). We
- // do not issue the stbar because to my knowledge all v8 machines implement TSO,
- // which guarantees that all stores behave as if an stbar were issued just after
- // each one of them. On these machines, stbar ought to be a nop. There doesn't
- // appear to be an equivalent of membar(StoreLoad) on v8: TSO doesn't require it,
- // it can't be specified by stbar, nor have I come up with a way to simulate it.
- //
- // Addendum. Dave says that ldstub guarantees a write buffer flush to coherent
- // space. Put one here to be on the safe side.
- Assembler::ldstub(SP, 0, G0);
+ // Under TSO, setting bit 3, 2, or 0 is redundant, so the only value
+ // of the mmask subfield of const7a that does anything that isn't done
+ // implicitly is StoreLoad.
+ const Membar_mask_bits effective_mask =
+ Membar_mask_bits(const7a & ~(LoadLoad | LoadStore | StoreStore));
+ if (effective_mask != 0) {
+ Assembler::membar(effective_mask);
}
}
@@ -748,7 +719,7 @@
if (offset != 0) sub(d, offset, d);
}
-inline void MacroAssembler::swap(Address& a, Register d, int offset) {
+inline void MacroAssembler::swap(const Address& a, Register d, int offset) {
relocate(a.rspec(offset));
if (a.has_index()) { assert(offset == 0, ""); swap(a.base(), a.index(), d ); }
else { swap(a.base(), a.disp() + offset, d); }
--- a/hotspot/src/cpu/sparc/vm/nativeInst_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/nativeInst_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -162,7 +162,7 @@
int i1 = ((int*)code_buffer)[1];
int* contention_addr = (int*) n_call->addr_at(1*BytesPerInstWord);
assert(inv_op(*contention_addr) == Assembler::arith_op ||
- *contention_addr == nop_instruction() || !VM_Version::v9_instructions_work(),
+ *contention_addr == nop_instruction(),
"must not interfere with original call");
// The set_long_at calls do the ICacheInvalidate so we just need to do them in reverse order
n_call->set_long_at(1*BytesPerInstWord, i1);
@@ -181,7 +181,7 @@
// Make sure the first-patched instruction, which may co-exist
// briefly with the call, will do something harmless.
assert(inv_op(*contention_addr) == Assembler::arith_op ||
- *contention_addr == nop_instruction() || !VM_Version::v9_instructions_work(),
+ *contention_addr == nop_instruction(),
"must not interfere with original call");
}
@@ -933,11 +933,7 @@
int code_size = 1 * BytesPerInstWord;
CodeBuffer cb(verified_entry, code_size + 1);
MacroAssembler* a = new MacroAssembler(&cb);
- if (VM_Version::v9_instructions_work()) {
- a->ldsw(G0, 0, O7); // "ld" must agree with code in the signal handler
- } else {
- a->lduw(G0, 0, O7); // "ld" must agree with code in the signal handler
- }
+ a->ldsw(G0, 0, O7); // "ld" must agree with code in the signal handler
ICache::invalidate_range(verified_entry, code_size);
}
@@ -1024,7 +1020,7 @@
int i1 = ((int*)code_buffer)[1];
int* contention_addr = (int*) h_jump->addr_at(1*BytesPerInstWord);
assert(inv_op(*contention_addr) == Assembler::arith_op ||
- *contention_addr == nop_instruction() || !VM_Version::v9_instructions_work(),
+ *contention_addr == nop_instruction(),
"must not interfere with original call");
// The set_long_at calls do the ICacheInvalidate so we just need to do them in reverse order
h_jump->set_long_at(1*BytesPerInstWord, i1);
@@ -1043,6 +1039,6 @@
// Make sure the first-patched instruction, which may co-exist
// briefly with the call, will do something harmless.
assert(inv_op(*contention_addr) == Assembler::arith_op ||
- *contention_addr == nop_instruction() || !VM_Version::v9_instructions_work(),
+ *contention_addr == nop_instruction(),
"must not interfere with original call");
}
--- a/hotspot/src/cpu/sparc/vm/nativeInst_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/nativeInst_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -70,8 +70,7 @@
bool is_zombie() {
int x = long_at(0);
return is_op3(x,
- VM_Version::v9_instructions_work() ?
- Assembler::ldsw_op3 : Assembler::lduw_op3,
+ Assembler::ldsw_op3,
Assembler::ldst_op)
&& Assembler::inv_rs1(x) == G0
&& Assembler::inv_rd(x) == O7;
--- a/hotspot/src/cpu/sparc/vm/register_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/register_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -249,12 +249,10 @@
case D:
assert(c < 64 && (c & 1) == 0, "bad double float register");
- assert(c < 32 || VM_Version::v9_instructions_work(), "V9 float work only on V9 platform");
return (c & 0x1e) | ((c & 0x20) >> 5);
case Q:
assert(c < 64 && (c & 3) == 0, "bad quad float register");
- assert(c < 32 || VM_Version::v9_instructions_work(), "V9 float work only on V9 platform");
return (c & 0x1c) | ((c & 0x20) >> 5);
}
ShouldNotReachHere();
--- a/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2459,7 +2459,7 @@
// Finally just about ready to make the JNI call
- __ flush_windows();
+ __ flushw();
if (inner_frame_created) {
__ restore();
} else {
--- a/hotspot/src/cpu/sparc/vm/sparc.ad Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/sparc.ad Fri Jun 21 00:51:56 2013 -0700
@@ -2778,10 +2778,7 @@
Register Rold = reg_to_register_object($old$$reg);
Register Rnew = reg_to_register_object($new$$reg);
- // casx_under_lock picks 1 of 3 encodings:
- // For 32-bit pointers you get a 32-bit CAS
- // For 64-bit pointers you get a 64-bit CASX
- __ casn(Rmem, Rold, Rnew); // Swap(*Rmem,Rnew) if *Rmem == Rold
+ __ cas_ptr(Rmem, Rold, Rnew); // Swap(*Rmem,Rnew) if *Rmem == Rold
__ cmp( Rold, Rnew );
%}
@@ -3067,7 +3064,7 @@
AddressLiteral last_rethrow_addrlit(&last_rethrow);
__ sethi(last_rethrow_addrlit, L1);
Address addr(L1, last_rethrow_addrlit.low10());
- __ get_pc(L2);
+ __ rdpc(L2);
__ inc(L2, 3 * BytesPerInstWord); // skip this & 2 more insns to point at jump_to
__ st_ptr(L2, addr);
__ restore();
--- a/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -566,7 +566,7 @@
StubCodeMark mark(this, "StubRoutines", "flush_callers_register_windows");
address start = __ pc();
- __ flush_windows();
+ __ flushw();
__ retl(false);
__ delayed()->add( FP, STACK_BIAS, O0 );
// The returned value must be a stack pointer whose register save area
@@ -575,67 +575,9 @@
return start;
}
- // Helper functions for v8 atomic operations.
- //
- void get_v8_oop_lock_ptr(Register lock_ptr_reg, Register mark_oop_reg, Register scratch_reg) {
- if (mark_oop_reg == noreg) {
- address lock_ptr = (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr();
- __ set((intptr_t)lock_ptr, lock_ptr_reg);
- } else {
- assert(scratch_reg != noreg, "just checking");
- address lock_ptr = (address)StubRoutines::Sparc::_v8_oop_lock_cache;
- __ set((intptr_t)lock_ptr, lock_ptr_reg);
- __ and3(mark_oop_reg, StubRoutines::Sparc::v8_oop_lock_mask_in_place, scratch_reg);
- __ add(lock_ptr_reg, scratch_reg, lock_ptr_reg);
- }
- }
-
- void generate_v8_lock_prologue(Register lock_reg, Register lock_ptr_reg, Register yield_reg, Label& retry, Label& dontyield, Register mark_oop_reg = noreg, Register scratch_reg = noreg) {
-
- get_v8_oop_lock_ptr(lock_ptr_reg, mark_oop_reg, scratch_reg);
- __ set(StubRoutines::Sparc::locked, lock_reg);
- // Initialize yield counter
- __ mov(G0,yield_reg);
-
- __ BIND(retry);
- __ cmp_and_br_short(yield_reg, V8AtomicOperationUnderLockSpinCount, Assembler::less, Assembler::pt, dontyield);
-
- // This code can only be called from inside the VM, this
- // stub is only invoked from Atomic::add(). We do not
- // want to use call_VM, because _last_java_sp and such
- // must already be set.
- //
- // Save the regs and make space for a C call
- __ save(SP, -96, SP);
- __ save_all_globals_into_locals();
- BLOCK_COMMENT("call os::naked_sleep");
- __ call(CAST_FROM_FN_PTR(address, os::naked_sleep));
- __ delayed()->nop();
- __ restore_globals_from_locals();
- __ restore();
- // reset the counter
- __ mov(G0,yield_reg);
-
- __ BIND(dontyield);
-
- // try to get lock
- __ swap(lock_ptr_reg, 0, lock_reg);
-
- // did we get the lock?
- __ cmp(lock_reg, StubRoutines::Sparc::unlocked);
- __ br(Assembler::notEqual, true, Assembler::pn, retry);
- __ delayed()->add(yield_reg,1,yield_reg);
-
- // yes, got lock. do the operation here.
- }
-
- void generate_v8_lock_epilogue(Register lock_reg, Register lock_ptr_reg, Register yield_reg, Label& retry, Label& dontyield, Register mark_oop_reg = noreg, Register scratch_reg = noreg) {
- __ st(lock_reg, lock_ptr_reg, 0); // unlock
- }
-
// Support for jint Atomic::xchg(jint exchange_value, volatile jint* dest).
//
- // Arguments :
+ // Arguments:
//
// exchange_value: O0
// dest: O1
@@ -656,33 +598,14 @@
__ mov(O0, O3); // scratch copy of exchange value
__ ld(O1, 0, O2); // observe the previous value
// try to replace O2 with O3
- __ cas_under_lock(O1, O2, O3,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr(),false);
+ __ cas(O1, O2, O3);
__ cmp_and_br_short(O2, O3, Assembler::notEqual, Assembler::pn, retry);
__ retl(false);
__ delayed()->mov(O2, O0); // report previous value to caller
-
} else {
- if (VM_Version::v9_instructions_work()) {
- __ retl(false);
- __ delayed()->swap(O1, 0, O0);
- } else {
- const Register& lock_reg = O2;
- const Register& lock_ptr_reg = O3;
- const Register& yield_reg = O4;
-
- Label retry;
- Label dontyield;
-
- generate_v8_lock_prologue(lock_reg, lock_ptr_reg, yield_reg, retry, dontyield);
- // got the lock, do the swap
- __ swap(O1, 0, O0);
-
- generate_v8_lock_epilogue(lock_reg, lock_ptr_reg, yield_reg, retry, dontyield);
- __ retl(false);
- __ delayed()->nop();
- }
+ __ retl(false);
+ __ delayed()->swap(O1, 0, O0);
}
return start;
@@ -691,7 +614,7 @@
// Support for jint Atomic::cmpxchg(jint exchange_value, volatile jint* dest, jint compare_value)
//
- // Arguments :
+ // Arguments:
//
// exchange_value: O0
// dest: O1
@@ -701,15 +624,12 @@
//
// O0: the value previously stored in dest
//
- // Overwrites (v8): O3,O4,O5
- //
address generate_atomic_cmpxchg() {
StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg");
address start = __ pc();
// cmpxchg(dest, compare_value, exchange_value)
- __ cas_under_lock(O1, O2, O0,
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr(),false);
+ __ cas(O1, O2, O0);
__ retl(false);
__ delayed()->nop();
@@ -718,7 +638,7 @@
// Support for jlong Atomic::cmpxchg(jlong exchange_value, volatile jlong *dest, jlong compare_value)
//
- // Arguments :
+ // Arguments:
//
// exchange_value: O1:O0
// dest: O2
@@ -728,17 +648,12 @@
//
// O1:O0: the value previously stored in dest
//
- // This only works on V9, on V8 we don't generate any
- // code and just return NULL.
- //
// Overwrites: G1,G2,G3
//
address generate_atomic_cmpxchg_long() {
StubCodeMark mark(this, "StubRoutines", "atomic_cmpxchg_long");
address start = __ pc();
- if (!VM_Version::supports_cx8())
- return NULL;;
__ sllx(O0, 32, O0);
__ srl(O1, 0, O1);
__ or3(O0,O1,O0); // O0 holds 64-bit value from compare_value
@@ -756,7 +671,7 @@
// Support for jint Atomic::add(jint add_value, volatile jint* dest).
//
- // Arguments :
+ // Arguments:
//
// add_value: O0 (e.g., +1 or -1)
// dest: O1
@@ -765,47 +680,22 @@
//
// O0: the new value stored in dest
//
- // Overwrites (v9): O3
- // Overwrites (v8): O3,O4,O5
+ // Overwrites: O3
//
address generate_atomic_add() {
StubCodeMark mark(this, "StubRoutines", "atomic_add");
address start = __ pc();
__ BIND(_atomic_add_stub);
- if (VM_Version::v9_instructions_work()) {
- Label(retry);
- __ BIND(retry);
-
- __ lduw(O1, 0, O2);
- __ add(O0, O2, O3);
- __ cas(O1, O2, O3);
- __ cmp_and_br_short(O2, O3, Assembler::notEqual, Assembler::pn, retry);
- __ retl(false);
- __ delayed()->add(O0, O2, O0); // note that cas made O2==O3
- } else {
- const Register& lock_reg = O2;
- const Register& lock_ptr_reg = O3;
- const Register& value_reg = O4;
- const Register& yield_reg = O5;
-
- Label(retry);
- Label(dontyield);
-
- generate_v8_lock_prologue(lock_reg, lock_ptr_reg, yield_reg, retry, dontyield);
- // got lock, do the increment
- __ ld(O1, 0, value_reg);
- __ add(O0, value_reg, value_reg);
- __ st(value_reg, O1, 0);
-
- // %%% only for RMO and PSO
- __ membar(Assembler::StoreStore);
-
- generate_v8_lock_epilogue(lock_reg, lock_ptr_reg, yield_reg, retry, dontyield);
-
- __ retl(false);
- __ delayed()->mov(value_reg, O0);
- }
+ Label(retry);
+ __ BIND(retry);
+
+ __ lduw(O1, 0, O2);
+ __ add(O0, O2, O3);
+ __ cas(O1, O2, O3);
+ __ cmp_and_br_short(O2, O3, Assembler::notEqual, Assembler::pn, retry);
+ __ retl(false);
+ __ delayed()->add(O0, O2, O0); // note that cas made O2==O3
return start;
}
@@ -841,7 +731,7 @@
__ mov(G3, L3);
__ mov(G4, L4);
__ mov(G5, L5);
- for (i = 0; i < (VM_Version::v9_instructions_work() ? 64 : 32); i += 2) {
+ for (i = 0; i < 64; i += 2) {
__ stf(FloatRegisterImpl::D, as_FloatRegister(i), preserve_addr, i * wordSize);
}
@@ -855,7 +745,7 @@
__ mov(L3, G3);
__ mov(L4, G4);
__ mov(L5, G5);
- for (i = 0; i < (VM_Version::v9_instructions_work() ? 64 : 32); i += 2) {
+ for (i = 0; i < 64; i += 2) {
__ ldf(FloatRegisterImpl::D, preserve_addr, as_FloatRegister(i), i * wordSize);
}
--- a/hotspot/src/cpu/sparc/vm/stubRoutines_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/stubRoutines_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -52,7 +52,3 @@
address StubRoutines::Sparc::_flush_callers_register_windows_entry = CAST_FROM_FN_PTR(address, bootstrap_flush_windows);
address StubRoutines::Sparc::_partial_subtype_check = NULL;
-
-int StubRoutines::Sparc::_atomic_memory_operation_lock = StubRoutines::Sparc::unlocked;
-
-int StubRoutines::Sparc::_v8_oop_lock_cache[StubRoutines::Sparc::nof_v8_oop_lock_cache_entries];
--- a/hotspot/src/cpu/sparc/vm/stubRoutines_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/stubRoutines_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -47,46 +47,14 @@
class Sparc {
friend class StubGenerator;
- public:
- enum { nof_instance_allocators = 10 };
-
- // allocator lock values
- enum {
- unlocked = 0,
- locked = 1
- };
-
- enum {
- v8_oop_lock_ignore_bits = 2,
- v8_oop_lock_bits = 4,
- nof_v8_oop_lock_cache_entries = 1 << (v8_oop_lock_bits+v8_oop_lock_ignore_bits),
- v8_oop_lock_mask = right_n_bits(v8_oop_lock_bits),
- v8_oop_lock_mask_in_place = v8_oop_lock_mask << v8_oop_lock_ignore_bits
- };
-
- static int _v8_oop_lock_cache[nof_v8_oop_lock_cache_entries];
-
private:
static address _test_stop_entry;
static address _stop_subroutine_entry;
static address _flush_callers_register_windows_entry;
- static int _atomic_memory_operation_lock;
-
static address _partial_subtype_check;
public:
- // %%% global lock for everyone who needs to use atomic_compare_and_exchange
- // %%% or atomic_increment -- should probably use more locks for more
- // %%% scalability-- for instance one for each eden space or group of
-
- // address of the lock for atomic_compare_and_exchange
- static int* atomic_memory_operation_lock_addr() { return &_atomic_memory_operation_lock; }
-
- // accessor and mutator for _atomic_memory_operation_lock
- static int atomic_memory_operation_lock() { return _atomic_memory_operation_lock; }
- static void set_atomic_memory_operation_lock(int value) { _atomic_memory_operation_lock = value; }
-
// test assembler stop routine by setting registers
static void (*test_stop_entry()) () { return CAST_TO_FN_PTR(void (*)(void), _test_stop_entry); }
--- a/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1054,7 +1054,7 @@
// flush the windows now. We don't care about the current (protection) frame
// only the outer frames
- __ flush_windows();
+ __ flushw();
// mark windows as flushed
Address flags(G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());
--- a/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1338,14 +1338,13 @@
void TemplateTable::fneg() {
transition(ftos, ftos);
- __ fneg(FloatRegisterImpl::S, Ftos_f);
+ __ fneg(FloatRegisterImpl::S, Ftos_f, Ftos_f);
}
void TemplateTable::dneg() {
transition(dtos, dtos);
- // v8 has fnegd if source and dest are the same
- __ fneg(FloatRegisterImpl::D, Ftos_f);
+ __ fneg(FloatRegisterImpl::D, Ftos_f, Ftos_f);
}
@@ -1470,19 +1469,10 @@
__ st_long(Otos_l, __ d_tmp);
__ ldf(FloatRegisterImpl::D, __ d_tmp, Ftos_d);
- if (VM_Version::v9_instructions_work()) {
- if (bytecode() == Bytecodes::_l2f) {
- __ fxtof(FloatRegisterImpl::S, Ftos_d, Ftos_f);
- } else {
- __ fxtof(FloatRegisterImpl::D, Ftos_d, Ftos_d);
- }
+ if (bytecode() == Bytecodes::_l2f) {
+ __ fxtof(FloatRegisterImpl::S, Ftos_d, Ftos_f);
} else {
- __ call_VM_leaf(
- Lscratch,
- bytecode() == Bytecodes::_l2f
- ? CAST_FROM_FN_PTR(address, SharedRuntime::l2f)
- : CAST_FROM_FN_PTR(address, SharedRuntime::l2d)
- );
+ __ fxtof(FloatRegisterImpl::D, Ftos_d, Ftos_d);
}
break;
@@ -1490,11 +1480,6 @@
Label isNaN;
// result must be 0 if value is NaN; test by comparing value to itself
__ fcmp(FloatRegisterImpl::S, Assembler::fcc0, Ftos_f, Ftos_f);
- // According to the v8 manual, you have to have a non-fp instruction
- // between fcmp and fb.
- if (!VM_Version::v9_instructions_work()) {
- __ nop();
- }
__ fb(Assembler::f_unordered, true, Assembler::pn, isNaN);
__ delayed()->clr(Otos_i); // NaN
__ ftoi(FloatRegisterImpl::S, Ftos_f, F30);
@@ -1537,16 +1522,7 @@
break;
case Bytecodes::_d2f:
- if (VM_Version::v9_instructions_work()) {
__ ftof( FloatRegisterImpl::D, FloatRegisterImpl::S, Ftos_d, Ftos_f);
- }
- else {
- // must uncache tos
- __ push_d();
- __ pop_i(O0);
- __ pop_i(O1);
- __ call_VM_leaf(Lscratch, CAST_FROM_FN_PTR(address, SharedRuntime::d2f));
- }
break;
default: ShouldNotReachHere();
@@ -1956,17 +1932,8 @@
__ ld( Rarray, Rscratch, Rscratch );
// (Rscratch is already in the native byte-ordering.)
__ cmp( Rkey, Rscratch );
- if ( VM_Version::v9_instructions_work() ) {
- __ movcc( Assembler::less, false, Assembler::icc, Rh, Rj ); // j = h if (key < array[h].fast_match())
- __ movcc( Assembler::greaterEqual, false, Assembler::icc, Rh, Ri ); // i = h if (key >= array[h].fast_match())
- }
- else {
- Label end_of_if;
- __ br( Assembler::less, true, Assembler::pt, end_of_if );
- __ delayed()->mov( Rh, Rj ); // if (<) Rj = Rh
- __ mov( Rh, Ri ); // else i = h
- __ bind(end_of_if); // }
- }
+ __ movcc( Assembler::less, false, Assembler::icc, Rh, Rj ); // j = h if (key < array[h].fast_match())
+ __ movcc( Assembler::greaterEqual, false, Assembler::icc, Rh, Ri ); // i = h if (key >= array[h].fast_match())
// while (i+1 < j)
__ bind( entry );
@@ -3418,9 +3385,7 @@
// has been allocated.
__ cmp_and_brx_short(RnewTopValue, RendValue, Assembler::greaterUnsigned, Assembler::pn, slow_case);
- __ casx_under_lock(RtopAddr, RoldTopValue, RnewTopValue,
- VM_Version::v9_instructions_work() ? NULL :
- (address)StubRoutines::Sparc::atomic_memory_operation_lock_addr());
+ __ cas_ptr(RtopAddr, RoldTopValue, RnewTopValue);
// if someone beat us on the allocation, try again, otherwise continue
__ cmp_and_brx_short(RoldTopValue, RnewTopValue, Assembler::notEqual, Assembler::pn, retry);
@@ -3701,14 +3666,7 @@
__ verify_oop(O4); // verify each monitor's oop
__ tst(O4); // is this entry unused?
- if (VM_Version::v9_instructions_work())
- __ movcc( Assembler::zero, false, Assembler::ptr_cc, O3, O1);
- else {
- Label L;
- __ br( Assembler::zero, true, Assembler::pn, L );
- __ delayed()->mov(O3, O1); // rememeber this one if match
- __ bind(L);
- }
+ __ movcc( Assembler::zero, false, Assembler::ptr_cc, O3, O1);
__ cmp(O4, O0); // check if current entry is for same object
__ brx( Assembler::equal, false, Assembler::pn, exit );
--- a/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -75,23 +75,14 @@
FLAG_SET_DEFAULT(AllocatePrefetchStyle, 1);
}
- if (has_v9()) {
- assert(ArraycopySrcPrefetchDistance < 4096, "invalid value");
- if (ArraycopySrcPrefetchDistance >= 4096)
- ArraycopySrcPrefetchDistance = 4064;
- assert(ArraycopyDstPrefetchDistance < 4096, "invalid value");
- if (ArraycopyDstPrefetchDistance >= 4096)
- ArraycopyDstPrefetchDistance = 4064;
- } else {
- if (ArraycopySrcPrefetchDistance > 0) {
- warning("prefetch instructions are not available on this CPU");
- FLAG_SET_DEFAULT(ArraycopySrcPrefetchDistance, 0);
- }
- if (ArraycopyDstPrefetchDistance > 0) {
- warning("prefetch instructions are not available on this CPU");
- FLAG_SET_DEFAULT(ArraycopyDstPrefetchDistance, 0);
- }
- }
+ guarantee(VM_Version::has_v9(), "only SPARC v9 is supported");
+
+ assert(ArraycopySrcPrefetchDistance < 4096, "invalid value");
+ if (ArraycopySrcPrefetchDistance >= 4096)
+ ArraycopySrcPrefetchDistance = 4064;
+ assert(ArraycopyDstPrefetchDistance < 4096, "invalid value");
+ if (ArraycopyDstPrefetchDistance >= 4096)
+ ArraycopyDstPrefetchDistance = 4064;
UseSSE = 0; // Only on x86 and x64
--- a/hotspot/src/cpu/sparc/vm/vm_version_sparc.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/vm_version_sparc.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -177,10 +177,6 @@
return AllocatePrefetchDistance > 0 ? AllocatePrefetchStyle : 0;
}
- // Legacy
- static bool v8_instructions_work() { return has_v8() && !has_v9(); }
- static bool v9_instructions_work() { return has_v9(); }
-
// Assembler testing
static void allow_all();
static void revert();
--- a/hotspot/src/cpu/x86/vm/globals_x86.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/globals_x86.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -55,7 +55,7 @@
define_pd_global(intx, InlineFrequencyCount, 100);
define_pd_global(intx, InlineSmallCode, 1000);
-define_pd_global(intx, StackYellowPages, 2);
+define_pd_global(intx, StackYellowPages, NOT_WINDOWS(2) WINDOWS_ONLY(3));
define_pd_global(intx, StackRedPages, 1);
#ifdef AMD64
// Very large C++ stack frames using solaris-amd64 optimized builds
--- a/hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1429,6 +1429,8 @@
assert(!length_arg.first()->is_Register() || length_arg.first()->as_Register() != tmp_reg,
"possible collision");
+ __ block_comment("unpack_array_argument {");
+
// Pass the length, ptr pair
Label is_null, done;
VMRegPair tmp;
@@ -1453,6 +1455,8 @@
move_ptr(masm, tmp, body_arg);
move32_64(masm, tmp, length_arg);
__ bind(done);
+
+ __ block_comment("} unpack_array_argument");
}
@@ -2170,27 +2174,34 @@
}
}
- // point c_arg at the first arg that is already loaded in case we
- // need to spill before we call out
- int c_arg = total_c_args - total_in_args;
+ int c_arg;
// Pre-load a static method's oop into r14. Used both by locking code and
// the normal JNI call code.
- if (method->is_static() && !is_critical_native) {
-
- // load oop into a register
- __ movoop(oop_handle_reg, JNIHandles::make_local(method->method_holder()->java_mirror()));
-
- // Now handlize the static class mirror it's known not-null.
- __ movptr(Address(rsp, klass_offset), oop_handle_reg);
- map->set_oop(VMRegImpl::stack2reg(klass_slot_offset));
-
- // Now get the handle
- __ lea(oop_handle_reg, Address(rsp, klass_offset));
- // store the klass handle as second argument
- __ movptr(c_rarg1, oop_handle_reg);
- // and protect the arg if we must spill
- c_arg--;
+ if (!is_critical_native) {
+ // point c_arg at the first arg that is already loaded in case we
+ // need to spill before we call out
+ c_arg = total_c_args - total_in_args;
+
+ if (method->is_static()) {
+
+ // load oop into a register
+ __ movoop(oop_handle_reg, JNIHandles::make_local(method->method_holder()->java_mirror()));
+
+ // Now handlize the static class mirror it's known not-null.
+ __ movptr(Address(rsp, klass_offset), oop_handle_reg);
+ map->set_oop(VMRegImpl::stack2reg(klass_slot_offset));
+
+ // Now get the handle
+ __ lea(oop_handle_reg, Address(rsp, klass_offset));
+ // store the klass handle as second argument
+ __ movptr(c_rarg1, oop_handle_reg);
+ // and protect the arg if we must spill
+ c_arg--;
+ }
+ } else {
+ // For JNI critical methods we need to save all registers in save_args.
+ c_arg = 0;
}
// Change state to native (we save the return address in the thread, since it might not
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -83,7 +83,7 @@
private:
#ifdef PRODUCT
-#define inc_counter_np(counter) (0)
+#define inc_counter_np(counter) ((void)0)
#else
void inc_counter_np_(int& counter) {
__ incrementl(ExternalAddress((address)&counter));
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -81,7 +81,7 @@
private:
#ifdef PRODUCT
-#define inc_counter_np(counter) (0)
+#define inc_counter_np(counter) ((void)0)
#else
void inc_counter_np_(int& counter) {
// This can destroy rscratch1 if counter is far from the code cache
--- a/hotspot/src/os/bsd/dtrace/jvm_dtrace.c Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/bsd/dtrace/jvm_dtrace.c Fri Jun 21 00:51:56 2013 -0700
@@ -122,9 +122,7 @@
}
static int file_close(int fd) {
- int ret;
- RESTARTABLE(close(fd), ret);
- return ret;
+ return close(fd);
}
static int file_read(int fd, char* buf, int len) {
--- a/hotspot/src/os/bsd/vm/attachListener_bsd.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/bsd/vm/attachListener_bsd.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -199,7 +199,7 @@
::unlink(initial_path);
int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
if (res == -1) {
- RESTARTABLE(::close(listener), res);
+ ::close(listener);
return -1;
}
@@ -217,7 +217,7 @@
}
}
if (res == -1) {
- RESTARTABLE(::close(listener), res);
+ ::close(listener);
::unlink(initial_path);
return -1;
}
@@ -345,24 +345,21 @@
uid_t puid;
gid_t pgid;
if (::getpeereid(s, &puid, &pgid) != 0) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
}
uid_t euid = geteuid();
gid_t egid = getegid();
if (puid != euid || pgid != egid) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
}
// peer credential look okay so we read the request
BsdAttachOperation* op = read_request(s);
if (op == NULL) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
} else {
return op;
@@ -413,7 +410,7 @@
}
// done
- RESTARTABLE(::close(this->socket()), rc);
+ ::close(this->socket());
// were we externally suspended while we were waiting?
thread->check_and_wait_while_suspended();
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2074,6 +2074,13 @@
}
}
+static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
+ int err) {
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
+ strerror(err), err);
+}
+
// NOTE: Bsd kernel does not really reserve the pages for us.
// All it does is to check if there are enough free pages
// left at the time of mmap(). This could be a potential
@@ -2082,18 +2089,45 @@
int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
#ifdef __OpenBSD__
// XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD
- return ::mprotect(addr, size, prot) == 0;
+ if (::mprotect(addr, size, prot) == 0) {
+ return true;
+ }
#else
uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
- return res != (uintptr_t) MAP_FAILED;
+ if (res != (uintptr_t) MAP_FAILED) {
+ return true;
+ }
#endif
+
+ // Warn about any commit errors we see in non-product builds just
+ // in case mmap() doesn't work as described on the man page.
+ NOT_PRODUCT(warn_fail_commit_memory(addr, size, exec, errno);)
+
+ return false;
}
-
bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
bool exec) {
- return commit_memory(addr, size, exec);
+ // alignment_hint is ignored on this OS
+ return pd_commit_memory(addr, size, exec);
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ if (!pd_commit_memory(addr, size, exec)) {
+ // add extra info in product mode for vm_exit_out_of_memory():
+ PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
+ vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
+ }
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size,
+ size_t alignment_hint, bool exec,
+ const char* mesg) {
+ // alignment_hint is ignored on this OS
+ pd_commit_memory_or_exit(addr, size, exec, mesg);
}
void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
@@ -2148,7 +2182,7 @@
}
bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
- return os::commit_memory(addr, size);
+ return os::commit_memory(addr, size, !ExecMem);
}
// If this is a growable mapping, remove the guard pages entirely by
@@ -2320,21 +2354,20 @@
}
// The memory is committed
- address pc = CALLER_PC;
- MemTracker::record_virtual_memory_reserve((address)addr, bytes, pc);
- MemTracker::record_virtual_memory_commit((address)addr, bytes, pc);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, mtNone, CALLER_PC);
return addr;
}
bool os::release_memory_special(char* base, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
// detaching the SHM segment will also delete it, see reserve_memory_special()
int rslt = shmdt(base);
if (rslt == 0) {
- MemTracker::record_virtual_memory_uncommit((address)base, bytes);
- MemTracker::record_virtual_memory_release((address)base, bytes);
+ tkr.record((address)base, bytes);
return true;
} else {
+ tkr.discard();
return false;
}
@@ -3512,7 +3545,7 @@
if (!UseMembar) {
address mem_serialize_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
+ guarantee( mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
os::set_memory_serialize_page( mem_serialize_page );
#ifndef PRODUCT
--- a/hotspot/src/os/bsd/vm/os_bsd.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -178,11 +178,11 @@
}
inline int os::close(int fd) {
- RESTARTABLE_RETURN_INT(::close(fd));
+ return ::close(fd);
}
inline int os::socket_close(int fd) {
- RESTARTABLE_RETURN_INT(::close(fd));
+ return ::close(fd);
}
inline int os::socket(int domain, int type, int protocol) {
--- a/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/bsd/vm/perfMemory_bsd.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -60,7 +60,7 @@
}
// commit memory
- if (!os::commit_memory(mapAddress, size)) {
+ if (!os::commit_memory(mapAddress, size, !ExecMem)) {
if (PrintMiscellaneous && Verbose) {
warning("Could not commit PerfData memory\n");
}
@@ -120,7 +120,7 @@
addr += result;
}
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
if (PrintMiscellaneous && Verbose) {
if (result == OS_ERR) {
warning("Could not close %s: %s\n", destfile, strerror(errno));
@@ -632,7 +632,7 @@
if (PrintMiscellaneous && Verbose) {
warning("could not set shared memory file size: %s\n", strerror(errno));
}
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
return -1;
}
@@ -656,7 +656,7 @@
if (result != -1) {
return fd;
} else {
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
return -1;
}
}
@@ -734,9 +734,7 @@
mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- // attempt to close the file - restart it if it was interrupted,
- // but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -755,8 +753,7 @@
(void)::memset((void*) mapAddress, 0, size);
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
return mapAddress;
}
@@ -909,7 +906,7 @@
// attempt to close the file - restart if it gets interrupted,
// but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -921,8 +918,7 @@
}
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
*addr = mapAddress;
*sizep = size;
--- a/hotspot/src/os/linux/vm/attachListener_linux.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/linux/vm/attachListener_linux.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -199,7 +199,7 @@
::unlink(initial_path);
int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
if (res == -1) {
- RESTARTABLE(::close(listener), res);
+ ::close(listener);
return -1;
}
@@ -212,7 +212,7 @@
}
}
if (res == -1) {
- RESTARTABLE(::close(listener), res);
+ ::close(listener);
::unlink(initial_path);
return -1;
}
@@ -340,24 +340,21 @@
struct ucred cred_info;
socklen_t optlen = sizeof(cred_info);
if (::getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void*)&cred_info, &optlen) == -1) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
}
uid_t euid = geteuid();
gid_t egid = getegid();
if (cred_info.uid != euid || cred_info.gid != egid) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
}
// peer credential look okay so we read the request
LinuxAttachOperation* op = read_request(s);
if (op == NULL) {
- int res;
- RESTARTABLE(::close(s), res);
+ ::close(s);
continue;
} else {
return op;
@@ -408,7 +405,7 @@
}
// done
- RESTARTABLE(::close(this->socket()), rc);
+ ::close(this->socket());
// were we externally suspended while we were waiting?
thread->check_and_wait_while_suspended();
--- a/hotspot/src/os/linux/vm/os_linux.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2612,11 +2612,49 @@
}
}
+static bool recoverable_mmap_error(int err) {
+ // See if the error is one we can let the caller handle. This
+ // list of errno values comes from JBS-6843484. I can't find a
+ // Linux man page that documents this specific set of errno
+ // values so while this list currently matches Solaris, it may
+ // change as we gain experience with this failure mode.
+ switch (err) {
+ case EBADF:
+ case EINVAL:
+ case ENOTSUP:
+ // let the caller deal with these errors
+ return true;
+
+ default:
+ // Any remaining errors on this OS can cause our reserved mapping
+ // to be lost. That can cause confusion where different data
+ // structures think they have the same memory mapped. The worst
+ // scenario is if both the VM and a library think they have the
+ // same memory mapped.
+ return false;
+ }
+}
+
+static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
+ int err) {
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
+ strerror(err), err);
+}
+
+static void warn_fail_commit_memory(char* addr, size_t size,
+ size_t alignment_hint, bool exec,
+ int err) {
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", addr, size,
+ alignment_hint, exec, strerror(err), err);
+}
+
// NOTE: Linux kernel does not really reserve the pages for us.
// All it does is to check if there are enough free pages
// left at the time of mmap(). This could be a potential
// problem.
-bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
+int os::Linux::commit_memory_impl(char* addr, size_t size, bool exec) {
int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
@@ -2624,9 +2662,32 @@
if (UseNUMAInterleaving) {
numa_make_global(addr, size);
}
- return true;
- }
- return false;
+ return 0;
+ }
+
+ int err = errno; // save errno from mmap() call above
+
+ if (!recoverable_mmap_error(err)) {
+ warn_fail_commit_memory(addr, size, exec, err);
+ vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "committing reserved memory.");
+ }
+
+ return err;
+}
+
+bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
+ return os::Linux::commit_memory_impl(addr, size, exec) == 0;
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ int err = os::Linux::commit_memory_impl(addr, size, exec);
+ if (err != 0) {
+ // the caller wants all commit errors to exit with the specified mesg:
+ warn_fail_commit_memory(addr, size, exec, err);
+ vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
+ }
}
// Define MAP_HUGETLB here so we can build HotSpot on old systems.
@@ -2639,8 +2700,9 @@
#define MADV_HUGEPAGE 14
#endif
-bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
- bool exec) {
+int os::Linux::commit_memory_impl(char* addr, size_t size,
+ size_t alignment_hint, bool exec) {
+ int err;
if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
uintptr_t res =
@@ -2651,16 +2713,46 @@
if (UseNUMAInterleaving) {
numa_make_global(addr, size);
}
- return true;
+ return 0;
+ }
+
+ err = errno; // save errno from mmap() call above
+
+ if (!recoverable_mmap_error(err)) {
+ // However, it is not clear that this loss of our reserved mapping
+ // happens with large pages on Linux or that we cannot recover
+ // from the loss. For now, we just issue a warning and we don't
+ // call vm_exit_out_of_memory(). This issue is being tracked by
+ // JBS-8007074.
+ warn_fail_commit_memory(addr, size, alignment_hint, exec, err);
+// vm_exit_out_of_memory(size, OOM_MMAP_ERROR,
+// "committing reserved memory.");
}
// Fall through and try to use small pages
}
- if (commit_memory(addr, size, exec)) {
+ err = os::Linux::commit_memory_impl(addr, size, exec);
+ if (err == 0) {
realign_memory(addr, size, alignment_hint);
- return true;
- }
- return false;
+ }
+ return err;
+}
+
+bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
+ bool exec) {
+ return os::Linux::commit_memory_impl(addr, size, alignment_hint, exec) == 0;
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size,
+ size_t alignment_hint, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ int err = os::Linux::commit_memory_impl(addr, size, alignment_hint, exec);
+ if (err != 0) {
+ // the caller wants all commit errors to exit with the specified mesg:
+ warn_fail_commit_memory(addr, size, alignment_hint, exec, err);
+ vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
+ }
}
void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
@@ -2678,7 +2770,7 @@
// small pages on top of the SHM segment. This method always works for small pages, so we
// allow that in any case.
if (alignment_hint <= (size_t)os::vm_page_size() || !UseSHM) {
- commit_memory(addr, bytes, alignment_hint, false);
+ commit_memory(addr, bytes, alignment_hint, !ExecMem);
}
}
@@ -2931,7 +3023,7 @@
::munmap((void*)stack_extent, (uintptr_t)addr - stack_extent);
}
- return os::commit_memory(addr, size);
+ return os::commit_memory(addr, size, !ExecMem);
}
// If this is a growable mapping, remove the guard pages entirely by
@@ -3053,7 +3145,7 @@
MAP_ANONYMOUS|MAP_PRIVATE|MAP_HUGETLB,
-1, 0);
- if (p != (void *) -1) {
+ if (p != MAP_FAILED) {
// We don't know if this really is a huge page or not.
FILE *fp = fopen("/proc/self/maps", "r");
if (fp) {
@@ -3271,22 +3363,21 @@
}
// The memory is committed
- address pc = CALLER_PC;
- MemTracker::record_virtual_memory_reserve((address)addr, bytes, pc);
- MemTracker::record_virtual_memory_commit((address)addr, bytes, pc);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, mtNone, CALLER_PC);
return addr;
}
bool os::release_memory_special(char* base, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
// detaching the SHM segment will also delete it, see reserve_memory_special()
int rslt = shmdt(base);
if (rslt == 0) {
- MemTracker::record_virtual_memory_uncommit((address)base, bytes);
- MemTracker::record_virtual_memory_release((address)base, bytes);
+ tkr.record((address)base, bytes);
return true;
} else {
- return false;
+ tkr.discard();
+ return false;
}
}
@@ -4393,7 +4484,7 @@
if (!UseMembar) {
address mem_serialize_page = (address) ::mmap(NULL, Linux::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
- guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
+ guarantee( mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
os::set_memory_serialize_page( mem_serialize_page );
#ifndef PRODUCT
--- a/hotspot/src/os/linux/vm/os_linux.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -76,6 +76,10 @@
static julong physical_memory() { return _physical_memory; }
static void initialize_system_info();
+ static int commit_memory_impl(char* addr, size_t bytes, bool exec);
+ static int commit_memory_impl(char* addr, size_t bytes,
+ size_t alignment_hint, bool exec);
+
static void set_glibc_version(const char *s) { _glibc_version = s; }
static void set_libpthread_version(const char *s) { _libpthread_version = s; }
--- a/hotspot/src/os/linux/vm/perfMemory_linux.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/linux/vm/perfMemory_linux.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -60,7 +60,7 @@
}
// commit memory
- if (!os::commit_memory(mapAddress, size)) {
+ if (!os::commit_memory(mapAddress, size, !ExecMem)) {
if (PrintMiscellaneous && Verbose) {
warning("Could not commit PerfData memory\n");
}
@@ -120,7 +120,7 @@
addr += result;
}
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
if (PrintMiscellaneous && Verbose) {
if (result == OS_ERR) {
warning("Could not close %s: %s\n", destfile, strerror(errno));
@@ -632,7 +632,7 @@
if (PrintMiscellaneous && Verbose) {
warning("could not set shared memory file size: %s\n", strerror(errno));
}
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
return -1;
}
@@ -656,7 +656,7 @@
if (result != -1) {
return fd;
} else {
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
return -1;
}
}
@@ -734,9 +734,7 @@
mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- // attempt to close the file - restart it if it was interrupted,
- // but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -755,8 +753,7 @@
(void)::memset((void*) mapAddress, 0, size);
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
return mapAddress;
}
@@ -907,9 +904,7 @@
mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
- // attempt to close the file - restart if it gets interrupted,
- // but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -921,8 +916,7 @@
}
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
*addr = mapAddress;
*sizep = size;
--- a/hotspot/src/os/solaris/dtrace/jvm_dtrace.c Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/solaris/dtrace/jvm_dtrace.c Fri Jun 21 00:51:56 2013 -0700
@@ -122,9 +122,7 @@
}
static int file_close(int fd) {
- int ret;
- RESTARTABLE(close(fd), ret);
- return ret;
+ return close(fd);
}
static int file_read(int fd, char* buf, int len) {
--- a/hotspot/src/os/solaris/vm/attachListener_solaris.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/solaris/vm/attachListener_solaris.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -392,7 +392,7 @@
return -1;
}
assert(fd >= 0, "bad file descriptor");
- RESTARTABLE(::close(fd), res);
+ ::close(fd);
// attach the door descriptor to the file
if ((res = ::fattach(dd, initial_path)) == -1) {
@@ -410,7 +410,7 @@
// rename file so that clients can attach
if (dd >= 0) {
if (::rename(initial_path, door_path) == -1) {
- RESTARTABLE(::close(dd), res);
+ ::close(dd);
::fdetach(initial_path);
dd = -1;
}
@@ -549,7 +549,7 @@
}
// close socket and we're done
- RESTARTABLE(::close(this->socket()), rc);
+ ::close(this->socket());
// were we externally suspended while we were waiting?
thread->check_and_wait_while_suspended();
--- a/hotspot/src/os/solaris/vm/os_solaris.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/solaris/vm/os_solaris.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2784,7 +2784,42 @@
return page_size;
}
-bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
+static bool recoverable_mmap_error(int err) {
+ // See if the error is one we can let the caller handle. This
+ // list of errno values comes from the Solaris mmap(2) man page.
+ switch (err) {
+ case EBADF:
+ case EINVAL:
+ case ENOTSUP:
+ // let the caller deal with these errors
+ return true;
+
+ default:
+ // Any remaining errors on this OS can cause our reserved mapping
+ // to be lost. That can cause confusion where different data
+ // structures think they have the same memory mapped. The worst
+ // scenario is if both the VM and a library think they have the
+ // same memory mapped.
+ return false;
+ }
+}
+
+static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec,
+ int err) {
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", %d) failed; error='%s' (errno=%d)", addr, bytes, exec,
+ strerror(err), err);
+}
+
+static void warn_fail_commit_memory(char* addr, size_t bytes,
+ size_t alignment_hint, bool exec,
+ int err) {
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", " SIZE_FORMAT ", %d) failed; error='%s' (errno=%d)", addr, bytes,
+ alignment_hint, exec, strerror(err), err);
+}
+
+int os::Solaris::commit_memory_impl(char* addr, size_t bytes, bool exec) {
int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
size_t size = bytes;
char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
@@ -2792,14 +2827,38 @@
if (UseNUMAInterleaving) {
numa_make_global(addr, bytes);
}
- return true;
- }
- return false;
-}
-
-bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
- bool exec) {
- if (commit_memory(addr, bytes, exec)) {
+ return 0;
+ }
+
+ int err = errno; // save errno from mmap() call in mmap_chunk()
+
+ if (!recoverable_mmap_error(err)) {
+ warn_fail_commit_memory(addr, bytes, exec, err);
+ vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, "committing reserved memory.");
+ }
+
+ return err;
+}
+
+bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
+ return Solaris::commit_memory_impl(addr, bytes, exec) == 0;
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t bytes, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ int err = os::Solaris::commit_memory_impl(addr, bytes, exec);
+ if (err != 0) {
+ // the caller wants all commit errors to exit with the specified mesg:
+ warn_fail_commit_memory(addr, bytes, exec, err);
+ vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
+ }
+}
+
+int os::Solaris::commit_memory_impl(char* addr, size_t bytes,
+ size_t alignment_hint, bool exec) {
+ int err = Solaris::commit_memory_impl(addr, bytes, exec);
+ if (err == 0) {
if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
// If the large page size has been set and the VM
// is using large pages, use the large page size
@@ -2821,9 +2880,25 @@
// Since this is a hint, ignore any failures.
(void)Solaris::set_mpss_range(addr, bytes, page_size);
}
- return true;
- }
- return false;
+ }
+ return err;
+}
+
+bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
+ bool exec) {
+ return Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec) == 0;
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t bytes,
+ size_t alignment_hint, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ int err = os::Solaris::commit_memory_impl(addr, bytes, alignment_hint, exec);
+ if (err != 0) {
+ // the caller wants all commit errors to exit with the specified mesg:
+ warn_fail_commit_memory(addr, bytes, alignment_hint, exec, err);
+ vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
+ }
}
// Uncommit the pages in a specified region.
@@ -2835,7 +2910,7 @@
}
bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
- return os::commit_memory(addr, size);
+ return os::commit_memory(addr, size, !ExecMem);
}
bool os::remove_stack_guard_pages(char* addr, size_t size) {
@@ -3457,22 +3532,21 @@
}
// The memory is committed
- address pc = CALLER_PC;
- MemTracker::record_virtual_memory_reserve((address)retAddr, size, pc);
- MemTracker::record_virtual_memory_commit((address)retAddr, size, pc);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)retAddr, size, mtNone, CURRENT_PC);
return retAddr;
}
bool os::release_memory_special(char* base, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
// detaching the SHM segment will also delete it, see reserve_memory_special()
int rslt = shmdt(base);
if (rslt == 0) {
- MemTracker::record_virtual_memory_uncommit((address)base, bytes);
- MemTracker::record_virtual_memory_release((address)base, bytes);
+ tkr.record((address)base, bytes);
return true;
} else {
- return false;
+ tkr.discard();
+ return false;
}
}
@@ -6604,11 +6678,11 @@
}
int os::close(int fd) {
- RESTARTABLE_RETURN_INT(::close(fd));
+ return ::close(fd);
}
int os::socket_close(int fd) {
- RESTARTABLE_RETURN_INT(::close(fd));
+ return ::close(fd);
}
int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
--- a/hotspot/src/os/solaris/vm/os_solaris.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/solaris/vm/os_solaris.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -168,6 +168,9 @@
static int _dev_zero_fd;
static int get_dev_zero_fd() { return _dev_zero_fd; }
static void set_dev_zero_fd(int fd) { _dev_zero_fd = fd; }
+ static int commit_memory_impl(char* addr, size_t bytes, bool exec);
+ static int commit_memory_impl(char* addr, size_t bytes,
+ size_t alignment_hint, bool exec);
static char* mmap_chunk(char *addr, size_t size, int flags, int prot);
static char* anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed);
static bool mpss_sanity_check(bool warn, size_t * page_size);
--- a/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/solaris/vm/perfMemory_solaris.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -62,7 +62,7 @@
}
// commit memory
- if (!os::commit_memory(mapAddress, size)) {
+ if (!os::commit_memory(mapAddress, size, !ExecMem)) {
if (PrintMiscellaneous && Verbose) {
warning("Could not commit PerfData memory\n");
}
@@ -122,7 +122,7 @@
addr += result;
}
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
if (PrintMiscellaneous && Verbose) {
if (result == OS_ERR) {
warning("Could not close %s: %s\n", destfile, strerror(errno));
@@ -437,7 +437,7 @@
addr+=result;
}
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
// get the user name for the effective user id of the process
char* user_name = get_user_name(psinfo.pr_euid);
@@ -669,7 +669,7 @@
if (PrintMiscellaneous && Verbose) {
warning("could not set shared memory file size: %s\n", strerror(errno));
}
- RESTARTABLE(::close(fd), result);
+ ::close(fd);
return -1;
}
@@ -749,9 +749,7 @@
mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
- // attempt to close the file - restart it if it was interrupted,
- // but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -770,8 +768,7 @@
(void)::memset((void*) mapAddress, 0, size);
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
return mapAddress;
}
@@ -922,9 +919,7 @@
mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
- // attempt to close the file - restart if it gets interrupted,
- // but ignore other failures
- RESTARTABLE(::close(fd), result);
+ result = ::close(fd);
assert(result != OS_ERR, "could not close file");
if (mapAddress == MAP_FAILED) {
@@ -936,8 +931,7 @@
}
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
*addr = mapAddress;
*sizep = size;
--- a/hotspot/src/os/windows/vm/os_windows.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/windows/vm/os_windows.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2524,7 +2524,7 @@
addr = (address)((uintptr_t)addr &
(~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
os::commit_memory((char *)addr, thread->stack_base() - addr,
- false );
+ !ExecMem);
return EXCEPTION_CONTINUE_EXECUTION;
}
else
@@ -2875,7 +2875,7 @@
PAGE_READWRITE);
// If reservation failed, return NULL
if (p_buf == NULL) return NULL;
- MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
+ MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, mtNone, CALLER_PC);
os::release_memory(p_buf, bytes + chunk_size);
// we still need to round up to a page boundary (in case we are using large pages)
@@ -2941,7 +2941,7 @@
// need to create a dummy 'reserve' record to match
// the release.
MemTracker::record_virtual_memory_reserve((address)p_buf,
- bytes_to_release, CALLER_PC);
+ bytes_to_release, mtNone, CALLER_PC);
os::release_memory(p_buf, bytes_to_release);
}
#ifdef ASSERT
@@ -2961,9 +2961,10 @@
// Although the memory is allocated individually, it is returned as one.
// NMT records it as one block.
address pc = CALLER_PC;
- MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, pc);
if ((flags & MEM_COMMIT) != 0) {
- MemTracker::record_virtual_memory_commit((address)p_buf, bytes, pc);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, mtNone, pc);
+ } else {
+ MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, mtNone, pc);
}
// made it this far, success
@@ -3154,8 +3155,7 @@
char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
if (res != NULL) {
address pc = CALLER_PC;
- MemTracker::record_virtual_memory_reserve((address)res, bytes, pc);
- MemTracker::record_virtual_memory_commit((address)res, bytes, pc);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, mtNone, pc);
}
return res;
@@ -3164,14 +3164,21 @@
bool os::release_memory_special(char* base, size_t bytes) {
assert(base != NULL, "Sanity check");
- // Memory allocated via reserve_memory_special() is committed
- MemTracker::record_virtual_memory_uncommit((address)base, bytes);
return release_memory(base, bytes);
}
void os::print_statistics() {
}
+static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
+ int err = os::get_last_error();
+ char buf[256];
+ size_t buf_len = os::lasterror(buf, sizeof(buf));
+ warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
+ ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
+ exec, buf_len != 0 ? buf : "<no_error_string>", err);
+}
+
bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
if (bytes == 0) {
// Don't bother the OS with noops.
@@ -3186,11 +3193,17 @@
// is always within a reserve covered by a single VirtualAlloc
// in that case we can just do a single commit for the requested size
if (!UseNUMAInterleaving) {
- if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false;
+ if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
+ NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
+ return false;
+ }
if (exec) {
DWORD oldprot;
// Windows doc says to use VirtualProtect to get execute permissions
- if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false;
+ if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
+ NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
+ return false;
+ }
}
return true;
} else {
@@ -3205,12 +3218,20 @@
MEMORY_BASIC_INFORMATION alloc_info;
VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
- if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL)
+ if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
+ PAGE_READWRITE) == NULL) {
+ NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
+ exec);)
return false;
+ }
if (exec) {
DWORD oldprot;
- if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot))
+ if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
+ PAGE_EXECUTE_READWRITE, &oldprot)) {
+ NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
+ exec);)
return false;
+ }
}
bytes_remaining -= bytes_to_rq;
next_alloc_addr += bytes_to_rq;
@@ -3222,7 +3243,24 @@
bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
bool exec) {
- return commit_memory(addr, size, exec);
+ // alignment_hint is ignored on this OS
+ return pd_commit_memory(addr, size, exec);
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
+ const char* mesg) {
+ assert(mesg != NULL, "mesg must be specified");
+ if (!pd_commit_memory(addr, size, exec)) {
+ warn_fail_commit_memory(addr, size, exec);
+ vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
+ }
+}
+
+void os::pd_commit_memory_or_exit(char* addr, size_t size,
+ size_t alignment_hint, bool exec,
+ const char* mesg) {
+ // alignment_hint is ignored on this OS
+ pd_commit_memory_or_exit(addr, size, exec, mesg);
}
bool os::pd_uncommit_memory(char* addr, size_t bytes) {
@@ -3240,7 +3278,7 @@
}
bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
- return os::commit_memory(addr, size);
+ return os::commit_memory(addr, size, !ExecMem);
}
bool os::remove_stack_guard_pages(char* addr, size_t size) {
@@ -3264,8 +3302,9 @@
// Strange enough, but on Win32 one can change protection only for committed
// memory, not a big deal anyway, as bytes less or equal than 64K
- if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
- fatal("cannot commit protection page");
+ if (!is_committed) {
+ commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
+ "cannot commit protection page");
}
// One cannot use os::guard_memory() here, as on Win32 guard page
// have different (one-shot) semantics, from MSDN on PAGE_GUARD:
--- a/hotspot/src/os/windows/vm/perfMemory_windows.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os/windows/vm/perfMemory_windows.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -58,7 +58,7 @@
}
// commit memory
- if (!os::commit_memory(mapAddress, size)) {
+ if (!os::commit_memory(mapAddress, size, !ExecMem)) {
if (PrintMiscellaneous && Verbose) {
warning("Could not commit PerfData memory\n");
}
@@ -1498,8 +1498,7 @@
(void)memset(mapAddress, '\0', size);
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
return (char*) mapAddress;
}
@@ -1681,8 +1680,7 @@
}
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_reserve((address)mapAddress, size, CURRENT_PC);
- MemTracker::record_virtual_memory_type((address)mapAddress, mtInternal);
+ MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);
*addrp = (char*)mapAddress;
@@ -1836,9 +1834,10 @@
return;
}
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
remove_file_mapping(addr);
// it does not go through os api, the operation has to record from here
- MemTracker::record_virtual_memory_release((address)addr, bytes);
+ tkr.record((address)addr, bytes);
}
char* PerfMemory::backing_store_filename() {
--- a/hotspot/src/os_cpu/linux_sparc/vm/assembler_linux_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "asm/macroAssembler.hpp"
-#include "runtime/os.hpp"
-#include "runtime/threadLocalStorage.hpp"
-
-#include <asm-sparc/traps.h>
-
-void MacroAssembler::read_ccr_trap(Register ccr_save) {
- // No implementation
- breakpoint_trap();
-}
-
-void MacroAssembler::write_ccr_trap(Register ccr_save, Register scratch1, Register scratch2) {
- // No implementation
- breakpoint_trap();
-}
-
-void MacroAssembler::flush_windows_trap() { trap(SP_TRAP_FWIN); }
-void MacroAssembler::clean_windows_trap() { trap(SP_TRAP_CWIN); }
-
-// Use software breakpoint trap until we figure out how to do this on Linux
-void MacroAssembler::get_psr_trap() { trap(SP_TRAP_SBPT); }
-void MacroAssembler::set_psr_trap() { trap(SP_TRAP_SBPT); }
--- a/hotspot/src/os_cpu/linux_sparc/vm/atomic_linux_sparc.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os_cpu/linux_sparc/vm/atomic_linux_sparc.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -169,7 +169,6 @@
: "memory");
return rv;
#else
- assert(VM_Version::v9_instructions_work(), "cas only supported on v9");
volatile jlong_accessor evl, cvl, rv;
evl.long_value = exchange_value;
cvl.long_value = compare_value;
--- a/hotspot/src/os_cpu/solaris_sparc/vm/assembler_solaris_sparc.cpp Thu Jun 20 10:16:47 2013 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#include "precompiled.hpp"
-#include "asm/macroAssembler.inline.hpp"
-#include "runtime/os.hpp"
-#include "runtime/threadLocalStorage.hpp"
-
-#include <sys/trap.h> // For trap numbers
-#include <v9/sys/psr_compat.h> // For V8 compatibility
-
-void MacroAssembler::read_ccr_trap(Register ccr_save) {
- // Execute a trap to get the PSR, mask and shift
- // to get the condition codes.
- get_psr_trap();
- nop();
- set(PSR_ICC, ccr_save);
- and3(O0, ccr_save, ccr_save);
- srl(ccr_save, PSR_ICC_SHIFT, ccr_save);
-}
-
-void MacroAssembler::write_ccr_trap(Register ccr_save, Register scratch1, Register scratch2) {
- // Execute a trap to get the PSR, shift back
- // the condition codes, mask the condition codes
- // back into and PSR and trap to write back the
- // PSR.
- sll(ccr_save, PSR_ICC_SHIFT, scratch2);
- get_psr_trap();
- nop();
- set(~PSR_ICC, scratch1);
- and3(O0, scratch1, O0);
- or3(O0, scratch2, O0);
- set_psr_trap();
- nop();
-}
-
-void MacroAssembler::flush_windows_trap() { trap(ST_FLUSH_WINDOWS); }
-void MacroAssembler::clean_windows_trap() { trap(ST_CLEAN_WINDOWS); }
-void MacroAssembler::get_psr_trap() { trap(ST_GETPSR); }
-void MacroAssembler::set_psr_trap() { trap(ST_SETPSR); }
--- a/hotspot/src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os_cpu/solaris_sparc/vm/atomic_solaris_sparc.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -60,21 +60,10 @@
#else
-extern "C" void _Atomic_move_long_v8(volatile jlong* src, volatile jlong* dst);
extern "C" void _Atomic_move_long_v9(volatile jlong* src, volatile jlong* dst);
inline void Atomic_move_long(volatile jlong* src, volatile jlong* dst) {
-#ifdef COMPILER2
- // Compiler2 does not support v8, it is used only for v9.
_Atomic_move_long_v9(src, dst);
-#else
- // The branch is cheaper then emulated LDD.
- if (VM_Version::v9_instructions_work()) {
- _Atomic_move_long_v9(src, dst);
- } else {
- _Atomic_move_long_v8(src, dst);
- }
-#endif
}
inline jlong Atomic::load(volatile jlong* src) {
@@ -209,7 +198,6 @@
: "memory");
return rv;
#else //_LP64
- assert(VM_Version::v9_instructions_work(), "cas only supported on v9");
volatile jlong_accessor evl, cvl, rv;
evl.long_value = exchange_value;
cvl.long_value = compare_value;
@@ -318,7 +306,6 @@
// Return 64 bit value in %o0
return _Atomic_cas64((intptr_t)exchange_value, (intptr_t *)dest, (intptr_t)compare_value);
#else // _LP64
- assert (VM_Version::v9_instructions_work(), "only supported on v9");
// Return 64 bit value in %o0,%o1 by hand
return _Atomic_casl(exchange_value, dest, compare_value);
#endif // _LP64
--- a/hotspot/src/os_cpu/solaris_sparc/vm/solaris_sparc.il Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/os_cpu/solaris_sparc/vm/solaris_sparc.il Fri Jun 21 00:51:56 2013 -0700
@@ -152,23 +152,6 @@
.nonvolatile
.end
- // Support for jlong Atomic::load and Atomic::store on v8.
- //
- // void _Atomic_move_long_v8(volatile jlong* src, volatile jlong* dst)
- //
- // Arguments:
- // src: O0
- // dest: O1
- //
- // Overwrites O2 and O3
-
- .inline _Atomic_move_long_v8,2
- .volatile
- ldd [%o0], %o2
- std %o2, [%o1]
- .nonvolatile
- .end
-
// Support for jlong Atomic::load and Atomic::store on v9.
//
// void _Atomic_move_long_v9(volatile jlong* src, volatile jlong* dst)
--- a/hotspot/src/share/vm/adlc/formssel.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/adlc/formssel.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -235,6 +235,9 @@
return false;
}
+bool InstructForm::is_ideal_negD() const {
+ return (_matrule && _matrule->_rChild && strcmp(_matrule->_rChild->_opType, "NegD") == 0);
+}
// Return 'true' if this instruction matches an ideal 'Copy*' node
int InstructForm::is_ideal_copy() const {
@@ -533,6 +536,12 @@
if( data_type != Form::none )
rematerialize = true;
+ // Ugly: until a better fix is implemented, disable rematerialization for
+ // negD nodes because they are proved to be problematic.
+ if (is_ideal_negD()) {
+ return false;
+ }
+
// Constants
if( _components.count() == 1 && _components[0]->is(Component::USE_DEF) )
rematerialize = true;
--- a/hotspot/src/share/vm/adlc/formssel.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/adlc/formssel.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -147,6 +147,7 @@
virtual int is_empty_encoding() const; // _size=0 and/or _insencode empty
virtual int is_tls_instruction() const; // tlsLoadP rule or ideal ThreadLocal
virtual int is_ideal_copy() const; // node matches ideal 'Copy*'
+ virtual bool is_ideal_negD() const; // node matches ideal 'NegD'
virtual bool is_ideal_if() const; // node matches ideal 'If'
virtual bool is_ideal_fastlock() const; // node matches 'FastLock'
virtual bool is_ideal_membar() const; // node matches ideal 'MemBarXXX'
--- a/hotspot/src/share/vm/c1/c1_IR.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/c1/c1_IR.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -506,7 +506,7 @@
_loop_map(0, 0), // initialized later with correct size
_compilation(c)
{
- TRACE_LINEAR_SCAN(2, "***** computing linear-scan block order");
+ TRACE_LINEAR_SCAN(2, tty->print_cr("***** computing linear-scan block order"));
init_visited();
count_edges(start_block, NULL);
@@ -683,7 +683,7 @@
}
void ComputeLinearScanOrder::assign_loop_depth(BlockBegin* start_block) {
- TRACE_LINEAR_SCAN(3, "----- computing loop-depth and weight");
+ TRACE_LINEAR_SCAN(3, tty->print_cr("----- computing loop-depth and weight"));
init_visited();
assert(_work_list.is_empty(), "work list must be empty before processing");
@@ -868,7 +868,7 @@
}
void ComputeLinearScanOrder::compute_order(BlockBegin* start_block) {
- TRACE_LINEAR_SCAN(3, "----- computing final block order");
+ TRACE_LINEAR_SCAN(3, tty->print_cr("----- computing final block order"));
// the start block is always the first block in the linear scan order
_linear_scan_order = new BlockList(_num_blocks);
--- a/hotspot/src/share/vm/c1/c1_LIR.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/c1/c1_LIR.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -201,23 +201,24 @@
#ifdef ASSERT
if (!is_pointer() && !is_illegal()) {
+ OprKind kindfield = kind_field(); // Factored out because of compiler bug, see 8002160
switch (as_BasicType(type_field())) {
case T_LONG:
- assert((kind_field() == cpu_register || kind_field() == stack_value) &&
+ assert((kindfield == cpu_register || kindfield == stack_value) &&
size_field() == double_size, "must match");
break;
case T_FLOAT:
// FP return values can be also in CPU registers on ARM and PPC (softfp ABI)
- assert((kind_field() == fpu_register || kind_field() == stack_value
- ARM_ONLY(|| kind_field() == cpu_register)
- PPC_ONLY(|| kind_field() == cpu_register) ) &&
+ assert((kindfield == fpu_register || kindfield == stack_value
+ ARM_ONLY(|| kindfield == cpu_register)
+ PPC_ONLY(|| kindfield == cpu_register) ) &&
size_field() == single_size, "must match");
break;
case T_DOUBLE:
// FP return values can be also in CPU registers on ARM and PPC (softfp ABI)
- assert((kind_field() == fpu_register || kind_field() == stack_value
- ARM_ONLY(|| kind_field() == cpu_register)
- PPC_ONLY(|| kind_field() == cpu_register) ) &&
+ assert((kindfield == fpu_register || kindfield == stack_value
+ ARM_ONLY(|| kindfield == cpu_register)
+ PPC_ONLY(|| kindfield == cpu_register) ) &&
size_field() == double_size, "must match");
break;
case T_BOOLEAN:
@@ -229,7 +230,7 @@
case T_OBJECT:
case T_METADATA:
case T_ARRAY:
- assert((kind_field() == cpu_register || kind_field() == stack_value) &&
+ assert((kindfield == cpu_register || kindfield == stack_value) &&
size_field() == single_size, "must match");
break;
--- a/hotspot/src/share/vm/ci/ciUtilities.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/ci/ciUtilities.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -96,7 +96,7 @@
CLEAR_PENDING_EXCEPTION; \
return (result); \
} \
- (0
+ (void)(0
#define KILL_COMPILE_ON_ANY \
THREAD); \
@@ -104,7 +104,7 @@
fatal("unhandled ci exception"); \
CLEAR_PENDING_EXCEPTION; \
} \
-(0
+(void)(0
inline const char* bool_to_str(bool b) {
--- a/hotspot/src/share/vm/classfile/genericSignatures.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/classfile/genericSignatures.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -124,7 +124,7 @@
fatal(STREAM->parse_error()); \
} \
return NULL; \
- } 0
+ } (void)0
#define READ() STREAM->read(); CHECK_FOR_PARSE_ERROR()
#define PEEK() STREAM->peek(); CHECK_FOR_PARSE_ERROR()
@@ -133,7 +133,7 @@
#define EXPECTED(c, ch) STREAM->assert_char(c, ch); CHECK_FOR_PARSE_ERROR()
#define EXPECT_END() STREAM->expect_end(); CHECK_FOR_PARSE_ERROR()
-#define CHECK_STREAM STREAM); CHECK_FOR_PARSE_ERROR(); (0
+#define CHECK_STREAM STREAM); CHECK_FOR_PARSE_ERROR(); ((void)0
#ifndef PRODUCT
void Identifier::print_on(outputStream* str) const {
--- a/hotspot/src/share/vm/classfile/symbolTable.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/classfile/symbolTable.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -598,6 +598,8 @@
bool StringTable::_needs_rehashing = false;
+volatile int StringTable::_parallel_claimed_idx = 0;
+
// Pick hashing algorithm
unsigned int StringTable::hash_string(const jchar* s, int len) {
return use_alternate_hashcode() ? AltHashing::murmur3_32(seed(), s, len) :
@@ -761,8 +763,18 @@
}
}
-void StringTable::oops_do(OopClosure* f) {
- for (int i = 0; i < the_table()->table_size(); ++i) {
+void StringTable::buckets_do(OopClosure* f, int start_idx, int end_idx) {
+ const int limit = the_table()->table_size();
+
+ assert(0 <= start_idx && start_idx <= limit,
+ err_msg("start_idx (" INT32_FORMAT ") oob?", start_idx));
+ assert(0 <= end_idx && end_idx <= limit,
+ err_msg("end_idx (" INT32_FORMAT ") oob?", end_idx));
+ assert(start_idx <= end_idx,
+ err_msg("Ordering: start_idx=" INT32_FORMAT", end_idx=" INT32_FORMAT,
+ start_idx, end_idx));
+
+ for (int i = start_idx; i < end_idx; i += 1) {
HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
while (entry != NULL) {
assert(!entry->is_shared(), "CDS not used for the StringTable");
@@ -774,6 +786,27 @@
}
}
+void StringTable::oops_do(OopClosure* f) {
+ buckets_do(f, 0, the_table()->table_size());
+}
+
+void StringTable::possibly_parallel_oops_do(OopClosure* f) {
+ const int ClaimChunkSize = 32;
+ const int limit = the_table()->table_size();
+
+ for (;;) {
+ // Grab next set of buckets to scan
+ int start_idx = Atomic::add(ClaimChunkSize, &_parallel_claimed_idx) - ClaimChunkSize;
+ if (start_idx >= limit) {
+ // End of table
+ break;
+ }
+
+ int end_idx = MIN2(limit, start_idx + ClaimChunkSize);
+ buckets_do(f, start_idx, end_idx);
+ }
+}
+
void StringTable::verify() {
for (int i = 0; i < the_table()->table_size(); ++i) {
HashtableEntry<oop, mtSymbol>* p = the_table()->bucket(i);
--- a/hotspot/src/share/vm/classfile/symbolTable.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/classfile/symbolTable.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -246,12 +246,19 @@
// Set if one bucket is out of balance due to hash algorithm deficiency
static bool _needs_rehashing;
+ // Claimed high water mark for parallel chunked scanning
+ static volatile int _parallel_claimed_idx;
+
static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS);
oop basic_add(int index, Handle string_or_null, jchar* name, int len,
unsigned int hashValue, TRAPS);
oop lookup(int index, jchar* chars, int length, unsigned int hashValue);
+ // Apply the give oop closure to the entries to the buckets
+ // in the range [start_idx, end_idx).
+ static void buckets_do(OopClosure* f, int start_idx, int end_idx);
+
StringTable() : Hashtable<oop, mtSymbol>((int)StringTableSize,
sizeof (HashtableEntry<oop, mtSymbol>)) {}
@@ -277,9 +284,12 @@
unlink_or_oops_do(cl, NULL);
}
- // Invoke "f->do_oop" on the locations of all oops in the table.
+ // Serially invoke "f->do_oop" on the locations of all oops in the table.
static void oops_do(OopClosure* f);
+ // Possibly parallel version of the above
+ static void possibly_parallel_oops_do(OopClosure* f);
+
// Hashing algorithm, used as the hash value used by the
// StringTable for bucket selection and comparison (stored in the
// HashtableEntry structures). This is used in the String.intern() method.
@@ -315,5 +325,8 @@
// Rehash the symbol table if it gets out of balance
static void rehash_table();
static bool needs_rehashing() { return _needs_rehashing; }
+
+ // Parallel chunked scanning
+ static void clear_parallel_claimed_index() { _parallel_claimed_idx = 0; }
};
#endif // SHARE_VM_CLASSFILE_SYMBOLTABLE_HPP
--- a/hotspot/src/share/vm/classfile/verifier.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/classfile/verifier.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -86,9 +86,9 @@
// These macros are used similarly to CHECK macros but also check
// the status of the verifier and return if that has an error.
#define CHECK_VERIFY(verifier) \
- CHECK); if ((verifier)->has_error()) return; (0
+ CHECK); if ((verifier)->has_error()) return; ((void)0
#define CHECK_VERIFY_(verifier, result) \
- CHECK_(result)); if ((verifier)->has_error()) return (result); (0
+ CHECK_(result)); if ((verifier)->has_error()) return (result); ((void)0
class TypeOrigin VALUE_OBJ_CLASS_SPEC {
private:
--- a/hotspot/src/share/vm/code/dependencies.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/code/dependencies.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -989,7 +989,7 @@
assert(changes.involves_context(context_type), "irrelevant dependency");
Klass* new_type = changes.new_type();
- count_find_witness_calls();
+ (void)count_find_witness_calls();
NOT_PRODUCT(deps_find_witness_singles++);
// Current thread must be in VM (not native mode, as in CI):
--- a/hotspot/src/share/vm/code/nmethod.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/code/nmethod.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2615,7 +2615,8 @@
relocation_begin()-1+ip[1]);
for (; ip < index_end; ip++)
tty->print_cr(" (%d ?)", ip[0]);
- tty->print_cr(" @" INTPTR_FORMAT ": index_size=%d", ip, *ip++);
+ tty->print_cr(" @" INTPTR_FORMAT ": index_size=%d", ip, *ip);
+ ip++;
tty->print_cr("reloc_end @" INTPTR_FORMAT ":", ip);
}
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -565,11 +565,9 @@
if(new_start_aligned < new_end_for_commit) {
MemRegion new_committed =
MemRegion(new_start_aligned, new_end_for_commit);
- if (!os::commit_memory((char*)new_committed.start(),
- new_committed.byte_size())) {
- vm_exit_out_of_memory(new_committed.byte_size(), OOM_MMAP_ERROR,
- "card table expansion");
- }
+ os::commit_memory_or_exit((char*)new_committed.start(),
+ new_committed.byte_size(), !ExecMem,
+ "card table expansion");
}
result = true;
} else if (new_start_aligned > cur_committed.start()) {
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1250,14 +1250,13 @@
avg_promoted()->deviation());
}
- gclog_or_tty->print( " avg_promoted_padded_avg: %f"
+ gclog_or_tty->print_cr( " avg_promoted_padded_avg: %f"
" avg_pretenured_padded_avg: %f"
" tenuring_thresh: %d"
" target_size: " SIZE_FORMAT,
avg_promoted()->padded_average(),
_avg_pretenured->padded_average(),
tenuring_threshold, target_size);
- tty->cr();
}
set_survivor_size(target_size);
@@ -1279,7 +1278,7 @@
avg_promoted()->sample(promoted + _avg_pretenured->padded_average());
if (PrintAdaptiveSizePolicy) {
- gclog_or_tty->print(
+ gclog_or_tty->print_cr(
"AdaptiveSizePolicy::update_averages:"
" survived: " SIZE_FORMAT
" promoted: " SIZE_FORMAT
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -101,7 +101,8 @@
}
char* const base_addr = committed_high_addr();
- bool result = special() || os::commit_memory(base_addr, bytes, alignment());
+ bool result = special() ||
+ os::commit_memory(base_addr, bytes, alignment(), !ExecMem);
if (result) {
_committed_high_addr += bytes;
}
@@ -154,7 +155,7 @@
if (tmp_bytes > 0) {
char* const commit_base = committed_high_addr();
if (other_space->special() ||
- os::commit_memory(commit_base, tmp_bytes, alignment())) {
+ os::commit_memory(commit_base, tmp_bytes, alignment(), !ExecMem)) {
// Reduce the reserved region in the other space.
other_space->set_reserved(other_space->reserved_low_addr() + tmp_bytes,
other_space->reserved_high_addr(),
@@ -269,7 +270,8 @@
}
char* const base_addr = committed_low_addr() - bytes;
- bool result = special() || os::commit_memory(base_addr, bytes, alignment());
+ bool result = special() ||
+ os::commit_memory(base_addr, bytes, alignment(), !ExecMem);
if (result) {
_committed_low_addr -= bytes;
}
@@ -322,7 +324,7 @@
if (tmp_bytes > 0) {
char* const commit_base = committed_low_addr() - tmp_bytes;
if (other_space->special() ||
- os::commit_memory(commit_base, tmp_bytes, alignment())) {
+ os::commit_memory(commit_base, tmp_bytes, alignment(), !ExecMem)) {
// Reduce the reserved region in the other space.
other_space->set_reserved(other_space->reserved_low_addr(),
other_space->reserved_high_addr() - tmp_bytes,
--- a/hotspot/src/share/vm/memory/allocation.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/memory/allocation.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -635,8 +635,15 @@
#define NEW_RESOURCE_ARRAY_IN_THREAD(thread, type, size)\
(type*) resource_allocate_bytes(thread, (size) * sizeof(type))
+#define NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(thread, type, size)\
+ (type*) resource_allocate_bytes(thread, (size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
+
#define REALLOC_RESOURCE_ARRAY(type, old, old_size, new_size)\
- (type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type) )
+ (type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type))
+
+#define REALLOC_RESOURCE_ARRAY_RETURN_NULL(type, old, old_size, new_size)\
+ (type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type),\
+ (new_size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
#define FREE_RESOURCE_ARRAY(type, old, size)\
resource_free_bytes((char*)(old), (size) * sizeof(type))
@@ -647,28 +654,40 @@
#define NEW_RESOURCE_OBJ(type)\
NEW_RESOURCE_ARRAY(type, 1)
+#define NEW_RESOURCE_OBJ_RETURN_NULL(type)\
+ NEW_RESOURCE_ARRAY_RETURN_NULL(type, 1)
+
+#define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail)\
+ (type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail)
+
+#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
+ (type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
+
#define NEW_C_HEAP_ARRAY(type, size, memflags)\
(type*) (AllocateHeap((size) * sizeof(type), memflags))
+#define NEW_C_HEAP_ARRAY2_RETURN_NULL(type, size, memflags, pc)\
+ NEW_C_HEAP_ARRAY3(type, size, memflags, pc, AllocFailStrategy::RETURN_NULL)
+
+#define NEW_C_HEAP_ARRAY_RETURN_NULL(type, size, memflags)\
+ NEW_C_HEAP_ARRAY3(type, size, memflags, (address)0, AllocFailStrategy::RETURN_NULL)
+
#define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags))
+#define REALLOC_C_HEAP_ARRAY_RETURN_NULL(type, old, size, memflags)\
+ (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, AllocFailStrategy::RETURN_NULL))
+
#define FREE_C_HEAP_ARRAY(type, old, memflags) \
FreeHeap((char*)(old), memflags)
-#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
- (type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
-
-#define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\
- (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc))
-
-#define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail) \
- (type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail)
-
// allocate type in heap without calling ctor
#define NEW_C_HEAP_OBJ(type, memflags)\
NEW_C_HEAP_ARRAY(type, 1, memflags)
+#define NEW_C_HEAP_OBJ_RETURN_NULL(type, memflags)\
+ NEW_C_HEAP_ARRAY_RETURN_NULL(type, 1, memflags)
+
// deallocate obj of type in heap without calling dtor
#define FREE_C_HEAP_OBJ(objname, memflags)\
FreeHeap((char*)objname, memflags);
@@ -713,13 +732,21 @@
// is set so that we always use malloc except for Solaris where we set the
// limit to get mapped memory.
template <class E, MEMFLAGS F>
-class ArrayAllocator : StackObj {
+class ArrayAllocator VALUE_OBJ_CLASS_SPEC {
char* _addr;
bool _use_malloc;
size_t _size;
+ bool _free_in_destructor;
public:
- ArrayAllocator() : _addr(NULL), _use_malloc(false), _size(0) { }
- ~ArrayAllocator() { free(); }
+ ArrayAllocator(bool free_in_destructor = true) :
+ _addr(NULL), _use_malloc(false), _size(0), _free_in_destructor(free_in_destructor) { }
+
+ ~ArrayAllocator() {
+ if (_free_in_destructor) {
+ free();
+ }
+ }
+
E* allocate(size_t length);
void free();
};
--- a/hotspot/src/share/vm/memory/allocation.inline.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/memory/allocation.inline.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -146,10 +146,7 @@
vm_exit_out_of_memory(_size, OOM_MMAP_ERROR, "Allocator (reserve)");
}
- bool success = os::commit_memory(_addr, _size, false /* executable */);
- if (!success) {
- vm_exit_out_of_memory(_size, OOM_MMAP_ERROR, "Allocator (commit)");
- }
+ os::commit_memory_or_exit(_addr, _size, !ExecMem, "Allocator (commit)");
return (E*)_addr;
}
--- a/hotspot/src/share/vm/memory/cardTableModRefBS.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/memory/cardTableModRefBS.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -110,11 +110,8 @@
jbyte* guard_card = &_byte_map[_guard_index];
uintptr_t guard_page = align_size_down((uintptr_t)guard_card, _page_size);
_guard_region = MemRegion((HeapWord*)guard_page, _page_size);
- if (!os::commit_memory((char*)guard_page, _page_size, _page_size)) {
- // Do better than this for Merlin
- vm_exit_out_of_memory(_page_size, OOM_MMAP_ERROR, "card table last card");
- }
-
+ os::commit_memory_or_exit((char*)guard_page, _page_size, _page_size,
+ !ExecMem, "card table last card");
*guard_card = last_card;
_lowest_non_clean =
@@ -312,12 +309,9 @@
MemRegion(cur_committed.end(), new_end_for_commit);
assert(!new_committed.is_empty(), "Region should not be empty here");
- if (!os::commit_memory((char*)new_committed.start(),
- new_committed.byte_size(), _page_size)) {
- // Do better than this for Merlin
- vm_exit_out_of_memory(new_committed.byte_size(), OOM_MMAP_ERROR,
- "card table expansion");
- }
+ os::commit_memory_or_exit((char*)new_committed.start(),
+ new_committed.byte_size(), _page_size,
+ !ExecMem, "card table expansion");
// Use new_end_aligned (as opposed to new_end_for_commit) because
// the cur_committed region may include the guard region.
} else if (new_end_aligned < cur_committed.end()) {
@@ -418,7 +412,7 @@
}
// Touch the last card of the covered region to show that it
// is committed (or SEGV).
- debug_only(*byte_for(_covered[ind].last());)
+ debug_only((void) (*byte_for(_covered[ind].last()));)
debug_only(verify_guard();)
}
--- a/hotspot/src/share/vm/memory/sharedHeap.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/memory/sharedHeap.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -47,7 +47,6 @@
SH_PS_SystemDictionary_oops_do,
SH_PS_ClassLoaderDataGraph_oops_do,
SH_PS_jvmti_oops_do,
- SH_PS_StringTable_oops_do,
SH_PS_CodeCache_oops_do,
// Leave this one last.
SH_PS_NumElements
@@ -127,6 +126,8 @@
{
if (_active) {
outer->change_strong_roots_parity();
+ // Zero the claimed high water mark in the StringTable
+ StringTable::clear_parallel_claimed_index();
}
}
@@ -154,14 +155,16 @@
// Global (strong) JNI handles
if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
JNIHandles::oops_do(roots);
+
// All threads execute this; the individual threads are task groups.
CLDToOopClosure roots_from_clds(roots);
CLDToOopClosure* roots_from_clds_p = (is_scavenging ? NULL : &roots_from_clds);
- if (ParallelGCThreads > 0) {
- Threads::possibly_parallel_oops_do(roots, roots_from_clds_p ,code_roots);
+ if (CollectedHeap::use_parallel_gc_threads()) {
+ Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, code_roots);
} else {
Threads::oops_do(roots, roots_from_clds_p, code_roots);
}
+
if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
ObjectSynchronizer::oops_do(roots);
if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
@@ -189,8 +192,12 @@
}
}
- if (!_process_strong_tasks->is_task_claimed(SH_PS_StringTable_oops_do)) {
- if (so & SO_Strings) {
+ // All threads execute the following. A specific chunk of buckets
+ // from the StringTable are the individual tasks.
+ if (so & SO_Strings) {
+ if (CollectedHeap::use_parallel_gc_threads()) {
+ StringTable::possibly_parallel_oops_do(roots);
+ } else {
StringTable::oops_do(roots);
}
}
--- a/hotspot/src/share/vm/memory/universe.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/memory/universe.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -529,7 +529,9 @@
if (vt) vt->initialize_vtable(false, CHECK);
if (ko->oop_is_instance()) {
InstanceKlass* ik = (InstanceKlass*)ko;
- for (KlassHandle s_h(THREAD, ik->subklass()); s_h() != NULL; s_h = (THREAD, s_h()->next_sibling())) {
+ for (KlassHandle s_h(THREAD, ik->subklass());
+ s_h() != NULL;
+ s_h = KlassHandle(THREAD, s_h()->next_sibling())) {
reinitialize_vtable_of(s_h, CHECK);
}
}
--- a/hotspot/src/share/vm/opto/c2_globals.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -406,10 +406,10 @@
develop(intx, WarmCallMaxSize, 999999, \
"size of the largest inlinable method") \
\
- product(intx, MaxNodeLimit, 65000, \
+ product(intx, MaxNodeLimit, 80000, \
"Maximum number of nodes") \
\
- product(intx, NodeLimitFudgeFactor, 1000, \
+ product(intx, NodeLimitFudgeFactor, 2000, \
"Fudge Factor for certain optimizations") \
\
product(bool, UseJumpTables, true, \
--- a/hotspot/src/share/vm/opto/chaitin.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/opto/chaitin.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -435,6 +435,9 @@
// Insert un-coalesced copies. Visit all Phis. Where inputs to a Phi do
// not match the Phi itself, insert a copy.
coalesce.insert_copies(_matcher);
+ if (C->failing()) {
+ return;
+ }
}
// After aggressive coalesce, attempt a first cut at coloring.
--- a/hotspot/src/share/vm/opto/coalesce.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/opto/coalesce.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -240,6 +240,8 @@
_unique = C->unique();
for( uint i=0; i<_phc._cfg._num_blocks; i++ ) {
+ C->check_node_count(NodeLimitFudgeFactor, "out of nodes in coalesce");
+ if (C->failing()) return;
Block *b = _phc._cfg._blocks[i];
uint cnt = b->num_preds(); // Number of inputs to the Phi
--- a/hotspot/src/share/vm/opto/matcher.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/opto/matcher.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -985,6 +985,8 @@
mstack.push(n, Visit, NULL, -1); // set NULL as parent to indicate root
while (mstack.is_nonempty()) {
+ C->check_node_count(NodeLimitFudgeFactor, "too many nodes matching instructions");
+ if (C->failing()) return NULL;
n = mstack.node(); // Leave node on stack
Node_State nstate = mstack.state();
if (nstate == Visit) {
--- a/hotspot/src/share/vm/opto/memnode.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/opto/memnode.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2930,7 +2930,9 @@
Node *MemBarNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (remove_dead_region(phase, can_reshape)) return this;
// Don't bother trying to transform a dead node
- if (in(0) && in(0)->is_top()) return NULL;
+ if (in(0) && in(0)->is_top()) {
+ return NULL;
+ }
// Eliminate volatile MemBars for scalar replaced objects.
if (can_reshape && req() == (Precedent+1)) {
@@ -2939,6 +2941,14 @@
if ((opc == Op_MemBarAcquire || opc == Op_MemBarVolatile)) {
// Volatile field loads and stores.
Node* my_mem = in(MemBarNode::Precedent);
+ // The MembarAquire may keep an unused LoadNode alive through the Precedent edge
+ if ((my_mem != NULL) && (opc == Op_MemBarAcquire) && (my_mem->outcnt() == 1)) {
+ assert(my_mem->unique_out() == this, "sanity");
+ phase->hash_delete(this);
+ del_req(Precedent);
+ phase->is_IterGVN()->_worklist.push(my_mem); // remove dead node later
+ my_mem = NULL;
+ }
if (my_mem != NULL && my_mem->is_Mem()) {
const TypeOopPtr* t_oop = my_mem->in(MemNode::Address)->bottom_type()->isa_oopptr();
// Check for scalar replaced object reference.
@@ -4384,7 +4394,7 @@
}
}
#else // !ASSERT
-#define verify_memory_slice(m,i,n) (0) // PRODUCT version is no-op
+#define verify_memory_slice(m,i,n) (void)(0) // PRODUCT version is no-op
#endif
--- a/hotspot/src/share/vm/prims/forte.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/prims/forte.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -619,7 +619,7 @@
void* null_argument_3);
#pragma weak collector_func_load
#define collector_func_load(x0,x1,x2,x3,x4,x5,x6) \
- ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),0 : 0 )
+ ( collector_func_load ? collector_func_load(x0,x1,x2,x3,x4,x5,x6),(void)0 : (void)0 )
#endif // __APPLE__
#endif // !_WINDOWS
--- a/hotspot/src/share/vm/prims/jvm.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvm.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -3241,24 +3241,10 @@
JVM_END
-// Utility object for collecting method holders walking down the stack
-class KlassLink: public ResourceObj {
- public:
- KlassHandle klass;
- KlassLink* next;
-
- KlassLink(KlassHandle k) { klass = k; next = NULL; }
-};
-
-
JVM_ENTRY(jobjectArray, JVM_GetClassContext(JNIEnv *env))
JVMWrapper("JVM_GetClassContext");
ResourceMark rm(THREAD);
JvmtiVMObjectAllocEventCollector oam;
- // Collect linked list of (handles to) method holders
- KlassLink* first = NULL;
- KlassLink* last = NULL;
- int depth = 0;
vframeStream vfst(thread);
if (SystemDictionary::reflect_CallerSensitive_klass() != NULL) {
@@ -3272,32 +3258,23 @@
}
// Collect method holders
+ GrowableArray<KlassHandle>* klass_array = new GrowableArray<KlassHandle>();
for (; !vfst.at_end(); vfst.security_next()) {
Method* m = vfst.method();
// Native frames are not returned
if (!m->is_ignored_by_security_stack_walk() && !m->is_native()) {
Klass* holder = m->method_holder();
assert(holder->is_klass(), "just checking");
- depth++;
- KlassLink* l = new KlassLink(KlassHandle(thread, holder));
- if (first == NULL) {
- first = last = l;
- } else {
- last->next = l;
- last = l;
- }
+ klass_array->append(holder);
}
}
// Create result array of type [Ljava/lang/Class;
- objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), depth, CHECK_NULL);
+ objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), klass_array->length(), CHECK_NULL);
// Fill in mirrors corresponding to method holders
- int index = 0;
- while (first != NULL) {
- result->obj_at_put(index++, first->klass()->java_mirror());
- first = first->next;
+ for (int i = 0; i < klass_array->length(); i++) {
+ result->obj_at_put(i, klass_array->at(i)->java_mirror());
}
- assert(index == depth, "just checking");
return (jobjectArray) JNIHandles::make_local(env, result);
JVM_END
--- a/hotspot/src/share/vm/prims/jvmti.xml Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvmti.xml Fri Jun 21 00:51:56 2013 -0700
@@ -1897,7 +1897,7 @@
</description>
</param>
<param id="monitor_info_ptr">
- <allocbuf outcount="owned_monitor_depth_count_ptr">
+ <allocbuf outcount="monitor_info_count_ptr">
<struct>jvmtiMonitorStackDepthInfo</struct>
</allocbuf>
<description>
--- a/hotspot/src/share/vm/prims/whitebox.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -159,7 +159,7 @@
WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
- os::commit_memory((char *)(uintptr_t)addr, size);
+ os::commit_memory((char *)(uintptr_t)addr, size, !ExecMem);
MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
WB_END
--- a/hotspot/src/share/vm/runtime/arguments.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1566,6 +1566,15 @@
return result;
}
+void Arguments::set_heap_base_min_address() {
+ if (FLAG_IS_DEFAULT(HeapBaseMinAddress) && UseG1GC && HeapBaseMinAddress < 1*G) {
+ // By default HeapBaseMinAddress is 2G on all platforms except Solaris x86.
+ // G1 currently needs a lot of C-heap, so on Solaris we have to give G1
+ // some extra space for the C-heap compared to other collectors.
+ FLAG_SET_ERGO(uintx, HeapBaseMinAddress, 1*G);
+ }
+}
+
void Arguments::set_heap_size() {
if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
// Deprecated flag
@@ -1885,21 +1894,6 @@
// Note: Needs platform-dependent factoring.
bool status = true;
-#if ( (defined(COMPILER2) && defined(SPARC)))
- // NOTE: The call to VM_Version_init depends on the fact that VM_Version_init
- // on sparc doesn't require generation of a stub as is the case on, e.g.,
- // x86. Normally, VM_Version_init must be called from init_globals in
- // init.cpp, which is called by the initial java thread *after* arguments
- // have been parsed. VM_Version_init gets called twice on sparc.
- extern void VM_Version_init();
- VM_Version_init();
- if (!VM_Version::has_v9()) {
- jio_fprintf(defaultStream::error_stream(),
- "V8 Machine detected, Server requires V9\n");
- status = false;
- }
-#endif /* COMPILER2 && SPARC */
-
// Allow both -XX:-UseStackBanging and -XX:-UseBoundThreads in non-product
// builds so the cost of stack banging can be measured.
#if (defined(PRODUCT) && defined(SOLARIS))
@@ -3525,6 +3519,8 @@
}
}
+ set_heap_base_min_address();
+
// Set heap size based on available physical memory
set_heap_size();
--- a/hotspot/src/share/vm/runtime/arguments.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -315,6 +315,8 @@
// limits the given memory size by the maximum amount of memory this process is
// currently allowed to allocate or reserve.
static julong limit_by_allocatable_memory(julong size);
+ // Setup HeapBaseMinAddress
+ static void set_heap_base_min_address();
// Setup heap size
static void set_heap_size();
// Based on automatic selection criteria, should the
--- a/hotspot/src/share/vm/runtime/os.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/os.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -647,10 +647,13 @@
#ifndef ASSERT
NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
+ MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
void* ptr = ::realloc(memblock, size);
if (ptr != NULL) {
- MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
+ tkr.record((address)memblock, (address)ptr, size, memflags,
caller == 0 ? CALLER_PC : caller);
+ } else {
+ tkr.discard();
}
return ptr;
#else
@@ -1456,7 +1459,7 @@
char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
char* result = pd_reserve_memory(bytes, addr, alignment_hint);
if (result != NULL) {
- MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
+ MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
}
return result;
@@ -1466,7 +1469,7 @@
MEMFLAGS flags) {
char* result = pd_reserve_memory(bytes, addr, alignment_hint);
if (result != NULL) {
- MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
+ MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
MemTracker::record_virtual_memory_type((address)result, flags);
}
@@ -1476,7 +1479,7 @@
char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
char* result = pd_attempt_reserve_memory_at(bytes, addr);
if (result != NULL) {
- MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
+ MemTracker::record_virtual_memory_reserve((address)result, bytes, mtNone, CALLER_PC);
}
return result;
}
@@ -1503,18 +1506,36 @@
return res;
}
+void os::commit_memory_or_exit(char* addr, size_t bytes, bool executable,
+ const char* mesg) {
+ pd_commit_memory_or_exit(addr, bytes, executable, mesg);
+ MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
+}
+
+void os::commit_memory_or_exit(char* addr, size_t size, size_t alignment_hint,
+ bool executable, const char* mesg) {
+ os::pd_commit_memory_or_exit(addr, size, alignment_hint, executable, mesg);
+ MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
+}
+
bool os::uncommit_memory(char* addr, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
bool res = pd_uncommit_memory(addr, bytes);
if (res) {
- MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
+ tkr.record((address)addr, bytes);
+ } else {
+ tkr.discard();
}
return res;
}
bool os::release_memory(char* addr, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
bool res = pd_release_memory(addr, bytes);
if (res) {
- MemTracker::record_virtual_memory_release((address)addr, bytes);
+ tkr.record((address)addr, bytes);
+ } else {
+ tkr.discard();
}
return res;
}
@@ -1525,8 +1546,7 @@
bool allow_exec) {
char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
if (result != NULL) {
- MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
- MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
+ MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, mtNone, CALLER_PC);
}
return result;
}
@@ -1539,10 +1559,12 @@
}
bool os::unmap_memory(char *addr, size_t bytes) {
+ MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
bool result = pd_unmap_memory(addr, bytes);
if (result) {
- MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
- MemTracker::record_virtual_memory_release((address)addr, bytes);
+ tkr.record((address)addr, bytes);
+ } else {
+ tkr.discard();
}
return result;
}
--- a/hotspot/src/share/vm/runtime/os.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/os.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -78,6 +78,10 @@
CriticalPriority = 11 // Critical thread priority
};
+// Executable parameter flag for os::commit_memory() and
+// os::commit_memory_or_exit().
+const bool ExecMem = true;
+
// Typedef for structured exception handling support
typedef void (*java_call_t)(JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread);
@@ -104,9 +108,16 @@
static char* pd_attempt_reserve_memory_at(size_t bytes, char* addr);
static void pd_split_reserved_memory(char *base, size_t size,
size_t split, bool realloc);
- static bool pd_commit_memory(char* addr, size_t bytes, bool executable = false);
+ static bool pd_commit_memory(char* addr, size_t bytes, bool executable);
static bool pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
- bool executable = false);
+ bool executable);
+ // Same as pd_commit_memory() that either succeeds or calls
+ // vm_exit_out_of_memory() with the specified mesg.
+ static void pd_commit_memory_or_exit(char* addr, size_t bytes,
+ bool executable, const char* mesg);
+ static void pd_commit_memory_or_exit(char* addr, size_t size,
+ size_t alignment_hint,
+ bool executable, const char* mesg);
static bool pd_uncommit_memory(char* addr, size_t bytes);
static bool pd_release_memory(char* addr, size_t bytes);
@@ -261,9 +272,16 @@
static char* attempt_reserve_memory_at(size_t bytes, char* addr);
static void split_reserved_memory(char *base, size_t size,
size_t split, bool realloc);
- static bool commit_memory(char* addr, size_t bytes, bool executable = false);
+ static bool commit_memory(char* addr, size_t bytes, bool executable);
static bool commit_memory(char* addr, size_t size, size_t alignment_hint,
- bool executable = false);
+ bool executable);
+ // Same as commit_memory() that either succeeds or calls
+ // vm_exit_out_of_memory() with the specified mesg.
+ static void commit_memory_or_exit(char* addr, size_t bytes,
+ bool executable, const char* mesg);
+ static void commit_memory_or_exit(char* addr, size_t size,
+ size_t alignment_hint,
+ bool executable, const char* mesg);
static bool uncommit_memory(char* addr, size_t bytes);
static bool release_memory(char* addr, size_t bytes);
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -2731,7 +2731,7 @@
// ResourceObject, so do not put any ResourceMarks in here.
char *s = sig->as_C_string();
int len = (int)strlen(s);
- *s++; len--; // Skip opening paren
+ s++; len--; // Skip opening paren
char *t = s+len;
while( *(--t) != ')' ) ; // Find close paren
--- a/hotspot/src/share/vm/runtime/virtualspace.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/runtime/virtualspace.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -533,11 +533,13 @@
lower_high() + lower_needs <= lower_high_boundary(),
"must not expand beyond region");
if (!os::commit_memory(lower_high(), lower_needs, _executable)) {
- debug_only(warning("os::commit_memory failed"));
+ debug_only(warning("INFO: os::commit_memory(" PTR_FORMAT
+ ", lower_needs=" SIZE_FORMAT ", %d) failed",
+ lower_high(), lower_needs, _executable);)
return false;
} else {
_lower_high += lower_needs;
- }
+ }
}
if (middle_needs > 0) {
assert(lower_high_boundary() <= middle_high() &&
@@ -545,7 +547,10 @@
"must not expand beyond region");
if (!os::commit_memory(middle_high(), middle_needs, middle_alignment(),
_executable)) {
- debug_only(warning("os::commit_memory failed"));
+ debug_only(warning("INFO: os::commit_memory(" PTR_FORMAT
+ ", middle_needs=" SIZE_FORMAT ", " SIZE_FORMAT
+ ", %d) failed", middle_high(), middle_needs,
+ middle_alignment(), _executable);)
return false;
}
_middle_high += middle_needs;
@@ -555,7 +560,9 @@
upper_high() + upper_needs <= upper_high_boundary(),
"must not expand beyond region");
if (!os::commit_memory(upper_high(), upper_needs, _executable)) {
- debug_only(warning("os::commit_memory failed"));
+ debug_only(warning("INFO: os::commit_memory(" PTR_FORMAT
+ ", upper_needs=" SIZE_FORMAT ", %d) failed",
+ upper_high(), upper_needs, _executable);)
return false;
} else {
_upper_high += upper_needs;
--- a/hotspot/src/share/vm/services/diagnosticArgument.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/diagnosticArgument.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -247,7 +247,7 @@
} else {
_value._time = 0;
_value._nanotime = 0;
- strcmp(_value._unit, "ns");
+ strcpy(_value._unit, "ns");
}
}
--- a/hotspot/src/share/vm/services/memBaseline.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memBaseline.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -130,7 +130,7 @@
if (malloc_ptr->is_arena_record()) {
// see if arena memory record present
MemPointerRecord* next_malloc_ptr = (MemPointerRecordEx*)malloc_itr.peek_next();
- if (next_malloc_ptr->is_arena_memory_record()) {
+ if (next_malloc_ptr != NULL && next_malloc_ptr->is_arena_memory_record()) {
assert(next_malloc_ptr->is_memory_record_of_arena(malloc_ptr),
"Arena records do not match");
size = next_malloc_ptr->size();
--- a/hotspot/src/share/vm/services/memPtr.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memPtr.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -457,9 +457,8 @@
public:
SeqMemPointerRecord(): _seq(0){ }
- SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size)
- : MemPointerRecord(addr, flags, size) {
- _seq = SequenceGenerator::next();
+ SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size, jint seq)
+ : MemPointerRecord(addr, flags, size), _seq(seq) {
}
SeqMemPointerRecord(const SeqMemPointerRecord& copy_from)
@@ -488,8 +487,8 @@
SeqMemPointerRecordEx(): _seq(0) { }
SeqMemPointerRecordEx(address addr, MEMFLAGS flags, size_t size,
- address pc): MemPointerRecordEx(addr, flags, size, pc) {
- _seq = SequenceGenerator::next();
+ jint seq, address pc):
+ MemPointerRecordEx(addr, flags, size, pc), _seq(seq) {
}
SeqMemPointerRecordEx(const SeqMemPointerRecordEx& copy_from)
--- a/hotspot/src/share/vm/services/memRecorder.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memRecorder.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -69,10 +69,11 @@
if (_pointer_records != NULL) {
// recode itself
+ address pc = CURRENT_PC;
record((address)this, (MemPointerRecord::malloc_tag()|mtNMT|otNMTRecorder),
- sizeof(MemRecorder), CALLER_PC);
+ sizeof(MemRecorder), SequenceGenerator::next(), pc);
record((address)_pointer_records, (MemPointerRecord::malloc_tag()|mtNMT|otNMTRecorder),
- _pointer_records->instance_size(),CURRENT_PC);
+ _pointer_records->instance_size(), SequenceGenerator::next(), pc);
}
}
@@ -116,7 +117,8 @@
}
}
-bool MemRecorder::record(address p, MEMFLAGS flags, size_t size, address pc) {
+bool MemRecorder::record(address p, MEMFLAGS flags, size_t size, jint seq, address pc) {
+ assert(seq > 0, "No sequence number");
#ifdef ASSERT
if (MemPointerRecord::is_virtual_memory_record(flags)) {
assert((flags & MemPointerRecord::tag_masks) != 0, "bad virtual memory record");
@@ -133,11 +135,11 @@
#endif
if (MemTracker::track_callsite()) {
- SeqMemPointerRecordEx ap(p, flags, size, pc);
+ SeqMemPointerRecordEx ap(p, flags, size, seq, pc);
debug_only(check_dup_seq(ap.seq());)
return _pointer_records->append(&ap);
} else {
- SeqMemPointerRecord ap(p, flags, size);
+ SeqMemPointerRecord ap(p, flags, size, seq);
debug_only(check_dup_seq(ap.seq());)
return _pointer_records->append(&ap);
}
--- a/hotspot/src/share/vm/services/memRecorder.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memRecorder.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -220,7 +220,7 @@
~MemRecorder();
// record a memory operation
- bool record(address addr, MEMFLAGS flags, size_t size, address caller_pc = 0);
+ bool record(address addr, MEMFLAGS flags, size_t size, jint seq, address caller_pc = 0);
// linked list support
inline void set_next(MemRecorder* rec) {
--- a/hotspot/src/share/vm/services/memReporter.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memReporter.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -190,17 +190,18 @@
while (cur_malloc_callsite != NULL || prev_malloc_callsite != NULL) {
if (prev_malloc_callsite == NULL ||
cur_malloc_callsite->addr() < prev_malloc_callsite->addr()) {
+ // this is a new callsite
_outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
amount_in_current_scale(cur_malloc_callsite->amount()),
cur_malloc_callsite->count(),
diff_in_current_scale(cur_malloc_callsite->amount(), 0),
diff(cur_malloc_callsite->count(), 0));
cur_malloc_callsite = (MallocCallsitePointer*)cur_malloc_itr.next();
- } else if (prev_malloc_callsite == NULL ||
+ } else if (cur_malloc_callsite == NULL ||
cur_malloc_callsite->addr() > prev_malloc_callsite->addr()) {
- _outputer.diff_malloc_callsite(cur_malloc_callsite->addr(),
- amount_in_current_scale(prev_malloc_callsite->amount()),
- prev_malloc_callsite->count(),
+ // this callsite is already gone
+ _outputer.diff_malloc_callsite(prev_malloc_callsite->addr(),
+ amount_in_current_scale(0), 0,
diff_in_current_scale(0, prev_malloc_callsite->amount()),
diff(0, prev_malloc_callsite->count()));
prev_malloc_callsite = (MallocCallsitePointer*)prev_malloc_itr.next();
@@ -222,6 +223,7 @@
VMCallsitePointer* prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.current();
while (cur_vm_callsite != NULL || prev_vm_callsite != NULL) {
if (prev_vm_callsite == NULL || cur_vm_callsite->addr() < prev_vm_callsite->addr()) {
+ // this is a new callsite
_outputer.diff_virtual_memory_callsite(cur_vm_callsite->addr(),
amount_in_current_scale(cur_vm_callsite->reserved_amount()),
amount_in_current_scale(cur_vm_callsite->committed_amount()),
@@ -229,9 +231,10 @@
diff_in_current_scale(cur_vm_callsite->committed_amount(), 0));
cur_vm_callsite = (VMCallsitePointer*)cur_vm_itr.next();
} else if (cur_vm_callsite == NULL || cur_vm_callsite->addr() > prev_vm_callsite->addr()) {
+ // this callsite is already gone
_outputer.diff_virtual_memory_callsite(prev_vm_callsite->addr(),
- amount_in_current_scale(prev_vm_callsite->reserved_amount()),
- amount_in_current_scale(prev_vm_callsite->committed_amount()),
+ amount_in_current_scale(0),
+ amount_in_current_scale(0),
diff_in_current_scale(0, prev_vm_callsite->reserved_amount()),
diff_in_current_scale(0, prev_vm_callsite->committed_amount()));
prev_vm_callsite = (VMCallsitePointer*)prev_vm_itr.next();
--- a/hotspot/src/share/vm/services/memTracker.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memTracker.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -69,6 +69,7 @@
volatile jint MemTracker::_pooled_recorder_count = 0;
volatile unsigned long MemTracker::_processing_generation = 0;
volatile bool MemTracker::_worker_thread_idle = false;
+volatile jint MemTracker::_pending_op_count = 0;
volatile bool MemTracker::_slowdown_calling_thread = false;
debug_only(intx MemTracker::_main_thread_tid = 0;)
NOT_PRODUCT(volatile jint MemTracker::_pending_recorder_count = 0;)
@@ -337,92 +338,14 @@
Atomic::inc(&_pooled_recorder_count);
}
-/*
- * This is the most important method in whole nmt implementation.
- *
- * Create a memory record.
- * 1. When nmt is in single-threaded bootstrapping mode, no lock is needed as VM
- * still in single thread mode.
- * 2. For all threads other than JavaThread, ThreadCritical is needed
- * to write to recorders to global recorder.
- * 3. For JavaThreads that are not longer visible by safepoint, also
- * need to take ThreadCritical and records are written to global
- * recorders, since these threads are NOT walked by Threads.do_thread().
- * 4. JavaThreads that are running in native state, have to transition
- * to VM state before writing to per-thread recorders.
- * 5. JavaThreads that are running in VM state do not need any lock and
- * records are written to per-thread recorders.
- * 6. For a thread has yet to attach VM 'Thread', they need to take
- * ThreadCritical to write to global recorder.
- *
- * Important note:
- * NO LOCK should be taken inside ThreadCritical lock !!!
- */
-void MemTracker::create_memory_record(address addr, MEMFLAGS flags,
- size_t size, address pc, Thread* thread) {
- assert(addr != NULL, "Sanity check");
- if (!shutdown_in_progress()) {
- // single thread, we just write records direct to global recorder,'
- // with any lock
- if (_state == NMT_bootstrapping_single_thread) {
- assert(_main_thread_tid == os::current_thread_id(), "wrong thread");
- thread = NULL;
- } else {
- if (thread == NULL) {
- // don't use Thread::current(), since it is possible that
- // the calling thread has yet to attach to VM 'Thread',
- // which will result assertion failure
- thread = ThreadLocalStorage::thread();
- }
- }
-
- if (thread != NULL) {
- // slow down all calling threads except NMT worker thread, so it
- // can catch up.
- if (_slowdown_calling_thread && thread != _worker_thread) {
- os::yield_all();
- }
-
- if (thread->is_Java_thread() && ((JavaThread*)thread)->is_safepoint_visible()) {
- JavaThread* java_thread = (JavaThread*)thread;
- JavaThreadState state = java_thread->thread_state();
- if (SafepointSynchronize::safepoint_safe(java_thread, state)) {
- // JavaThreads that are safepoint safe, can run through safepoint,
- // so ThreadCritical is needed to ensure no threads at safepoint create
- // new records while the records are being gathered and the sequence number is changing
- ThreadCritical tc;
- create_record_in_recorder(addr, flags, size, pc, java_thread);
- } else {
- create_record_in_recorder(addr, flags, size, pc, java_thread);
- }
- } else {
- // other threads, such as worker and watcher threads, etc. need to
- // take ThreadCritical to write to global recorder
- ThreadCritical tc;
- create_record_in_recorder(addr, flags, size, pc, NULL);
- }
- } else {
- if (_state == NMT_bootstrapping_single_thread) {
- // single thread, no lock needed
- create_record_in_recorder(addr, flags, size, pc, NULL);
- } else {
- // for thread has yet to attach VM 'Thread', we can not use VM mutex.
- // use native thread critical instead
- ThreadCritical tc;
- create_record_in_recorder(addr, flags, size, pc, NULL);
- }
- }
- }
-}
-
// write a record to proper recorder. No lock can be taken from this method
// down.
-void MemTracker::create_record_in_recorder(address addr, MEMFLAGS flags,
- size_t size, address pc, JavaThread* thread) {
+void MemTracker::write_tracking_record(address addr, MEMFLAGS flags,
+ size_t size, jint seq, address pc, JavaThread* thread) {
MemRecorder* rc = get_thread_recorder(thread);
if (rc != NULL) {
- rc->record(addr, flags, size, pc);
+ rc->record(addr, flags, size, seq, pc);
}
}
@@ -487,39 +410,43 @@
return;
}
}
- _sync_point_skip_count = 0;
{
// This method is running at safepoint, with ThreadCritical lock,
// it should guarantee that NMT is fully sync-ed.
ThreadCritical tc;
- SequenceGenerator::reset();
+ // We can NOT execute NMT sync-point if there are pending tracking ops.
+ if (_pending_op_count == 0) {
+ SequenceGenerator::reset();
+ _sync_point_skip_count = 0;
- // walk all JavaThreads to collect recorders
- SyncThreadRecorderClosure stc;
- Threads::threads_do(&stc);
+ // walk all JavaThreads to collect recorders
+ SyncThreadRecorderClosure stc;
+ Threads::threads_do(&stc);
+
+ _thread_count = stc.get_thread_count();
+ MemRecorder* pending_recorders = get_pending_recorders();
- _thread_count = stc.get_thread_count();
- MemRecorder* pending_recorders = get_pending_recorders();
+ if (_global_recorder != NULL) {
+ _global_recorder->set_next(pending_recorders);
+ pending_recorders = _global_recorder;
+ _global_recorder = NULL;
+ }
- if (_global_recorder != NULL) {
- _global_recorder->set_next(pending_recorders);
- pending_recorders = _global_recorder;
- _global_recorder = NULL;
+ // see if NMT has too many outstanding recorder instances, it usually
+ // means that worker thread is lagging behind in processing them.
+ if (!AutoShutdownNMT) {
+ _slowdown_calling_thread = (MemRecorder::_instance_count > MAX_RECORDER_THREAD_RATIO * _thread_count);
+ }
+
+ // check _worker_thread with lock to avoid racing condition
+ if (_worker_thread != NULL) {
+ _worker_thread->at_sync_point(pending_recorders, InstanceKlass::number_of_instance_classes());
+ }
+ assert(SequenceGenerator::peek() == 1, "Should not have memory activities during sync-point");
+ } else {
+ _sync_point_skip_count ++;
}
-
- // see if NMT has too many outstanding recorder instances, it usually
- // means that worker thread is lagging behind in processing them.
- if (!AutoShutdownNMT) {
- _slowdown_calling_thread = (MemRecorder::_instance_count > MAX_RECORDER_THREAD_RATIO * _thread_count);
- }
-
- // check _worker_thread with lock to avoid racing condition
- if (_worker_thread != NULL) {
- _worker_thread->at_sync_point(pending_recorders, InstanceKlass::number_of_instance_classes());
- }
-
- assert(SequenceGenerator::peek() == 1, "Should not have memory activities during sync-point");
}
}
@@ -708,3 +635,243 @@
}
#endif
+
+// Tracker Implementation
+
+/*
+ * Create a tracker.
+ * This is a fairly complicated constructor, as it has to make two important decisions:
+ * 1) Does it need to take ThreadCritical lock to write tracking record
+ * 2) Does it need to pre-reserve a sequence number for the tracking record
+ *
+ * The rules to determine if ThreadCritical is needed:
+ * 1. When nmt is in single-threaded bootstrapping mode, no lock is needed as VM
+ * still in single thread mode.
+ * 2. For all threads other than JavaThread, ThreadCritical is needed
+ * to write to recorders to global recorder.
+ * 3. For JavaThreads that are no longer visible by safepoint, also
+ * need to take ThreadCritical and records are written to global
+ * recorders, since these threads are NOT walked by Threads.do_thread().
+ * 4. JavaThreads that are running in safepoint-safe states do not stop
+ * for safepoints, ThreadCritical lock should be taken to write
+ * memory records.
+ * 5. JavaThreads that are running in VM state do not need any lock and
+ * records are written to per-thread recorders.
+ * 6. For a thread has yet to attach VM 'Thread', they need to take
+ * ThreadCritical to write to global recorder.
+ *
+ * The memory operations that need pre-reserve sequence numbers:
+ * The memory operations that "release" memory blocks and the
+ * operations can fail, need to pre-reserve sequence number. They
+ * are realloc, uncommit and release.
+ *
+ * The reason for pre-reserve sequence number, is to prevent race condition:
+ * Thread 1 Thread 2
+ * <release>
+ * <allocate>
+ * <write allocate record>
+ * <write release record>
+ * if Thread 2 happens to obtain the memory address Thread 1 just released,
+ * then NMT can mistakenly report the memory is free.
+ *
+ * Noticeably, free() does not need pre-reserve sequence number, because the call
+ * does not fail, so we can alway write "release" record before the memory is actaully
+ * freed.
+ *
+ * For realloc, uncommit and release, following coding pattern should be used:
+ *
+ * MemTracker::Tracker tkr = MemTracker::get_realloc_tracker();
+ * ptr = ::realloc(...);
+ * if (ptr == NULL) {
+ * tkr.record(...)
+ * } else {
+ * tkr.discard();
+ * }
+ *
+ * MemTracker::Tracker tkr = MemTracker::get_virtual_memory_uncommit_tracker();
+ * if (uncommit(...)) {
+ * tkr.record(...);
+ * } else {
+ * tkr.discard();
+ * }
+ *
+ * MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
+ * if (release(...)) {
+ * tkr.record(...);
+ * } else {
+ * tkr.discard();
+ * }
+ *
+ * Since pre-reserved sequence number is only good for the generation that it is acquired,
+ * when there is pending Tracker that reserved sequence number, NMT sync-point has
+ * to be skipped to prevent from advancing generation. This is done by inc and dec
+ * MemTracker::_pending_op_count, when MemTracker::_pending_op_count > 0, NMT sync-point is skipped.
+ * Not all pre-reservation of sequence number will increment pending op count. For JavaThreads
+ * that honor safepoints, safepoint can not occur during the memory operations, so the
+ * pre-reserved sequence number won't cross the generation boundry.
+ */
+MemTracker::Tracker::Tracker(MemoryOperation op, Thread* thr) {
+ _op = NoOp;
+ _seq = 0;
+ if (MemTracker::is_on()) {
+ _java_thread = NULL;
+ _op = op;
+
+ // figure out if ThreadCritical lock is needed to write this operation
+ // to MemTracker
+ if (MemTracker::is_single_threaded_bootstrap()) {
+ thr = NULL;
+ } else if (thr == NULL) {
+ // don't use Thread::current(), since it is possible that
+ // the calling thread has yet to attach to VM 'Thread',
+ // which will result assertion failure
+ thr = ThreadLocalStorage::thread();
+ }
+
+ if (thr != NULL) {
+ // Check NMT load
+ MemTracker::check_NMT_load(thr);
+
+ if (thr->is_Java_thread() && ((JavaThread*)thr)->is_safepoint_visible()) {
+ _java_thread = (JavaThread*)thr;
+ JavaThreadState state = _java_thread->thread_state();
+ // JavaThreads that are safepoint safe, can run through safepoint,
+ // so ThreadCritical is needed to ensure no threads at safepoint create
+ // new records while the records are being gathered and the sequence number is changing
+ _need_thread_critical_lock =
+ SafepointSynchronize::safepoint_safe(_java_thread, state);
+ } else {
+ _need_thread_critical_lock = true;
+ }
+ } else {
+ _need_thread_critical_lock
+ = !MemTracker::is_single_threaded_bootstrap();
+ }
+
+ // see if we need to pre-reserve sequence number for this operation
+ if (_op == Realloc || _op == Uncommit || _op == Release) {
+ if (_need_thread_critical_lock) {
+ ThreadCritical tc;
+ MemTracker::inc_pending_op_count();
+ _seq = SequenceGenerator::next();
+ } else {
+ // for the threads that honor safepoints, no safepoint can occur
+ // during the lifespan of tracker, so we don't need to increase
+ // pending op count.
+ _seq = SequenceGenerator::next();
+ }
+ }
+ }
+}
+
+void MemTracker::Tracker::discard() {
+ if (MemTracker::is_on() && _seq != 0) {
+ if (_need_thread_critical_lock) {
+ ThreadCritical tc;
+ MemTracker::dec_pending_op_count();
+ }
+ _seq = 0;
+ }
+}
+
+
+void MemTracker::Tracker::record(address old_addr, address new_addr, size_t size,
+ MEMFLAGS flags, address pc) {
+ assert(old_addr != NULL && new_addr != NULL, "Sanity check");
+ assert(_op == Realloc || _op == NoOp, "Wrong call");
+ if (MemTracker::is_on() && NMT_CAN_TRACK(flags) && _op != NoOp) {
+ assert(_seq > 0, "Need pre-reserve sequence number");
+ if (_need_thread_critical_lock) {
+ ThreadCritical tc;
+ // free old address, use pre-reserved sequence number
+ MemTracker::write_tracking_record(old_addr, MemPointerRecord::free_tag(),
+ 0, _seq, pc, _java_thread);
+ MemTracker::write_tracking_record(new_addr, flags | MemPointerRecord::malloc_tag(),
+ size, SequenceGenerator::next(), pc, _java_thread);
+ // decrement MemTracker pending_op_count
+ MemTracker::dec_pending_op_count();
+ } else {
+ // free old address, use pre-reserved sequence number
+ MemTracker::write_tracking_record(old_addr, MemPointerRecord::free_tag(),
+ 0, _seq, pc, _java_thread);
+ MemTracker::write_tracking_record(new_addr, flags | MemPointerRecord::malloc_tag(),
+ size, SequenceGenerator::next(), pc, _java_thread);
+ }
+ _seq = 0;
+ }
+}
+
+void MemTracker::Tracker::record(address addr, size_t size, MEMFLAGS flags, address pc) {
+ // OOM already?
+ if (addr == NULL) return;
+
+ if (MemTracker::is_on() && NMT_CAN_TRACK(flags) && _op != NoOp) {
+ bool pre_reserved_seq = (_seq != 0);
+ address pc = CALLER_CALLER_PC;
+ MEMFLAGS orig_flags = flags;
+
+ // or the tagging flags
+ switch(_op) {
+ case Malloc:
+ flags |= MemPointerRecord::malloc_tag();
+ break;
+ case Free:
+ flags = MemPointerRecord::free_tag();
+ break;
+ case Realloc:
+ fatal("Use the other Tracker::record()");
+ break;
+ case Reserve:
+ case ReserveAndCommit:
+ flags |= MemPointerRecord::virtual_memory_reserve_tag();
+ break;
+ case Commit:
+ flags = MemPointerRecord::virtual_memory_commit_tag();
+ break;
+ case Type:
+ flags |= MemPointerRecord::virtual_memory_type_tag();
+ break;
+ case Uncommit:
+ assert(pre_reserved_seq, "Need pre-reserve sequence number");
+ flags = MemPointerRecord::virtual_memory_uncommit_tag();
+ break;
+ case Release:
+ assert(pre_reserved_seq, "Need pre-reserve sequence number");
+ flags = MemPointerRecord::virtual_memory_release_tag();
+ break;
+ case ArenaSize:
+ // a bit of hack here, add a small postive offset to arena
+ // address for its size record, so the size record is sorted
+ // right after arena record.
+ flags = MemPointerRecord::arena_size_tag();
+ addr += sizeof(void*);
+ break;
+ case StackRelease:
+ flags = MemPointerRecord::virtual_memory_release_tag();
+ break;
+ default:
+ ShouldNotReachHere();
+ }
+
+ // write memory tracking record
+ if (_need_thread_critical_lock) {
+ ThreadCritical tc;
+ if (_seq == 0) _seq = SequenceGenerator::next();
+ MemTracker::write_tracking_record(addr, flags, size, _seq, pc, _java_thread);
+ if (_op == ReserveAndCommit) {
+ MemTracker::write_tracking_record(addr, orig_flags | MemPointerRecord::virtual_memory_commit_tag(),
+ size, SequenceGenerator::next(), pc, _java_thread);
+ }
+ if (pre_reserved_seq) MemTracker::dec_pending_op_count();
+ } else {
+ if (_seq == 0) _seq = SequenceGenerator::next();
+ MemTracker::write_tracking_record(addr, flags, size, _seq, pc, _java_thread);
+ if (_op == ReserveAndCommit) {
+ MemTracker::write_tracking_record(addr, orig_flags | MemPointerRecord::virtual_memory_commit_tag(),
+ size, SequenceGenerator::next(), pc, _java_thread);
+ }
+ }
+ _seq = 0;
+ }
+}
+
--- a/hotspot/src/share/vm/services/memTracker.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/memTracker.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -54,6 +54,18 @@
NMT_sequence_overflow // overflow the sequence number
};
+ class Tracker {
+ public:
+ void discard() { }
+
+ void record(address addr, size_t size = 0, MEMFLAGS flags = mtNone, address pc = NULL) { }
+ void record(address old_addr, address new_addr, size_t size,
+ MEMFLAGS flags, address pc = NULL) { }
+ };
+
+ private:
+ static Tracker _tkr;
+
public:
static inline void init_tracking_options(const char* option_line) { }
@@ -68,19 +80,18 @@
static inline void record_malloc(address addr, size_t size, MEMFLAGS flags,
address pc = 0, Thread* thread = NULL) { }
static inline void record_free(address addr, MEMFLAGS flags, Thread* thread = NULL) { }
- static inline void record_realloc(address old_addr, address new_addr, size_t size,
- MEMFLAGS flags, address pc = 0, Thread* thread = NULL) { }
static inline void record_arena_size(address addr, size_t size) { }
static inline void record_virtual_memory_reserve(address addr, size_t size,
- address pc = 0, Thread* thread = NULL) { }
+ MEMFLAGS flags, address pc = 0, Thread* thread = NULL) { }
+ static inline void record_virtual_memory_reserve_and_commit(address addr, size_t size,
+ MEMFLAGS flags, address pc = 0, Thread* thread = NULL) { }
static inline void record_virtual_memory_commit(address addr, size_t size,
address pc = 0, Thread* thread = NULL) { }
- static inline void record_virtual_memory_uncommit(address addr, size_t size,
- Thread* thread = NULL) { }
- static inline void record_virtual_memory_release(address addr, size_t size,
- Thread* thread = NULL) { }
static inline void record_virtual_memory_type(address base, MEMFLAGS flags,
Thread* thread = NULL) { }
+ static inline Tracker get_realloc_tracker() { return _tkr; }
+ static inline Tracker get_virtual_memory_uncommit_tracker() { return _tkr; }
+ static inline Tracker get_virtual_memory_release_tracker() { return _tkr; }
static inline bool baseline() { return false; }
static inline bool has_baseline() { return false; }
@@ -165,6 +176,45 @@
};
public:
+ class Tracker : public StackObj {
+ friend class MemTracker;
+ public:
+ enum MemoryOperation {
+ NoOp, // no op
+ Malloc, // malloc
+ Realloc, // realloc
+ Free, // free
+ Reserve, // virtual memory reserve
+ Commit, // virtual memory commit
+ ReserveAndCommit, // virtual memory reserve and commit
+ StackAlloc = ReserveAndCommit, // allocate thread stack
+ Type, // assign virtual memory type
+ Uncommit, // virtual memory uncommit
+ Release, // virtual memory release
+ ArenaSize, // set arena size
+ StackRelease // release thread stack
+ };
+
+
+ protected:
+ Tracker(MemoryOperation op, Thread* thr = NULL);
+
+ public:
+ void discard();
+
+ void record(address addr, size_t size = 0, MEMFLAGS flags = mtNone, address pc = NULL);
+ void record(address old_addr, address new_addr, size_t size,
+ MEMFLAGS flags, address pc = NULL);
+
+ private:
+ bool _need_thread_critical_lock;
+ JavaThread* _java_thread;
+ MemoryOperation _op; // memory operation
+ jint _seq; // reserved sequence number
+ };
+
+
+ public:
// native memory tracking level
enum NMTLevel {
NMT_off, // native memory tracking is off
@@ -276,109 +326,74 @@
// record a 'malloc' call
static inline void record_malloc(address addr, size_t size, MEMFLAGS flags,
address pc = 0, Thread* thread = NULL) {
- if (is_on() && NMT_CAN_TRACK(flags)) {
- assert(size > 0, "Sanity check");
- create_memory_record(addr, (flags|MemPointerRecord::malloc_tag()), size, pc, thread);
- }
+ Tracker tkr(Tracker::Malloc, thread);
+ tkr.record(addr, size, flags, pc);
}
// record a 'free' call
static inline void record_free(address addr, MEMFLAGS flags, Thread* thread = NULL) {
- if (is_on() && NMT_CAN_TRACK(flags)) {
- create_memory_record(addr, MemPointerRecord::free_tag(), 0, 0, thread);
- }
- }
- // record a 'realloc' call
- static inline void record_realloc(address old_addr, address new_addr, size_t size,
- MEMFLAGS flags, address pc = 0, Thread* thread = NULL) {
- if (is_on() && NMT_CAN_TRACK(flags)) {
- assert(size > 0, "Sanity check");
- record_free(old_addr, flags, thread);
- record_malloc(new_addr, size, flags, pc, thread);
- }
+ Tracker tkr(Tracker::Free, thread);
+ tkr.record(addr, 0, flags, DEBUG_CALLER_PC);
}
- // record arena memory size
static inline void record_arena_size(address addr, size_t size) {
- // we add a positive offset to arena address, so we can have arena memory record
- // sorted after arena record
- if (is_on() && !UseMallocOnly) {
- assert(addr != NULL, "Sanity check");
- create_memory_record((addr + sizeof(void*)), MemPointerRecord::arena_size_tag(), size,
- DEBUG_CALLER_PC, NULL);
- }
+ Tracker tkr(Tracker::ArenaSize);
+ tkr.record(addr, size);
}
// record a virtual memory 'reserve' call
static inline void record_virtual_memory_reserve(address addr, size_t size,
- address pc = 0, Thread* thread = NULL) {
- if (is_on()) {
- assert(size > 0, "Sanity check");
- create_memory_record(addr, MemPointerRecord::virtual_memory_reserve_tag(),
- size, pc, thread);
- }
+ MEMFLAGS flags, address pc = 0, Thread* thread = NULL) {
+ assert(size > 0, "Sanity check");
+ Tracker tkr(Tracker::Reserve, thread);
+ tkr.record(addr, size, flags, pc);
}
static inline void record_thread_stack(address addr, size_t size, Thread* thr,
address pc = 0) {
- if (is_on()) {
- assert(size > 0 && thr != NULL, "Sanity check");
- create_memory_record(addr, MemPointerRecord::virtual_memory_reserve_tag() | mtThreadStack,
- size, pc, thr);
- create_memory_record(addr, MemPointerRecord::virtual_memory_commit_tag() | mtThreadStack,
- size, pc, thr);
- }
+ Tracker tkr(Tracker::StackAlloc, thr);
+ tkr.record(addr, size, mtThreadStack, pc);
}
static inline void release_thread_stack(address addr, size_t size, Thread* thr) {
- if (is_on()) {
- assert(size > 0 && thr != NULL, "Sanity check");
- assert(!thr->is_Java_thread(), "too early");
- create_memory_record(addr, MemPointerRecord::virtual_memory_uncommit_tag() | mtThreadStack,
- size, DEBUG_CALLER_PC, thr);
- create_memory_record(addr, MemPointerRecord::virtual_memory_release_tag() | mtThreadStack,
- size, DEBUG_CALLER_PC, thr);
- }
+ Tracker tkr(Tracker::StackRelease, thr);
+ tkr.record(addr, size, mtThreadStack, DEBUG_CALLER_PC);
}
// record a virtual memory 'commit' call
static inline void record_virtual_memory_commit(address addr, size_t size,
address pc, Thread* thread = NULL) {
- if (is_on()) {
- assert(size > 0, "Sanity check");
- create_memory_record(addr, MemPointerRecord::virtual_memory_commit_tag(),
- size, pc, thread);
- }
+ Tracker tkr(Tracker::Commit, thread);
+ tkr.record(addr, size, mtNone, pc);
}
- // record a virtual memory 'uncommit' call
- static inline void record_virtual_memory_uncommit(address addr, size_t size,
- Thread* thread = NULL) {
- if (is_on()) {
- assert(size > 0, "Sanity check");
- create_memory_record(addr, MemPointerRecord::virtual_memory_uncommit_tag(),
- size, DEBUG_CALLER_PC, thread);
- }
+ static inline void record_virtual_memory_reserve_and_commit(address addr, size_t size,
+ MEMFLAGS flags, address pc, Thread* thread = NULL) {
+ Tracker tkr(Tracker::ReserveAndCommit, thread);
+ tkr.record(addr, size, flags, pc);
}
- // record a virtual memory 'release' call
- static inline void record_virtual_memory_release(address addr, size_t size,
- Thread* thread = NULL) {
- if (is_on()) {
- assert(size > 0, "Sanity check");
- create_memory_record(addr, MemPointerRecord::virtual_memory_release_tag(),
- size, DEBUG_CALLER_PC, thread);
- }
- }
// record memory type on virtual memory base address
static inline void record_virtual_memory_type(address base, MEMFLAGS flags,
Thread* thread = NULL) {
- if (is_on()) {
- assert(base > 0, "wrong base address");
- assert((flags & (~mt_masks)) == 0, "memory type only");
- create_memory_record(base, (flags | MemPointerRecord::virtual_memory_type_tag()),
- 0, DEBUG_CALLER_PC, thread);
- }
+ Tracker tkr(Tracker::Type);
+ tkr.record(base, 0, flags);
+ }
+
+ // Get memory trackers for memory operations that can result race conditions.
+ // The memory tracker has to be obtained before realloc, virtual memory uncommit
+ // and virtual memory release, and call tracker.record() method if operation
+ // succeeded, or tracker.discard() to abort the tracking.
+ static inline Tracker get_realloc_tracker() {
+ return Tracker(Tracker::Realloc);
+ }
+
+ static inline Tracker get_virtual_memory_uncommit_tracker() {
+ return Tracker(Tracker::Uncommit);
+ }
+
+ static inline Tracker get_virtual_memory_release_tracker() {
+ return Tracker(Tracker::Release);
}
@@ -444,6 +459,31 @@
static MemRecorder* get_pending_recorders();
static void delete_all_pending_recorders();
+ // write a memory tracking record in recorder
+ static void write_tracking_record(address addr, MEMFLAGS type,
+ size_t size, jint seq, address pc, JavaThread* thread);
+
+ static bool is_single_threaded_bootstrap() {
+ return _state == NMT_bootstrapping_single_thread;
+ }
+
+ static void check_NMT_load(Thread* thr) {
+ assert(thr != NULL, "Sanity check");
+ if (_slowdown_calling_thread && thr != _worker_thread) {
+ os::yield_all();
+ }
+ }
+
+ static void inc_pending_op_count() {
+ Atomic::inc(&_pending_op_count);
+ }
+
+ static void dec_pending_op_count() {
+ Atomic::dec(&_pending_op_count);
+ assert(_pending_op_count >= 0, "Sanity check");
+ }
+
+
private:
// retrieve a pooled memory record or create new one if there is not
// one available
@@ -522,6 +562,12 @@
// if NMT should slow down calling thread to allow
// worker thread to catch up
static volatile bool _slowdown_calling_thread;
+
+ // pending memory op count.
+ // Certain memory ops need to pre-reserve sequence number
+ // before memory operation can happen to avoid race condition.
+ // See MemTracker::Tracker for detail
+ static volatile jint _pending_op_count;
};
#endif // !INCLUDE_NMT
--- a/hotspot/src/share/vm/services/threadService.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/services/threadService.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -327,27 +327,30 @@
while (waitingToLockMonitor != NULL || waitingToLockBlocker != NULL) {
cycle->add_thread(currentThread);
if (waitingToLockMonitor != NULL) {
- currentThread = Threads::owning_thread_from_monitor_owner(
- (address)waitingToLockMonitor->owner(),
- false /* no locking needed */);
- if (currentThread == NULL) {
- // This function is called at a safepoint so the JavaThread
- // that owns waitingToLockMonitor should be findable, but
- // if it is not findable, then the previous currentThread is
- // blocked permanently. We record this as a deadlock.
- num_deadlocks++;
+ address currentOwner = (address)waitingToLockMonitor->owner();
+ if (currentOwner != NULL) {
+ currentThread = Threads::owning_thread_from_monitor_owner(
+ currentOwner,
+ false /* no locking needed */);
+ if (currentThread == NULL) {
+ // This function is called at a safepoint so the JavaThread
+ // that owns waitingToLockMonitor should be findable, but
+ // if it is not findable, then the previous currentThread is
+ // blocked permanently. We record this as a deadlock.
+ num_deadlocks++;
- cycle->set_deadlock(true);
+ cycle->set_deadlock(true);
- // add this cycle to the deadlocks list
- if (deadlocks == NULL) {
- deadlocks = cycle;
- } else {
- last->set_next(cycle);
+ // add this cycle to the deadlocks list
+ if (deadlocks == NULL) {
+ deadlocks = cycle;
+ } else {
+ last->set_next(cycle);
+ }
+ last = cycle;
+ cycle = new DeadlockCycle();
+ break;
}
- last = cycle;
- cycle = new DeadlockCycle();
- break;
}
} else {
if (concurrent_locks) {
--- a/hotspot/src/share/vm/utilities/bitMap.cpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.cpp Fri Jun 21 00:51:56 2013 -0700
@@ -41,7 +41,7 @@
BitMap::BitMap(bm_word_t* map, idx_t size_in_bits) :
- _map(map), _size(size_in_bits)
+ _map(map), _size(size_in_bits), _map_allocator(false)
{
assert(sizeof(bm_word_t) == BytesPerWord, "Implementation assumption.");
assert(size_in_bits >= 0, "just checking");
@@ -49,7 +49,7 @@
BitMap::BitMap(idx_t size_in_bits, bool in_resource_area) :
- _map(NULL), _size(0)
+ _map(NULL), _size(0), _map_allocator(false)
{
assert(sizeof(bm_word_t) == BytesPerWord, "Implementation assumption.");
resize(size_in_bits, in_resource_area);
@@ -65,8 +65,10 @@
if (in_resource_area) {
_map = NEW_RESOURCE_ARRAY(bm_word_t, new_size_in_words);
} else {
- if (old_map != NULL) FREE_C_HEAP_ARRAY(bm_word_t, _map, mtInternal);
- _map = NEW_C_HEAP_ARRAY(bm_word_t, new_size_in_words, mtInternal);
+ if (old_map != NULL) {
+ _map_allocator.free();
+ }
+ _map = _map_allocator.allocate(new_size_in_words);
}
Copy::disjoint_words((HeapWord*)old_map, (HeapWord*) _map,
MIN2(old_size_in_words, new_size_in_words));
--- a/hotspot/src/share/vm/utilities/bitMap.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -48,6 +48,7 @@
} RangeSizeHint;
private:
+ ArrayAllocator<bm_word_t, mtInternal> _map_allocator;
bm_word_t* _map; // First word in bitmap
idx_t _size; // Size of bitmap (in bits)
@@ -113,7 +114,7 @@
public:
// Constructs a bitmap with no map, and size 0.
- BitMap() : _map(NULL), _size(0) {}
+ BitMap() : _map(NULL), _size(0), _map_allocator(false) {}
// Constructs a bitmap with the given map and size.
BitMap(bm_word_t* map, idx_t size_in_bits);
--- a/hotspot/src/share/vm/utilities/exceptions.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/utilities/exceptions.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -194,15 +194,15 @@
#define HAS_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->has_pending_exception())
#define CLEAR_PENDING_EXCEPTION (((ThreadShadow*)THREAD)->clear_pending_exception())
-#define CHECK THREAD); if (HAS_PENDING_EXCEPTION) return ; (0
-#define CHECK_(result) THREAD); if (HAS_PENDING_EXCEPTION) return result; (0
+#define CHECK THREAD); if (HAS_PENDING_EXCEPTION) return ; (void)(0
+#define CHECK_(result) THREAD); if (HAS_PENDING_EXCEPTION) return result; (void)(0
#define CHECK_0 CHECK_(0)
#define CHECK_NH CHECK_(Handle())
#define CHECK_NULL CHECK_(NULL)
#define CHECK_false CHECK_(false)
-#define CHECK_AND_CLEAR THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return; } (0
-#define CHECK_AND_CLEAR_(result) THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return result; } (0
+#define CHECK_AND_CLEAR THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return; } (void)(0
+#define CHECK_AND_CLEAR_(result) THREAD); if (HAS_PENDING_EXCEPTION) { CLEAR_PENDING_EXCEPTION; return result; } (void)(0
#define CHECK_AND_CLEAR_0 CHECK_AND_CLEAR_(0)
#define CHECK_AND_CLEAR_NH CHECK_AND_CLEAR_(Handle())
#define CHECK_AND_CLEAR_NULL CHECK_AND_CLEAR_(NULL)
@@ -282,7 +282,7 @@
CLEAR_PENDING_EXCEPTION; \
ex->print(); \
ShouldNotReachHere(); \
- } (0
+ } (void)(0
// ExceptionMark is a stack-allocated helper class for local exception handling.
// It is used with the EXCEPTION_MARK macro.
--- a/hotspot/src/share/vm/utilities/taskqueue.hpp Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/src/share/vm/utilities/taskqueue.hpp Fri Jun 21 00:51:56 2013 -0700
@@ -340,8 +340,12 @@
if (dirty_n_elems == N - 1) {
// Actually means 0, so do the push.
uint localBot = _bottom;
- // g++ complains if the volatile result of the assignment is unused.
- const_cast<E&>(_elems[localBot] = t);
+ // g++ complains if the volatile result of the assignment is
+ // unused, so we cast the volatile away. We cannot cast directly
+ // to void, because gcc treats that as not using the result of the
+ // assignment. However, casting to E& means that we trigger an
+ // unused-value warning. So, we cast the E& to void.
+ (void)const_cast<E&>(_elems[localBot] = t);
OrderAccess::release_store(&_bottom, increment_index(localBot));
TASKQUEUE_STATS_ONLY(stats.record_push());
return true;
@@ -397,7 +401,12 @@
return false;
}
- const_cast<E&>(t = _elems[oldAge.top()]);
+ // g++ complains if the volatile result of the assignment is
+ // unused, so we cast the volatile away. We cannot cast directly
+ // to void, because gcc treats that as not using the result of the
+ // assignment. However, casting to E& means that we trigger an
+ // unused-value warning. So, we cast the E& to void.
+ (void) const_cast<E&>(t = _elems[oldAge.top()]);
Age newAge(oldAge);
newAge.increment();
Age resAge = _age.cmpxchg(newAge, oldAge);
@@ -640,8 +649,12 @@
uint dirty_n_elems = dirty_size(localBot, top);
assert(dirty_n_elems < N, "n_elems out of range.");
if (dirty_n_elems < max_elems()) {
- // g++ complains if the volatile result of the assignment is unused.
- const_cast<E&>(_elems[localBot] = t);
+ // g++ complains if the volatile result of the assignment is
+ // unused, so we cast the volatile away. We cannot cast directly
+ // to void, because gcc treats that as not using the result of the
+ // assignment. However, casting to E& means that we trigger an
+ // unused-value warning. So, we cast the E& to void.
+ (void) const_cast<E&>(_elems[localBot] = t);
OrderAccess::release_store(&_bottom, increment_index(localBot));
TASKQUEUE_STATS_ONLY(stats.record_push());
return true;
@@ -665,7 +678,12 @@
// This is necessary to prevent any read below from being reordered
// before the store just above.
OrderAccess::fence();
- const_cast<E&>(t = _elems[localBot]);
+ // g++ complains if the volatile result of the assignment is
+ // unused, so we cast the volatile away. We cannot cast directly
+ // to void, because gcc treats that as not using the result of the
+ // assignment. However, casting to E& means that we trigger an
+ // unused-value warning. So, we cast the E& to void.
+ (void) const_cast<E&>(t = _elems[localBot]);
// This is a second read of "age"; the "size()" above is the first.
// If there's still at least one element in the queue, based on the
// "_bottom" and "age" we've read, then there can be no interference with
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/CommandLine/CompilerConfigFileWarning.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7167142
+ * @summary Warn if unused .hotspot_compiler file is present
+ * @library /testlibrary
+ */
+
+import java.io.PrintWriter;
+import com.oracle.java.testlibrary.*;
+
+public class CompilerConfigFileWarning {
+ public static void main(String[] args) throws Exception {
+ String vmVersion = System.getProperty("java.vm.version");
+ if (vmVersion.toLowerCase().contains("debug") || vmVersion.toLowerCase().contains("jvmg")) {
+ System.out.println("Skip on debug builds since we'll always read the file there");
+ return;
+ }
+
+ PrintWriter pw = new PrintWriter(".hotspot_compiler");
+ pw.println("aa");
+ pw.close();
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-version");
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldContain("warning: .hotspot_compiler file is present but has been ignored. Run with -XX:CompileCommandFile=.hotspot_compiler to load the file.");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/CommandLine/ConfigFileWarning.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7167142
+ * @summary Warn if unused .hotspot_rc file is present
+ * @library /testlibrary
+ */
+
+import java.io.PrintWriter;
+import com.oracle.java.testlibrary.*;
+
+public class ConfigFileWarning {
+ public static void main(String[] args) throws Exception {
+ String vmVersion = System.getProperty("java.vm.version");
+ if (vmVersion.toLowerCase().contains("debug") || vmVersion.toLowerCase().contains("jvmg")) {
+ System.out.println("Skip on debug builds since we'll always read the file there");
+ return;
+ }
+
+ PrintWriter pw = new PrintWriter(".hotspotrc");
+ pw.println("aa");
+ pw.close();
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-version");
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldContain("warning: .hotspotrc file is present but has been ignored. Run with -XX:Flags=.hotspotrc to load the file.");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/SharedArchiveFile/CdsDifferentObjectAlignment.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test CdsDifferentObjectAlignment
+ * @summary Testing CDS (class data sharing) using varying object alignment.
+ * Using different object alignment for each dump/load pair.
+ * This is a negative test; using object alignment for loading that
+ * is different from object alignment for creating a CDS file
+ * should fail when loading.
+ * @library /testlibrary
+ */
+
+import com.oracle.java.testlibrary.*;
+
+public class CdsDifferentObjectAlignment {
+ public static void main(String[] args) throws Exception {
+ String nativeWordSize = System.getProperty("sun.arch.data.model");
+ if (!Platform.is64bit()) {
+ System.out.println("ObjectAlignmentInBytes for CDS is only " +
+ "supported on 64bit platforms; this plaform is " +
+ nativeWordSize);
+ System.out.println("Skipping the test");
+ } else {
+ createAndLoadSharedArchive(16, 64);
+ createAndLoadSharedArchive(64, 32);
+ }
+ }
+
+
+ // Parameters are object alignment expressed in bytes
+ private static void
+ createAndLoadSharedArchive(int createAlignment, int loadAlignment)
+ throws Exception {
+ String createAlignmentArgument = "-XX:ObjectAlignmentInBytes=" +
+ createAlignment;
+ String loadAlignmentArgument = "-XX:ObjectAlignmentInBytes=" +
+ loadAlignment;
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:SharedArchiveFile=./sample.jsa",
+ "-Xshare:dump",
+ createAlignmentArgument);
+
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldContain("Loading classes to share");
+ output.shouldHaveExitValue(0);
+
+ pb = ProcessTools.createJavaProcessBuilder(
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:SharedArchiveFile=./sample.jsa",
+ "-Xshare:on",
+ loadAlignmentArgument,
+ "-version");
+
+ output = new OutputAnalyzer(pb.start());
+ String expectedErrorMsg =
+ String.format(
+ "The shared archive file's ObjectAlignmentInBytes of %d " +
+ "does not equal the current ObjectAlignmentInBytes of %d",
+ createAlignment,
+ loadAlignment);
+
+ output.shouldContain(expectedErrorMsg);
+ output.shouldHaveExitValue(1);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/SharedArchiveFile/CdsSameObjectAlignment.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test CdsSameObjectAlignment
+ * @summary Testing CDS (class data sharing) using varying object alignment.
+ * Using same object alignment for each dump/load pair
+ * @library /testlibrary
+ */
+
+import com.oracle.java.testlibrary.*;
+
+public class CdsSameObjectAlignment {
+ public static void main(String[] args) throws Exception {
+ String nativeWordSize = System.getProperty("sun.arch.data.model");
+ if (!Platform.is64bit()) {
+ System.out.println("ObjectAlignmentInBytes for CDS is only " +
+ "supported on 64bit platforms; this plaform is " +
+ nativeWordSize);
+ System.out.println("Skipping the test");
+ } else {
+ dumpAndLoadSharedArchive(8);
+ dumpAndLoadSharedArchive(16);
+ dumpAndLoadSharedArchive(32);
+ dumpAndLoadSharedArchive(64);
+ }
+ }
+
+ private static void
+ dumpAndLoadSharedArchive(int objectAlignmentInBytes) throws Exception {
+ String objectAlignmentArg = "-XX:ObjectAlignmentInBytes="
+ + objectAlignmentInBytes;
+ System.out.println("dumpAndLoadSharedArchive(): objectAlignmentInBytes = "
+ + objectAlignmentInBytes);
+
+ // create shared archive
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:SharedArchiveFile=./sample.jsa",
+ "-Xshare:dump",
+ objectAlignmentArg);
+
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldContain("Loading classes to share");
+ output.shouldHaveExitValue(0);
+
+
+ // run using the shared archive
+ pb = ProcessTools.createJavaProcessBuilder(
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:SharedArchiveFile=./sample.jsa",
+ "-Xshare:on",
+ objectAlignmentArg,
+ "-version");
+
+ output = new OutputAnalyzer(pb.start());
+
+ try {
+ output.shouldContain("sharing");
+ output.shouldHaveExitValue(0);
+ } catch (RuntimeException e) {
+ // CDS uses absolute addresses for performance.
+ // It will try to reserve memory at a specific address;
+ // there is a chance such reservation will fail
+ // If it does, it is NOT considered a failure of the feature,
+ // rather a possible expected outcome, though not likely
+ output.shouldContain(
+ "Unable to reserve shared space at required address");
+ output.shouldHaveExitValue(1);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/threads/TestFalseDeadLock.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.ThreadMXBean;
+import java.util.Random;
+
+/*
+ * @test
+ * @bug 8016304
+ * @summary Make sure no deadlock is reported for this program which has no deadlocks.
+ * @run main/othervm TestFalseDeadLock
+ */
+
+/*
+ * This test will not provoke the bug every time it is run since the bug is intermittent.
+ * The test has a fixed running time of 5 seconds.
+ */
+
+public class TestFalseDeadLock {
+ private static ThreadMXBean bean;
+ private static volatile boolean running = true;
+ private static volatile boolean found = false;
+
+ public static void main(String[] args) throws Exception {
+ bean = ManagementFactory.getThreadMXBean();
+ Thread[] threads = new Thread[500];
+ for (int i = 0; i < threads.length; i++) {
+ Test t = new Test();
+ threads[i] = new Thread(t);
+ threads[i].start();
+ }
+ try {
+ Thread.sleep(5000);
+ } catch (InterruptedException ex) {
+ }
+ running = false;
+ for (Thread t : threads) {
+ t.join();
+ }
+ if (found) {
+ throw new Exception("Deadlock reported, but there is no deadlock.");
+ }
+ }
+
+ public static class Test implements Runnable {
+ public void run() {
+ Random r = new Random();
+ while (running) {
+ try {
+ synchronized (this) {
+ wait(r.nextInt(1000) + 1);
+ }
+ } catch (InterruptedException ex) {
+ }
+ recurse(2000);
+ }
+ if (bean.findDeadlockedThreads() != null) {
+ System.out.println("FOUND!");
+ found = true;
+ }
+ }
+
+ private void recurse(int i) {
+ if (!running) {
+ // It is important for the test to call println here
+ // since there are locks inside that path.
+ System.out.println("Hullo");
+ }
+ else if (i > 0) {
+ recurse(i - 1);
+ }
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary/com/oracle/java/testlibrary/Platform.java Fri Jun 21 00:51:56 2013 -0700
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.java.testlibrary;
+
+public class Platform {
+ private static final String osName = System.getProperty("os.name");
+ private static final String dataModel = System.getProperty("sun.arch.data.model");
+ private static final String vmVersion = System.getProperty("java.vm.version");
+
+ public static boolean is64bit() {
+ return dataModel.equals("64");
+ }
+
+ public static boolean isSolaris() {
+ return osName.toLowerCase().startsWith("sunos");
+ }
+
+ public static boolean isWindows() {
+ return osName.toLowerCase().startsWith("win");
+ }
+
+ public static boolean isOSX() {
+ return osName.toLowerCase().startsWith("mac");
+ }
+
+ public static boolean isLinux() {
+ return osName.toLowerCase().startsWith("linux");
+ }
+
+ public static String getOsName() {
+ return osName;
+ }
+
+ public static boolean isDebugBuild() {
+ return vmVersion.toLowerCase().contains("debug");
+ }
+
+ public static String getVMVersion() {
+ return vmVersion;
+ }
+}
--- a/hotspot/test/testlibrary/com/oracle/java/testlibrary/ProcessTools.java Thu Jun 20 10:16:47 2013 -0700
+++ b/hotspot/test/testlibrary/com/oracle/java/testlibrary/ProcessTools.java Fri Jun 21 00:51:56 2013 -0700
@@ -112,10 +112,8 @@
* @return String[] with platform specific arguments, empty if there are none
*/
public static String[] getPlatformSpecificVMArgs() {
- String osName = System.getProperty("os.name");
- String dataModel = System.getProperty("sun.arch.data.model");
- if (osName.equals("SunOS") && dataModel.equals("64")) {
+ if (Platform.is64bit() && Platform.isSolaris()) {
return new String[] { "-d64" };
}