►
From YouTube: .NET Design Reviews: Hardware Intrinsics (Intel)
Description
Today, we're looking at the proposal to expose hardware intrinsics for Intel.
https://github.com/dotnet/corefx/issues/22940
A
B
C
All
right
so,
okay,
sorry
I,
like
to
over
the
current
implementation
status
of
the
other
interesting
projects,
internet
core,
that
some
people
may
not
familiar
with
them.
The
progress
right
and
then
I
classified
in
a
guy
issues,
and
we
want
to
talk
powers
to
it.
Several
categories
I
think
three,
the
first
three
I
got
more
important
that
may
block
our
following:
okay
and
I
think
we
can.
C
Post
objective
x,
cube
in
a
current
soil,
we
or
hypothesis,
and
just
a
of
you
guys
remaining
now.
You
know
I
think
that
we'll
be
finished
in
the
Romanian
work
is
okay.
The
attribute
I
suggested
to
label
of
you
remaining
ABS
pyramid,
BMI,
interesting
and
all
the
SSE
4.2
steam
precising
increasing.
But
for
that
one
we
needed
to
redesign
the
API
part
that
will
be
interested
to
take
I
thinking
and
maybe
some
more
interesting,
that's
required
by
community
in.
A
E
C
Ok,
ok,
the
first
one
is
that
to
improve
the
open
to
extreme
first
nineteen
inches,
the
API
okay
for
the
first
of
two
items
we
already
I
think
we
already
Canada
that
completely
better.
We
can
make
that
perfect
of
that
implicates
understand
that
explain,
service
and
data.
That's
we
can
know
it
by
the
overlook.
C
C
We
have
one
constant,
predator
yeah.
That
will
be
much
easier
to
implement
and
more
stable
on
the
wrong
time.
So
here
is
a
peek
at
boards
preview.
So
you
will
design
a
compare
impressing
nurse
here
and
now
we
just
help
the
below
one.
That's
we
can.
We
can
see
that
we
included
a
result
flop
into
the
function,
name
that
for
this
one
that's
corresponding
to
the
task
match
yeah,
but
up
so
that.
F
D
I,
okay:
this
is
one
of
the
api's
where,
unlike
most
of
the
other
instructions,
it's
a
very
complex,
there's
more
instructions
that
actually
perform
like
30
different
functions
total.
So
the
instructions
are
been
overloaded
and
we
need
to
have
a
good
API
design
or
how
we
expose
it
and
break
it.
Apart
into
multiple
methods,
because.
D
F
G
C
The
problem
here
is
that
okay,
here
is
that
you
can
at
home
of
it.
Some
of
the
value
has
different
somatic
different
contexts
and
at
some
discussion,
worried
about
that
is
not
very
type
safe
is
intrinsic
hold.
Okay,
we
can
use
the
most
of
the
individuals
in
this
value
in
a
intrinsic,
but
that's
doesn't
need
it.
That's
actually
needed
a
unit
mask,
but
that
actually
that
works.
Okay,
because
we
know
in
the
instruction
level,
however,
instruction
level
dance
is
that
doesn't
have
this
kind
of
type,
that's
just
a
common
subject.
C
A
C
A
D
The
way
we've
done
it
for
the
other
API
so
effectively,
the
string
comparison
mode
is
an
immediate
value.
It
has
to
be
a
constant
or
in
the
instruction
be
emitted
and
for
most
of
the
other
instructions
they
don't
have
like
name
values
per
se,
so
we've
just
had
to
take
a
bite
and
then
interpret
it
correctly.
This
is
one
of
the
cases
where,
on
the
native
end,
they
provide
a
they
provide
several
defines
for
well-known
values,
but
the
native
signature
still
takes
a
bite
has
to
be
the
media.
D
A
But
when
the
existing
ones,
how
many
of
them
are
logically
bit
masks
anyway,
where
you
basically
encode
you
know
permutations,
for
example,
but
it
always
has
to
be
effectively
and
versus
cases
like
here,
where
you
basically
say.
Well,
it's
a
number,
but
realistically
there's,
like
you,
know,
six
or
seven
different,
specific
bits
that
mean
specifically
the.
D
Only
one
so
the
only
other
instruction,
maybe
practice
the
comparison
instructions
which,
for
the
128-bit
versions
on
SSI
NECC.
We
just
broke
them
out
because
there's
only
four
or
five
compare
states,
so
they're
actual
explosive
methods,
but
for
the
256
bit
extensions.
There's
32
different
comparisons
and
we
have
an
enum
for
that.
But.
A
F
You
see
like
there's
a
question
post
here
should
string
comparison
mode,
the
typeset
we're
close
to
the
hardware
behavior
and
my
intuition
tells
me
we
are
either
doing
ginger
and
we
are
doing
good
ideas,
I
kind
of
don't
like
that
in
the
middle
which,
like
you
know,
if
we
have
opportunity
to
do
in
translates
because
they
kind
of
make
sense,
they
are
simple
to
understand.
We
just
do
it
and
we
say
they
are
intrinsic
rather
wise.
I
think
we
should
switch
to
the
mode
where
we
are
just
designing.
You
know,
potentially
you
know
api's.
F
It
potentially
take
advantage
of.
Sometimes
where
features
where
you
know
like
you
can
kind
of
keep
it
like.
I
understand,
intro
palsy,
it's
kind
of
like
in
the
middle.
It's
neither
yeah
really
intrinsic
nor
its.
How
we
will
design
idea
dotnet
API,
because
there
are,
like
the
you,
know,
viable
values
in
dying
them
that
you
can
to
know
which
ones
you
you
can
pass.
Where
would
you
go
that
far
though
I
mean
I
would
I
mean
I?
It's
not.
A
H
H
H
F
H
F
H
A
A
public
static,
class
strings,
ours
and
other
constants
don't
help
you.
Therefore,
you
have
to
know
what
you're
doing
I'm,
not
sure
what
you're
proposing
or
like.
Are
you
saying
that
you
should
just
have
a
static
class
with
fields
that
are
clones
because
that's
effective
about
the
cinemas
as
well?
Or
you
saying
don't
have
anything
that
we
just
type
in
the
radio?
Well.
F
F
H
I
I
D
H
I
C
C
Another
one
is
about
how
to
determine
expose
the
horror
engine
think
that
only
support
six
people
beat
both.
We
know.
Okay,
most
of
the.
How
interesting
we
proposed
is
Cindy
increasing
some
of
these
guys
also
operate
over
general
purpose
registers
and
that
some
of
these
guys
require
all
their
six
64
bits.
General
propose.
That's
re,
X
RDX,
something
like
this,
so
this
kind
of
enchanting
can
Alex
work
on
32-bit
platforms.
C
In
a
current
to
me,
we
just
throw
a
platform,
not
support
exception
when
you
called
a
base
kind
of
interesting
on
the
they're
at
six
thirty
two-bit
platform
right
but
okay,
but
this
solution
has
a
drawback
that
okay.
We
know
that
it's
it's
really
straightforward
if
we
use
a
SSD
enchanting,
but
before
that
we
check
if
fSV
is
supported,
and
it
is
maybe
not
six
places.
We
also
needed
to
check
environment
is
64
bits
right,
yeah,
you
know
precise
and
somebody
or
always
forget
to
check
it.
That's
so
that's!
Maybe
a
problem
here.
C
G
C
H
D
D
H
Wonderful,
a
cube,
I
know
that
we're
naming
the
intrinsic
spaced
of
the
the
is
a
but
I
wonder
if
we
should
split
it
into
you
know:
I'm
gonna,
certain
sse2,
sse3,
scored,
64
or
something
and
then
put
these
64-bit
only
there.
So
they
go
back
to
you
called
it
is
supported
and,
and
then
is
supported
for
that
one
will
build
in
the
MinC
or
60,
but
I
think
so
it's
kind
of
what
we
did
for
our.
D
H
D
F
A
Yeah
I
think
this
would
be
the
problem
and
it's
really
about
the
predictability
right
and
I
guess
developer.
What
am
I
supposed
to
do?
Write
an
API
servers,
kind
of
implies
that
you
check
one
thing:
independent
runs
truth
and
everything
is
supported
by
this
will
be
at
this
rink
over
the
same.
That's
to
ninety-nine
percent
of
the
time,
except
what
it's
not
true.
It's
not
really
helpful
at
that
point,
I
mean
maybe
analyzer
is
the
way
to
do
it.
A
Maybe
that
is
good
enough
if
it's
really
such
a
little
number
of
things,
because
it
also
feels
that
giving
have
to
split
the
types
and
center
and
said
like
I
like
inheritance,
because
it
removes
the
oh,
my
god,
I
only
care
about
SSE
or
I,
only
cable
AVX,
but
I
don't
know
I
have
to
like
remember
which
it
starts
going
to
do
some
sse2.
Will
this
leads
me
or
whatever
right?
A
F
H
J
J
H
J
D
H
D
H
D
Only
if
you
want
pop
count
of
64-bit
and
if
you're
on
32-bit,
then
you
have
to
do
like
to
pop
counts
one
for
each
side
and
that's
where
the
general
purpose
like
bit:
ops,
okay,
so
like
so
hop
count,
32
works
on
32
and
then
pop
count.
64
works,
I'm
64.
Only
because
pop
count
64
requires
a
64-bit
register.
D
H
H
H
C
Okay,
we
needed
these
ancient
things
because
sometimes
that
we
needed
we
have
a
intrinsic
that
only
works
one
base
type
of
that
actor,
but
actually
we
we
doesn't
care
about
its
adamant
type
in
the
underlying
humming
instruction
like
the
shuffle
or
move
that's
just
a
booster
advanced
doesn't
care
about
the
the
format
right,
okay
and
this
enchanting
used
in
okay,
mainly
to
situations
that
okay.
The
first
of.
Why
is
that
in
this
kind
of
shuffle
of
the
interesting
step
and
the
other
one?
Is
that
make
the
non-generic
enchanting
work
with
the
generic
code?
G
C
Floats
and
the
double
is
in
of
X
and
in
taker
versions
are
5
X
2.
If
the
user
can
write
it
their
own
version
of
the
generic
one,
that's
to
check
the
type
then
we
can
write.
Something
like
this
is
that
the
Casa
de
not
sure
I'm
happy
to
check
one
and
so
in
a
currents
problem
is
that
the
community
feedbacks
that
sometimes
we
get
a
too
many
Derek
caster
call
limit
invocation
in
their
program,
so
they
want
a,
maybe
a
more
a
better
design
to
eliminate
this.
This
kind
of
configuration,
okay
to
me,
okay,.
A
D
So
I
guess
the
the
problem
with
fully
exploding.
This
type
is
that
we've
got
ten
base
types
which
may
expand
in
the
future
and
ten
target
types
so
you're
gonna
have
like
at
least
you
know.
Eighty
overloads
or
have
read
about
that,
and
so
one
of
the
recommendations
was
to
partially
explode.
It
so
basically
drop
the
drop
tea
or
you
and
explicitly
so
so
you
would.
The
generic
type
would
be
the
return
type
and
then
you
would
explicitly
explode
the
input
type
that
way
you've
got
at
least
less
typing.
D
You
need
to
do
for
the
conversions
one
of
one
of
the
reasons
why
this
is
so
hard
in
c-sharp.
Is
we
made
the
decision
to
explicitly
differentiate
the
integer
types,
whereas
in
C++
you
only
have
the
m1
28
I
type,
which
represents
all
eight
integer
types
at
once?
So
anyone
using
this
to
work
with
integers
require
significantly
more
casting
than
you
would
in
native
code.
So
is
it
is.
F
Can
we
go
get
okay?
So
what
is
me
like
dude?
So
it's
gonna
be,
like
you
said
eighty
or
ninety
overloads,
yet
you
pulled
it.
Was
it
so
bad
because
I
kind
of
feel
like
if
we
just
expand
one
side,
people
looking
at
the
API
would
be
like
one
day
they
just
like
randomly
pick.
You
know
one
side
and
expand
it.
Well,
it's
so
not
like
transparent.
We
try
to
start
trying
to
make
API
such
that
you
look
at
them
and
you
kind
of
can
guess
what
the
designers.
C
Probably
further,
the
first
suggestion
here
density
explored
frequently
used
in
changing
to
more
based
hype,
overload
and
yeah
according
to
the
same
programming
experience
and
will
be
their
distance.
Some
of
the
enchanting
we
needed
to
export
them
to
the
order
based
hype
there,
for
example,
here
the
align
right
of
the
cadaver
ball
in
a
deck
stood
in
a
hard
well
Daniel.
That's
there
that
stays
okay.
This
supports
just
at
the
eight
bits
white
elements,
but
the
actual
we
can
use
it
for
all
the
Integra
types.
F
D
F
H
So
I
mean
you
said
you
know
10
and
10
and
then
said
8
is
the
full
matrix,
not
support,
because
that
it's
like
the
full
matrix,
okay,
because
I
remember
one
of
my
reasons.
We're
suggesting
exploding
with
generics
in
the
arm
was
not
like.
There
were
holes
in
yeah
the
story
and
it
was
like,
let's
make
it
very
clear
that
there's
a
hole
I
just
not
having
that
ended.
Yeah.
D
And
in
this
case
it
will,
but
basically
all
you're
doing
is
a
reinterpret
cast,
so
it
doesn't
care
what
the
type
128-bits
is.
As
long
as
you
know,
it's
one
of
the
primitive
types
that
the
API
supports
and
then
the
Jade
literally
today,
just
inserts
a
it
inserts
a
little
bit
of
magic
to
say
like
drop.
This
call
just
treated
as
if
it
was
always
this
type
and
but
then,
if
it's
the
type.
H
A
Mean
I
think
to
me
that
the
bigger
concerns
these
explosions
is
like
how
bad
is
it
moving
forward?
I
mean
I,
don't
see
it
robbery
would
add
like
20
more
times
to
that,
but
I
mean
one
more.
Two
more
is
conceivable
right
and
but
it
doesn't
seem
like
this
would
be
too
bad.
I
mean
their
sister.
This
concern
that
I,
don't
even
matter
does
that
cop
element
would
be
bloated
by
these
things
right.
Here's.
D
And
right
now,
the
big
part
of
metadata
explosion.
My
convention
last
week
is
because
all
the
method
calls
are
recursive,
so
we
can't
follow
multiple
method
signatures
into
one
right,
but
if
it
was
a
concern,
then
conceivably,
we
could
change
how
that
was
recognized
and
that
way
we
could
actually
bolt
signatures
together
to
remove.
F
F
F
F
F
F
A
The
poem
is
also
when
you
hover
in
intelligence-
and
you
get
this
in
a
generic
things,
because
the
choice
of
generic
silent
and
shows
the
determiner
fell,
and
it
never
looks.
Nice
I
mean
my
other
concern
roses
like
right
now.
If
the
full
matrix
is
supported
great,
so
we
could
do
generics,
then
we
add,
like
a
new
primitive,
that
it's
not
everywhere
supported
and
only
suddenly
introduced.
Pn
is
e
somewhere.
We've
got
use
their
own
time
that
bad
things
happen.
If
you
explore
the
me
ever
have
a
problem.
A
D
A
D
A
A
F
D
Well,
it's
still
operate
on
the
internet
types,
so
so
this
is
where
last
week
we
discussed
things
like
set
all
that
nerve.
We
might
want
to
move
to
the
actual
tigers
themselves,
in
which
case
you
might
consider
exposing
factor
128
dot,
cast
to
write
whatever
we've
got
a
similar
method
for
spam,
for
example,
right
or
I,
guess
with
unsafe,
we
call
it
as
so,
you
might,
you
might
consider
vector,
128
ads.
We
want
to
take.
B
F
A
Recorded
the
same
issue
last
time
at
that
we
said,
like
the
two
things
we
should
put
on
the
on
the
macro
type
is
effectively
setting
and
counseling.
I
think
this
is
the
other
side
of
it,
because
I
still
talk
to
the
visualization
and
it's
the
plastic
side,
so
I
would
say:
yeah
I
mean
the
day
I
mean
there
is
a
Hana
independent
I
did
that
we
just
yeah
like
working
around
our
type
system,
so
they
should.
They
always
work
they're
independent
of
whether
we
add
new
primitives
or
not
so.
D
Them
crust
like
actually
no
well,
no
I
was
saying
like.
If
you
expose
a
method
called
like
adds,
you
have
32,
then
you
could
just
say
you
know,
vector
or
laughs
dot
as
you
and
32,
when
you're
passing
in
it,
which
is
very
readable,
it
doesn't
require
the
brackets
for
generics.
Yeah
would
be
exposed
directly
on
the
vector
pipe.
So.
D
A
A
D
The
other
point
is
for
the
it's.
The
first
point.
Therefore,
the
methods
where,
like
the
the
instruction
manual,
says
it
operates
on
bite,
but
where
people
may
want
to
also
operate
on
it
as
if
it
was
a
UN.
Do
we
just
want
to
expose
a
despite
and
tell
them
to
use
the
cast,
or
do
we
want
to
expose
additional
overloads?
I
would
imagine
just
the
cast
to
keep
it
simple,
and
that
way,
it's
clear
that
this
is
what
it
actually
operates
on.
A
A
G
A
C
A
C
That
changing,
collectively
I'm
terrible,
that's
okay,
have
to
track
the
somatic
on
all
the
integral
hype
that
in
this
situation,
we
can
explore.
Oh
yeah
all
done,
but
a
situation
like
the
Nats
and
every
that
others
wants
to
manually
a
single
binary
base
with
the
integral
type.
Then
that's
the
last
cutter.
It's
to
the
float,
audible.
G
D
C
Never
been
children,
okay
and
now
we
know
that
so
we
already
exposed
all
the
ssee
to
a
dev
site
next
to
me
and
that
there
are
some
new
employment
from
the
community
and
other
most
of
them
scattering
cheating,
that's
not
properly
abstracted
by
Crone's
language
yeah
here.
So
the
two
questions
comes
from
these
kind
of
requirements.
We
think
the
fertile
is
which
instruction
should
be
that
again
as
part
of
the
interesting.
C
That's
a
this
word
parlance,
just
a
comes
when
my
wife
and
most
of
them
don't
have
it,
although
it
can
also,
but
from
our
I,
think
that
we
think
if
they
say
part
us
already
have
this,
how
increasing
we
probably
need
that
you
matched
since
it
was
past
time
if
it
started
to
break
the
C
sharp
static.
Do
you
know
how
C++
jobs
which
engines
explain
like
what
word?
What
was
their
thought.
I
I
D
Infinity
I
think
for
the
most
part
for
most
of
the
native
intrinsics,
having
looked
at
the
ones
that
the
various
compilers
exposed.
There
is
a
corset
that
is
shared
between
them
and
for
the
most
part,
they're
things
that
are
difficult
to
do.
Code
pattern,
recognition
on
so,
for
example,
had
with
Carrie
that's
difficult
to
recognize
an
exact
pattern
for
to
get
it
to
emit
yet
carry
instruction,
and
so
most
of
all
are
in
fact
all
of
the
compilers
expose
an
ad
carry
intrinsic.
D
So
you
can
explicitly
say
this
is
going
to
be
a
carry
operation
optimize
it
as
such.
There's
others
like
dev
mod,
where
only
1
or
2
D
compilers
expose
the
intrinsic,
because
that
one's
generally
easier
to
recognize
that
happen
for
just
look
for
it
divided
in
a
modulus
operator
on
the
same
line,
but
some
it's
something
that,
like
the
JIT
today,
doesn't
recognize.
So.
F
I
I
D
H
D
Require
SSE
to
episode
right.
It
must
be
fairly
new,
but
there's
some
of
them
like
which
may
have
specific
CPU
support
like
the
enhance
repeat,
move
string
by
that
one
is
it's
been
supported
since
the
first
Intel
CPU,
but
on
newer
CPUs
there's
a
specific
feature
that
says
like
this
is
as
fast
as
a
optimized
xmm
copy
for
various
cases,
but.
C
H
The
feed
the
encoded
instruction
would
be
the
same.
It
would
work
all
right
right
because
my
I
mean
not
really
doing
the
answer.
My
guess,
what
like
we're
saying
everything
else,
it's
the
name
of
the
is
a
to
defined
it.
So
this
is
something
that
was
defined
in
286
and
we
just
make
a
class
I
knew,
Asics
and
and.
F
A
Only
argument
against
it
is
thank
you,
I,
don't
know
what
our
minimum
requirement
is
right
now,
400
on
and
run
time,
if
it's
something
that
came
out
five
years
ago,
when
was
this
would
also
be
okay
to
say,
that's
our
baseline,
that's
what
we
call
base
and
everything
that
ships
after
is
named
after
the
actual
instruction
set
right,
because
I
mean
at
this
point.
Who
cares
where
there
was
aid
any
sings
for
286?
But
this
is
like
ancient
history
that
you
don't
know
anymore
well,.
A
F
D
G
H
F
H
D
I
think
it's
basically
anything
that
was
always
supported
his
base
and
everything
else
is
in
the
cpu
ID
check
and
so
far
we've
said
that
anything,
that's
behind
the
CPU
ID
check
for
an
actual
encoding.
We
put
it
behind
a
corresponding,
is
a
within
his
supporter,
check
and
I
think
we
should
probably
just
keep
that
for
logical
sanity.
I
think.
F
A
You
can
basically
now
to
eight
years
by
exactly
the
same,
because
it
because
the
Germany
doesn't
scale
right
so
like
sensitive,
so
the
problem,
so
we
did
the
same
continent
conversation
on
pop
card
right
for
some
things
that
we
will
implement
everywhere.
The
way
it
should
work
is
the
everywhere
API
virtually
just
has,
if
statements
in
it
that
calls
interesting
now.
A
D
H
D
D
F
F
D
D
J
A
I
mean
that
that
one
I
have
to
be
honest,
I,
don't
care
that
much
because
I
would
say
that
that
is
shown
to
work
managed
code
right
like
it's
always
that
you
call
the
method
and
it
does
something
right,
but
I
think
the
question
is
I.
Think
it's
fair
to
say
that
some
of
the
intrinsics
probably
should
be
general-purpose
methods,
because
we
know
they
effectively
support
everywhere
and
if
they're,
not
at
least
we
ever
send.
A
D
A
A
F
D
F
A
A
K
F
A
A
Other
side
of
it
very
integral
could
be
a
general-purpose
methods
where,
depending
on
the
CPU,
we
use
different
intrinsics
and
those
you
code
are
in
c-sharp.
You
say
if
this
is
supported.
Call
this
else.
If
else,
if
else,
if
else,
if
and
then,
either
throw
or
young
locked
up
all
day,
but
it's
all
c-sharp
code
rather
than
there's
some
magic
component
in
the
jib.
That
is
like
three
pages
long
and
you've,
no
idea
what
it
does
and.
D
C
D
Guess
the
other
question
here
is
we
made
the
decision
last
week
to
just
not
do
generics,
there's
I
think
for
x86
other
than
static
cast.
There
was
three
or
four
methods
I
think
broadcast.
A
scaler
was
one
of
them.
Where
we
currently
exposes
a
generic.
Are
we
going
to
make
the
same
decision
just
explode
them.
I
H
D
D
D
D
H
G
H
D
H
J
K
A
H
C
C
F
H
H
H
A
D
D
A
D
D
F
A
C
A
A
The
original
here,
alright,
so
then
I
think
you
have
covered
everything.
Then
I
will
post
the
notes.
I,
don't
know
where
I
will
put
them
right
now.
I
put
them
actually
on
this
one
here,
because
it's
the
only
logical
place
where
we
have
one
thing
and
then
that's
it
and
the
rest
will
be
more
or
less
email
based
on
the
CEO
thing.