►
From YouTube: OMR Compiler Architecture Meeting 20181219
Description
Meeting agenda:
Introduce a CG phase to simplify instructions (#3278) [ @0dvictor ]
B
Thank
You
Darryl,
so
so,
basically
I
will
say
in
the
in
the
code
generated
by
our
evaluator
I
found.
There
are
a
lot
of
opportunities
that
we
can
simplify
the
sequence,
for
example
the
work
sample.
We
had
I
I
phones,
that
I
found
a
very
simple
sequence
that
like
test
the
condition
and
then
set
a
static,
a
register
according
to
the
condition
and
fin-tastic
the
condition
according
to
the
registrar
into
the
branch.
B
So
we
can
simplify
them
into
a
sim
into
a
symbolic
task,
condition
and
a
branch
according
to
the
condition
so,
and
we
also
have
there
so,
but
although
we
can
do
it
in
the
evaluators,
but
it
involves
more
much
more
complex
logics
and
there
are
challenges
that
we
mess.
In
certain
cases
like
by
bipartite
matching
the
trees,
we
may
not
be
able
to
find
all
those
opportunities,
but
instead,
if
we
go
through
the
generate
instructions
are
instruc
reflection.
We
should
be
able
to
find
all
the
opportunities
at
that
point.
So.
A
How
would
that
some?
How
do
you
envision
is
working
so
you,
you
know
you
have
a
sort
of
set
of
opportunities
that
you
could
potentially
find
for.
Let's
say
a
compare
instruction,
so
what
you
do
is
you're,
basically
walking
every
instruction
in
the
method.
If
you
happen
to
come
to
a
instruction
for
which
you
have
some
kind
of
an
action
or
you
can
do
some
kind
of
or
you
can
initiate
some
kind
of
an
action
and
you
go
when
you
start
to
look
around
for
opportunities
based
on
that
instruction.
Yes,.
B
C
B
A
So
I'll
just
give
a
bit
of
a
historical
perspective
on
this,
because
this
particular
this
kind
of
a
pass
has
been
proposed
in
the
past
and
and
in
the
end
it
was
never
actually
implemented
because
we
always
sort
of
found
another
way
to
get
the
the
functionality
we
wanted.
But
having
said
that,
though,
keeping
an
open
mind
about
what
we're
trying
to
achieve
here,
but
the
in
terms
of
the
history,
though
the
main
objection
to
this
kind
of
thing
has
always
been
the
compile
time
cost
versus
the
opportunity
that
we're
trying
to
get
right.
A
So,
if
you're
looking
for
a
very
specific
kind
of
opportunity,
that
may
not
be
that
common,
for
example.
Then
then
the
cost
of
actually
walking
all
the
instructions
may
not
be
may
not
be
worth
it.
But
I.
Think.
Having
said
that,
though,
I
think
that
if
the
framework
that
gets
put
in
place
is
general
enough
and
perhaps
efficient
enough,
and
we
can
potentially
limit
it
in
some
way,
like
only
look
at
blocks
that
are
interesting,
for
example,
then
then
there
might
be
an
opportunity
for
this.
I
am
interested
actually
in
hearing.
A
If
anybody
from
who
knows
anything
about
power
or
Z,
or
on
right
now,
maybe
Philip
they've
added
P
polling,
passes
and
I'm
just
curious
how
expensive
those
have
been
and
how
effective
they
have
been
in
in
terms
of
solving
this
kind
of
problem.
I
know
that's
happening
after
register
assignment,
which
is
what
you're
doing
here,
but.
D
So
I
can
speak
on
behalf
of
Z
on
so
about
three
months
ago,
or
so
we
actually
did
puttin
up
free
RA
people
pass.
So
we
have
a
preview
RA
and
a
post
are
a
people
pass
which
is
I
think
this?
What
Victor
is
proposing
is
exactly
that
except
I
guess
a
common
code
generated
level,
so
this
has
been
working
for
us
quite
well
on
up
to
this
day,
we
have
37.
D
In
total
people
passes
that
we
execute
on
various
different
instructions
and
instruction
sequences
and
the
way
we
get
around
that
limitation
that
you
mentioned
Darrell,
is
we
kind
of
have
a
sliding
window
of
how
far
ahead
we
look
for
these
types
of
opportunities
and
dependent
is
only
going
to
cost
benefit
analysis
done
beforehand.
You
would
select
an
arbitrary
window,
usually
around
five
to
ten
instructions.
They
would
peek
ahead
to
look
for
opportunities,
so
it's
not
too
expensive.
D
D
D
D
We
we
would
yes,
typically
dogus
for
the
pre
RA
pass.
A
virtual
register
can't
live
the
end
of
a
basic,
so
extended
basic
block.
Anyway,
it's
kind
of
a
non-issue
yeah.
That's
a
good
point,
yet
I'm,
not
sure
that
we
have
anything
that
looked
across
basic
block,
though
that
wouldn't
be,
is
subject
of
people.
It's
more
like
a
global
type,
optimization.
A
D
Architects,
definitely
it
can
be
common
I
did
want
to
actually
comment
up.
The
both
the
pre
and
the
post
are
a
people
passes
for
they're
available
because
I
noticed
I,
don't
think
I
say
six,
even
how
the
people
passed
and
powered
implements
their
own,
but
they
only
have
a
post
are
a
half
such
the
complete
mess.
I
think
the
bigger
issue
here
is
that
these
cogent
phases
are
kind
of
not
extensible
in
any
way.
So
there
was
no
way
for
us
to
extend
any
functionality.
A
D
Photographers
Perkins,
or
is
it
bigger
than
that?
It's
usually
a
couple
instructions
on
very
simple
stuff.
Like
I,
don't
know
it's
a
easy
one,
but
sometimes
we
have
redundant
load
on
Pro,
which
we
have
I
guess
three
offering
non-destructive
instruction,
which
we
could
replace
it
with
also
be
like
a
kind
of
a
load
register
and
like
an
ad
can
be
replaced
with
a
non-destructive
ad
there's
like
load
store
reductions.
D
This
is
the
one
for
I
guess
the
pre
RA
people
where
we
would
look
for
loads,
a
load
from
memory
and
then
a
store
of
that
register
directly
back
into
memory,
and
we
need
to
do
that
before
Ras,
because
we
need
to
know
the
use
counts
of
the
register
to
make
sure
that
nothing
else
needs
that
value,
in
which
case
we
just
generate
on
in
memory
clunky.
So
simple
stuff
like
that,
usually
the
window.
B
A
B
Like
the
one
I'm
going
to
trying
to
implement
is
not
it
to
the
compare
was
like
to
compare
and
I
want
to.
What
I
want
to
simplify
is
a
like.
They
see
when
they
condition
evaluator
I
see
we
have
it.
We
have
a
condition.
Evaluator
and
jet
evaluates
to
a
condition
and
insert
into
a
register,
and
then
we
test
whether
the
register
is
0
or,
and
then
branch
based
on
that
has
so
does
for
that
one.
It
should
be
a
wrong
place.
B
The
II
was,
the
original
sequence,
should
be
five
instructions
and
they
could
be
simplified
into
the
instruction.
That
is
the
one
I'm
going
to
the
in
my
mind
right
now,
but
we
compared
was
not
going
to
implement
immediately,
but
because
currently
the
zip
is
a
similar
analysis
has
been
done
by
the
compare
evaluator.
So
in
the
compare
evaluators
in
the
compare
evaluator,
we
walk
through.
We
walk
through
walk
backwards
of
the
generated
instructions,
find
the
previous
instruction
at
static
condition
and
make
this
area
and
the
evaluator
level.
B
Those
and
other
things
that,
in
my
mind,
I
haven't
looked
at
it
yet
is,
or
somebody
can
convert
a
certain
like
a
certain
branch
into
the
conditional
move
and
we
can
convert
some
redundant
load
box
on,
will
convert
a
move
memory
load
with
arithmetic
into
the
memory
like
register
memory,
form
of
instruction.
So
I.
A
Guess
the
the
I
mean
in
in
mine,
I,
guess
just
to
satisfy
the
the
concern
that's
always
been
raised
with
with
respect
to
compile
time.
I
think
that
any
solution
come
up
with
needs
to
be
vetted
against
the
things
that
we
care
about
or
compile
time
right,
yep,
but
also
looking
at
how
many
opportunities
are
actually
being
uncovered
right.
If
you're
writing
a
fairly
significant
app,
then
you're
only
finding
opportunities
and
cold
blocks
and
free
methods.
So
then
that
but
I
mean
I
think
the
framework
is
general
enough.
A
B
B
If
we
can
identify
the
opportunity
in
the
for
registrar
location
like
we
standards
identify
the
property
there,
because
potential
is
not
only
without
by
two
years
before
the
register
allocation
will
not
only
reduce
the
number
of
instructions,
but
we
also,
but
also
reduce
the
number
of
registers
that
we
need.
So
the
RA
could
fit
a
group
like,
but
we
can
make
our
a
easier.
A
I
mean
I
think
that
the
reason
that
she
did
that
and
correct
me
if
I'm
wrong,
is
because
they
could
say
they
found
opportunities
that
happen
on
both
sides
of
both
sides
of
our
array.
Right,
like
after
register
sign,
has
occurred.
You
can
find
out
/
like
you're
copying
the
same
register
into
a
store
example,
or
you
can
very
easily
get
rid
of
that
yep.
That's.
D
C
B
C
Up
now,
the
more
information
on
what
the
people
changes
got
us
in
terms
of
improvements
at
and
where
those
improvements
are,
what
kind
of
applications
is
it
in
hot
and
scorching
methods,
for
example,
where
compiled
time
would
be
even
lesser
of
a
concern?
Is
it
in
relatively
flat
profile
apps,
where
you
would
have
to
do
it
at
warm.
D
We
do
it
at
all
compiled
levels
again,
I
think
just
counting
searching
for
a
while
and
for
in
our
people
file,
there's
only
a
handful
of
currencies
where
we
actually
have
a
loop.
It's
usually
just
bunch
of
if
statements
arm
stirred,
is
barely
any
looping
logic.
We
look
for
successful
instructions
or
couple
of
instructions
apart.
It's
fairly
cheap,
okay,.
D
D
Where
we
feed
the
the
result
of
a
four
into
a
comparison
and
quite
expensive
Lindsay,
another
one
is
where
we
feed
the
results
of
a
load
into
an
address.
Calculation
is
also
another
penalty.
Md,
there's
quite
a
lot
of
people
to
eliminate
those
kinds
of
things
or
kind
of
put
them
further
apart.
So
so
as
to
avoid
these
types
of
penalties.
A
D
A
A
B
If
the
case
is
near,
how
is
imposed
re
go
sorry,
people
right
now,
I
named
it,
this
I
named
it
as
the
simplification,
because
what
is
a
people
part,
but
the
people
too,
we
already
use
a
few.
Poles
went
on
the
face,
so
I
I
named
it
a
simplification,
so
the
code
is
pretty
much
identical
with
in
current
people
did
and
right
now.
The
actual
actual
implementation
is
the
app
is
anti
function,
just
as
the
people
favorite
right
now
on
X
basics,.
B
B
A
Okay,
so
this
was
essentially
the
agenda
for
today
we'll
pick
these
up
in
the
new
year,
you
I
will
be
changing
the
the
day
of
the
week
on
which
these
meetings
are
going
to
be
held
in
the
future.
To
try
to
increase
the
number
of
of
participants.
I
know
that
some
have
indicated
they
have
conflicts
on
the
time
that
we
currently
are
doing
it.
So
I'm
shifting
things
to
two
Thursday
Eastern
Time
in
the
afternoon,
so
hopefully
that'll
see
more
people
joining.