►
From YouTube: .NET Design Review: ARM Intrinsics
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
C
C
F
D
D
D
G
B
D
D
G
A
G
B
C
C
C
C
B
C
J
C
J
C
C
C
C
D
D
H
H
C
C
E
H
D
C
H
L
C
D
M
M
J
B
C
E
C
C
Was
looking
at
men
instead
of
max
but
yeah,
but
it
it
basically
rather
than
propagating
the
man,
it
returns
the
the
other
value,
so
so
so
with
normal
max.
If
one
input
is
nan
and
the
other
there's
a
actual
value,
it
returns
man
with
this
one.
It
returns
the
value
rather
than
the
man
yeah,
and
we
only
need
floats
on
that.
One
we
don't
need
doubles.
The
double
form
is
armed,
sixty-four
specific,
so
it's
gonna
be
lower
even
for
vector
128
arm.
32
is.
H
L
B
E
D
C
E
G
D
H
B
I
C
It
says
which
one
from
right
do
you
want
to
use
for
the
multi
addiction?
There
are
great
light
index
yeah.
It's
particularly
useful
for
if
you
have
a
set
of
constants
you're
going
to
be
multiplying
by
and
you
don't
want
to
have
to
trash
a
bunch
of
registers,
is
it
by
conducts
or
relevant
to
Lux
it's
a
bite
which
is
an
element
index.
Okay,.
C
N
Gold,
sorry
yeah
all
right
so
I
think
the
origin.
So
the
specification
there
is,
it's
missing
the
discussion
we
had
about
last
time,
since
that
particular
form
was
there
for
the
convenience.
Since
more
often,
people
would
like
to
use
the
scalar
value,
but
that's
a
discussion
we
had
to
get
below,
which.
C
H
C
H
C
C
H
Okay
and
just
hope
that
nobody
accidentally
hits
this
overload
unless
I
intend
to
yeah
I
mean
I,
can
see
both
arguments
but
because
I
mean,
if
you're,
if
you've
hit.
This
overload,
you've
probably
hit
f1
in
the
idea,
even
like
one
on
our
business
right
index
parameter
and
then
I
didn't
realized.
Yes,
this
is
what
I
wanted
or
hold
up.
Let
me
backspace
and
remove
that
fourth
parameter
p.m.
I.
M
D
I
mean
honestly
overloading
barity
is
not
that
bad,
because
it's
pretty
often
intellisense,
we
really
with
people.
If
you
have
very
subtle
differences
in
types
because
then
it's
like
well,
you
have
to
really
meet
the
documentation
of
what
this
thing
does
what
this
guy's
like.
Well,
it
tells
you
that
it
takes
a
bite,
you
know
and
another
index
which
you
would
have
to
pass
in.
Somehow
I
didn't
like.
That
seems
not
something
you
would
accidentally
do
maybe,
but.
G
G
H
D
G
G
Because
really,
the
problem
is
when
somebody
finds
this
and
they
hit
f1
they're,
going
to
assume
that
all
of
the
same
thing
with
the
same
name
is
going
to
behave
the
same.
It's
the
complexity
of
life,
no
than
looking
in
the
documentation
like
realizing
that
between
here
and
here
it
was
actually
a
very
different
thing.
You
know
the
name
didn't
change.
C
That
I,
don't
think,
select
scalar
would
quite
work,
but
maybe
if
we
inserted
by
in
the
middle
there
so
multiply
and
by
select
scalar
yeah,
just
from
I
think
select,
scalar
would
indicate
like
if
you
select,
for
it,
does
only
2/4
and
use
everything
else,
the
same
yeah.
So
you
should
be
selected
instead
of
select
but
yeah
yeah
looks
by
add
by
selected
scalar
or
index
scalar
or
something
yeah.
That's
a
what
about
multiply,
add
by
scalar
index
or
if.
G
C
B
C
D
G
K
C
G
C
G
C
K
G
G
One's
going
to
understand
us
indeed
well,
let's,
but
obviously
minuend
is
related
to
the
subtract,
D
half
and
then
you
look
at
the
forms
like
you're,
not
gonna,
remember
which
one
it
is,
but
that
order
matters.
But
what
really
the
important
thing
is
we
use
a
word
that
makes
it
clear
that
it's
related
to
the
subtractive
parts
and
the
multiply
party
yeah
well.
H
D
E
C
H
C
D
C
C
G
I
mean
like
well
well,
I
think
that
the
names
need
to
match
that
met
semantics,
that
making
the
parameter
orders
be
correct
and
not
doing
like
jet
twists,
and
that
nature
seems
like
you're.
Using
your
programming
against
the
is
a
the
name
is
gonna
help.
You
say
like
one
of
the
like:
we
have
left
right
and
the
other
one
and.
H
That
tells
you
which
one
is
special,
so
one
thing
that
we
could
do
to
assist
here
is.
We
could
also
imagine
having
a
like
a
code.
Analyzer
that
says
hey.
You
are
within
the
same
method,
calling
x86,
f,
MA
and
arm
f,
MA
and
you're
passing
the
parameters
and
differently
in
both
places
like
you
can
imagine
that,
via
something
to
help
developers
see
that
they
have
a
problem.
I
yeah,
if
they
use
named
parameters
as
I,
would
probably
do
if
I
were
coding
against
us
and
like
it
won't
be
an
issue.
I
C
H
H
G
G
D
C
E
E
C
Someone's
gonna
I
had
a
different
man.
Team
are
generally
when
something's
been
complex,
like
this
we've
shared
what
the
term
means.
Okay,
just
to
give
everyone
on
this
make
sure
everyone's
on
the
same
page,
at
least
some.
What
I
don't
think,
there's
any
better
name
or
anything
else,
but
we
generally
just
share
the
roughly
share
of
concepts.
C
C
K
J
C
G
C
D
C
Reciprocal
estimate
does
a
it's
basically
a
fast
way
to
compute
1
over
X
without
computer,
and
it
introduces
some
margin
of
error
divisions
expensive
this.
Does
it
faster
just
with
a
minimal
amount
of
error
introduced
use
for
games
primarily,
but
for
other
places
where
faster,
if
Matias
wanted,
except
and.
G
Yes,
4
polynomial,
multiplying
this
gaming
of
the
x86-based
9
essays
have
a
similar
thing,
because
if
we
really,
my
point
would
just
be
if
we
added
vector
64
events
to
the
x86
ones
eat,
especially
because
I
assume
it's
not
going
to
be
the
same
exact
instruction
in
the
end
and
no
typing
coating.
We
should
be
as
consistent
with
the
overloads
here.
Is
that
one?
So
if
we
added
convenience
wrappers
from
in
to
long
and
stuff
there,
we
should
do
it
here
and
if
we
didn't
there,
we
shouldn't,
but.
G
C
B
G
H
C
G
And
reciprocal
square
root
for
x86
yeah,
we
already
didn't
use,
estimate
to
make
it
not
feel
like
a
stem
I
would
match
the
terms
across
the
two
if
there,
as
long
as
they
are
functionally
equivalent
like
that
they're,
both
producing,
not
exact
answers,
then
you
have
the
reciprocal
ability.
I
can
go
either
way
so.
M
H
D
There's
an
argument
for
consistency
between
them.
Would
that
be
the
only
thing
it
would
say
is
like
it
will
be
very
impossible
to
align
until
in
arm
in
general,
so
I
wouldn't
even
try,
because
if
you
try
to
make
things
more
consistent
than
you
actually
can
you
actually
do
with
this
servers?
I
think
I
think
it's
more
important
that
arm
defendants
Elvis
self
consistent,
because
that's
the
only
thing
you
can
tell
people
or
explain
people.
B
A
D
C
G
The
parameter
yeah
talking
about
the
memory
errors
reciprocal
step.
The
final
parameter
which
is
currently
named
index,
is
not
indexing
into
left
or
into
right.
If
it
is
the
step,
the
number
of
steps
or
the
step
number
you
think
you're
on,
then
we
call
it
that
one.
What
are
left
and
right
here.
The
first
event
is.
G
C
K
C
D
So
here's
another
question:
okay,
that's
finished!
There
was
a
little
once
and
then
my
question
would
be.
Should
we
continue
this
one,
because
we
will
definitely
take
the
for
30
minutes
and
not
finish
this
or
should
we
look
on
the
other
one
and
finish
the
other
one
I'm
not
sure
that,
and
that
helps
your
case
on
if
we
will
definitely
have
to
have
another
meaning
to
finish
this
one,
no
matter
what
we
do
well,.
C
D
C
Since
the
the
arm,
32
ones,
I
think
we
can
basically
skip
because
we're
not
going
to
be
implemented
implementing
these
four
five
O's,
we
should
just
say
we
should
come
back
to
them
in
the
future
issue:
okay
and
then
the
arm
64,
it's
basically
everything.
We've
already
reviewed
just
with
the
arm,
64
specific
overloads,
there's
no
new
instructions.
C
C
G
G
C
G
H
C
C
G
C
G
Don't
know
what
arm
does
and
that
that
isn't
like
just
this
instruction
can
generate
a
floating-point
exception
yeah,
so
that
I'm
just
curious.
What
happens
when
that?
If
can
means
sometimes
doesn't?
Oh
sorry,
means
if
you've
turned
off
exceptions,
won't
as
opposed
to
right
can
means,
depending
on
the
inputs,
it
might
yeah.
C
C
H
C
C
H
H
C
E
D
G
H
C
H
C
J
H
H
M
D
K
D
C
E
C
H
K
K
D
H
C
G
D
C
H
D
I
H
B
G
C
C
C
C
L
H
D
E
H
H
N
C
G
C
G
G
C
Yeah,
so
here's
where
we
weren't
able
to
decide
on
the
convention
here.
The
issue
is
that
so
there's
a
couple
so
max
numeric
pairwise
has
a
scalar
version,
since
it's
scalar
we
and
therefore
it
takes
the
same
arguments
but
does
a
different
behavior.
We
have
to
call
it
differently
than
just
max
numeric
pairwise
functionally
for
float.
It
is
a
max
dimeric
across,
but
when
you
count
the
half
precision
support
that
will
have
to
be
added
in
the
future.
D
I
C
Know
cuz
pair
pairwise
is
always
pairwise
has
never
across
two
registers
like
that,
it's
always
pairwise
just
means.
You
take
two
consecutive
elements
into
the
comparison
rather
than
comparing
across
two
vectors,
and
when
you
have
two
registers
you
can
catenate
them
to
get
into
one
big
register
right,
but
pairwise
specifically
is
just
comparing
two
neighboring
elements.
C
G
E
D
C
C
C
C
Comma
right,
0
plus
write
down
1
and
it
continues
for
the
entire
sequence.
So
if
you
have
like
2
3,
even
2
3
would
start
here
before
you
process
right
and
so
the
instead
of
operating
on
these
pairs.
You
operate
on
these
payers,
and
so
it's
still
a
it's
still
a
scalar.
It's
just
a
pairwise
scalar
coming
from
one
register,
rather
than
two
registers.
D
D
D
C
G
C
G
D
D
C
D
Unfortunately,
I
booked
the
next
two
weeks
next
week,
so
so
yeah.
The
next
actually
third
would
be
available
yeah.
We
will
probably
just
need
to
have
a
bunch
of
one
off
of
yours.
Yeah
I
mean
honestly
like
if
we,
if
I
think
we
can
probably
easily
fill
another
two
hours
of
just
focusing
on
this,
like.
Let's
do
one
more
thing
at
the
third
and
then
just
finish
this,
and
hopefully
we
get
over
there.