Jaos - Java on Aos. Oberon Event 03 Patrik Reali

Transcription

1 Jaos - Java on Aos Oberon Event 03 Patrik Reali 1

2 Agenda! Oberon vs. Java! Java for Aos! Type Mapping! Compiling! Linking! Exceptions! Native Methods! Concurrency! Special Topics! Strings! Overloading! Interoperability! Results! Implementation! Future Oberon Event 03 Patrik Reali: Jaos: Java on Aos 2

3 Oberon vs. Java! Similarities! Strongly typed! Object-Oriented! Garbage Collected! Dynamic Loading! Differencies! Loading / Initialization time! Hierarchy Design Oberon Event 03 Patrik Reali: Jaos: Java on Aos 3

4 Oberon vs. Java Object Closure Transitive closure of java.lang.object contains 299 classes (GNU Classpath 0.03) class Object { public String tostring();... class String { } public String touppercase(locale loc);... } public final class Locale implements Serializable, Cloneable {... } Oberon Event 03 Patrik Reali: Jaos: Java on Aos 4

5 Oberon vs. Java OO-Design Limits GNU Classpath 0.03 class String { public String touppercase() { return touppercase(locale.getdefault()); } class Locale { public static final Locale ENGLISH = new Locale("en"); public Locale(String language, String country) { country = country.touppercase();... } Oberon Event 03 Patrik Reali: Jaos: Java on Aos 5

6 Oberon vs. Java Module vs. Class Initialization Oberon Modules:! all imported modules must be loaded and initialized Java Classes:! instance of T is created.! a static method declared by T is invoked.! A static field declared by T is assigned.! A static field declared by T is used and the reference to the field is not a compile-time constant.! References to compile-time constants must be resolved at compile time to a copy of the compile-time constant value, so uses of such a field never cause initialization. Oberon Event 03 Patrik Reali: Jaos: Java on Aos 6

7 Concepts! Use Aos conventions and API for! Memory Layout + Garbage Collection! Calling Convention! Thread Handling! Exception Handling! Compile Byte-Code to IA32! System Integration! Metadata-Loader Plugin! Class-Loader Plugin Oberon Event 03 Patrik Reali: Jaos: Java on Aos 7

8 Type Mapping Basic Types! int LONGINT! long HUGEINT! float REAL! double LONGREAL! char CHAR16 Charsets are incompatible! Identifiers are also different: java: 256 chars (allows _ ) oberon: 32 chars Compound Types! T[] Tarray = OBJECT (jjlobject) p: POINTER TO ARRAY OF T; END Tarray;! Class C MODULE C; TYPE C = OBJECT... END C; END C.! Interfaces! own implementation Arrays have class sematic Active Oberon now uses the same implementation for DEFINITIONS Oberon Event 03 Patrik Reali: Jaos: Java on Aos 8

9 Type Mapping class C: C { float j; static int i; } void M() {} static bool P() {} Warning: static and instance members are not mixed symbol lookup is different MODULE C; TYPE C = OBJECT (C ) VAR j: REAL; PROCEDURE M(); END C; VAR i: LONGINT; PROCEDURE P(): BOOLEAN; END C. Oberon Event 03 Patrik Reali: Jaos: Java on Aos 9

10 Type Mapping! Runtime structures for a Class:! 1 type descriptor! 1 module! Semantic loss:! Java Packages cannot be represented (although the java compiler enforce them) Oberon Event 03 Patrik Reali: Jaos: Java on Aos 10

11 Byte-Code Overview Memory Access! tload / tstore! ttload / ttstore! tconst! getfield / putfield! getstatic / putstatic Operations! tadd / tsub / tmul / tdiv! tshifts Conversions! f2i / i2f / i2l /... Stack! dup / dup2 / dup_x1 /... Control! ifeq / ifne / iflt /...! if_icmpeq / if_acmpeq! invokestatic! invokevirtual! invokeinterface! athrow! treturn Allocation! new / newarray Casting! checkcast / instanceof Oberon Event 03 Patrik Reali: Jaos: Java on Aos 11

12 Compilation Strategies! Interpreted! java is so sloooooow!! but it s everywhere! Compiled! Just-in-time compiler! Ahead-of-time compiler! Mixed Mode! Compiler kinds! client! fast compilation! few optimizations! server! many optimizations! long compilation! Compiler Optimizations! dynamic recompilation! pointer-escape analysis!... Oberon Event 03 Patrik Reali: Jaos: Java on Aos 12

13 Jaos Compilers! Pattern Expansion Compiler! for each byte-code one code pattern! Optimizing Compiler! Idea: Intel / ORP! work on virtual stack! flush virtual stack to code on need! problem: many stack operations! better use of registers Oberon Event 03 Patrik Reali: Jaos: Java on Aos 13

14 Pattern Expansion Compiler PUSH N CASE op OF 2..8: (* iconst-<n> *) JC0.GenPUSH(JC0.Imme, 0, nobase, noinx, noscale, nodisp, op-3); INC(pc) : (* iload-<n> *) index := (op-26) MOD 4; JC0.GenPUSH(JC0.Mem, 0, FP, noinx, noscale, FpOffset(index), noimm); INC(pc); 96: (* iadd *) Pop(EAX); PUSH off[fp] POP EAX ADD 0[SP], EAX JC0.GenTyp1(JC0.ADD, JC0.RegMem, EAX, SP, noinx, noscale, 0, noimm); INC(pc) Oberon Event 03 Patrik Reali: Jaos: Java on Aos 14

15 Pattern Expansion Compiler iload_4 iload_5 iadd istore_6 push off4[fp] push off5[fp] pop EAX add 0[SP], EAX pop off6[fp] Oberon Event 03 Patrik Reali: Jaos: Java on Aos 15

16 Optimizing Compiler Main Idea:! use internal virtual stack! stack values are consts / fields / locals / array fields / registers /...! flush stack as late as possible MOV EAX, off 5 [FP] ADD EAX, off 4 [FP] virtual stack off 4 [FP] off 5 [FP] off 4 [FP] EAX off 4 [FP] EAX MOV off 6 [FP], EAX iload4 iload5 iadd istore6 Oberon Event 03 Patrik Reali: Jaos: Java on Aos 16

17 Optimizing Compiler iload0.. iload3: virtual stack op PushLocal(JavaInt, (op - iload0) MOD 4) iadd: PopItem(JavaINT, v2); IF v2.mode = Stack THEN LoadItem(v2) END; mode := v2.mode; PopAndLoadItem(JavaINT, v1); code emission ReleaseItem(v2); JC0.GenTyp1(op, Mode[mode], v1.base, v2.base, v2.index, v2.scale, v2.disp, v2.val); PushItem(v1) Oberon Event 03 Patrik Reali: Jaos: Java on Aos 17

18 Compiler Comparison 5 instructions 9 memory accesses iload_4 iload_5 iadd istore_6 3 instructions 3 memory accesses Pattern Expansion push off4[fp] push off5[fp] pop EAX add 0[SP], EAX pop off6[fp] Optimized mov EAX, off4[fp] add EAX, off5[fp] mov off6[fp], EAX Oberon Event 03 Patrik Reali: Jaos: Java on Aos 18

19 Linking Linking:! resolution of references among compilation units Ideal case:! JIT inserts the right address when compiling A class A { }......B.x class B { int x; } But...! B is delayed (loaded at first use)! Linking at first use Oberon Event 03 Patrik Reali: Jaos: Java on Aos 19

20 Linking Use code instrumentation to detect first access of static fields and methods B.x class A { }......B.x class B { int x; } CheckClass(B); B.x IF ~B.initialized THEN Initialize(B) END; Oberon Event 03 Patrik Reali: Jaos: Java on Aos 20

21 Exceptions void catchone() { try { tryitout(); } catch (TestExc e) { handleexc(e); } } void catchone() 0 aload_0 1 invokevirtual tryitout(); 4 return 5 astore_1 6 aload_0 7 aload_1 8 invokevirtual handleexc 11 return ExceptionTable From To Target Type TestExc Oberon Event 03 Patrik Reali: Jaos: Java on Aos 21

22 ! 100 Java for Aos Exception Handling / Zero Overhead try {... } catch (Exp1 e) {... } catch (Exp2 e) {... } pc start pc end pc handler1 pc handler2 Global Exception Table start end exception handler pc start pc end Exp1 pc handler1 pc start pc end Exp2 pc handler2 void ExceptionHandler(state) { pc = state.pc, exc = state.exception; } while (!Match(table[i], pc, exc)) { i++; if (i == TableLength) { PopActivationFrame(state); pc = state.pc; i = 0; } } state.pc = pc; ResumeExecution(state) Oberon Event 03 Patrik Reali: Jaos: Java on Aos 22

23 ! 100 Java for Aos Exception Handling / Zero Overhead! exception table filled by the loader / linker! traverse whole table for each stack frame! system has default handler for uncatched exceptions! no exceptions => no overhead! exception case is expensive system optimized for normal case Oberon Event 03 Patrik Reali: Jaos: Java on Aos 23

24 ! 100 Java for Aos Exception Handling / Fast Handling push catch descriptors on the stack try {... } catch (Exp1 e) {... } catch (Exp2 e) {... } pc handler1 pc handler2 use an exception stack to keep track of the handlers add code instrumentation try { save (FP, SP, Exp1, pc handler1 ) save (FP, SP, Exp2, pc handler2 )... remove catch descr. jump end } catch (Exp1 e) {... remove catch descr. jump end } catch (Exp2 e) {... remove catch descr. jump end } end: Oberon Event 03 Patrik Reali: Jaos: Java on Aos 24

25 ! 100 Java for Aos Exception Handling / Fast Handling void ExceptionHandler(ThreadState state) { int FP, SP, handler; Exception e; } do{ retrieve(fp, SP, e, handler); } while (!Match(state.exp, e)); state.fp = FP; // set frame to the one state.sp = SP; // containing the handler state.pc = handler; // resume with the handler ResumeExecution(state) pop next exception descriptor from exception stack can resume in a different activation frame Oberon Event 03 Patrik Reali: Jaos: Java on Aos 25

26 ! 100 Java for Aos Exception Handling / Fast Handling! code instrumentation! insert exception descriptor at try! remove descriptor before catch! fast exception handling! overhead even when no exceptions system optimized for exception case Oberon Event 03 Patrik Reali: Jaos: Java on Aos 26

27 Native Methods java class java loader java linker oberon stub implemented oberon stub type desc Java Methods Oberon Methods Oberon Event 03 Patrik Reali: Jaos: Java on Aos 27

28 Native Methods! Using this strategy, the Oberon implementation can:! define hidden types! define additional methods! define additional fields Oberon Event 03 Patrik Reali: Jaos: Java on Aos 28

29 Concurrency, Locking monitor_enter IF ~lockedbyself() THEN takelock(self) ELSE INC(count) END monitor_exit DEC(count); IF count = 0 THEN releaselock(self) END jjlobject.lock jjlobject.unlock Oberon Event 03 Patrik Reali: Jaos: Java on Aos 29

30 Concurrency, Synchronization Object = OBJECT VAR current, nextticket, count: LONGINT; native impl. of java.lang.object PROCEDURE wait*(); VAR t, count: LONGINT; BEGIN count := SELF.count; t := nextticket; INC(nextTicket); AWAIT((current - t) >= 0); SELF.count := count; END wait; PROCEDURE notify*(); BEGIN INC(current) END notify; simplified version (no timeout) PROCEDURE notifyall*(); BEGIN current := nextticked END nofifyall; END Object Oberon Event 03 Patrik Reali: Jaos: Java on Aos 30

31 Concurrency, Synchronization Thread = OBJECT(Object) PROCEDURE start*(); BEGIN Lock(SELF); state := running; Unlock(SELF); END start; BEGIN {ACTIVE} Lock(SELF); AWAIT(state = running); Unlock(SELF); run; state := dead END Thread; Oberon Event 03 Patrik Reali: Jaos: Java on Aos 31

32 Special Topics Interoperability Oberon source Java source Compiler Compiler Object File Object File Object File Object & Symbol Class File Reflection API Loader Linker Class Loader JIT Compiler Loaded Module Loaded Module Loaded Module Loaded Module Class Class Class Class Class Oberon Event 03 Patrik Reali: Jaos: Java on Aos 32

33 Special Topics Interoperability Oberon source Oberon Browser Java Reflection API Class File Compiler Metadata Object & Symbol Oberon Metadata Loader Java Metadata Loader Loader JIT Compiler Oberon Loader Linker Loader Linker Linker Loaded Loaded Loaded Class Module Module Loaded Module Oberon Event 03 Patrik Reali: Jaos: Java on Aos 33

34 Special Topics Interoperability IMPORT System := java/lang/system, String := java/lang/string ; VAR s: String.String; BEGIN s := String.valueOf(123); System.out.println(s) END Oberon Event 03 Patrik Reali: Jaos: Java on Aos 34

35 Conclusions Java Code Implementation Overview Oberon Code reflect/* Symbol Table Exception Handling Java Libraries (GNU Classpath) Loader OptCompiler Compiler Linker System Runtime InputFileStream OutputFileStream String FileDescr. Throwable Thread Object ClassLoader File Active Objects Aos Kernel Memory Mngmnt Module Mngmnt Files Oberon Event 03 Patrik Reali: Jaos: Java on Aos 35

36 Conclusions Implementation Overview 1076 JVM.Mod 1943 JVMBase.Mod 1252 JVMCompiler.Mod 1010 JVMCompiler0.Mod 432 JVMConsole.Mod 102 JVMConverter.Mod 1087 JVMDebug.Mod 3 JVMEmpty.Mod 583 JVMExceptions.Mod 176 JVMInterfaces.Mod 324 JVMLinker.Mod 1178 JVMLoader.Mod 2509 JVMOptCompiler.Mod 83 JVMParser.Mod 307 JVMRefs.Mod 331 JVMStubs.Mod 561 JVMSystem.Mod 390 JVMThreads.Mod 708 JVMTypes.Mod 363 jjifile.mod 91 jjifiledescriptor.mod 152 jjifileinputstream.mod 114 jjifileoutputstream.mod 69 jjiinputstream.mod 47 jjioutputstream.mod 182 jjldouble.mod 162 jjlfloat.mod 217 jjlmath.mod 57 jjlnumber.mod 279 jjlobject.mod 231 jjlsecuritymanager.mod 540 jjlstring.mod 327 jjlsystem.mod 211 jjlthrowable.mod 96 jjlvmclassloader.mod 53 jjlvmobject.mod 97 jjlvmsecuritymanager.mod 46 jjlvmsystem.mod LOC total some files like jjlstring.mod consists only of definitions! Jaos size: 27 modules 200 KB code 70 KB static data Classpath library: 1025 classfiles 3529 KB Oberon Event 03 Patrik Reali: Jaos: Java on Aos 36

37 Conclusions Benchmarks VM CPU Jaos P-II 700 MHz HotSpot 1.3 P-III 866 MHz 201 compress 202 jess 209 db Oberon Event 03 Patrik Reali: Jaos: Java on Aos 37

38 Conclusions Future Development! Release! Missing Pieces! network! GUI! Optimization! Deployment! Java on a floppy is possible:! Aos Kernel + Jaos ~600KB! Java Libraries ~700 KB (stripped down) Oberon Event 03 Patrik Reali: Jaos: Java on Aos 38