jx-poster.pdf

(2886 KB) Pobierz
JX
i
n
d
- A flexible Java Operating System
an
a
p
s
d
in
d
e
h
e
Global Heap
t
r
a
n
i
n
d
e
p
e
n
d
e
n
t
s
c
h
e
n
d
e
d
u
p
e
e
Domain A
Domain B
Threads
n
t
co
r
e
n
t
d
e
s
h
a
p
a
s
Heap
Heap
statics
statics
Components
Components
n
d
p
e
l
in
ri
n
g
Threads
local
sc heduler
g
traditional
JVM
JX
Heap of Domain A
e
n
t
G
C
local
sc heduler
Heap of Domain B
Domain A
Domain B
Heap of Domain C
global
sc heduler
Threads of one domain can be scheduled
independently of other domains. It is
possible to use domain-specific
schedulers that are written
in Java.
Each domain has its own heap that is completely
independent from the heaps of other domains. This is
in contrast to namespace-based domains of
traditional Java systems and allows independent
garbage collection runs, domain-specific
garbage collection implementations, and
domain termination with immediate
resource reclamation.
Shared Components
Immutable state can be shared between domains.
This includes compiled code and string
constants. Mutable state, such as static
variables, is created per domain which
makes code sharing completely
transparent.
Domain
Domain
Por tal
Service
Components
Threads
r
o
Threads
f
l
e
t
d
e
vice
d
ri
v
s
e
b
u
DRAM
Memory
Memor y
IRQ-Thread
AtomicV ariab le
Heap
Domain
Heap
Components
Heap
Heap
nf
l
e
c
o
ig
u
r
a
t
io
x
i
b
Configuration examples
FS
VFS
FS
ext2FS
Buffer
NFSd
RPC
ext2FS
Buffer
UDP
BlockIO
FS
VFS
FS
NFSd
RPC
UDP
n
rs
Components
Threads
virtual JVM
garbage collector
conservative
collector
copying
garbage
collector
mark&swep
garbage
collector
Heap
DeviceMemor y
Threads
DomainZero
domain
management
scheduler
portal
invocation
memory
management
component
management
virtual JVM
Java-level
scheduler
preemptive
round-robin
scheduler
non-preemptive
round-robin
scheduler
low-level
CPU management
virtual JVM
Memory
NFS Daemon
UDP
UDP
UDP
Device Driver Domain
Registers,
On-device
memory
FileSystem
BlockIO
BlockIO
IDE
UDP
IP
Ether
NIC
BlockIO
JX
All device drivers are written in Java and benefit from
the robustness that is provided by type safety.
Robustness is further supported by special
portal interfaces that allow drivers to access
device registers and interrupt handler
threads to synchronize with other
threads.
Domain
Manager
Naming
IP
Ether
NIC
IDE
BlockProvider
µKernel
garbage collector
support framework
Network
monolitic NFS Server
monitoring
Runtime System
DomainZero Portals
The protection domain structure is independent
of the component structure. Components
can be placed into the same or in
separate domains without
changing them.
Hardware
c
u
g
r
i
t
a
n
d c
on
ta
in
y
Heap
rfor
d
p
e
m
a
n
c
o
o
IOZONE benchmark: JX vs. Linux
record size in KBytes:
4
8
16
32
64
128
256
512
%
achieved throughput in percent
s
e
Components
Threads
100
90
80
70
60
50
40
30
20
10
0
4 8 16
o
m
c
a
t
i
s
e
r
v
ic
e
c
r
e
a
t
Domain B
Security
a
u
t
m
e
n
t
check
e
(1)
Service
Object
Domain A
(2)
Service
i
o
n
Heap
Heap
Domain A
(3)
32
64
128
256
filesize in KBytes
512
Service
Domain B
Por tal
transfer portal
Components
Threads
Components
Threads
Domain A
Domain B
Domains are isolated and can communicate only via
dedicated channels: the portal objects. The JX
security system can control the propagation of all
portals as well as their use. The security system
that contains the security policy is separated
from the domains and can be
exchanged without changing the
application domains.
Domain A
Domain B
The performance of JX compares well with a
traditional UNIX system, such as Linux. Our ext2-
compatible file system, which is completely
written in Java, achieves a throughput of
50 to 100 percent of Linux in the
IOZONE re-read
benchmark.
A service is automatically created when a service
object is passed to another domain. This includes
the creation of a new service thread or the
addition of the service to an existing
thread pool. The other domain
receives a portal to the
service.
m
l
i
g
h
t
-
w
e
i
g
a
t
i
o
n
w
i
t
h
m
i
n
r
h
t
ctio
n
a
r
o
t
e
n
d
p
a
u
t
o
m
a
t
i
c
m
en
t
o
f
a
g
e
m
a
n
Domain A
Memor y
i
at
e
r
e
so
m
e
d
m
i
before
termination
Por tal
e
m
c
e
u
r
©
2002 JX-Team
A protection domain is a complete Java execution
environment but has a very low memory footprint.
Creating 1000 domains that concurrently print
“Hello World!” in a loop requires about 35
MBytes, creating 1000 domains that
concurrently serve 1000 TCP
connection needs 105
MBytes.
t
e
University of Erlangen-Nuremberg
Department of Computer Science
Michael Golm
•
Meik Felser
•
Christian Wawersich
•
Jürgen Kleinöder
s
c
a
la
b
il
ity
DRAM
Memory
Memory
after
termination
Por tal
o
r
y
Heap
Invalid
re
c
l
a
m
a
ti
o
Heap
Service
Heap
a
re
a
s
Memor y
Reference
Counts
Domain A
Por tal
Heap
Domain A
Invalid
Por tal
Domain C
Heap
Heap
Heap
Domain B
Domain B
Domain B
JX provides a special abstraction
–
memory portals
–
to cope with large memory or special memory
areas, such as memory-mapped device
registers. Memory portals can be
shared between domains and are
garbage-collected.
Except device driver domains all domains
can be terminated immediately and
their resources can be released
completely.
n

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin