►
From YouTube: OMR Architecture Meeting 20201022
Description
Agenda:
* Port library initialization with JitBuilder and OMR compiler (#1644) [ @0xdaryl ]
A
Welcome
everyone
to
this
week's
omar
architecture.
Meeting
this
week
we
have
one
topic
to
discuss.
I
apologize
for
the
sort
of
rush
nature
of
it.
I
only
had
a
short
amount
of
time
to
prepare
for
it,
but
I'm
hoping
that
we
can
make
some
some
progress
on
it.
It
is
a
bit
of
an
older
issue
that
that
we
wanted
to
make
some
some
headway
on
for
for
quite
some
time,
and
that
is
using
the
port
library
within
the
compiler
or
the
jit
builder
components.
A
We
had
a
talk
at
the
omr
architecture
meeting
about
two
and
a
half
years
ago
in
early
2018
and
at
that
time,
when
we
I'm
going
to
try
to
summarize
the
discussion
from
that
time.
But
what
basically
happened
there
was
we
wanted
to
talk
about
a
similar
topic,
but
it
sort
of
evolved
into
a
broader
architecture,
discussion
around
omar
component
initialization
and
how
it
should
be
done,
and
there
were
many
aspects
of
that
kind
of
of
that
discussion.
A
I
think
I
mean
I
think
there
were
a
lot
of
good
points
that
were
that
were
brought
out
in
there,
but
I
don't
think
that
there
were
a
lot
of
concrete
actions
that
that
came
from
that.
But
some
of
the
some
of
the
discussions
that
happened
were
around
what
are
the
actual
components
within
omr
that
we
that
we
really
care
about
and
and
that
should
be
initialized.
A
What
are
the
dependencies
between
the
various
components?
It's
not
really
clear.
So
there
was
some
desire
to
have
more
documentation
on
how
the
different
components
are
dependent
on
one
another
and
what
the
initialization
path
would
would
look
like,
and
then
there
was
some
discussion
around
whether
or
not
these
independent
components
are
truly
independent
in
the
sense
that,
even
though
you
may
not
be
using
a
particular
component,
you
still
have
to
build
it
into
your
product
that
that,
like
you,
you
can't
just
build
it
out
it.
A
A
We
also
had
a
a
bit
of
a
discussion
around
the
various
the
role
of
various
data
structures
and
what
they
mean.
If
you
look
outside
of
the
compiler
and
jit
builder,
you'll
see
references
to
the
omr
vm
structure,
the
omrvm
thread
structure,
there's
an
omr,
runtime
structure,
language
thread,
language
vm.
A
A
There
was
some
concerns
that
were
raised
on
specifically
about
the
port
library
and
and
using
the
port
library
within
certain
components,
how
the
how,
if
multiple
components,
need
to
use
the
same
component
like
the
port
library?
How
does
that
actually
get
initialized?
What
is
you
don't
want
to
be
initializing,
your
own
port
library,
if
one
has
already
been
created
and
initialized,
so
the
discussion
went
on
about
how
do
you
discover
that
a
port
library
is
available
and
then
there
are
ones
around
that?
A
But
the
one
thing
that
we
eventually
all
seem
to
agree
on
was
if
we
were
going
to
redo
the
initialization
approach
for
all
these
different
components.
What
would
it
look
like,
and
it's
essentially,
we
agreed
that
initialization
should
probably
follow
a
three-step
approach.
The
first
is
to
do
a
process-wide
initialization,
which
would
include
things
like
the
port
library
and
the
thread
library.
A
The
next
phase
in
that
would
be
a
vm
wide
initialization,
which
includes
things
like
the
gc
and
perhaps
some
parts
of
the
compiler,
and
then
there
would
be
a
thread
specific
initialization
or
a
vm
thread
specific
set
of
initialization.
That
would
take
care
of
the
example
that
was
given
were
some
sub-components
of
the
garbage
collector
that
needed
that
kind
of
granularity.
A
So
there
was
agreement
that
that
was
the
way
that
we
should
go
at
that
time.
Robert
young
was
working
on
some
gc
object,
model
work
and
a
gc
builder
component,
and
he
had
already
done
some
refactoring
of
the
gc
in
his
own
branch
to
to
test
out
that
kind
of
an
initialization
scheme,
and
he
found
that
it
that
he
was
able
to
get
that
to
work.
So
there
was
definitely
some
some
positivity
there
going
forward.
A
A
The
thinking
on
that
has
to
go
a
lot
deeper.
I
think-
and
it's
it's
more
it.
It
requires
more
effort
than
I
think
that
we're
prepared
to
to
put
into
that
at
this
point.
So
I'd
like
to
talk
just
about
jit
builder
and
compiler,
using
the
I
mentioned
that
we've
already
got
a
build
dependence
on
the
port
library,
which
is
good.
A
A
The
understanding
is
that
the
the
port
library
and
thread
library
need
to
come
as
a
pair,
so
we
have
to
initialize
both
so
create
them,
initialize
them
and
then
hang
a
pointer
to
the
port
library
off
of
the
compiler
end
structure,
openj9
biggest
consumer
of
omr
already
does
this:
they
have
a
port,
a
pointer
to
the
port
library
living
on
the
their
specialization
of
the
compiler
and
structure.
So
in
the
open,
j9
code
itself,
the
compiler
code,
they
do
use
the
port
library
from
there.
A
A
So
I
think
that
in
order
to
do
that,
we
should
simply
just
harvest
the
code
that
lives
in
the
omr
initialized
vm
structure,
the
the
you
know,
20
30
lines
of
code,
that's
already
there
to
initialize
the
thread
in
the
port
library
and
simply
can
simply
reuse
that
the
challenge
is
one
of
the
challenges
is
that
there
isn't
really
any
standard
api
for
initializing,
the
compiler
or
jit
builder.
I
know
that
we
have
a
like
an
initialized
jit
builder
function.
A
There's
an
initialized
test
jet
function,
other
language
environments
that
are
consuming
omr
have
their
own
initialization
methods.
There
isn't
really
sort
of
a
standard
api
for
that,
but
the
things
that
they
have
in
there
are
somewhat
similar
in
the
sense
that
you
create
a
raw
allocator.
You
have
to
create
a
compiler
infrastructure.
You
have
to
initialize
that
compiler
and
structure,
depending
upon
the
environment
that
you're
in.
So
I
think
as
part
of
that
sort
of
series
of
steps
that
all
these
different
language
environments
take.
B
D
B
D
Good
question,
so
I
remember
one
of
the
issues
when
we
talked
about
this
last
time
was
that
you're
not
really
supposed
to
have
more
than
one
port
library
that
there
are
at
least
historically
there
have
been
some
problems
that
have
arisen
when
a
second
port
library
was
attempted
to
be
created,
so
it
really
is
kind
of
a
singleton
type
thing,
as
I
understand
it
anyway.
Unfortunately,
there's
nobody
there's
nobody
from
the
non-jet
team.
D
On
the
call
right
now
to
to
help
us
understand
that,
so
we
might
want
to
follow
up
with
some
people
on
this,
but
but
my
understanding
is
that,
where
there's
only
supposed
to
be
one
port
library
in
the
whole
process
or
maybe
per
vm,
so
so
somebody
has
to
create
it.
I
was
just
like.
While
daryl
was
talking,
I
was
going
to
look
at
the
the
the
walmart
startup
code.
D
I
mean
it
basically
just
has
a
static
variable,
that's
the
port
library,
and
then
you
end
up
using
passing
a
pointer
to
that
thing
around.
So
I
guess
the
question
is,
I
mean
there's
going
to
be
a
bunch
of
example,
uses
out
there
of
people
who
are
probably
leveraging
similar
code
to
what's
in
that
omr
vm
startup
online,
either
creating
their
own
port
library
or
there's
some
port
library
being
created
at
some
point.
D
And
if
it
creates
its
own,
then
you
run
into
this
potential
problem
where
others
might
have
created
it,
and
then
I
guess
jet
builder
has
the
same
issue
right.
If
you
want
to
use
jit
builder
inside
something
else,
then
you
might
have
already
allocated
your
own
port
builder,
sorry
port
library,
but
if
you
want
to
be
just
using
jit
builder
in
a
stand-alone
universe,
when
you
call
initialized
jit,
that
really
should
be
creating
the
port
library
in
this,
this
new
world
that
daryl's
describing.
A
So
we
did
talk
about
that
last
time
and
I
think
that
that's
one
of
the
solutions
that
came
up
was
actually
just
to
provide
two
apis,
one
like
an
initialization
api
for
jit
builder.
That
provides
a
port
library
and
one
that
doesn't.
And
if
you
don't
provide
one,
then
you
are
on
your
own
to
go
ahead
and
or
you
should
feel
free
to
go
ahead
and
create
one
and
initialize.
A
D
A
D
So
that
might
also
depend
on
what
parts
of
the
port
library
that
the
compiler
component
ends
up
using
right
like
if
it.
If
it
really
is
only
the
cpu
detection
stuff,
then
maybe
that's,
maybe
that's
a
facility
that
you
can
tolerate,
having
two
copies
of
the
port
library,
because
you'll
just
you'll
just
double
up
the
queries
from
you
know,
you'll
ask
the
same
query
of
different
objects
and
it
will
give
you
hopefully
the
same
result,
but
it
won't.
There
won't
be
any
like
state
like.
D
D
D
D
D
The
other
problem,
with
the
the
what
you
what
you
described
for
the
approach
for
jit
builder,
would
be
that
the
projects
which
have
their
own
port
library
and
use
jitbuilder
those
would
all
have
to
be
updated
since
they
would
be
in
their
own.
Like
you,
the
the
way
that,
by
default,
calling
initialize
jet
would
be
would
be
going
would
be
going
to
create
a
a
second
port
library.
I
guess.
D
D
A
D
B
A
A
I
was
thinking
we
could
lift
the
30
lines
or
so
of
code
from
omr
initialize
vm.
I
don't
think
that
omr
initialized
vm
should
actually
be
the
function
like
it's
called.
I
think
it
should
be
just
because
we
don't
need
everything.
That's
in
there
to
do
this.
It's
almost
like.
We
would
create
our
own
either.
We
provide
a
function
in
the
port
library
to
do
this
or
we
create
our
own.
Let's
say
that
lives
in
the
omr
compiler
that
is
responsible
for
initializing,
the
port
and
and
thread
library.
A
D
A
I
didn't
see
that
I,
I
wasn't
actually
even
sure
of
the
dependency
between
the
thread,
library
and
the
port
library,
because
I
can't
see
where
the
connection
is
being
made
between
them,
at
least
in
that,
if
you're
looking
at
omr
initialize
vm,
I
don't
see
the
code
that
actually
makes
the
there's
no
pointer
from
the
port
library
to
the
thread,
library
or
or
vice
versa.
So
I'm
not
sure
what
the
what
the
dependency
there
is.
D
A
Yeah
I
could
pick
on
somebody
right
now.
Nazim
who's
actually
done
this
in
the
past.
Did
you
do?
I
don't
know
if
you
recall
the
code
that
you
wrote
there,
but
I
know
you
have
initialized
the
port
library
within
within
jet
builder.
Did
you
have
to,
I
think
you've
had
a
relatively
smooth
experience
with
it.
It
wasn't
like
it
was.
You
had
to
do
a
lot
of
jump
through
a
lot
of
hoops
for
that.
C
Now
we
were
doing
that
quickly,
yeah,
yes,
for
the
remember
it
wasn't
that
complicated
to
just
pass
an
initialized
quote
library
into
initialize
it.
I
had
to
change
the
api
to
accept
that
and
then
that
was
fine
and
well.
I
don't
remember
much
of
the
details,
but
I
probably
might
be
able
to
get
the
code.
A
A
I
guess
one
of
the
things
to
make
to
make
the
discussion
of
this
a
little
bit
easier
and
perhaps
easier
to
to
broaden
to
other
to
pull
in
other
people.
It
might
be
useful
to
actually
have
a
some
kind
of
a
pull
request
like
a
work
in
progress,
pull
request
just
so
that
there's
some
real
code
in
front
of
people
to
actually
visualize
and
see
what
this,
what
this
would
actually
look
like.