►
From YouTube: OMR Compiler Architecture Meeting 20180815
Description
This compiler architecture meeting discussed requirements for refactoring the Options processing in the compiler.
Please add any comments/questions to the GitHub agenda issue: https://github.com/eclipse/omr/issues/2842
A
B
C
Thank
you
Darrell.
So
thank
you
all
for
coming
to
this
meeting.
So
today,
I
am
going
to
be
talking
about
the
plan
to
rework
the
options
processing
framework,
and
this
has
been
a
topic
that
I
here
has
been
brought
to
the
discussion
table
a
number
of
times
in
the
past,
but
now
that
omr
is
an
open
source
project.
It's
very
important
now
that
we
make
things
easier
to
deal
with
when
it
comes
to
options
processing
so
that
new
developers
coming
into
working
with
the
project
has
a
much
easier
time
dealing
with
it.
C
You
look
up
information
regarding
options.
There
is
a
no
consistent
way
of
looking
things
up
within,
like
per
compilation
context.
Often
that
efficient
gets
the
passed
on
to
like
a
code
generator
or
the
global
options
object
and
so
on,
but
it
should
really
be
something
something
simpler
where
there
is
a
central
querying
mechanism
and
we
are,
and
whatever
needs
to
be
delegated
to
other
places
can
be
delegated
accordingly.
C
So
that's
one
limitation
that
needs
to
be
addressed
as
well.
Another
issue
is
the
option.
Names,
so
they
don't
really
follow
any
kind
of
consistent
pattern,
so
some
options
that
are
boolean.
They
contain
boolean
values,
so
they
have
a,
for
example,
the
name
of
a
feature
and
and
and
then
it's
assigned
true
or
false,
and
some
of
them
have
boolean
values
but
have
like
enabled
that
certain
feature
is
enabled
and
then
now
it
has
true
or
false
to
that.
C
And
another
limitation
is
that
in
the
options
table
items
structure,
we
actually
have
to
order
everything
in
an
alphabetical
order,
which
is
one
of
the
kind
of
barriers
that
many
developers
will
choose
to
add
their
options
there,
and
it
is
just
another
barrier
and
if
we
can
get
rid
of
that,
it
would
be
nice.
It's
probably
not
a
very
major
problem,
but
it
is
still
something
that
may
be
worth
solving
and
another
issue
we
have
a
limitation
we
have
is
that
the
user
cannot
output
the
list
of
options
that
are
in
effect
easily.
C
So
can't
really
know
like
what
exactly
is
going
on
and
what
kind
of
options
can
I
try
totaling
right
now
to
see
the
outcome
so
like
having
such
an
mechanism
would
be
nice
and
also
another
limitation.
Is
we
don't
have
any
options,
compatibly
checking
mechanism
so
some
of
the
options
they
conflict
with
one
another
and
sometimes
the
only
way
to
know
that
they
don't
think
you
can't
really
apply
to
your
different
options.
C
So
another
problem
is
that
we
don't
really
have
too
much
documentation
on
how
to
add
options
on
that.
The
existing
documentation
is
more
about
how
to
use
them
and
where
to
look
up
in
options,
but
when
it
comes
to
adding
there
isn't
really
much
documentation
on
that
and
I
think
having
that
would
help
new
developers
make
use
of
it.
So
these
are
limitations
that
are
primarily
driving
the
third
plan
to
rework
the
framework,
and
in
order
to
do
that,
there
are
certain
things
that
we
are
going
to
do.
C
Okay,
so
like
the
first,
you
think
that
we
plan
to
do
is
specializing
the
TR
options
into
more
specialized
classes
and
creating
a
central
feature
querying
mechanism
that
is
more
compilations
right,
specific
and
and
checking
to
see
whether
it
causes
any
significant
performance
regression
and
we
do
implement
it,
because
one
huge
advantage
of
the
current
options
processing
framework
is
that
it
is
a
very
efficient
and
it
is
going
to
be
very
hard
to
beat
when
it
comes
to
the
runtime
performance.
A
given
number
of
pouring
that
happen
within
the
compiler
okay.
A
I'm
not
really
sure
what
more
specialized
classes
means
like
I,
don't
know
what
the
delineations
are
that
make
any
sense
in
that
big
blob
of
joy,
that
we
all
work
on
I'm,
not
clear
on
that.
I
would
also
say
that
degradation
in
performance
when
it
starts
impacting
compile
time,
will
not
encounter
huge
tolerance
in
the
Java
world
right
like
if,
if
the
options
query
and
gets
significantly
slower,
there
will
be
a
lot
of
resistance
from
the
open
j9
project
to
a
dot.
A
B
B
At
Rutan,
but
I
mean
I
think
the
problem
that
one
of
the
problems
that
exists
with
the
options
class
at
the
moment
is
that
it
does
suffer
like
other
parts
of
the
compiler
just
suffer
with
a
bit
of
a
conceptual
integrity
thing
where
it
tends
to
do
a
lot
of
different
things.
I
think
the
separation
that
regime's
talking
about
is
really
identify.
What
those
sort
of
independent
pieces
are
a
processing
of
the
actual
processing
of
the
command
line.
B
C
Yeah
so
the
answer.
The
first
question
you
had
about
what
the
different
components
are
so
limited
cause,
for
example,
are
basically
totally
handled
by
the
options
class
and
so
is
a
processing
of
each
of
the
each
of
the
different
options
and
I
think
they
should
be
in
a
different
place.
Instead
of
a
place
that
contains
the
information
that
is
needed
by
the
rest
of
the
code
acquiring
from.
C
C
A
It
so
that
we
can
have
options
that
apply
to
subsets
that
it
can
be
put
into
sub
project
like
projects
that
derive
from
form
R.
So
one
of
the
major
pain
points
for
the
open,
j9
project
at
the
moment
is
that
there
are
options
that
exist
in
the
current
for
more
options:
dot
CPP
that
are
very
clearly
open,
j9
options.
They
are
there
to
control
open
j9
behavior,
but
they
need
to
apply
and/or,
be
used
in
a
subset
context,
where
you're
going
to
match
a
method
or
my
nation
level.
A
Yes,
and
at
the
moment
for
to
have
that
work,
the
option
has
to
be
in
Omar,
so
there's
a
significant
number
of
pull
requests
where,
basically
it's
the
addition
of
an
option
which
is
not
used
by
Omar
in
any
way
shape
or
form
then
be
consumed
in
open
j9,
because
the
open
j9
option
is
processing.
Logic
cannot
deal
with
that.
So,
even
if
all
we
got
working
was
that
you
would
cut
a
fair
amount
of
churn
out
of
the
Omar
codebase
from
open
to
nine
people,
just
sort
of
blendering
through
drop.
C
So
getting
to
that
which
is
the
is
something
that
you
know,
I
really.
You
know
we
really
want
to
see,
but
at
this
time
like
how
that's
going
to
turn
out
I,
don't
really
have
a
clear
answer
on
that
figure
because,
of
course,
I
need
to
go
forward
with
some
the
refactoring
work.
That
needs
to
be
done
and
then
be
like
what
can
be
done
about
separating
the
open,
j9,
specific
options
from
or
more
options.
I.
A
Think
is
also
some
sidious
dependencies
that
are
going
to
have
to
be
looked
at
because
it's
possible
to
change
options
during
compilation,
and
there
are
parts
of
the
optimizer
that
rely
on
that
behavior
there.
Certain
optimization
does
or
does
not
do
something.
It
enables
or
disables
something
that
behavior
can
be
very
subtle.
And
if
you
change
how
all
that
work,
you
may
introduce
some
very
subtle,
bugs,
not
functional
but
possibly
even
performance,
bugs
where
you
can
get
very
strange,
behaviors
from
a
system
using
options
to
do
that.
There.
B
Are
parts
of
the
code
that
do
use
options
so
one
of
the
one
of
the
problems
I
think
that
that
you
can
get
in
too
much
detail.
But
if
you
actually
look
at
what's
in
the
option,
it
actually
has
a
lot
more
responsibility
for
making
decisions
about
even
which
method
gets
compiled
and
how
it
gets
compiled
and
stuff
like
that,
and
it
probably
should
it's
not
just
an
optional
process
for
having
a
little
do
contain
only
respects
or.
C
A
A
B
A
Too
many
other
things
too,
looking
nonsense.
These
are
the
gory
bug
in
that
code.
Yeah
for
item
number,
three
be
very
careful
with
TR
enable
OS,
R
and
T
are
disabled.
Os
are
they
are
not
inverses
of
one
another
are
confusing.
Oh,
it's,
the
most
awful
awful
option,
processing
logic,
I.
Think
in
probably
the
whole
thing,
TR
enable
OS,
R
and
T
are
disabled.
Os
are
not
inverses
of
each
other
and
they
are
set
differently
in
different
places
of
the
code.
Other
have.
B
A
A
The
turn-on
renames
the
option,
as
well
as
flipping
the
bit
okay,
but
the
enable
OS
are
a
disabled.
Os
r
is
one
that
I
know
didn't
go
through
that
process
and
actually
different
tentacles
of
grow
notable
parts
of
it.
There
have
been
at
least
two
attempts
to
fix
that
and
we
all
just
got
befuddled
by
exactly.
F
C
A
D
D
A
Pretty
religiously
that
you
know
disabled
is
like
going
to
be
like
the
state
is
incumbent
like
the
default
state
is
encoded
in
the
name,
so
that,
when
you're
reading,
if
option
blah
blah,
you
know
what
sense
the
test
needs
to
have
for
it
to
work
by
default,
and
if
you
remove
the
enable
or
disable,
then
the
piece
of
logic
that
you
need
to
test.
Whether
the
condition
has
the
correct
sense,
whether
it
should
be
a
positive
test
or
negative
test,
then
have
to
be
done
by
referencing.
Whatever
the
default.
C
So
another
you
know
feature
discussed
was
having
some
sort
of
like
a
configuration
file
so
just
like,
we
can
specify
a
purpose
loud
now,
like
maybe
in
the
command
line.
We
can
specify
a
configuration
file
from
which
options
can
be
read
in
that
way
it
presents
the
us
having
to
re-enter
options
again
and
again,
especially
when
it's
like
a
long
set
of
options.
So
what
are
your
opinions
on
that,
and
how
do
you
think
would
be
the
best
way
to
implement
such
a
thing.
C
The
format
of
it
is
like
it
should
have
like
you
know,
all
the
options
that
are
like
one
way.
One
thing
we
can
do
about
it
is
like
the
default
values
probably
could
be
out
of
that
config
file
and,
in
that
way,
like
they
user
can
easily
know
that.
Okay,
these
are
the
quantifiers
and
I
can
just
toggle
them,
and
another
option
is
just
being
able
to
have
like
the
config
files.
C
C
E
D
F
A
B
Going
to
be
and
correctly
if
you're
thinking
is
wrong,
but
I
think
the
the
there
are
still
going
to
be
a
number
of
ways.
You
could
potentially
input
options
settings.
However,
you
want
to
restrict
it
a
bit
as
well
that
we
have
an
environment
variable
approach
right
now,
with
Evan
get
in
there's
command
line
stuff,
but
then
there's
other
environment
variables
as
well,
they're
also
being
consumed.
We
probably.
B
As
much
as
possible,
reduce
that
to
one
Nazim
was
talking
about
it
again
and
view
is
like
early
on
in
the
JIT
lifecycle
at
the
moment,
the
only
way
that
we
can
actually
consume
any
kind
of
or
affect
any
behavior
externally
is
with.
If
you
get
in,
because
options
aren't
available
point
so
I'm
talking
about
getting
rid
of
that
dependency
early
on
I
think
that
there
are
some
scenarios
where
it's
difficult
to
get
access
to
the
command
line,
it's
probably
more
easier
to
actually
inject
an
environment
variable.
So
if
we
needed
influence
behavior
so.
D
B
D
About
how
you
specify
options
or
not
right
up
to
the
run
time,
to
decide
what
adults
look
like
like
enabling
the
district
jets?
Could
it
be
decade
it?
Should
it
be
you
whatever,
like
the
run?
Pun,
wants
it
to
be,
and
then
somehow
that's
it
I'm,
enabling
that's
just
a
bad
example,
but
I
may
not
be
not
every
run.
Time
is
necessarily
going
to
want
to
add
a
command
line.
Option
that
looks
reasonable.
B
D
Guess
it
comes
down
to
so
then
the
second
question,
I
guess,
is
related.
So
this
is
a.
This
was
identical
because
is
that
this
meeting
and
it
was
specific
identified
as
affecting
how
compiler
options
work
and
we've
been
talking
primarily
about
how
to
react,
effective,
piler
options,
stuff,
I,
guess
the
question
becomes
why?
Why
is
why
does
this
have
to
be
just
a
compiler
options?
D
Question,
and
if
you
broaden
it
to
more
than
just
a
compiler
options
question,
then
you
lose
what
you
just
said,
because
now
you've
got
or
I
guess
you
you
end
up
asking
runtimes
to
provide
a
omar
option
which
gives
you
all
the
options
for
all
of
all
more
not
just
as
a
kid
I
mean
I.
Think,
there's
some
larger
questions
here
around.
D
What
does
it
mean
to
be
consumable
for
language?
Runtime
can
specify
options
and
be
able
to
configure.
Is
it
it
it
strings?
This
is
string
the
currency
of
indicating
options
to
between
omar
and
run
time.
Is
it
some
type
of
configuration
structure
is
another
valid
way
of
doing
it.
The
finest
truck
got
a
little
bunch
of
stuff
in
it,
as
well
as
technology.
D
For
changing
it
and
you
pass
in
the
script
as
part
of
your
initialization
for
more
I,
don't
know,
painters,
I'm,
not
saying
that's
a
good
way
to
do
it
under
saying
that's
another
way
you
could
do
it
doesn't
handle
options,
that's
very
well,
but
module
that
I
guess
thinking
about
how
it
is
that
another
language
runtime
would
want
to
communicate
its
values.
Maybe
not
just
one,
certainly
not
just
open
j9
anyway,
because
we
have
erage.
There
already
works
that
way.
D
D
You
don't
want
to
ask
a
ruby
or
a
Python
or
whoever
to
be
putting
things
into
their
environment
so
that
they
can
configure
a
component
that
they
build
with.
That's
just
an
own
I
think
that
the
non-starter
approach
it's
just
kind
of
the
way
or
where
we're
at.
But
what
is
the
preferred
mechanism?
I
guess
it
still
strings
that
something
else.
I
guess
those
are
some
of
the
larger
questions.
I've
got
around
this.
Don't
really
have
feeling
for
I,
guess:
I'm
curious.
What
other
people
think
that
way?
I.
D
Right
so
there's
so
there's
some
attraction
to
that
I
think
because
it
would
allow
us
to
forgive
the
word:
divorce,
open,
G,
nines,
often
processing,
which
is
obviously
set
up,
a
particular
way
around
strings
that
they're
a
grown
to
know
and
love
and
rely
upon,
and
it
would
allow
all
Marr
to
you
know
possibly
adapt
that
syntax
30
covers
if
it.
If
a
better
syntax
would
be
more
appropriate.
B
D
Consume
regardless
on
how
that
gets
produced
right.
So
if
we're
going
to
react
effect,
options
for
something
if
people
wore
layer-
and
we
have
this
big
heavyweight
consumer
cold,
open,
genuine,
which
has
built
a
bunch
of
its
operating
options,
processing
on
top
of
the
Omar
facilities
in
compiler
and
outside
the
compiler.
So
it
kind
of
has
this:
like
multiplicity
of
options,
implementation,
it's
going
to
be
really
hard
to
reaaargh,
attacked
I,
think
at
people
Willmar
layer
without
being
forced
to
do
it.
Also
at
the
open,
j9
layer.
D
You
know
what
I
mean
like
there
will
have
to
do
a
crapload
of
work
in
Willmar
already
that
this
is
look
we're
changing
a
fairly
fundamental
infrastructure
pieces
of
the
compiler
and
hopefully
Omar
eventually
like
the
rest
of
Omar
as
well,
but
I,
don't
think
we
can
get
away
with
doing
that
without
also
doing
exactly
the
same
things
in
open
j9,
which
is
other
load
of
code,
that,
yes,
we
are.
We.
We
know
the
developers
who
are
able
to
make
such
changes,
but
it
just
makes
the
job
that
much
harder.
Thank.
D
I,
don't
think
you
can
avoid
that
I
agree.
I,
guess
I'm
wondering
if
it
has
to
be
open
j9.
This
only
works
if
open,
j9
and
Omar
move
completely
to
a
new
options.
Implementation,
or
is
there
some
intermediate
ground
where
we
could
test
the
waters
warm
our
vehicle
containing
wants
to
adopt
at
a
later
date?
So
there's.
B
A
lot
of
work
that
can
happen
without
even
touching
that
boundary
right,
because
I
mean
we're
you're
I
think
touching
on
is
the.
How
do
you
input
the
options
into
the
compiler
technology
or
whatever
in
Omar,
and
a
lot
of
what
Azim
was
already
talking
about
is
how
it
gets
consumed
internally?
How
do
you
check
to
see
whether
or
not
this
feature
is
enabled
or
not?
Where
is
the
one
place
that
I
go
do
to
ask
if
this
is
on
or
off?
B
A
One
additional
thought
that
I'd
had
a
while
ago
and
I
don't
know
it
makes
sense
in
the
Omar
context
or
not.
But
if
you
look
at
LLVM
and
there's
a
way
that
optimizations
there
add
themselves
to
the
past
manager,
right,
look,
there's
a
past
manager
and
the
reason
the
past
manager
file
where
you
go
and
list
all
the
passes.
The
past
has
there's
a
whole
Mars
case.
A
So
one
of
the
things
that
I,
don't
like
at
the
moment
about
the
options
processing,
is
that
the
options
are
removed
from
the
place
where
they're
actually
defined
to
be
used
right
like
so,
you
have
options
the
control,
loop
version
or
you
have
options
the
control
loop
stridor.
You
have
options
with
control,
idiom,
recognition
or
whatever
all
of
those
options
are
over
in
the
option
about
CPP
in
the
global
list.
A
To
know
what
the
options
are
when
you're
looking
at
the
optimization
requires
you
to
go
and
look
at
that
table
and
notes,
search
where
and
what
to
search
for
which
is
not
always
obvious
right,
because
sometimes
there
are
internal
options.
Don't
even
include
the
name
of
the
actual
optimization
right
and
you
have
to
find
them,
and
then
you
have
to
find
out
which
of
them
are
in
there
and
figure
out
what
their
state
is.
And
does
anybody
toggle
the
state
in
any
of
the
pre-processing
logical
level?
A
A
F
A
So
it's
a
bit
different
than
what
we
do
at
the
moment,
but
I
just
always
throw
it
out
there
because
maybe
having
the
big
global
list
of
everything,
especially
if
you're
composed
enums
and
whatever
else
we
end
up
doing.
Maybe
that
isn't
the
best
way
to
build
this,
so
that
we
don't
all
keep
trying
to
check
in
this
8
and
5
plus
I
think
I.
Try.
A
E
C
B
A
A
There
are
another
plethora
of
options
which
are
very
specific
internal
kind
of
debugging
handles
and
tracing
handles,
and
things
that,
if
you're
somebody
who
knows
about
that
off
tour
whatever
you
want
to
know
about
those,
but
they
should
come
out
on
the
command
line
as
a
list
of
things
that
you
can
use,
and
things
like
that.
So
one
of
the
problems
with
using
the
yet
to
get
and.
B
So
is
that
and
one
of
the
huge
advantages
of
what
we
currently
have
with
all
the
wards,
the
infrastructure
has:
is
the
per
method
filtering
of
options,
so
the
option
substance
right,
so
you
can't
get
that
with
the.
If
you
get
in.
Basically,
our
global
option
applies
to
all
compile.
So
if
you
did
want
to
add
some
kind
of
flying
or
green
controls
or
whatever
code
you
were
working
on,
it
would
be
better
to
have
an
option.
A
Those
that
I'm
defining
is
my
public
options,
which
I
will
document
nicely
and
will
out
support
and
have
various
behaviors
that
I'm
willing
to
describe,
and
then
there's
the
internal
handles
right
and
that's
what
that's
the
majority
of
whether
you
get
n
vis
today,
great
you're,
deep
in
the
middle
of
trying
to
debug
VP
and
there's
a
certain
particular
part
of
it
that
you're
debugging
and
hopefully
the
developer.
Who
is
there
before
you
left
certain
things
that
you
can
turn
on
to
get
more
information
about?
A
C
Okay,
so
I
did
think
about
you
know
localizing
setting
up
options,
but
in
order
to
look
at
that,
it's
know
we
need
to
actually
see
how
much
performance
is
that
that
might
have,
because
so
far
like
there
are
projects
that
that
is
implement
ways
to
localize
options
and
and
even
tools
that
are
available.
That
will
allow
it
to
do
that.
Both
libraries
in
phase
one
that
allows
you
don't
go
in
when
you
boost
now
I
love.
A
C
I
mean
you
don't
have
to
use
boost
but
Laura's
on
their
ideas,
but
then
can
use
the
right
now.
I,
don't
really
have
any
answers
to
how
much
performance
cost
that'll
be,
and-
and
you
know
it's
something
like
that
is
implemented-
it
might
not
go
to
go.
I
mean
outside
well
with
others,
especially
I
was
talking
about
opened
a
line
so.
B
A
Think
that,
with
some
creativity
you
may
be
able
to
get
fun,
might
not
be
able
to
get
all
of
the
benefits
of
those
things,
but
it
may
be
possible
to
do
it
without
too
much.
How
may
require
a
bit
of
creativity
with
how
things
are
initialized,
when
polls
necessarily
state
of
LLVM
exactly
the
model
to
go
with,
but
it
is
a
model
that
keeps
something's
and
can
it
handle
conflicts?
C
A
D
We
want
to
talk
about
the
fact
that
we
have
kind
of
came
up
before
maybe
a
mess
of
a
discussion
around
this,
but
the
the
fact
that
there
are
sort
of
areas
of
the
code
that
need
to
ask
different
kinds
of
ask
about
different
kinds
of
options.
So,
for
example,
inside
when
you're
inside
a
compilation,
you
should
probably
be
asking
questions
about
the
current
options
set,
because
that
will
take
into
account
any
option
settings
that
are
specific
to
them
at
that
that
you're
compiling,
oh
yeah
Sara's.
D
If
you're,
not
in
code,
that's
running
in
a
compiled
in
a
compilation,
you
need
to
ask
a
more
globally
commandlineoptions
kind
of
question
and
then
the
answer
is
mentioning:
we
have
the
JIT
versus
the
OT
bifurcation
that
I
instigated
on
the
world.
Thank
you
very
much.
Yeah
you're
welcome
to
take
me
dude.
There
was
a
good
reason
for
it
at
the
time
just
went
away
after
that,
although
maybe
just
as
a
service
brings
it
back
I,
don't
know
you
know.
D
D
B
Maybe,
if
you're
in
the,
if
you
are
in
the
middle
of
a
compilation-
and
you
have
a
compilation,
object,
you
have
some
kind
of
an
options
I'm
just
making
stuff.
You
just
have
some
kind
of
an
option
underneath
the
bigger
one,
an
option,
at
least
underneath
the
compilation
under
compilation.
That's
where
that
that's
what's
responsible,
ranching
figure.
D
So,
for
example,
a
code
and
pH
table,
for
example,
might
get
queried
while
you're
in
a
compiler,
because
you're
updating
the
CH
table
based
on
something
that's
happening
in
that
compilation
or
you
might
be
being
called
as
part
of
a
class
load
or
unload
hook,
and
it
wants
to
figure
out
how
to
tailor
its
operation
for
the
table,
even
though
it's
not
doing
accomplishment
right
now.
So
it
would
be
nice
if,
if
developers
didn't
have
to
think
about
that
and
just
wrote,
I
want
to
know
what
this
options
on
or
off
in
under
the
covers.
D
D
D
C
B
Think
that
that
is
a
requirement
that
at
least
some
version
of
what
I've
seen
it's
been.
It's
a
goal
for
free
I
mean
we
do
always
have
I
think
in
any
of
those
contexts.
There
is
a
thread
that
we
happen
to
have
our
hands
on
now,
whether
or
not
that
the
compilation
thread
or
not
is
the
different
thing.
So
maybe
there's
some
way
of
attaching
this
information
to
the
thread.
This
is
n.
Another.
B
That's
a
whole
other
discussion,
I'm,
sorry,
Jake
I
think
that's
going
to
be
that's
not
going
to
get
over
the
mix.
Yeah!
That's
going
to
get
changed
a
lot
too.
Hopefully
soon.
I'll
come
talk
about
some
ideas
for
that
as
well,
but
that's
actually
the
similar
kind
of
concern
in
that
the
answer
would
they
affect
the
answer
to
some
questions
about
the
environment
is
different
depending
upon
what
you're
doing
but
get
my
compiling
a
shared
classic
thing.
Am
I
compiling
or
am
I
not.
B
Of
a
compilation
right,
that's
the
thing,
the
same
kind
of
difference
that
we
have
there
so
there's
potentially
some
similar
solution
that
we
have
to
come
up
with
between
options
and
and
the
environment
for
it,
but
the
one
common
thing
in
all
this
cases
that
you
do
actually
have
a
thread
in
your
hand.
Now
what
you
can
do
with
that
or
what
information
we
have
available
there
remains
you
see
left
so
maybe
the
options,
for
example,
have
to
live
a
little
bit
higher
up
the
it's
not
just
in
a
data
structure.
B
F
B
D
G
D
B
D
A
E
You're
thinking
of
doing
this
of
the
VMS
or
some
sort
of
tread
levels,
are
you
actually
thinking
of
having
copies
of
the
object,
the
options,
object
per
thread
or
a
guide
person
or
having
just
one
object?
But
yet
everybody
eventually
asks
what
the
main
worry
I
have.
Living
press
is
more
than
one
thread,
but.
B
Again,
I
think
it'll
kind
of
come
down
to
how
it
will
also
live.
The
questions
that
you
were
the
I'm
in
a
compilation,
contact
and
I've
done
in
a
compilation
contract
how
much
those
are
going
to
influence
the
answer.
I'm
at
a
little
bit
early
I
mean
I,
don't
know
that
is
not
I
kept
I!
Think
about
it,
but.
D
E
D
Workers
around
yeah,
okay
and
in
the
primordial
case
that
point
you.
If
you
have
to
wait
for
I,
don't
know,
Robert
can
probably
get
one
better
than
I
can
but
giving
up
the
weight
before
there's
the
opportunity
to
create
a
whole
/
vm
thread
before
you.
Could
we
probably
solved
this
problem
already
by
not
asking
all
these
questions
earlier
than
that
it's
just
going
to
create
a
no
rpm.
A
B
D
So
I
think
the
question
there
will
break
down
into
how
how
much
of
an
imposition
that
will
bring
to
people
who
don't
want
yet
rate
of
OPM
right.
So,
if
you're,
using
JIT
builder
in
a
context
where
you're
just
trying
to
accelerate
some
competition
and
you're
not
trying
to
write
a
language,
runtime
I
would
prefer
that
not
to
carry
along
a
bunch
of
baggage,
but
isn't
that
will
be
actually
used
for
anything.
Well.
B
I
mean
if
you
didn't
provide
your
own.
If
you
didn't
provide
what
is
in
phase,
if
you
don't
provide
your
own
VM,
shredder
or
PM,
you
would
go
and
create
a
default
one
for
you.
That,
actually,
is
you,
know
correct.
It
actually
can
answer
questions
properly,
but
then
again,
you're
bringing
in
the
B
and
thread
baggage
and
the
VM
baggage
as
well
right.
B
D
G
Tend
to
think
that
it's
a
almost
outside
of
the
scope
of
gypto
there
to
try
to
do
any
kind
of
VM
wide
smartness
and
she
employed
web
smart
like
smarts,
yet
have
any
kind
of
knowledge
of
like
DM
access
or
heap
access,
or
anything
like
that.
It
almost
seems
like
it's
outside
of
the
scope
of
Jeff
older
I'd
like
to
be
able
to
construct
my
own
VM
thread
and
then
attach
like
a
shipbuilder
context
to
that
somehow,
like
sort
of
stuff,
a
pointer
to
a
to
builder
context,
if
I
need
it
and
if.
B
G
D
B
C
G
G
B
That
is
well
if
there,
if
there's
one
thing,
that
the
look
when
you're
asking
a
question
outside
of
a
compilation
context
and
within
a
compilation
context.
The
one
thing
that
both
of
them
shipbuilder
notwithstanding
has
in
common
is
the
fact
that
you
actually
have
a
a
Nomar
VM
thread
at
least
can
work,
and
if
we
had
to
hang
something
somewhere,
it
could
be
there.
But
if
chip
builder
just
has
a
fake
one,
then
that's
something
we
need
to
look
into
and
understand.
D
That
probably
pushes
you
closer
to
a
world
where
you
are
going
to
combine
the
kid
and
äôt
commandlineoptions
into
a
single
command
line.
Option
object
with
male
Andrews
happy
about,
although
it
comes
with
complexities.
Corsets
are
everything
that
just
one
reason:
why
I
did
it
that
way
in
first
place.
D
D
B
D
Well,
I
mean
that's,
oh
right
now,
optimization
level
doesn't
take
peyote
into
account
right.
We
do.
We
have
a
ot
cold.
We
can
do
a
OT,
warm
we
do
like.
There's
you
have
that
sort
of
there's
two
independent
things
right,
optimization
level
on
GOP.
You
need
some
way
for
the
options
processing
to
distinguish
between
pdot
cold
and
the
cold
equation
right,
which
right
now
in
the
way
we
structure
the
options
set.
Descriptor
right
you
right
now.
D
F
A
B
D
Myself
Asians,
but
the
way
that
that
we
describe
them
in
the
rowboats
logs
makes
it
look
like
a
hotness
name:
I
get
the
AOD
cold,
a
or
D
one
load,
which
is
another
thing
that
doesn't
exist
yet
at
all.
As
a
hotness
pain
load
is
kind
of
a
different
thing
and
they're
also
in
open
j9,
an
unfortunate
part
of
the
design
of
this
CO.
D
Is
it
so
a
OTE
loathes
used
to
be
completely
a
runtime
sight
thing
so
old
code
did
it
existed
in
a
place
used
to
not
even
know
about
compilation,
objects,
didn't
used
to
be
one
and
then
circa,
Java
7,
we
merged
the
heuristics
for
doing
a
load
or
a
or
a
pile
back
into
the
compilation
thread
stuff.
So
at
a
very
high
level.
D
One
of
the
reasons
why
it
was
done
originally
this
way
for
open
canine
or
for
canine
I
guess
was
that
the
original
it's
kind
of
connected
of
what
I
was
just
talking
about.
You
used
to
be
able
to
run
canine
without
a
gift,
so
you
don't
need
load
the
core
runtime
and
that
has
the
ability
of
low
do
tangent
functions
and
it
seems
weird
the
options
that
enables
the
JIT
was
called
check
on
by
default.
D
If
you
didn't
want
to
jet-
and
you
only
wanted
an
interpreter,
you
could
date
X,
no
good
and
it
felt
weird
to
have
adoptions
be
listed
as
sub
options
on
the
dash
X
no
get
X,
no
jet.
Here's
all
the
options.
You
should
use
very
ot
here,
so
we
ended
up
putting
it
on
I'd,
say
Ooty,
because
we
needed
a
way
to
enable
and
disable
IOT
as
well,
and
then
once
you've
got
an
option
to
enable
IOT.
D
Well,
maybe
the
command-line
options
for
all
dat
stuff
could
be
there,
so
that
that
one
of
the
reasons
why
we
land
it
on
the
path
that
we
did
land
on,
however,
I
wish
I
had
fully
understood
the
full
complexity
of
our
command
line.
Processing
stuff
before
I
had
embarked
on
that
particular
challenge
and
then
ended
up
duplicating
quite
a
lot
of
code.
C
So
yeah
so,
like
the
other
things
that
I
wanted
to
talk
about,
was
so
getting
so.
This
is
something
that
Phillip
brought
to
the
discussion.
He
was
talking
about.
Outputting,
help
tag
for
each
particular
option,
and
you
know
like
getting
like
the
settings
that
can
be
applied
on
those
instead
of
like
kind
of
guessing
what
they
are,
because
it's
not
possible
to
really
document
each
and
every
obscure
option,
and
it's
probably
easier
to
just
have
some
sort
of
a
objects
that
can
be
output
right
away.
C
C
B
C
C
A
C
A
A
number
of
name
clashes,
yeah
name
flashes,
and
what
well
like
somebody
has
a
bool.
That
is
the
version
of
the
option
without
the
TR
underscore
is
certainly
one
common
pattern.
Try
you
query
to
you
because
you
don't
want
to
keep
clearing
the
option
in
certain
circumstances,
so
you
create
a
local
pool
that
holds
it
or
you.
A
D
D
C
C
C
What
we
are
envisioning
is
a
something
like
a
central
option
squaring
place
that
will
take
care
of
like
asking
the
global
if
needed,
and
right
now,
like
I,
think
I'm,
like
I,
don't
have
a
clear
answer
about
how
like
we
are
going
to
detect
what
kind
of
problems
are
happening,
except
you
know
actually
running
the
benchmarks
and
a
different
tests
that
are
currently
being
used.
I
think.
D
For
some
I
have
situation
yeah.
Well,
if
we're
going
to
move
towards
the
model,
where
you
ask
one
question
and
it
gets
decided
which
one
is
going
to
ask
as
an
intermediate
step
before
we
commit
completely
to
that
single
thing.
You
pass
if
you
change,
instead
of
just
changing
it.
To
whatever
ask
that
thing
about
this
option,
you
pass
an
additional
option,
which
does
what
was
the
original
query
that
got
asked
here
and
then
and
then
you
can
easily
find
cases
where
you
are
choosing
the
wrong
right.
D
You
can
verify
in
the
service
that
you
chose
the
right
answer
and
then,
if
something
goes
wrong,
you
have
a
set
of
candidate
places
to
look
for
what
went
wrong
at
least
what
I
would
almost
be
useful
even
and
then,
once
you
are
suppose
right
once
we
assure
ourselves
that
everything's
good,
then
you
can
do
a
simple
set,
replacing
it
really
often
it
gets
best
in
okay
and
we're
in
a
happy
place.
Maybe.
D
There
who
you
could
start
by
overriding,
call,
get
off
him
and
get
get
a
ot
command
line.
Offices
up
with
the
code
bases,
implement
your
service
they're
right
underneath
those
queries,
so
you
already
know
what
which
one
being
called
and
then
see.
If
your
service
predicts
the
right
one,
all
right,
you
can
have
that
you
can
have
that
chain,
Buffalo,
nothing
changes
in
the
code
base,
yet
you
can
implement
your
service
and
once
it's
good
enough
now
you
push
out
to
replace
all
the
calls
to
come,
get
off
the
poles
to
get
taken
off.
D
Sure
that's
going
to
be
harder
than
I
think
he
will
even
seems
like
the
starting
place,
because
that
way,
even
people
who
are
still
working
in
the
codebase
and
copying
things
and
creating
new
ones
they'll
create
whatever
thing
they
think
is
the
right
thing
to
start
with,
whatever
one
they're
copying
they'll
get
that
one.
No,
not
that
kind
of
worry
about
new
people
writing
new
code
needing
to
understand
what
it
is
you're
doing.
It
covers.
D
Where
I
wasn't
convinced
looking
at
it
quickly
as
it
was
asking
the
right
commands
of
Great
mountains
objects
in
their
workplaces,
where
there
was
a
set,
would
you
bother
me,
but
now
andrew
says
we
do
that
in
places
less
surprised,
you
know
in
just
how
go
off
it.
Just
kind
of
bothers
me
that
option
is
the
way
that
we
do
that
somehow,
like
there
should
be
some
other
mechanism
of
controls
like
options
should
be.
What
options
were
you
given?
Not
what
options
do
I
think
well
that
are
right
that
they
represent
the
feature.
D
You
know
I'm
more,
like
the
one
opt
finding
something
or
doing
something
and
then
setting
an
option.
A
something
later
should
do
something
differently,
because,
like
I
understand
the
unable
and
optimization,
because
I
found
an
opportunity
for
this
optimization
that
should
get
cleaned
up
later,
because
I
just
created
it,
but
the
use
of
options
to
do
that
will
only
to
me.
B
B
B
C
Yeah,
so
the
first
step
that
I'm
working
on
right
now
is
reflecting
the
entire
code
around
options
and
and
like
you
know,
and
after
that
is
done.
Like
I'm
gonna
start
working
on
like
a
out
on
the
new
page,
a
firing
mechanism.
So
that-
and
you
know
like
just
seeing
the
impact
of
that
on
the
promise
or
whether
we're
getting
the
wrong
results
or
so
on
and
I'm,
going
to
suggest
that
we
I.
B
But
think
about
some
of
the
requirements
that
were
raised
here
and
how
and
the
core
requirements
that
you
have
and
and
how
those
are
going
to
influence
design.
They
don't
think
that
just
for
the
straightforward!
Well,
we
have.
We
need
to
make
sure
we
have
some
kind
of
a
solution
in
place
that
addresses
as
many
of
these
as
we
can,
as
opposed
to
let's
say
just
having
a
simple
class
or
an
object
which
is
asking
everywhere
you
on
or
off
kind
of
thing.
We
need
to
have
something
that
works
in
all
aspects.