🚀 go-pugleaf

jarekr pisze:
> 
>> Przygotowywanie tego rodzaju testów jest bardzo delikatną sprawą bo
>> trzeba wziąć pod uwagę znacznie więcej współczynników niż zdajecie sobie
>> sprawy a nawet wtedy interpretacja wyników nie jest tak prosta jak
>> wskazanie kierunku relacji większości.
> NIkt tu nie  o jakiejś poważnej interpretacji wyników - oprócz trollka
> - nie mówi.
> Osobiście ciekawi mnie gdzie co gcc robi lepiej od C2 na  podanym
> kawałku kodu. (bo może trzeba mu coś poprawić :-) ).
> 
> Tak przy okazji.
> W sumie parę ciekawych wyników mam przy okazji tego zagadnienia.
> Np. bardzo zawiodłem się na implementacji System arraycopy.
> Z dobrych rzeczy natomiast  - w Dolphin (java 7.0) sensownie
> przeorganizowali ( w źródłach JVM) - kompilację
> native wrapperów.(library_call.cpp). Teraz dodanie (na poziomie kodu
> JVM) nowych jest dość proste i można się spodziewać
> że w niedalekiej przyszłości dużo nowych funkcji z jdk będzie miało
> native wrappery bez JNI zrobione (czyli tak jak Math.sin i inne).
> 
Tu nie ma żadnego jni i wcale niewiele się zmieni w 7ce. Metody typu 
"arraycopy", "indexOf", "hashCode" etc, to są tzw intrinsics 
(vmSymbols.hpp) (Nawet InvokeDynamic bazuje na intrinsics a nie na 
dodatkowym rozkazie, np MethodHandle, AnonymousClassLoader, czy pool 
patchery). One są bezpośrednio stubowane w natywny kod, ale przedtem ich 
argumenty podlegają takim samym optymalizacjom jak np. GVN na grafie 
SSA/MachNode jak normalny kod (przy "arraycopy" następuje nawet 
eliminacja sprawdzeń zasięgu dla tablic, czy src > 0 itp).


W przypadku tego benchmarku pechowy jest OSR, czyli rekompilacja w locie 
(w czasie działania pętli) i resynchronizacja ramki interpretera i stosu 
natywnego.

http://java.sun.com/developer/technicalArticles/Networking/HotSpot/onstack.html

więc (8x główna metoda):

java -server -XX:+PrintCompilation exp


   1       java.util.BitSet::wordIndex (5 bytes)
   2       java.util.BitSet::checkInvariants (111 bytes)
   3       java.util.BitSet::set (58 bytes)
   4       java.util.BitSet::expandTo (23 bytes)
   1%      exp::foo @ 24 (183 bytes)			// nastąpił OSR
   5       java.util.BitSet::ensureCapacity (39 bytes)
   6       java.util.BitSet::clear (70 bytes)
   7       java.util.BitSet::recalculateWordsInUse (39 bytes)
   8       java.util.BitSet::get (69 bytes)
   1%  made not entrant  (2)  exp::foo @ 24 (183 bytes)  // metoda 
kompilowana przez OSR staje się zombi a potem nastąpi rekompilacja (btw, 
to kompilacja zewnętrznego while'a który też był mierzony)
Ilosc: 2
172 ms.
   9       exp::foo (183 bytes)
   2%      exp::foo @ 24 (183 bytes) // ...


więcej będzie widać przy:
java -server -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation exp

...
<task_queued compile_id='1' compile_kind='osr' method='exp foo ()V' 
bytes='183' count='1' backedge_count='14563' iicount='1' osr_bci='24' 
stamp='0.117' comment='backedge_count' hot_count='14563'/>
...
<nmethod compile_id='1' compile_kind='osr' compiler='C2' level='2' 
entry='0x009aefe0' size='2216' address='0x009aeec8' 
relocation_offset='180' code_offset='280' stub_offset='1208' 
consts_offset='1263' scopes_data_offset='1264' scopes_pcs_offset='1880' 
dependencies_offset='2072' handler_table_offset='2084' 
nul_chk_table_offset='2180' oops_offset='2192' method='exp foo ()V' 
bytes='183' count='1' backedge_count='14563' iicount='1' stamp='0.125'/>
...



<make_not_entrant thread='2384' compile_id='1' compile_kind='osr' 
compiler='C2' level='2' stamp='0.279'/>
...


rekompilacja:

<task_queued compile_id='9' method='exp foo ()V' bytes='183' count='2' 
backedge_count='5000' iicount='2' decompiles='1' null_assert_traps='1' 
stamp='0.279' comment='count' hot_count='2'/>

<nmethod compile_id='9' compiler='C2' level='2' entry='0x009b05c0' 
size='4052' address='0x009b0408' relocation_offset='180' 
code_offset='440' stub_offset='1720' consts_offset='1885' 
scopes_data_offset='1888' scopes_pcs_offset='3212' 
dependencies_offset='3572' handler_table_offset='3584' 
oops_offset='4016' method='exp foo ()V' bytes='183' count='2' 
backedge_count='5000' iicount='2' decompiles='1' null_assert_traps='1' 
stamp='0.293'/>
<writer thread='2384'/>
...
<task_queued compile_id='2' compile_kind='osr' method='exp foo ()V' 
bytes='183' count='2' backedge_count='6024' iicount='2' decompiles='1' 
null_assert_traps='1' osr_bci='24' stamp='0.293' 
comment='backedge_count' hot_count='6024'/>

decompiles='1' mówi że musiała nastąpić dekompilacja w celu 
synchronizacji ramki interpretera z ramka natywną (liczniki pętli i inne 
zmienne lokalne)
W przypadkach uncommon_traps (np null_check, range_check, class_unloaded 
itp) mówi się na to bail-out (sytuacje nieprzewidziane i lub pogwałcenie 
semantyki javy).

btw, żadne opcje typu poniżej nie będą mieć większego znaczenia:
-XX:CompileThreshold=100, nie w tym przypadku, 100 a 250000 dla takich 
benchmarkow to mała różnica, btw, to może zmylić heurystyki profilera 
onlinowego, (warto tu też wspomnieć o MaxInlineSize i MaxInlineLevel)
-XX:+AggressiveOpts, jest dość spekulacyjna
-XX:+UseFastAccessorMethods, jest domyślna, a i tak hotspot je zainlinuje
-Xverify:none, weryfikator bytecodu (znaczenie tylko przy startup, ale i 
tak wtedy lepiej skorzystać z bootclasspath)
-XX:+UseBiasedLocking, bez komentarza



java -server -XX:+PrintOptoAssembly exp

Kod natywny wydaje się być duży, głównie dlatego że zainlinowane zotały 
wszystkie metody BitSet itp. Kosztują tutaj guardy hotspota: 
uncommon_trap(reason='range_check' action='make_not_entrant'), 
uncommon_trap(reason='null_check' action='maybe_recompile') i guardy 
samego bitset'a (np: public boolean get(int bitIndex)), private void 
checkInvariants()).

np:
0ce   	MOV    EDI,[EBX] ! Field java/util/BitSet.words
0d0   	MOV    ECX,[EDI + #8]
0d3   	NullCheck EDI

Generalnie warto napisać własny bitset lub bezpośrednio walić w tablice 
z modulo i maską.

Warto też zwrócić uwagę na:
CALL_LEAF,runtime  OSR_migration_end

I na koniec: pisać MAŁE METODY... (po co hotpost ma kompilować złożone 
metody z inicjalizacjami i rzadko podążanymi ścieżkami ?, utrudnia to 
wszystko, od analizy SSA aż po alokację rejestrów, hotspot może wtedy 
nawet zrezygnować z kompilacji ze względu na zbyt dużą złożoność czy 
przepełnienie CodeCache -XX:+PrintInlining).

{method}
  - klass: {other class}
  - method holder:     'exp'
  - constants:         0x084e7fd4{constant pool}
  - access:            0xc1000008  static
  - name:              'foo'
  - signature:         '()V'
  - max stack:         6
  - max locals:        8
  - size of params:    0
  - method size:       20
  - vtable index:      -2
  - code size:         183
  - code start:        0x141ed3e0
  - code end (excl):   0x141ed497
  - method data:       0x141eda50
  - checked ex length: 0
  - linenumber start:  0x141ed497
  - localvar length:   0
#
#  void ( rawptr:BotPTR )
#
#r000 ecx   : parm 0: rawptr:BotPTR
# -- Old esp -- Framesize: 80 --
#r045 esp+76: return address
#r044 esp+72: pad2, in_preserve
#r043 esp+68: pad2, in_preserve
#r042 esp+64: Fixed slot 0
#r061 esp+60: spill
#r060 esp+56: spill
#r059 esp+52: spill
#r058 esp+48: spill
#r057 esp+44: spill
#r056 esp+40: spill
#r055 esp+36: spill
#r054 esp+32: spill
#r053 esp+28: spill
#r052 esp+24: spill
#r051 esp+20: spill
#r050 esp+16: spill
#r049 esp+12: spill
#r048 esp+ 8: spill
#r047 esp+ 4: spill
#r046 esp+ 0: outgoing argument
#
000   N577: #	B1 <- BLOCK HEAD IS JUNK   Freq: 1
000   	INT3
       	NOP 	# 3 bytes pad for loops and calls

004   B1: #	B34 B2 <- BLOCK HEAD IS JUNK   Freq: 1
004   	# stack bang
	PUSHL  EBP
	SUB    ESP,72	# Create frame
012   	MOV    EBX,[ECX + #8]
015   	MOV    EDI,[ECX + #16]
018   	MOV    [ESP + #4],EDI
01c   	MOV    EBP,[ECX + #28]
01f   	MOV    [ESP + #8],EBP
023   	MOV    EDI,[ECX + #12]
026   	MOV    [ESP + #20],EDI
02a   	MOV    ESI,ECX
02c   	MOV    EBP.lo,[ESI + #20]
	MOV    EBP.hi,[ESI + #20]+4
032   	MOV    [ESP + #24],EBP
	MOV    [ESP + #28],EDI
03a   	MOV    [ESP + #0],ECX
03d   	CALL_LEAF,runtime  OSR_migration_end
         No JVM State Info
         #
042   	MOV    EBP,[ESP + #4]
046   	TEST   EBP,EBP
048   	Jeq    B34  P=0.001000 C=-1.000000
048
04e   B2: #	B33 B3 <- B1  Freq: 0.999
04e   	MOV    EAX,EBP
050   	MOV    ECX,[EBP + #4]
053   	CMPu   ECX,precise klass java/util/BitSet: 
0x00a05b20:Constant:exact *
059   	Jne,u  B33  P=0.100000 C=-1.000000
059
05f   B3: #	B4 <- B2  Freq: 0.8991
05f   	#checkcastPP of EAX
05f   	LEA    EBP,[EAX + #8]
062   	LEA    ECX,[EAX + #16]
065   	MOV    EDI,EAX
065
067   B4: #	B14 B5 <- B3 B34  Freq: 0.9001
067   	MOV    EDX,[ESP + #8]
06b   	INC    EDX
06c   	CMP    EBX,[ESP + #8]
070   	Jgt    B14  P=0.000000 C=11264.000000
       	NOP 	# 10 bytes pad for loops and calls

080   B5: #	B40 B6 <- B4 B13 	Loop: B5-B13 inner stride: not constant 
Freq: 216881
080   	TEST   EDI,EDI
082   	Jeq    B40  P=0.000001 C=-1.000000
082
088   B6: #	B39 B7 <- B5  Freq: 216881
088   	TEST   EBX,EBX
08a   	Jlt    B39  P=0.000000 C=6701.000000
08a
090   B7: #	B10 B8 <- B6  Freq: 216881
090   	MOV    [ESP + #36],EBX
094   	MOV    [ESP + #32],EDX
098   	MOV    [ESP + #16],EDI
09c   	MOV    [ESP + #12],ECX
0a0   	MOV    ECX,[EBP] ! Field java/util/BitSet.wordsInUse
0a3   	MOV    [ESP + #4],EBP
0a7   	MOV    EBP,EBX
0a9   	SAR    EBP,#6
0ac   	MOV    EBX,EBP
0ae   	INC    EBX
0af   	MOV    [ESP + #40],EBX
0b3   	CMP    ECX,EBX
0b5   	Jge,s  B10  P=0.984331 C=6701.000000
0b5
0b7   B8: #	B38 B9 <- B7  Freq: 3398.37
0b7   	MOV    ECX,EDI
0b9   	MOV    EDX,EBX
0bb   	CALL,static  java.util.BitSet::ensureCapacity
         # java.util.BitSet::expandTo @ bci:14  L[0]=esp + #16 L[1]=_ 
L[2]=esp + #40
         # java.util.BitSet::set @ bci:38  L[0]=esp + #16 L[1]=esp + #36 
L[2]=EBP
         # exp::foo @ bci:33  L[0]=esp + #8 L[1]=esp + #24 L[2]=_ 
L[3]=esp + #16 L[4]=esp + #20 L[5]=esp + #36 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)
AllocatedObj(0x03fbe9f4)
AllocatedObj(0x03fbe9f4)

0c0
0c0   B9: #	B10 <- B8  Freq: 3398.3
         # Block is sole successor of call
0c0   	MOV    EBX,[ESP + #4]
0c4   	MOV    ECX,[ESP + #40]
0c8   	MOV    [EBX],ECX ! Field java/util/BitSet.wordsInUse
0c8
0ca   B10: #	B37 B11 <- B9 B7  Freq: 216881
0ca   	MOV    EBX,[ESP + #12]
0ce   	MOV    EDI,[EBX] ! Field java/util/BitSet.words
0d0   	MOV    ECX,[EDI + #8]
0d3   	NullCheck EDI
0d3
0d3   B11: #	B36 B12 <- B10  Freq: 216881
0d3   	CMPu   EBP,ECX
0d5   	Jge,u  B36  P=0.000001 C=-1.000000
0d5
0db   B12: #	B35 B13 <- B11  Freq: 216880
0db   	LEA    ESI,[EDI + EBP << #3]
0de   	MOV    EAX.lo,#1.lo
	MOV    EAX.hi,#1.hi
0e5   	MOV    ECX,[ESP + #36]
0e9   	TEST   ECX,32
	JEQ,s  small
	MOV    EAX.hi,EAX.lo
	XOR    EAX.lo,EAX.lo
small:	SHLD   EAX.hi,EAX.lo,ECX
	SHL    EAX.lo,ECX
0fa   	OR     EAX.lo,[ESI + #16]
	OR     EAX.hi,[ESI + #16]+4
100   	MOV    [EDI + #16 + EBP << #3],EAX.lo
	MOV    [EDI + #16 + EBP << #3]+4,EAX.hi
108   	MOV    EBX,ECX
10a   	INC    EBX
10b   	CMP    EBX,[ESP + #32]
10f   	Jge    B35	# Loop end  P=0.000000 C=11264.000000
10f
115   B13: #	B5 <- B12  Freq: 216880
115   	MOV    EBP,[ESP + #4]
119   	MOV    ECX,[ESP + #12]
11d   	MOV    EDI,[ESP + #16]
121   	MOV    EDX,[ESP + #32]
125   	JMP    B5
125
12a   B14: #	B27 B15 <- B35 B4  Freq: 0.103417
12a   	MOV    ESI,#2
12f   	MOV    ECX,[ESP + #8]
133   	CMP    ECX,#4
136   	Jlt    B27  P=0.500000 C=-1.000000
136
13c   B15: #	B43 B16 <- B14 B25 	Loop: B15-B25  Freq: 0.51683
13c   	TEST   EDI,EDI
13e   	Jeq    B43  P=0.000001 C=-1.000000
13e
144   B16: #	B42 B17 <- B15  Freq: 0.516829
144   	MOV    [ESP + #16],ESI
148   	MOV    [ESP + #12],EDX
14c   	MOV    [ESP + #8],EDI
150   	MOV    [ESP + #4],ECX
154   	MOV    ECX,EDI
156   	MOV    EDX,ESI
158   	NOP 	# 3 bytes pad for loops and calls
15b   	CALL,static  java.util.BitSet::get
         # exp::foo @ bci:57  L[0]=esp + #4 L[1]=esp + #24 L[2]=_ 
L[3]=esp + #8 L[4]=esp + #20 L[5]=esp + #16 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

160
160   B17: #	B23 B18 <- B16  Freq: 0.516819
         # Block is sole successor of call
160   	TEST   EAX,EAX
162   	Jeq,s  B23  P=0.100000 C=-1.000000
162
164   B18: #	B24 B19 <- B17  Freq: 0.465137
164   	MOV    EBX,[ESP + #20]
168   	INC    EBX
169   	MOV    EBP,[ESP + #16]
16d   	SHL    EBP,#1
16f   	CMP    EBP,[ESP + #4]
173   	Jgt,s  B24  P=0.500000 C=-1.000000
       	NOP 	# 11 bytes pad for loops and calls

180   B19: #	B41 B20 <- B18 B21 	Loop: B19-B21 inner stride: not 
constant  Freq: 2.3255
180   	MOV    [ESP + #20],EBX
184   	MOV    ECX,[ESP + #8]
188   	MOV    EDX,EBP
18a   	NOP 	# 1 bytes pad for loops and calls
18b   	CALL,static  java.util.BitSet::clear
         # exp::foo @ bci:81  L[0]=esp + #4 L[1]=esp + #24 L[2]=_ 
L[3]=esp + #8 L[4]=esp + #20 L[5]=esp + #16 L[6]=EBP L[7]=_
         # AllocatedObj(0x03fbe9f4)

190
190   B20: #	B22 B21 <- B19  Freq: 2.32545
         # Block is sole successor of call
190   	INC    EBP
191   	CMP    EBP,[ESP + #12]
195   	Jge,s  B22  P=0.100000 C=-1.000000
195
197   B21: #	B19 <- B20  Freq: 2.09291
197   	MOV    EBX,[ESP + #20]
19b   	JMP,s  B19
19b
19d   B22: #	B24 <- B20  Freq: 0.232545
19d   	MOV    EBX,[ESP + #20]
1a1   	JMP,s  B24
1a1
1a3   B23: #	B24 <- B17  Freq: 0.0516819
1a3   	MOV    EBX,[ESP + #20]
1a3
1a7   B24: #	B26 B25 <- B22 B18 B23  Freq: 0.516796
1a7   	MOV    ESI,[ESP + #16]
1ab   	INC    ESI
1ac   	TSTL   #polladdr,EAX	! Safepoint: poll for GC        # exp::foo @ 
bci:96  L[0]=esp + #4 L[1]=esp + #24 L[2]=_ L[3]=esp + #8 L[4]=EBX 
L[5]=ESI L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

1b2   	MOV    ECX,ESI
1b4   	IMUL   ECX,ESI
1b7   	CMP    ECX,[ESP + #4]
1bb   	Jgt,s  B26  P=0.100000 C=-1.000000
1bb
1bd   B25: #	B15 <- B24  Freq: 0.465116
1bd   	MOV    ECX,[ESP + #4]
1c1   	MOV    [ESP + #20],EBX
1c5   	MOV    EDI,[ESP + #8]
1c9   	MOV    EDX,[ESP + #12]
1cd   	JMP    B15
1cd
1d2   B26: #	B44 <- B24  Freq: 0.0516796
1d2   	MOV    ECX,[ESP + #4]
1d6   	MOV    EDI,[ESP + #8]
1da   	MOV    EDX,[ESP + #12]
1de   	JMP    B44
1de
1e3   B27: #	B44 <- B14  Freq: 0.0517085
1e3   	MOV    EBX,[ESP + #20]
1e7   	JMP    B44
1e7
1ec   B28: #	B29 <- B44  Freq: 0.051694
1ec   	MOV    [ESP + #16],ESI
1ec
1f0   B29: #	B49 B30 <- B28 B32 	Loop: B29-B32 inner stride: not 
constant  Freq: 0.516894
1f0   	TEST   EDI,EDI
1f2   	Jeq    B49  P=0.000001 C=-1.000000
1f2
1f8   B30: #	B47 B31 <- B29  Freq: 0.516894
1f8   	MOV    [ESP + #12],EDX
1fc   	MOV    [ESP + #8],EDI
200   	MOV    [ESP + #4],EBX
204   	MOV    EBP,ECX
206   	MOV    ECX,EDI
208   	MOV    EDX,[ESP + #16]
20c   	NOP 	# 3 bytes pad for loops and calls
20f   	CALL,static  java.util.BitSet::get
         # exp::foo @ bci:108  L[0]=EBP L[1]=esp + #24 L[2]=_ L[3]=esp + 
#8 L[4]=esp + #4 L[5]=esp + #16 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

214
214   B31: #	B45 B32 <- B30  Freq: 0.516883
         # Block is sole successor of call
214   	MOV    ECX,[ESP + #4]
218   	INC    ECX
219   	TEST   EAX,EAX
21b   	MOV    EBX,[ESP + #4]
21f   	CMOVne EBX,ECX
222   	MOV    ECX,[ESP + #16]
226   	INC    ECX
227   	CMP    ECX,[ESP + #12]
22b   	Jge    B45	# Loop end  P=0.100000 C=-1.000000
22b
231   B32: #	B29 <- B31  Freq: 0.465195
231   	MOV    [ESP + #16],ECX
235   	MOV    ECX,EBP
237   	MOV    EDI,[ESP + #8]
23b   	MOV    EDX,[ESP + #12]
23f   	JMP,s  B29
23f
241   B33: #	N577 <- B2  Freq: 1e-006
241   	MOV    ECX,#-75
246   	MOV    EBP,[ESP + #8]
24a   	PUSH   [ESP + #24]
	POP    [ESP + #8]
	PUSH   [ESP + #28]
	POP    [ESP + #12]
25a   	PUSH   [ESP + #20]
	POP    [ESP + #4]
262   	MOV    [ESP + #16],EBX
266   	MOV    [ESP + #20],EAX
26a   	NOP 	# 1 bytes pad for loops and calls
26b   	CALL,static  wrapper for: uncommon_trap(reason='unreached' 
action='reinterpret')
         # exp::foo @ bci:24  L[0]=EBP L[1]=esp + #8 L[2]=_ L[3]=esp + 
#20 L[4]=esp + #4 L[5]=esp + #16 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

270   	INT3   ; ShouldNotReachHere
270
271   B34: #	B4 <- B1  Freq: 0.000999987
271   	MOV    EBP,NULL+8
276   	MOV    ECX,NULL+16
27b   	MOV    EDI,NULL
280   	JMP    B4
280
285   B35: #	B14 <- B12  Freq: 0.103417
285   	MOV    EDI,[ESP + #16]
289   	MOV    EDX,[ESP + #32]
28d   	JMP    B14
28d
292   B36: #	N577 <- B11  Freq: 1e-006
292   	MOV    ECX,#-28
297   	PUSH   [ESP + #8]
	POP    [ESP + #4]
29f   	PUSH   [ESP + #24]
	POP    [ESP + #8]
	PUSH   [ESP + #28]
	POP    [ESP + #12]
2af   	PUSH   [ESP + #36]
	POP    [ESP + #24]
2b7   	MOV    [ESP + #36],EDI
2bb   	CALL,static  wrapper for: uncommon_trap(reason='range_check' 
action='make_not_entrant')
         # java.util.BitSet::set @ bci:47  L[0]=esp + #16 L[1]=esp + #24 
L[2]=_ STK[0]=esp + #36 STK[1]=EBP STK[2]=esp + #36 STK[3]=EBP
         # exp::foo @ bci:33  L[0]=esp + #4 L[1]=esp + #8 L[2]=_ 
L[3]=esp + #16 L[4]=esp + #20 L[5]=esp + #24 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)
AllocatedObj(0x03fbe9f4)

2c0   	INT3   ; ShouldNotReachHere
2c0
2c1   B37: #	N577 <- B10  Freq: 1e-006
2c1   	MOV    ECX,#-10
2c6   	MOV    [ESP + #4],EDI
2ca   	NOP 	# 1 bytes pad for loops and calls
2cb   	CALL,static  wrapper for: uncommon_trap(reason='null_check' 
action='maybe_recompile')
         # java.util.BitSet::set @ bci:47  L[0]=_ L[1]=_ L[2]=_ STK[0]=_ 
STK[1]=_ STK[2]=esp + #4 STK[3]=EBP
         # exp::foo @ bci:33  L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ L[5]=_ 
L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

2d0   	INT3   ; ShouldNotReachHere
2d0
2d1   B38: #	B48 <- B8  Freq: 0.0339837
2d1   	# exception oop is in EAX; no code emitted
2d1   	MOV    ECX,EAX
2d3   	JMP    B48
2d3
2d8   B39: #	N577 <- B6  Freq: 1e-006
2d8   	MOV    ECX,#21
2dd   	MOV    EBP,[ESP + #8]
2e1   	PUSH   [ESP + #24]
	POP    [ESP + #8]
	PUSH   [ESP + #28]
	POP    [ESP + #12]
2f1   	MOV    [ESP + #4],EDI
2f5   	PUSH   [ESP + #20]
	POP    [ESP + #16]
2fd   	MOV    [ESP + #20],EBX
301   	NOP 	# 2 bytes pad for loops and calls
303   	CALL,static  wrapper for: uncommon_trap(reason='unloaded' 
action='reinterpret' index='21')
         # java.util.BitSet::set @ bci:4  L[0]=_ L[1]=esp + #20 L[2]=_
         # exp::foo @ bci:33  L[0]=EBP L[1]=esp + #8 L[2]=_ L[3]=esp + 
#4 L[4]=esp + #16 L[5]=esp + #20 L[6]=_ L[7]=_
         # AllocatedObj(0x03fbe9f4)

308   	INT3   ; ShouldNotReachHere
308
309   B40: #	N577 <- B5  Freq: 1e-006
309   	MOV    ECX,#-10
30e   	MOV    EBP,EDI
310   	MOV    [ESP + #4],EBX
314   	NOP 	# 3 bytes pad for loops and calls
317   	CALL,static  wrapper for: uncommon_trap(reason='null_check' 
action='maybe_recompile')
         # exp::foo @ bci:33  L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ L[5]=_ 
L[6]=_ L[7]=_ STK[0]=EBP STK[1]=esp + #4
         # AllocatedObj(0x03fbe9f4)

31c   	INT3   ; ShouldNotReachHere
31c
31d   B41: #	B48 <- B19  Freq: 2.3255e-005
31d   	# exception oop is in EAX; no code emitted
31d   	MOV    ECX,EAX
31f   	JMP,s  B48
31f
321   B42: #	B48 <- B16  Freq: 5.16829e-006
321   	# exception oop is in EAX; no code emitted
321   	MOV    ECX,EAX
323   	JMP,s  B48
323
325   B43: #	N577 <- B15  Freq: 1e-006
325   	MOV    ECX,#-10
32a   	MOV    EBP,EDI
32c   	MOV    [ESP + #4],ESI
330   	NOP 	# 3 bytes pad for loops and calls
333   	CALL,static  wrapper for: uncommon_trap(reason='null_check' 
action='maybe_recompile')
         # exp::foo @ bci:57  L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ L[5]=_ 
L[6]=_ L[7]=_ STK[0]=EBP STK[1]=esp + #4
         # AllocatedObj(0x03fbe9f4)

338   	INT3   ; ShouldNotReachHere
338
339   B44: #	B28 B45 <- B26 B27  Freq: 0.103388
339   	CMP    ESI,ECX
33b   	Jle    B28  P=0.500000 C=-1.000000
33b
341   B45: #	B50 B46 <- B31 B44  Freq: 0.103382
341   	CALL_LEAF,runtime  currentTimeMillis
         No JVM State Info
         #
346   	MOV    [ESP + #16],EAX
	MOV    [ESP + #20],EDX
34e   	MOV    EBP,#332
353   	MOV    EBP,[EBP + precise klass java/lang/System: 
0x00a06e88:Constant:exact *] ! Field java/lang/System.out
359   	TEST   EBP,EBP
35b   	Jeq,s  B50  P=0.000001 C=-1.000000
35b
35d   B46: #	N577 <- B45  Freq: 1e-006
35d   	MOV    ECX,#-20
362   	MOV    [ESP + #4],EBX
366   	NOP 	# 1 bytes pad for loops and calls
367   	CALL,static  wrapper for: uncommon_trap(reason='null_assert' 
action='make_not_entrant')
         # exp::foo @ bci:131  L[0]=_ L[1]=esp + #24 L[2]=_ L[3]=_ 
L[4]=esp + #4 L[5]=_ L[6]=esp + #16 L[7]=_ STK[0]=EBP
         # AllocatedObj(0x03fbe9f4)

36c   	INT3   ; ShouldNotReachHere
36c
36d   B47: #	B48 <- B30  Freq: 5.16894e-006
36d   	# exception oop is in EAX; no code emitted
36d   	MOV    ECX,EAX
36d
36f   B48: #	N577 <- B38 B42 B41 B47  Freq: 0.0340173
36f   	ADD    ESP,72	# Destroy frame
	POPL   EBP
	
373   	JMP    rethrow_stub
373
378   B49: #	N577 <- B29  Freq: 1e-006
378   	MOV    ECX,#-10
37d   	MOV    EBP,EDI
37f   	CALL,static  wrapper for: uncommon_trap(reason='null_check' 
action='maybe_recompile')
         # exp::foo @ bci:108  L[0]=_ L[1]=_ L[2]=_ L[3]=_ L[4]=_ L[5]=_ 
L[6]=_ L[7]=_ STK[0]=EBP STK[1]=esp + #16
         # AllocatedObj(0x03fbe9f4)

384   	INT3   ; ShouldNotReachHere
384
385   B50: #	N577 <- B45  Freq: 1e-006
385   	MOV    ECX,#11
38a   	MOV    EBP,EBX
38c   	NOP 	# 3 bytes pad for loops and calls
38f   	CALL,static  wrapper for: uncommon_trap(reason='unloaded' 
action='reinterpret' index='11')
         # exp::foo @ bci:131  L[0]=_ L[1]=esp + #24 L[2]=_ L[3]=_ 
L[4]=EBP L[5]=_ L[6]=esp + #16 L[7]=_ STK[0]=#NULL
         #
394   	INT3   ; ShouldNotReachHere
394


lopex