►
From YouTube: OMR Architecture Meeting 20230427
Description
Agenda:
* Additional vector IL opcodes proposal (#6942) [ @gita-omr ]
* arraycmplen IL opcode proposal (#6951) [@Spencer-Comin ]
B
B
B
And
this
is
just
a
latest
sort
of
bunch
for
now
like
and
it's
motivated
by
a
vector,
API
Java,
Vector
API.
If
you
want
to
implement
support
and
open
G9.
So
we
need
this
op
code.
So
when
I
say,
for
example,
a
vacation
it
it's
like
vector,
API
invocation,
just
to
illustrate
how
you
can
sort
of
in
start
using
the
sub
codes
and
then
the
avbv
stands
for
Vector.
It
kind
of
you'll
see
it's
pretty
intuitive
and
of
course
that
is
VM.
B
So,
for
example,
first
by
first
two,
we
bit
count
and
VM
bit
count.
So
it's
a
counting
bits
for
each
element
of
the
vector.
It's
a
Lane
Wise
operation,
unary,
that's
how
it's
invoked
in
Vector
API
and
here's
like
optional
mask
I
forgot
to
put
it
here.
It's
only
for
non-fp
types
and
it's
equivalent
to
calling
integer
bit
count
or
long
bit
count
on
each
lane
and
smaller
tabs
get
promoted
first
to
integer
type.
B
A
A
D
B
A
E
B
A
F
B
G
B
D
B
B
B
B
B
B
B
B
Vshl
right
so
it
will
be
the
essential
yeah.
That's
I
think
it's.
This
makes
sense,
yeah
so
and
then
it'll
be
the
I
said,
show
shift
left.
Oh
sorry,
it's
right,
it
said,
keep
confusing!
That's
good!
Okay,
so
it
says
sorry,
this
one
yeah
so
shift
left
will
be
the
shl
or
NVM
shell.
So
let
me
write
down
and
okay
and
then
there
is
separate
one
by
constant,
because
it's
more
efficient
way.
B
There
is
a
method
in
Vector
API
that
takes
a
constantly
selected,
not
the
vector
constant
here
and
so
that
we
don't
need
to
broadcast
it.
There
are
sometimes
instructions
that
can
produce.
Sometimes
Hardware
has
a
section
that
shifts
every
element
by
constant
and
the
actual
different.
It's
implemented
a
bit
differently,
so
we
added
like
separate.
So
it
would
be
the
the
vshl
const
VM,
essential
const
foreign.
B
B
B
D
A
B
B
D
B
H
B
D
C
G
B
Think
this
is
maybe
we
should
not
compare
to
our
regular
shift
up
cost
because
it's
typically
it's
still
have
two
children,
then
both
are
vectors,
and
here
is
just
saying
that
one
is
Vector
and
one
is
scalar.
So
it's
you
know
in
of
course,
that
we
have
already
that's
always
scalar
right
here.
It's
like
versus
this
one
kind
of
saying
it's
killer.
B
D
A
E
B
E
D
E
B
Like
Library
will
do,
for
example,
there
is
method
in
the
library
that
takes
like
constant,
add
constant,
but
Library
itself
will
do
broadcast
and
which
will
translate
to
Splat.
So
there
is
no
such
thing,
but,
interestingly,
for
shift
and
rotate,
there
is
special
intrinsic,
which
I
think,
probably
because
there
are
instructions
like
that.
Take
advantage
of
instructions
that
shift
and
rotate.
E
G
B
D
B
D
E
B
E
B
F
B
D
This
is
the
simplest
possible
pattern
that
you
could
have
to
to
to
look
for
and
recognize,
and
if
we
do
look
for
it
and
recognize
it
then
we'll
catch
cases
that
weren't
even
using
this
right
like
if
somebody
did
a
splat
and
then
gave
it
to
the
and
then
passed
in
the
vector.
We
would
want
to
optimize
that
too.
B
E
B
B
B
D
B
C
E
Okay,
we
could
approach
it
from
a
different
side
too.
Is
that
it's
easy
to
add,
you
can't
argue
against
having
a
shift
operation.
You
can't
argue
against
having
a
broadcast
operation
together.
They
can
be
used
and
recognized
to
do
this
shift
by
a
constant
thing.
If
you
want
it
or
not,
but
it's
it's
better
than
adding
VL
shift
const
or
whatever
it
gets
called,
and
then
realizing
that
we
really
shouldn't
like
it's
more
difficult
to
make
the
decision
to
take
something
out
like
that.
B
B
We
need
to
remain
and
there's
mask
version
and
then
const
will
remove
for
now
cost
version
and
then
it
this
will
be
you
as
HR,
which
is
consistent,
I
think
that's
what
we
have
on
science
shift
right,
I
think
they
have
to
associate
so
USC
sure,
okay,
that's
right,
request!
Remove
for
now.
Fine,
let's
find
your
now
rotate.
B
D
B
Yeah
yeah,
it
was
fun,
it's
fine,
it's
in
the
library
yeah,
they
use
those
names,
yeah,
I,
guess,
I
kind
of
was
thinking,
make
it
more
descriptive,
but
absolutely
I
can
use
those
short
names,
so
const
removed
for
now
yeah.
Those
rotate
right,
which
is
also
like
mask
non-muscle,
mask
versions
kind
of
similar
so
will
become
Ro
right.
C
B
B
A
I
mean
if
in
this
case,
if
you
need
to
insert
an
extra
operation
to
do
the
negation
and
then
do
the
rotation
in
that
direction
in
the
left,
Direction
I
think
just
for
symmetry.
We
should
have
two
separate
opcodes
just
so
that
you
don't
have
to
do
that,
because
they
will
ultimately
map
down
to
a
different
instructions.
B
E
C
I'm
looking
into
the
Z
pops
right
now,
I
don't
see
shift
right,
there
is
only
shift
left
instruction
and,
and
the
the
nodes
yeah
yeah
rooted
left
on
is
is
the
only
operation
that
we
have.
They
do
in
programming.
Node
says
that
if
you
want
to
achieve
the
rooted
right
then
provide
the
negative
amount.
D
B
B
B
B
It's
kind
of
I:
don't
have
some
preference
like
it's
a
bit
different.
It's
it's,
not
a
Lane
Wise
operation,
a
bit
different
way
of
using
mask.
Definitely
here
a
very
different
way
of
using
mask.
You
know
we're
expanding.
It's
not
like
we're,
applying
well
they're,
applying
I,
guess
operation
in
the
sense
that
we're,
including
that
element.
So.
B
A
A
A
B
D
Here's
a
just
a
a
very
high
level
question
about
masks.
That's
kind
of
related
to
that
other
stuff
that
we
were
talking
about
is
sort
of
decomposing
in
in
fewer
operations
or
or
sort
of
leaving
things
decomposed.
For
now
we
have
these
V
and
VM
pairs,
but
you
know:
is
there
some
constant
mask
that
we
could
pass
in
to
the
VM
variant?
That
makes
you
know?
Basically,
the
the
V,
the
V,
the
plain
V
version
without
a
mask
is:
is
that
just
a
special
case
of
the
VM
one.
B
B
A
B
But
do
you
see
no
I
think
it
would
be,
the
aisle
would
be
looking
really
complicated
and
we
don't
have
Vector
constants
right.
So
how
we
would
represent
that
we
will
V
bit
count
would
be
V
and
bit
count
is
three.
This
one
has
two
children.
This
one
has
three
and
for
that
we're
gonna
have
third
child.
D
B
A
A
Well,
it's
more
than
that
I
mean
we
want
when
people
see
the
name.
We
want
them
to
understand
like
to
be
able
to
parse
the
name
and
understand
what
it
is.
This
is
a
vector,
op
code.
It's
got
a
math,
it's
it's
got
a
mask
operation
and
you
can
figure
out
the
type
in
some
cases.
So
we
do
want
to
be
somewhat
consistent,
but
I
don't
know
I.
D
A
B
B
Believe
it
for
now
I
have
a
feeling
it's
better
to
live
like
that,
because
it
might
be
confusing
that
it's
people
kind
of
will
think
it's
something
Lane
Wise,
for
example,
say:
if
platform
doesn't
have
mask
operations
for
this
type
of
they
use,
select
they
do
operation,
and
then
you,
you
select
op
code
here.
I,
don't
think
you
can
use
the
same
approach:
okay,
no
yeah!
It
will
be
different,
yeah
sort
of
diff,
slightly
different
kind
of
meaning
all
right.
So
where
did
he
left?
B
B
G
B
I
think
it
just
basically
takes
the
mask
and
like
compresses
all
like
elements,
you
know,
so
it's
a
bit
different
again
it
different.
It
doesn't
need
the
mask
itself
right.
You
see,
it
doesn't
need
argument
mask
so
it
just
compresses
them.
There's
no
like
false
elements
in
the
mask
only
like
once,
if
I
remember
correctly,
so
a
different
semantic.
So
here
again
like
we
don't
want
to
use
M
because
it's
different
meaning
it's
meaning
that
takes
a
mask.
It's
different
sort
of
semantics.
Sure.
B
D
D
It
seems
to
me
like
here:
let's
say
that
you
want
to
you,
have
a
mask:
it's
going
to
pick
out,
I,
don't
know
every
other
lane
or
something,
and
then
you
want
to
you,
use
a
v
compress
that
now
you've
got
a
vector
with
you
know
those
lanes
that
were
identified
but
they're
all
together,
yeah
and
then
let's
say
that
you
want
to
store
that.
But
you
only
want
to
store
as
much
data
as
you
have.
B
B
That's
where
the
data
is
in
your
compressed
Vector,
that's
you
basically
yeah,
possibly
possibly
the
use
of
it,
how
you
use
it,
but
otherwise
by
itself
it's
like
sort
of
it's
sort
of
relatively.
If
musk
has
five
elements
set,
maybe
not
every.
If
you
know
like
not
contiguously,
then
we
will
get
masks
with
first
five
elements
set
and
we
can
use
it
you're
right
for
that
other
iteration
like
it
will
be
equivalent
sort
of
it
will
match.
The
tractor
here.
B
Yeah,
so
what
about
the
name
like
you
think
it's
okay
specifically
for
mask
it's
not
masked
operation,
but
it's
it
takes
mask
as
an
argument
and
Returns
Mask.
Oh
it
returns
to
ask.
Maybe
it
should
be
Emma
mask
or
maybe
this
should
be
M
compressed,
because
we
have
up
codes
on
mask
well,
we
already
have
like
op
code,
starting
with
M.
B
B
B
B
B
B
D
B
B
C
B
Yeah
I
know
cheesy
yeah
all
right.
So
that's
good
thanks,
yeah,
absolutely
yeah,
so
you
just
sort
of
yeah.
So
the
name
of
those
reverse
and
M
reverse
it's
so
again,
it's
Lane
Wise!
That's
why
it
has
like
version
and
yeah
it's
equivalent
to
calling
integer
reverse
a
for
each
element.
A
again.
It's
like
elements,
it's
not
anything!
It's
element
of
vector.
B
A
B
B
D
D
B
H
D
E
C
B
B
A
Just
in
terms
of
the
documentation
here,
what
is
your
plan
for
describing
the
semantics
of
these
I
I
know?
We
don't
have
a
great
place
to
put
this
in
the
code
just
yet,
but
just
given
the
discussion
that
we've
had
on
some
of
these
op
codes-
and
you
know
it,
it
would
seem
that
we
would
that
we
should
have
a
more
precise
description
of
what
each
of
these
does
and
have
that
documented
somewhere
either
in
the
code,
which
is
maybe
preferable
or
or
we're
in
a
separate
document.
You.
B
B
B
A
B
A
A
G
H
All
right,
you
can
see
that
that's
good
all
right,
so
I
guess
my
my
proposal
here
is
to
take
the
array,
compare
op
code
and
split
it
into
two.
So
a
bit
of
a
refresher
on
what
the
array
compare
op
code
does:
there's
three
sort
of
flavors,
I,
guess
of
the
array.
Compare
out
code,
there's
a
comparison,
one
here
on
the
left
and
there's
between
the
two:
it's
not
much
of
a
difference,
it's
more
of
whether
you're
returning
one
or
two
or
one
or
negative.
H
One
I
might
have
the
the
constants
mixed
up
here,
but
not
not
important
for
the
proposal
here
and
then
the
other
other
flavor
is
to
return
the
length.
So
this
one,
you
kind
of
return,
an
ordering
some
constant
that
says
which
ones
lexicographically.
However,
you
say
that
word
which
one's
higher
and
this
one
you
actually
turn
the
return.
The
index
of
the
mismatched
element,
so
yeah
there's
already
fair
amount
of
difference
there.
H
H
D
H
D
It's
if
we're
already
passing
in
a
long
length,
then
that's
great,
but
if,
if
if
the
child
properties
were
correct,
then
then
that
would
be.
You
know
an
undo
limitation
right
on
even
these
ones
on
the
left,
but
definitely
for
the
one
on
the
right.
You
know
you
want
to
be
able
to
compare
up
up
to
whatever
size
we
have
in
memory,
and
you
know
you
can't
return
larger
than
32
bits
anyway,
I'll,
let
you
continue.
H
Well,
that
that
was
about
it,
I
guess
the
one.
The
one
use
case
that
it
came
up
in
was
in
transforming
Java
methods
that
vectorize
mismatch
which
we're
looking
at.
It
does
essentially
the
same
thing
as
the
array
compare
length
just
with
some
trickery
on
the
return
value.
When
you
don't
find
the
mismatch,
so
we
can
basically
translate
it
into
this
tree.
G
H
D
G
Yeah
I
I
wholeheartedly
agree,
I,
think
it's
a
mistake
to
over
overload
and
off
code
too
much
and
believe
it
or
not.
This
is
actually
already
a
simplified
version
before
from
before
we
went
open
open
source
the
code,
so
it
used
to
be
even
worse
than
this,
but
but
yeah
I
mean
I
I
I
I
support
splitting
it
up
into
different
op
codes,
just
makes
it
cleaner
and
doesn't
trip
up
people
who
want
to
do
anything
at
all
with
a
raycomp.
They
have
to
understand
all
these
complexities,
otherwise.
D
Yeah
I
think
also
I'd.
You
know
further
than
this,
although
this
is
not
part
of
of
the
current
proposal.
Is
that
I
I
think
that
these
two
on
the
left
should
we
should
do
something
about
it
about
that
too,
but
for
the
moment,
I
think
just
to
get
the
use
case.
That
Spencer
has
been
been
working
on
where
we
may
be
comparing
arrays,
whose
sizes
don't
fit
in
32
bits.
D
We
want
to
make
sure
that
we
can
represent
that
length
of
the
longest
matching
prefix
in
bytes
in
in
the
result,
and
so
there
were
a
couple
of
possibilities
that
we
talked
about
by
the
way
in
terms
of
making
sure
that
that's
representable
in
the
result
type,
so
one
would
be
so.
The
main
thing
I
wanted
to
avoid
is
having
the
return
or
result
type
B
dependent
on
the
flag.
D
Normally
we
would
have
a
pair
of
op
codes,
one
of
which
we
use
on
64-bit
and
one
of
which
we
use
on
32-bit,
but
I,
don't
think
it's
worth
having
the
weird
unprecedented
thing
or
the
pair
of
op
codes.
For
this
case,
it
seems
to
me
that
on
32-bit
we
can
just
truncate
the
result
and
I
think
that
that
is
sufficient
in
in
terms
of
this
operation.
D
G
D
G
D
D
G
A
H
H
See,
okay
and
as
an
argument
for
for
separating
to
the
evaluators,
whether
you
have
a
rate
compare
length
or
a
rate.
Compare
on
some
of
the
back
ends
are
already
quite
separate,
so
mapping
that
from
One
op
code
with
a
flag
set,
two
op
codes
is
pretty
simple,
did
a
test
of
it
and
it
took
me
about
two
hours
of
just
copy
and
paste.
A
E
G
E
A
F
Yeah
I
just
wanted
to
pursue
briefly
what
Devin
was
saying
earlier
about
the
two
operands
on
the
left
or
sorry.
The
two
operators
on
the
left
and
I
mean
I
had
been
thinking
earlier
in
the
year
about
this
topic
and
I've
been
thinking
about
whether
all
of
all
of
array
comp
ought
to
settle
on
the
array,
comp,
Len
and
then
situations
where
a
one
or
a
two
or
a
one
or
a
minus
one
or
the
difference
between
the
last.
The
the
first
element.
F
D
D
F
F
D
F
D
G
D
E
But
you
have
no
guarantees
on
that
right,
like
if
somebody
writes
a
code
that
does
an
array,
compare
and
gets
a
result
back
and
then
loads,
the
values
again
they'll
be
different
or
they
could
be
different.
There's
nothing!
That's
going
to
protect
you
from
that.
Unless
you
synchronize
it
yourself,
I,
don't
think,
there's
any
real
atomicity
guarantee
that
an
OP
code
is
giving.
You
is
my
point,
I
guess.
G
I
think
that's
true,
but
at
the
risk
of
speaking
for
Devin,
when
he's
here
and
perfectly
capable
of
fitting
his
thought
process,
I
think
he's
worried
about.
You
might
get
a
value.
That
is
very
weird
right
in
this
case
like
if
you
loaded
up
the
array
element
again
after
the
return,
has
happened
and
then
did
some
arithmetic.
G
E
So
I
think
we're
arguing
ourselves
out
of
Henry's
proposal
is
what
I'm
getting
from
this
yeah.
It's
asking
for
the
location
where
the
difference
is,
is
the
wrong
API
right
right?
If
what
you
want
to
know
is
or
like
what
is
the
difference,
then
the
answer
should
be.
The
difference.
Is
this
yeah
right,
yeah,
yeah
and
decomposing?
That
exposes
you
to
problems
like
we're
talking
about
yeah,
there's,
no
way
to
fix
that
by
right.
A
G
A
D
E
E
D
E
G
G
Do
it
in
three
installments
and
I'm
saying
there
was
one
installment
before,
and
yours
is
the
second
one
and
leave
it
to
somebody
else
to
the
third
one
whatever
it
is
that
we
want
to
do.
Let's
just
do
it
with
knowledge.
Now
that
we've
had
this
discussion,
whether
it's
Spencer,
who
actually
does
it
or
all
of
it
or
not,
to
this
different
matter.
D
G
D
D
So
I
don't
know
we.
We
have
these
these
few
ideas
so
far
off
the
top
of
our
of
our
heads
in
terms
of
maybe
have
one
of
these
is
the
real
one
and
we
do
some
bitwise
tricks,
or
you
know
bitwise
and
arithmetic
or
whatever,
and
then
the
other
one
was
pass
in
the
constants
I,
don't
know
if
we
want
to
try
to
brainstorm
or
try
to
pick
one
of
those
two
or
or
what.
A
There
may
be
some
performance
implications
to
that
choosing
one
or
the
other
that
might
be
work
for
one
of
those
projects
to
to
resolve
to
get
better
performance
out
of
it.
If
there's
additional
overhead
here
so
but
I
mean
I,
I
agree
with
the
we
should
have
off
code,
an
OP
code
with
the
with
common
semantics.
I,
don't
think
we
should
have
two
different
implementations
but
I
think.