►
From YouTube: OMR Architecture Meeting 20200116
Description
Agenda:
* Port OpenJ9 shared classes implementation to OMR (#4687) [ @mthom ]
B
All
right
welcome
everyone
to
the
January.
16Th
puts
all
more
architecture
meeting
marks
sitting
in
for
Darrell
who
I
believe
sitting
on
a
plane
right
now,
today
we're
going
to
be
hearing
from
Mark
palm
about
his
work
to
port
the
open
design,
share
class
cache
technology
into
Eclipse
Lamar.
In
so
I
will
house
over
the
reins
to
Margaret
Haley
mark.
A
Great
okay,
so
this
is
a
high-level
overview
of
the
work
I've
been
doing
and
past
eight
or
nine
months
or
so
to
port.
The
open
j9
share
class
cash
over
to
eclipse
Alomar,
and
primarily
this
was
done
with
an
eye
to
towards
achieving
backward
compatibility
with
the
open.
J9
share
classes
cash,
but
also
done
in
such
a
way
that
would
enable
people
to
both
understand
the
cash
at
a
high
level
and
to
be
able
to
adapt
it
to
their
own
run
times.
A
So
let
me
just
try
and
see
if
I
can
figure
out
how
to
go
forward
in
this.
This
is
kind
of
mind
your
you
set
up.
Actually,
this
is
a
bit
new
to
me.
So,
let's
see
yeah
there
we
go
okay,
so
just
to
give
you
an
overview
of
what
I'll
be
presenting,
we
want
to
talk
about.
The
general
goals
of
the
shared
class.
Cash
is
realized
in
open,
j9
I'll.
A
Shared
cash
and
I
should
also
say
that
all
this
material
has
been
culled
from
the
paper
that
I
submitted
to
cast
20:19,
which
was
rejected.
Incidentally,
that's
a
much
deeper
dive
into
the
material
that
I'm
going
to
be
covering
here.
This
is
going
to
be
a
very
high-level
overview,
so
I.
Imagine
that
you'll
have
questions
from,
like
all
sorts
of
it's
actually
different
angles,
so
that
should
leave
us
some
time
for
a
discussion.
A
Okay,
so
just
remind
you
or
if
you're
gonna,
wear
the
goals
of
the
shared
class
cash
in
open
j9
is,
of
course,
to
share
a
various
dip,
various
kinds
of
data
between
multiple
running,
open,
g9
virtual
machines
and
are
either
running
within
the
same
process
space
or
across
a
network.
Or
what
have
you
and
examples
of
these
meta
data
include
both
Jedi
ot
compiled
code
to
read
only
portions
of
Java
classes,
strings
that
have
been
persisted
to
the
cache
JIT
profiling
data
and
quite
a
few
others,
not
good
enough
for
you
with
the
details.
A
A
So
if
we
start
at
the
lowest
layer
of
the
cache,
that
would
be
the
OS
cache
and
I'll
show
you
a
truncated
version
of
the
OS
cache
class
hierarchy
in
C++
in
a
minute,
but
generally
what
the
OS
cache
class
is
determined
is
a
manner
and
location
of
where
the
cache
is
located
in
memory,
and
it
determines
how
that
memory
is
accessed.
It
provides
primitives
to
the
caller
to
allow
that
memory
to
be
accessed,
to
be
synchronized,
to
enact
different
levels
of
page
protection,
there's
quite
a
few
different
things
that
you
can
do.
A
A
There's
this
function,
which
is
SH,
underscore
ROS,
cache
colon
colon
and
if
you
do
a
github
search
for
the
file
OS
cached
on
HPP
in
the
open,
j9
repository
github
you'll
find
it
that's
kind
of
a
nice
representation
of
how
the
cache
is
instantiated
according
to
I
believe
it's
command-line
options.
It's
been
a
while
since
I
reviewed
that
section
of
code
but
I
believe
that's
where
it
happens,
so
here's
the
promised
OS
cache
class
hierarchy.
A
So
you
start
at
the
top
for
the
most
abstract
level,
and
then
you
just
sort
of
drill
down
according
to
whether
the
caches
are
that
persistent
or
non
persistent.
So
persistency
means
that
cache
survives
between
separate
implications
of
open
j9
instances
just
to
say
that
persistent
cache
is
first
created,
then
after
the
last
connecting
VM
disconnects
from
it.
A
So
this
VI
think
it
comes
from
the
system
v
architecture
which
is
where
that
whole
set
of
inter
process
communication
primitives
comes
from.
But
of
course
it's
using
the
Oh
more
poor
library,
which
is
to
say
that
obviously,
it's
reach
is
much
broader
than
simply
systems
that
incorporate
or
descended
from
system.
B.
A
Okay,
so
that's
the
class
hierarchy
if
we
move
up
one
layer
of
abstraction
above
the
OS
cache
to
find
the
composite
cache
which
actually
implements
the
very
techniques
for
synchronizing.
Primarily
excuse
me:
yeah,
synchronizing,
the
allocating
memory
to
different
parts
of
the
cache,
those
parts
which
I'm
going
to
refer
from
now
on
as
regions.
A
A
And
it
said
this
layer
that
we
find
this
visual
representation
of
what
cache
block
looks
like
in
memory.
So
in
the
past
it
was
actually
possible
for
people
to
chain
multiple
instances
of
cache
blocks
together.
I
think
that
functionality
has
been
removed,
but
it
used
to
be
some
reason.
They
use
the
terminology.
Nested
cache
I
was
a
really
circular
reasoning
for
that
choice
of
name,
but
in
general,
if
we
suppose
that
the
cache
just
exists
on
a
single
contiguous
block,
this
is
the
layout.
A
A
So,
just
working
our
way
from
left
to
right,
we
find
that
the
ROM
class
segment
lists.
True,
the
name
contains
your
on
classes
and
when
I
said
it
grows
forward,
I
really
mean
that
it
just
goes
to
the
writes,
starting
at
the
left,
at
least
in
memory.
If
you
imagine,
this
segment
is
going
from
the
top
down
actually
marching
down.
A
A
And
lastly,
at
the
top
of
the
class
hierarchy,
we
have
a
cache
map
which
talks
to
the
cop
is
a
cache
object
and
a
cache
map
is
largely
a
runtime
layer
and
I.
Believe
it's
responsibility
at
startup
is
to
actually
iterate
over
the
entries
within
the
metadata
layer
and
to
fill
various
hash
tables
and
other
lookup
structures
at
the
runtime.
We
use
to
actually
retrieve
data
from
cache.
A
And
just
to
see
some
examples
of
these
hash
tables
that
are
organized
into
this
manager,
family
of
subclasses,
which
are
usually
specialized
around
the
type
of
data
that
they
manage.
So
it's
pretty
immediately
evident
from
the
examples
that
I
gave
here.
You
have
wrong
classes,
classes,
class
paths,
different
time,
stamps
many
others
of
course,
okay.
So
with
that
out
of
the
way
we're
about
repaired
to
talk
about
the
refactor,
no
less
cache.
A
Which
largely
tries
to
divvy
up
the
function
of
the
open
chain
in
classes
into
a
set
of
smaller
and
one
might
say,
more
intelligible,
more
specialized
classes
with
most
of
this
is
done
with
a
view
to
just
making
to
design
the
cache
a
bit
more
intelligible
to
an
outsider.
Someone
is
perhaps
using
Omar,
but
is
it
really
familiar
with
the
intricacies
of
how
inter-process
communication
works
or
exactly
how
the
open
junior
cache
does
things
and
what
we
want
to
achieve?
That
am
basic,
just
intelligibility.
A
So
the
cache
layout
is
a
manager
object
that
actively
owns
all
of
the
runtime
objects
that
represent
each
of
the
cache
regions,
and
it's
meant
to
allow
means
to
mediate
disputes
between
regions.
So
when
we
covered
the
composite
cache
layer.
A
moment
ago,
I
mentioned
to
you
that
the
ROM
class
segment
list
in
the
meta
data
area
allocate
toward
one
another
and
that
it's
possible
to
have
a
quote
unquote
dispute
between
the
two
if
they
try
to
allocate
too
close
to
one
another.
A
So
just
to
give
you
a
really
brief
idea
of
what
this
interface
looks
like.
We
have
these
three
pure
virtual
functions
in
C++
I
just
identified
the
start
of
the
region,
the
size
of
the
region.
Try
to
get
function
is
address
in
a
region
which
indicates
whether
item
an
address
of
a
certain
size
is
contained,
and
the
only
data
members
that
it
contains
are
told
you,
the
ID
and
a
pointer
to
its
own.
A
A
That's
just
the
general
idea,
as
I
said,
because
it
contains
pure
virtual
functions.
It's
in
effect
an
abstract
class
you'd
call
it
in
Java.
So
what
that
means
is
that
we
expected
to
be
subclass
and
for
the
subclasses
to
provide
those
methods.
So
the
only
subclass
of
the
region
class
that
I
provide
within
refactored
version
of
the
shared
cache.
It's
always
cache
contiguous
region
probably
track
the
aim
eventually
contiguous
region.
Just
is
what
it
says
in
the
Tim
is
just
a
contiguously
allocated
region.
A
The
OS
cache
region
base
class
tries
not
to
make
the
assumption
that
a
region
is
allocated
either
contiguously
or
in
any
other
way.
It's
just
a
general
interface.
It's
just
that.
We
have
this
thing
and
it
lies
it
somewhere.
In
memory
and
where
it's
stored,
oh
its
contents,
are
distributed
throughout
memory.
We
don't
really.
A
A
A
Very
often
that
involves
dealing
with
one
or
a
handful
of
words
within
the
header
so
know
as
cache
region
focus
is
essentially
just
a
pointer,
an
object
of
type
T,
because
the
template
cut.
Excuse
me
a
template
class
which
by
default,
cannot
be
receded
as
well.
It
contains
a
pointer
to
the
objects
region
of
residence.
Perhaps
I
should
say
field.
A
A
The
refactoring
that
I
do
apply
mostly
just
consists
of
C++
templates,
combined
with
just
Google
flash
and
polymorphism
just
virtual
functions,
mostly
templates,
so
I'm,
not
throwing
an
exception
in
the
case
of
the
balance.
Check,
fails
really
just
like
making
a
TRC
assert
within
the
body
of
that
constructor.
To
clarify
how
that's
done.
I
should
also
specify
that
it's
the
owning
region
that's
deferred
to
to
confirm
that
the
focus
is
contained
within
that
region.
A
A
In
this
case
the
plus
+
and
+
equals
operators
and
the
only
modifying
operators
defined.
But
beyond
that
there
are
comparison
operators
just
find
using
operator
overloading.
So
that's
no
big
deal
really
after
each
bump.
There's
again
bounce
check
using
exactly
the
same
means
that
I
described
in
the
previous
slide,
except
this
time,
rather
than
failing
with
fantasy
cert,
it
just
returns
a
null
pointer.
A
The
reason
for
doing
a
cert
at
instruction
time
in
this
case
is
likely,
because
this
is
something
that
you
would
expect
to
fail
at
cache.
Initialization
I
think
just
sort
of
an
assumption.
I
made
that's,
maybe
not
too
well-founded,
but
what
I
know
the
open
j9
cache.
That
type
of
thing
usually
causes
the
entire
thing
to
fail
by
thing.
In
the
last
instance,
I
just
mean
like
cache,
initialization.
A
Okay,
so
that's
regions
in
layout
now
the
next
topic
three
is
second
answer.
I
should
say
just
refers
to
configuring.
The
cache
which
I
assumed
to
occur
primarily
in
the
header
I,
do
have
a
separate
structure.
That's
dedicated
to
runtime
configuration
data
which
we'll
discuss
shortly,
but
just
focusing
on
the
header.
For
now,
we
should
note
that
the
OS
cache
M
map
and
sis
V,
the
previous
persistent
non
persistent
versions
of
the
O's
caching
over
time.
A
Yeah,
so
the
exact
configuration
and
contents
of
the
header
actually
varies
quite
widely
in
terms
of
which
fields
are
included.
What
order
they
appear
based
upon
the
Java
version
that
open
j9
is
running
a
generation
of
the
cache
as
a
designer's
term
did
that's
being
used
so
as
a
cache
changed
evolved
over
time
so
to
and
the
way
that
was
handled
in
open
j9
was
to
use
of
preprocessor
constants
I,
suppose
like
just
C
preprocessor
Flags
I
could
be
toggled
on
or
off,
so
just
able
or
disable
certain
parts
of
the
setup.
A
But
yeah,
if
you
want
to
have
some
idea
of
what's
capably
containment,
lis,
a
shredder
I
think
I
kind
of
alluded
to
this
before.
Actually,
but
this
case
we
have
the
eye
catcher
for
its
logs
of
creation
time
last
time
the
cache
was
attached
last
time
it
was
detached
again,
you
probably
also
find
like
the
VM,
ID
or
byte
logs
from
their
various
things.
A
But
the
point
is:
is
that,
depending
on
the
version
of
the
cash
and
cash
semantics,
the
contents
of
the
header
might
change
so
one
of
the
nice
things
about
C,
of
course,
is
just
being
able
to
manipulate
pointers.
Is
that
once
we've
instantiate
'add
a
struct
representing
the
contents
of
a
cache
header
on
the
stack
you
just
align
the
address
of
that
struct
to
point
to
the
head
of
the
cache
and
just
immediately
all
the
fields
of
that
struct
will
be
populated.
A
That's
quite
nice
to
do
that's,
obviously
much
less
error-prone
than
just
filling
that
all
hand,
dimension
less
verbose.
So
I
really
like
to
preserve
that
and
naturally
the
first
thing
that
I
reached
forward
to
try
and
accomplish
that
was
class
inheritance
in
C++
I
found
that
to
be
a
bit
too
and
flexible
even
for
open
j9,
which
is,
it
really
makes
a
fairly
conservative
approach
to
its
use
of
C++
over
C.
A
A
A
Oh,
along
with
renaming
the
OS
cash
M
map,
atlas
cache
this
VT.
These
I
also
introduced
these
header
classes
from
within
C++.
Just
to
encapsulate
all
the
header
logic
may
in
turn
own
these
header
mapping,
empathy
objects
which
in
turn
own
these
cache
header
mapping,
T
pointers,
which
actually
are
the
pointers
that
point
to
the
heads.
A
Excuse
me,
the
fields
of
the
cache
header
and
really,
and
often
it's
much
more
flexible
to
just
take
the
cache
header
mappings
that
I
have
defined
for
the
OS
memory,
mapped
cache
into
a
shared
memory
cache
and
to
just
compose
them
with
any
subclasses
of
these
mappings.
So
that,
like
if
I
introduced,
a
new
cache
which
inherits
from
OS
memory
mapped
cache.
For
instance,
and
I
introduce
my
own
custom
header
fields.
I
can
just
include
the
mappings
that
are
catered
toward.
The
core
OS
memory
mapped
cache
as
a
field
within.
A
You
and
combined
with
the
visitor
pattern,
which
is
kind
of
glorified,
slash
poor
man's
version
of
pattern
matching
for
C++.
You
can
reuse
a
lot
of
the
previous
logic
that
we
use
to
initialize
and
serialize
cache
headers,
so
I'm,
just
kind
of
introducing
this
sort
of
a
goofy
terminology
here,
so
serialize
just
means
that
the
cache
is
first
created.
A
The
header
has
to
be
set
up
and
when
the
cache
is
connected
to
or
attached
from
one
disk
or
say
a
shared
memory
snapshot,
certain
fields
may
need
to
be
updated
again,
but
they're
going
to
be
left
exactly
as
it
were.
So
it's
a
different
process
depending
on
whether
you're
creating
a
new
cache
or
just
initializing.
The
existing.
A
The
visitor
pattern
in
this
case
allows
you
to
better
match
over
different
object
types,
and
it's
particularly
nice
for
reusing
code
that
we
previously
used
to
visit
objects
belong
to
super
classes,
because
then
you
just
rerun
the
visitor
on
the
superclass
object
and
sort
of
append
our
own
logic
under
that
just
as
sort
of
an
addendum.
So
that's.
A
A
A
It's
at
least
an
open
j9
had
contains
like
a
lot
of
specialized
knowledge
about
the
amor
port
library
works.
So
part
of
the
idea
is
that
config
options
class
is
that
it
knows
how
to
talk
to
you
more
portly,
Brer
II,
but
it
represents
the
configuration
of
those
options
at
a
much
higher
level
to
the
user.
They
don't
necessarily
need
to
be
familiar
with
the
Omar
port
library
in
order
to
configure
the
cache.
So
you
can
use
a
builder
pattern.
This
is
all
in
another
builder
class.
A
A
few
excuse
me
in
the
open,
j9
should
cash.
There
are
several
instances
where
you
might
want
to
lock
the
cash
entirely,
which
is
to
say
that
you
want
to
forbid
all
rights
to
the
cash
until
we
say
so.
Well
forbid
is
a
really
the
word
that
I
want
to
use
this
block
yeah.
You
want
to
block
right
to
the
cash
until
some
rate
is
finished,
so.
A
So
it's
really
just
more
about
convenience
than
anything
memory
protections.
Another
instance
where
the
virtual
visitor
pattern
could
be
beneficial
say
if
memory
protection
policies
for
over
different
regions,
likewise
for
producing
CRC's
yeah.
So
once
you
fight
grappled
with
the
core
concepts
that
I
explained
in
the
previous
two
sections,
the
refactored
cache
will
see
that
the
additional
features
just
add
their
own
functionality
based
upon
what
we
saw
earlier.
So,
there's
really
not
much
more
to
elaborate
about
it
beyond
that.
A
If
you
want
to
see
a
demo
version
that
consumes
the
refactored
cash
over
the
summer,
Peter
Yankovic,
yogi,
Kree,
love
and
I
did
some
work
on
extending
Charlie
Gracie's
previous
extensions,
the
sound
plus
plus
Smalltalk
interpreter,
or
he
added
a
compilation
component
and
JIT
builder.
Prior
to
that
it
was
just
purely
a
small
talk
interpreter
we
adapted
that
to
use
the
revised
casts
to
store
its
own
internal
representations
of
small
talk
classes,
compiled
coach
relocations
of
various
types.
A
What
was
it
called
again
here,
yeah
prior
to
wagon
jet,
though
there
was
some
project
that
was
intended
to
be
a
reference
of
mutation
of
webassembly
binary?
Ok,
yes,
that's
right
rabbit;
ok,
they
added
a
JIT
to
wabbit
and
similar
manner
that
Charlie
edited
Southwest
boss
he's
a
JIT
builder.
So
we
did
some
work
with
that
as
well.
Just
storing
code
in
that
case
allows
them
is
a
much
simpler
and
less
dynamic
language.
Then
small
talks
of
many
ways
doesn't
post
the
same
technical
challenges
that
designing
a
good
for
small
talk
would
yeah
that's.
A
A
Yeah
I
have
a
talk
that
I
dedicated
to
that.
That
I
gave
a
cask
on
2019
if
anyone's
interested
in
the
slides.
Just
send
me
an
email,
I
suppose
I
told
you
all
about
the
first
item
already.
The
second
contain
some
example
uses
of
additional
features
that
I've
been
telling
you
about,
all
of
which
are
also
found
in
the
open,
genuine
shared
cache.
B
B
A
Open
j9
trade
cash
I'm,
not
really
sure,
with
the
priorities
of
the
designers
Mainers
are
currently
I
guess.
One
thing
this
could
offer
like,
as
I
said
before,
is
just
better
compartmentalization
of
various
features.
It
gives
a
person
a
better
idea
of
how
the
cash
is
organized,
how
it
operates
or
can
be
thought
to
operate.
I
suppose,
just
as
a
conceptual
model.
B
A
B
Is
that
representation?
Sorry,
you
talked
about
how
the
different
regions
are
are
built
in
the
open,
j9
cherry
kasha.
That's
similar
in
terms
of
those
the
the
Omar
shared
cache
that
you've
built.
So
it's
compiled
code
is
fits
into
the
metadata
type
section,
or
does
that
have
its
own
kind
of
suction
or
that's.
A
B
A
B
That's
one
more
question:
whether
separations
they
can
jump
in
I
wanted
to
ask
about
I
know
you
have
a
poor
work
that
you've
opened.
Is
that
do
you
have
a
do?
You
have
a
plan
in
mind
for
how
that
is
all
the
codes
you
talked
about
today
in
that
poll
requested
that
the
sum
total
of
everything
worth
in.
B
I
was
gonna,
make
that
observation
as
well,
but
it's
pretty
unapproachable
and
then
the
size
that
it
didn't
that
right
now
it
would
be
more
helpful
to
break
it
down.
Even
if
you
didn't
break
down
the
the
pieces
that
could
be
contributed
to
one
component
without,
like
maybe
the
support
library
changes
there
in
there,
it
could
be
separated
over.
You
know
that
kind
of
flavor
of
of
change
at
least
Geographic
breakdown,
yeah.
A
The
psalm
implementation
persists
code
to
the
cache
and
reloads
it
at
subsequent
startup
of
Assam
via
so,
whereas
a
a
ot
code
would
classically
go
to
something
like
an
O
file.
In
this
case
it
goes
to
the
cache
and
is
right
back
from
the
cache.
What's
the
VM
started.
So
as
far
as
a
ot
code
is
concerned,
it
just
serves
as
a
storage,
medium.
C
A
B
C
So
that
is
there
to
us,
that's
very
interesting
because
well,
unfortunately,
Yan
is
not
on
the
architecture
meeting
today.
He
can
even
can
speak
about
this
in
much
more
detail,
but
basically
our
interest
in
this
is
that
we
use
the
psalm
as
an
example
of
validating
the
risk,
5
port.
So
there's
there's
two
ways
to
validate
that
the
port
works.
At
this
point,
one
is
through.
C
Drill
tests
and
the
other
one
is:
we
run
some
four
plus
your
implementation
on
the
risk,
five
port
and
see
that
okay.
Well,
it
won't
not
only
does
it
work
on
Intel,
but
also
on
these
five.
So
if
parts
of
that
universe
are
ending
up
in
the
OM
our
code
base,
you
know
that
that
makes
that
makes
our
proof
of
validity
depend
on
less
external
code.