.Net Foundation Design Reviews, 5 May 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: ARM API Review: Part 1 of N

Description

Multistreaming with https://restream.io/

A

A

A

I mean, would it be better just to make it break like we had we had the class and don't defined any members on it and now that's the proposal.

A

Well, but you're, adding the is like the proposed API says to add the is supported. I guess the problem is, if we extend it, it'll still inherit the thing. So we need all right. So we need to do it because we need them. We need to mask out the inherited member even on the right type, specific subclass, sad.

A

A

I really wish c-sharp did not allow base classification of static members, so I derived type invocation of static members. Well,.

B

It's kind of good and bad, because that's also the thing that enables us to say that sha-3, it says all the static members, some shot one shot, some shot three and shot two and so on. Alright, so that's the a shot. One is a bad example, but SSE we have done that right so that you can have the don't have to reason about, or was this a method introduced in sse2 sse3 right? If you requires a three year on you, don't have to worry about that.

B

But I guess that's unfortunate.

B

B

Are there any concerns with that API? Otherwise, it seems very reasonable to me this is the only one reading as it says, something like no.

C

It would be for all classes, so all our all classes under system, runtime, intrinsics arm and all classes under system runtime, 26 x86- would have respective arm 64 and x64 sub classes where they don't exist. Today,.

B

D

How often does x86 versus x64 make that distinction.

C

Very few places there there's only a couple intrinsic surround dealing with long, namely reading, namely dealing with long as a non as an actual value, rather than a reference.

C

In which case it has to be in register, but the the a few clay the few pieces where it does exist, we we have exposed the x64 class, and so there are cases like there's one for SSE for 1 dot, X 64, but a BX 2 doesn't have one today.

D

D

So when I'm right something I'm I know that I'm on a specific platform, what benefit do I get from being explicit about checking for arm 64? That is supported.

C

It tells you that you're running on arm versus running on x86, so the JIT, so you can use arm intrinsics safely under there and then the JIT will collide the dead code pads.

C

So so you're expected to check for is this particular instruction set supported, which includes checking for baseline instruction sets, because you could be running on arm. For example, in which case the x86 baselines won't be supported.

D

D

Okay, I think it makes sense to me.

A

D

A

Question is, should we add the the second half of the check or not so if you said child Shaul, one-armed 64, that is supported but you're on arm 32. Should that return false? Because why are you asking an arm, 64 question and well, given that no one should really be hitting these sub ones, because we haven't defined any instructions uniquely under them. I would be fine with saying, let's just add the redundant check for the pointer size. Well,.

C

The way it probably be implemented is the same way it is supported are today, which is we actually have two copies of of the class. One is used for the arm compilation and it always returns false for the x86 and then onyx, and then there's a separate implementation for x86, which is recursive and the JIT handles, and there's already all the hookups for the JIT to handle that today.

A

You okay, but is so it's going to be the same. Legit fills this in.

C

The platform where it can return true, the JIT- will fill it in and on platforms where it can't return true, it will always be false. Okay,.

A

Yeah I would recommend that we make it have the behavior of the commented out sub expression, which is because it says, arm sixty-four, even though it's not actually the instructions that are talking about our actually relevant to arm sixty-four, that it should return false because don't don't let things get muddled right.

C

That's the way they all work today: okay,.

B

I mean one's a bit odd. With that pattern, though, is I thought is supported, is effectively guarding the members on that time, but in this case it wouldn't guard the members on the arm sixty-four time. It would guard the members on the containing type right.

C

It's guarding the members so so arm six. So in this case, Shaw wand arm 64 will also expose the members from arm base arm 64, because that's the way the c-sharp compiler exposes them, and so the is support. It is basically saying I'm 64 bit and I support sha-1.

C

And it avoids the weird scenario where you would dot off of it and it would return true, even though sha-1 returns false.

C

You so you can there's still members that you can access on it. So.

B

Basically, what that means is, if I'm doing sha-1 blah blah blah in order to know whether blah blah blah is but I still have to only ask sha-1 dot is supported, but if I want to access other members on sha-1 or arm 64 table blah blah, then today the problem is because the is supported is defined on the base type. It would lead to misleading results.

A

Right I believe there are no unique methods exposed via sha-1 armed 64, which is why we're in this state. We didn't, we didn't define that class, so it inherited it from the base class. Correct.

E

B

So guess what I'm unclear is like what calls are actually guarded by his newest supported thing like what can I.

F

B

C

B

C

B

C

You did the chip, if you did the check, then it would. It would tell you that and- and it was supported, then you'd be able to call any of the ARM based arm sixty-four methods and they just work. If you, if you call the check and it's not supported, then you then the code path will never be hit and you don't have to worry about it.

C

Now there could be a scenario where a user does the arm, 60 does sha-1 arm, 64 dot is supported and they call in arm-based arm 64 method and they're, not realizing they're doing that. But that might be something that we should handle by by an analyzer.

B

I guess I'm confused now, because, if the, if it guards nothing, why is it important to have these things then, like? What will people make the.

C

The issue is that shot. The way it works when you have an actual x64 class is the x64 class is a combination of be the containing classes, is supported and in pointer size equals eight effectively so sse2 x64 is both sse2 is supported and int pointer sizes. Eight.

C

However, if you move to avx2, for example, which doesn't have an x64 class, then when the user types a B, x2 X 64, the compiler allows it but dot. X 64 is actually SSE for 1 X 64, and so you think, you're checking against avx2 x64 is supported, and you might assume that you can then call avx2 methods.

C

But in actuality, you're you're calling sse4 one is supported. Yeah.

A

So tanner is there a there right now, any reason that we would want someone to ever say sha-256 that arm 64? That is supported not today. So what? If, instead of doing what you have proposed here, we do editor browsable, never public, ABS or public, sealed class arm, 64, : or curly curly. So we define it and you will now fail to compile if you said sha-256 that arm 64. That is supported because now, we've masked out the base class, where we've masked out the nested type from the base class.

C

I think that would be fine.

B

Make more sense to me, because otherwise it's a bit weird to have seems like you're asking the wrong question anyway. Here so yeah.

A

And that's the that's. The point is that the derived type floated up from the base class right and you're you're, not actually walking through a thing that makes sense to walk through so yeah, so I think what we want to do is is mask out the class so give it know, define it give it know. Members don't inherit the base arm, 64 and then just put editor R as well. Never on it.

B

We should that.

A

Will be a recompile breaking change like if someone was doing this already, but it turns out what we're telling them is the question you asked made no sense.

C

That's probably better than a potentially silent breaking change. Yeah.

A

And if there is a later armed, 64 extension to the sha-1 things, then we can remove the e-beam ever and add the the base extension. If that's what we've done in the other types.

B

Remind me, why did we make the sha-1 extendo-arm base, for example, because there is it's basically just modeling the instruction sets right. It doesn't like people, don't usually call ARM based members to shell, one either right right.

C

It's not normally the case, but because the checks are hierarchical in nature, sha-1 support implies our.

B

B

Then I think what Jeremy said makes a lot more sense to me because they, basically you are selectively hiding branches that don't make sense.

B

B

And I think that makes sense. Alright, then, let me try to write this up in a meaningful fashion.

B

B

Is it just for I'm 64 or is this for all the nested classes? It's.

C

For all of them,.

C

B

Now this would mean you, you.

B

It would say this would be editor browsable, never edit or browse the ball. Whatever the freaking eat, it was called.

B

B

B

B

All right, so the thing that makes sense to me know that me here and paste it in here, so we can all agree on what our vote makes sense. You.

B

B

You looks good to me, yep.

C

B

Right then, that's that one.

B

Would be this one on this one edit.

B

I'm gonna apply braking change already, that's good.

B

All right sweet! So then next one, the three.

C

Four: nine to nine.

C

So we we exposed vector, 64, create methods we didn't expose, vector, 64, create scaler for double long or you long. They currently can be done via the create methods it because they just take one argument, but it's it can be difficult for some users to resolve or find them. So their proposal is just. We also expose create scalar methods for parity.

C

You we're already exposed and create scaler for the other seven types it's just these ones were peculiar because they are the same size as vector 64.

G

And we probably also can remove create for these knives. That's.

C

A breaking change, so we wouldn't be able to okay.

B

And a sensor, so basically you said: that's why it's hard to discover, because we don't have overloads that basically would look for a create scaler, but it couldn't be able they wouldn't be able to find it because it doesn't exist and the create one hasn't. Overloaded basically does the same, but it doesn't follow our naming conventions. Is that fair.

C

B

We at least hide them them.

C

I, don't think, there's any harm they functionally do the same thing that the difference between scaler and the non-scalar for every other type is whether it's a broadcast or fill-in. The first element in this case that means the same thing so I, don't think, there's any particular harm and having both.

B

And isn't only four-vector 60, full of makers. It's.

C

Only four vector 64 in every other case, the underlying T, is not the same size as the containing vector.

B

And so the only overalls, you would literally add at least three. Yes.

C

C

C

B

I'm, just looking at the existing definition of sixty-four like we have both create, we have create scaler and we have create scaler and save, and so, which ones are they equivalent to.

C

These are equivalent to create scaler it. It's so create scaler means create a vector where only the first element is set in this case. The first element is also the only element.

B

Because what I'm asking is like so basically you just said: there's an existing overload. That already is there, but you existed it's a cool into it. Existing create scalar but like we are creating the create scalar overloads for W long and long.

A

Sorry, I'm not sure what you're saying I believe it's create scaler for these three types will be an alias for create for these three types. Yes, okay,.

B

That makes more sense now.

B

You I guess why I'm confused is because you already have create scalar one. So this wasn't a complete oversight right to be basically verbally added to create.

C

B

Once we only edit them for sometimes but not for all of them right, and that was the.

C

Median and we've we didn't add them, we didn't add them for the three types where the T and the vector was the same size where they're, both 64 bits and I, believe that was just an oversight, make sense.

C

B

Yeah, don't trying to be nitpicky I, just try to understand the decisions that we made before I'm, making sure that we're not flip-flopping with decisions is.

A

Is this something we only need for arm 64 Tanner? Do we also need it for amd64 this.

C

Type exists for it's a shared type, but it doesn't have any actual use on x64.

A

Okay, because there's no namespace you're, so I, don't.

C

Know it's system runtime intrinsics, that's.

B

How I edited here is they had the same problem? Okay,.

A

I just saw the arm. 64 label wouldn't thought we were in a architecture, scope, never.

B

Mind Atena a sneaky he's, sneaking an additional feature of our goodness to Vivar alright. So then this one good or something else.

C

Three five: zero three seven and then we can just go an order after that. One.

B

All through seven, this one right.

B

C

You so this one covers various move. Intrinsics is what they're referred to in the ARM architecture manual, they're, largely just intrinsics- that take a scalar value and move them somewhere into a vector in the case of the first ones. They take the scalar value and splat it into every element.

C

So this is what vector sixty-four dot create would use under the covers, for example, it's equivalent to the broadcast instructions on x86.

B

So the tide doesn't exist. Yes, we would define the type as well right, so type doesn't exist, EDB simply.

C

That type exists already I.

B

Don't see it, maybe if you have this problem again that I'm indexing, something that is like old they'll, be Edison five or maybe.

C

Yeah, it's five-o I saw loved it. All of our miss knew four five Oh.

B

I'm in the advanced simply type, then I guess video is that right.

C

It's under the armed namespace Oh.

B

Gotcha so then, okay, so babe, this is a brand new API that then, what we also doesn't matter. What's all the time, usually, what I like to do is look at the type to make sure that the new things we're adding kind of makes sense. We do the same thing we already have, but well.

C

You could look, but it's about a thousand intrinsic that we've already reviewed.

B

Yeah, it's mostly for naming conventions.

B

So these ones don't have loads and doubles that intentional.

E

C

B

No long along the.

C

Long and you long our 64-bit, specific and so they're a little bit lower.

B

G

I still, you think unemployment, fourteen-point versions, because it's going to be equivalent to duplicate, select, selected scale levels index equals zero.

C

Yeah, that might be the case.

B

B

What does duplicate here mean? It just means it value, and you basically blasted into all the other elements cause. The value is that it were me using elsewhere. What is that? Something? Okay.

C

She's broad we use broadcast for x86 because that's the name of the x86 instruction I chose duplicate here, because that's the name of the arm instruction, which is what we've done elsewhere. You.

B

Know that makes sense then.

D

Could these ones be accomplished by an optimizer just seeing you access specific index and called duplicate detector.

C

Not trivially in in this case, these are the base instructions that we would generally use to optimize. Other algorithms, like vector 128, create.

D

Okay, so each one of these maps to an explicit instruction. Yes,.

C

C

So the general helper that people would normally uses vector 128, create, for example, and then we would implement vector, 128, create using duplicate to vector 128 or sequence of inserts or other optimizations in the JIT.

B

Yeah, to a certain extent, I mean, like that's the point of intrinsic right, that we try to if developer expressiveness, rather than relying on magic, optimizations right.

B

So what does V you mean in this context.

C

V, dupe is so dupe, is the arm 64 instruction v dupe? Is the arm 32 instruction we're not implementing arm 32 for.net v, but we've still been documenting, which arm 32 instruction. It corresponds to.

B

But it would have the same behavior just different size. It would just also call the duplicate to vector 32, poly, then or.

C

No they're also vector 64 and vector 128 on I'm 32, unlike x86 and x64, which basically used these same instructions and same instruction names just with different register, support, arm, 32 and arm 64 use different instruction names, I, see.

B

C

I'd, have these are largely functional, equivalent.

B

Yeah there would be the same methods, except that we just implement them by omitting a different of code. Yes yeah, okay, that makes sense. Okay, then we will hit selected scaler to vector 64.

C

So, in this case, it's similar to the previous, but rather than taking a raw scalar value that might exist in, say a general purpose register. This picks the scalar from an existing vector. So you could say broadcast the first element from a vector to every element of this new vector you're. Creating selected scalar is the naming that we've used for some of the other intrinsics we've already approved.

B

Make sense to me, we usually use bytes for indices to.

C

In in the case of the intrinsics, we have been because you're only allowed to encode a limited number of bits and.

B

What, if we I guess all these bytes here would also be whatever our attribute is to say there should be a literal right.

C

If and when we add it, yes, the beach, it is not limited to them being literals. It will just generate very, very inefficient code if it's not right.

B

But like fundamentally the the the opcode encodes the index correct like it's not part of it, it's not a champion.

D

B

All right, I guess this is not the same thing except for different data types.

C

Yep just extending duplicate to vector to support long and you long and then in the latter case for insert selected scaler.

C

It is picking a.

C

Picking a scalar value from a vector and inserting it into the specified index of a target vector. So in this case, if you scroll right a little bit, it's uhh.

B

You say that it's not the city, okay,.

C

It's taking value a value index in inserting it into result, result index and all other elements are taken from result. I'm.

B

Slightly confused, so you are the comment says it's effectively. An assignment result result index is assigned to I, guess, value value index or something right.

C

So you see, you have an existing vector that say, has values: 1, 2, 3, &, 4 right and you have another vector that has value, say: 5, 6, 7, 8 and.

E

C

You're going to say insert into the first vector at element: what's the value from the second vector at element, 3, in which case it would return, 1, 2, 3, 8,.

B

I guess what confuses me is that you have an argument called result and just to return the video.

C

It's the value that all other elements are taken from I, don't think we have a good name for that. We've used upper in the past, but that's generally, when it's impacting the lowest element.

C

You and then we can't use value because values the name for the thing that we're inserting.

B

So when you say insert like what does it mean, you shift all the other ones down. How is that, logically, what happens? No.

C

Like it's like taking, it's like an array assignment, so if you imagine a vector, is an array, then you're taking the element from value you're, basically doing value or result result index equals value value index. So the rest of the rest of result stays the same and you're only modifying the value at a given index.

D

The C++ intrinsics for like insert PS use, destination and source for this. Could that make sense here.

B

What I don't understand is why do you have to positive result at all I understand I would have to plus in result index, but because.

C

You need to know what the remaining values are going to be your only modifying one index. So, if you've got.

E

A vector contains.

C

8 elements you're only modifying one of those 8 and you need to know what the other 7 values are. Yeah.

B

Of course, sorry, my brain has not seen enough coffee, apparently, ok, no, no, it makes more sense.

B

G

B

G

Why short selected skill or defined on land? There are 64.

C

I didn't see an equivalent forearm, 32 or selected scaler, in particular, I think.

G

Is you can implement it for vector 128? What perfect accord float and double? Because it's the fact they're going to be just.

G

If you have result index and we're doing the constant we can figure out, the appropriate registers is.

C

It still going to be a single instruction now yeah.

G

They're going to be be more between B or D registers, I guess.

G

But I guess the mark and.

G

From the nose burger.

G

G

G

B

G

D

G

A Cleveland that looks like the black inks instruction in arms. It was back but I guess I can dig it. When I start implementing this and field, you can extend them so I'm. Second, to none 64.

B

And then the order of these instructions is kind of weird, it's very hard to see whether you missed any types.

B

C

In order for the by via the namespace names, which is the same way, they're ordered in metadata and enumeration, so it's tight in 16 in 32, I guess.

B

C

Single s by that's.

B

Why yeah cuz I'm, looking at this I'm, like Jesus, hey I, just tried to find the difference between the top and the bottom and a second, hmm it's a request moment addresses that I'm willing to I guess double is missing long. You long right, yeah,.

C

There's there's no overload that that deals with a long you long and double for the one that takes a vector, 64 value, because there's only one element and there's no corresponding overload of the instruction.

B

Yes, this it's between just a normal scalar assignment, a particular thing, which we already have probably right: Oh yeah. Alright, then, unless somebody else's constraints, this looks good after I convinced my brain, that it does.

G

G

So the vector 128 will you overload or first group of insert select scalar, because we can you insert from vector 120 need into vector 120.

C

That's what the second group is: okay,.

G

So the question became: can you do this or get 264 resolved.

C

I, don't think this is one of the ones were where you could, but let me double-check because.

G

It looks like the instruction itself accepts immediate after the maximum number of elements in vector 120, but it means still possible to use it for smaller types that should work with it before.

C

C

I didn't expose the other ones, because the index one is always for 128-bits.

C

The result is also always 128-bits. So it's not a safe operation because, unlike the ones that normally operate on 64, it would not zero out the upper 64 bits. It's.

G

Just fine because a consecutive order, 120 being in the same register it just only a lower part, is going to be used for vehicle 64 right.

C

C

We don't have anything that returns a 64-bit result and doesn't also zero the the upper 64 bit it's today.

C

G

I guess my question is confusing, so basically what I'm asking can we have? We sort select a scaler that returns vehicle 64 of T and accept vector 64 of T as a result and say accept value, but where we're inserting from all sales vector, 64 or vector one point E, and if.

E

G

C

Think we can, because the actual instruction returns 128-bits and if, if users really care about it, then they can explicitly do the operation so that their accounting for the fact that the upper 64 bits are being modified and then they can call get lower to get a 64 bit results. What.

G

Do you mean instruction returns, vector 128 result instruction, only modifies a register which we can look at as a vector, 128 or retro 64, and if it doesn't modify the upper part, no.

C

The the result, if you look at the operation under the instruction, the result is always 128 bits. So if we took 64 bit as a result here and we returned 64, then behind the scenes the processor would still be reading a 128-bit result in preserving upper bits. Whatever they were in the return value was.

G

C

It's unsafe because every other place we we actually we easier the the hardware zeros the upper bits. We don't have anything that lies about the the size that it's taking today when when.

E

C

C

C

G

You well I, don't think I agree, but that's what you're probably.

B

B

Is for the pair who don't have to agree? We can still approve that.

B

Take this offline.

B

B

One more down so which one is next, no, this one.

C

We can just go and order unless Igor has something in particular, he wants to push up no.

G

Actually, I would use this one because it's larger work, item and I need blood work item to keep up working music.

G

C

So this first set is just called shift logical because it doesn't strictly perform either a left shift or a right shift, which direction the shift is is done, is selected on a per element basis based on whether the shift, the corresponding element in the shift operand, is positive or negative. If it's positive, it's a left shift. If it's negative, it's a right shift and.

C

It's always logical, which means, if it's a right shift, it will insert zeros rather than carrying the sign bit egor at the very bottom of the issue. Here suggested that we we only expose the versions that take a unsigned operand for shift, logical I, don't necessarily have a preference.

C

B

What's the rationale for that, it.

C

Reduces the number of overloads and if you're in c-sharp, then shifting for a signed integral value is, is always arithmetic about logical.

C

And likewise for unsigned, it's always logical rather than arithmetic, so you could still get the total sum of desired operations. You might just have to insert a a cast if you wanted to do logical shift on a side and input, but that's the same as that. You'd have to do in c-sharp, I mean.

A

I would agree if it was just name shift, but since the name logical is in the name, I don't or the word logical, Xin, the name I, don't see why we would make people have to write the cast operators manually.

B

Yeah I mean to me reduce the number of overloads I generally agree with there, but this to main it seems kind of a lost, a lost war anyway, because there's like so many of them and yeah. Given that there's already quite a ceremony involved in calling any of these methods because they all tend to have very long names and non trivial type names, it seems a bit backwards to make. People also write the cast.

G

I guess it's horse eating that the instruction itself called shiftless in I'm 64 spec, even though it can shoot right right. Maybe confusion comes from the logical there may be. It could be something else, not shoot logical.

G

C

Still doing a logical shift, so the alternative.

G

C

Named it shift and then have the signed versions. Do the arithmetic shift but I don't think that's strictly clearer in the code.

C

Like when you're actually reading the code, if you just see, shift and you've got a vector and a vector where you might not have the type immediately obvious.

C

Having it explicitly called logical, helps, disambiguate and there's other cases below where we do need to call it logical, and we did the same on x86, for example,.

B

So what sorry right, I think.

A

Having logical in the name is good and I think that there's no reason to trim the signed types.

B

Which means they just stay is proposed here right because they relisted yeah.

G

The only reason I suggested to dream up inside because we have and not just one Eurasian of beasts like the logical, logical, separate, logical, rounding separate and what we call the mirroring satori.

B

Oh I see so it's not like for overloads, you're saving and saving like 40, or something like that.

G

It's like 30% citrus now, doubling the size and also it looks like on C++, well they're, not using logical. They just use instruction name or naming the intrinsic, but if they iterate on signed like they always do, arithmetic and the American canal signed it on the logical which.

C

Is a bit different how x86 works, which which supports it for either.

B

Right yeah I mean even though there's a lot of methods again like this whole domain has so many methods that it seems I mean we generally don't make people jump through hoops like that for these, so.

B

Them, as they're listed here.

G

I guess I should give the name of second parameters found because it has not been used for technical signal.

B

Emails you mean instead of shift count.

C

Yeah, that's what we named it on x86. It looks like.

B

Yeah I in there makes sense.

B

B

B

And then shift logical, scaler how's that different.

C

uh It it it's a different so for all of the intrinsics that operate on a scalar element which includes vector, vector sixty-four of long, you long and double so far, we've named them scalar because they only operate on a single element, but.

B

Which element? Are they operating on the first or well.

C

The first is the only element, there's only there's only one the vector is the same size as the underlying type.

B

Oh I see fair enough.

B

Yeah I guess that makes them.

B

B

B

What does rounding mean in this context? It's not what I think of rounding, probably rain.

C

Did you scroll down on the screen, although.

B

I schooled on my screen.

B

C

So so it's similar to rounding with normal, so shifting is similar to division by two or a power of two, and so this basically just accounts for a rounding error there. So if you did five right shift one, it would return three rather than two.

C

Or okay, something like that.

B

My bid fitting days are a little bit far away, so I am NOT following entirely, but.

C

It basically does that operation described yeah.

B

That's what I'm looking at and I'm like I'm trying to like do this in my head and it's not happening.

B

Sure do this in their sleep spell like I, just checked us forward to see what's happening.

G

B

C

It basically adds one and then does the shift yeah.

B

That's how I read it.

E

B

C

The reason the math is slightly complex is because for a left shift, it's going to add nothing but for a right shift. It's going to.

C

It's going to adjust since, since you have to account for rounding win-win right, shifting.

B

B

B

Oh yeah, my machine is not heavy.

B

All right, let's try this one more time this time, hopefully I can copy and paste the API. Yes, no I can.

B

B

B

B

Makes sense and then same thing there, Rona, scalar and.

C

Then shift arithmetic, these only support, sign types and just which also matches what we do for x86, since arithmetic shift only applies to write shift or to sign types unlike logical, which can apply to either right.

B

B

B

B

B

Shifter is not a grounded, I guess the same thing combined.

B

B

And unsigned saturate shift left.

C

Which left shifts, and rather than dropping bits that shift out it, saturates, the value? So it will overflow too, to unsigned op max value.

B

Is it what we called it before, I mean like didn't, call it accelerated or something like that? We.

C

Just used the word saturate on x86.

C

C

So ad saturate subtract, saturate, etcetera.

B

I guess in the case that is consistent of what we have done before so.

C

And then same thing but rounded saturation.

B

B

Yep and then the arithmetic version of that.

A

A

And all these shifts are they supposed to be all renamed count? Yes,.

B

Sir, that's what my screen reads already.

B

You shift arithmetic, Rome, said I tried. Ok, then one we have.

C

And then we're off the ones that can do either left or right shift and a per element basis and on to essentially all the same methods, but only left shifts and by a constant amount for all elements.

B

C

We have basically overloads.

B

For shift left shift right, all the ones we had before, instead of taking a vector as the second dagger, we just take it constant. That is a bite. Yes, yes, yep, I, think in that case, unless somebody has a desire to walk them, all I think we can say that's it, because that it seems like winds and repeat of the batter.

B

Any objections to that, otherwise just go all the way to the border. There's.

C

Some more after we scroll down a little bit all.

B

Right I was afraid you would say.

A

I mean do we know what the processor is going to do if you ask it to shift 100, this is just give you zero uhh.

A

Does it error? Does it.

B

Will format your hard drive.

G

Before immediate rush, we probably can't because going to be encoded, as in the operon, is limited resolution, but for register version. I, don't know.

A

And what's the jet going to do if it gets an immediate that it can't encode and throw jet exception.

C

So if we get a non immediate, if we get something that isn't a constant, we emit a fallback that will throw platform or that will throw argument out of range exception and we'll do the same. If we get a constant input. That's too big.

A

Okay, so if somebody says shift bright, logical, rounded ,, a hundred they'll get an argument exception because that doesn't make any sense. Okay,.

B

Which seems reasonable yep.

A

Just understanding our failure paths.

G

Registration looks like at least or described instead that it ignores beads higher than seven being. If you got some value a little bit, you know some masking using and uses only eight pieces right.

C

But I think that the question is: what happens if you shift a bite by nine and that I do not know and.

G

Probably will ship by one because it will ignore the force, be it.

G

A

But for if, if the shifts the value for shift, which will soon be count, is a variable expression, then you're running it through a validator that checks against the size of the the T in the vector.

C

No, we would just pass the vector as given to the instruction the the hardware doesn't throw on that, but I don't know what it will return, but.

A

I thought you said if it was a variable expression, then you're you're running it through a thing that checks the bounds for for.

C

The one so for the ones that take a bite shift, we make sure that it fits into the number of encoder bits or the one that takes a vector.

C

We will do no modification to it. Indochina existed.

G

Right, you just need instruction and what looks like they described from the operation for this contraction that it's just masking and only taken to account to load it be meaning with your first time in one of the register lanes and trying to shift right will effectively shifted by one instead of nine. Well,.

C

G

C

Eight bits well.

G

On night shift.

A

Shift count of nine but I think the question is.

C

If you shift a so normally, if you shift an int by more than 31, for example, the result is undefined, which is why c-sharp inserts inand 1f against any shift count that you provide.

G

C

That I think the question is: what does the? What does arm do in the case that you pass 32 to an integer to a 32-bit inch shift which is encode Abul and that I don't know? Okay,.

A

So you throw if a Const isn't if autumn dawn yeah, if it's not encoded, but if it's a variable expression so you're, following back to the to the indirect shift count version, then you just get whatever the platform does right.

C

Which the hardware menu or the operation for the instruction doesn't clarify. It just says it left shifts by the shift amount. So we have to test it and find out exactly what the behavior.

G

If you shift integer to the left on 32-bit and set a bit sheet, you ignore the upper it's very loud.

G

Saturating ones that will return the maximum bottle, but for most iteration growth network life, it's the return, zero.

A

Okay, yeah I mean ideally we'll have some tests for these things, so that we understand the behavior before people complain about it.

C

We have lots of tests, okay, don't.

G

Think recovers that corner cases.

B

All right so because.

A

If what they're masking is everything down to anything that would fit, you know less than or equal to 64 if shift bite 9? Is you get 0 because that fit in the encode abble range, then, like that's very different and interesting than shift left 65, which now means one like so being able to document, but it does have tests that prove what it does are all goodness, because this is public API.

A

B

Yeah so I scroll down to past the group, I think I think is the first one shift left logical, saturated unsigned, really have a new naming convention.

C

Yeah, so this does logical, left shift and I. Don't remember off top my head. What the unsigned part means: I guess.

G

Etcetera up to maximum value, okay is pointing unsigned type.

C

Yes, that would be the case, so it would return s byte, dot, min value rather than s, white dot, max value.

C

C

It returns byte dot max value because we return an unsigned result. That's why they're called unsigned it takes a signed input and returns an unsigned output.

A

And it's bit bleeding so.

A

Having just a hiber as doing shift to zero of a negative number gives you back the unsigned cast interpretation of that number.

A

The site, the you you specified assigned type going in, but it just immediately cast it unsigned before doing the operation I believe.

C

It casts it too unsigned after doing the operation.

A

So it would preserve the high bit and then cast.

A

A

I'm just trying to understand what it, if you that you gave it a you give it you know in the best bite you give it 7f and shift it left. One. Are you getting back 7e or you getting back god? F e, yeah I know X.

C

It looks like it's preserving the sign on the original input, okay, which.

D

Ways the native instruction so.

C

Right it treats it as a signed input and then returns an unsigned output. Okay,.

A

Very complicated, I'm sure there's a formula that needs it. Yes,.

C

For a risk architecture, there are lots of complicated instructions.

A

Maybe they forget what the R stands for.

B

Saying produced was the starting point: man that worked their way up from there all right. So then I guess that makes it I mean, is yeah.

A

The only question is, is this: do we have anywhere else that we need that we've combined saturate their saturated nests and sided nests, and are we being consistent in our adjective ordering ah yeah.

B

That's the same question I had originally.

C

I put the unsigned after because it's returning and it's it's it's a.

C

It is effectively ah returning the unsigned saturation rather than doing a shift left logical, which is unsigned.

C

So if we put the unsigned after left, logical I think that would imply that the the input is bit cast and then done it its reinterpreted and then done the shift rich versus saturated unsigned, which hopefully makes it clear that the left shift is signed. And then the saturated is the unsigned thing. Sure.

A

I mean I, don't know that it makes it clear, because I had to ask the question, but the I can buy the unsigned his last, because it's the last operation done, even if that means that we're inconsistent with something else so yeah all right. I.

B

Mean consistency seems gently hard here, because the instruction sets are not really consistent of how they do things either right. So.

A

This is if we, if somewhere else, we already had a thing that combined saturate and unsigned and was something other than shifting or whatever like like. If it was, you know, multiply scaler saturate, unsigned, I'm, saying words: there.

G

Was actually a G's in the right order.

A

G

Yeah there is a science iterating extract on side, narrow.

B

Yeah that that comes further down the right wing.

G

Yeah I, don't think it's here, but I mean if we're thinking about order where we should point outside right and the future will need to review instruction that will do unsigned and narrow I.

B

Think is a as a principle for constructing these names, I think holding them in the order in which they are logically occurring. I think makes probably the most sense yeah.

A

I can so I guess. The only question is because we were talking about clarity, I'm aware the names are already long, but should it be because we're putting signed after the shift, so the chefs grouped together, should it be shift left, logical, signed, saturate or to saturate imply signed well.

B

They did I, don't.

A

Know what saturate means I think.

C

Saturate implies, whichever sinus it was starting with. So if you're doing sign saturation, it will cap at s by top max value, or so, if you're doing unsigned it will cap it at height, dot max valid. So.

A

So if I had under stiff I'd known what saturate meant, then I would have known that that meant that it was already assigned operation and then unsigned comes later. So that is the order of operations so well. The.

C

Left shift is signed, whereas the saturation in this case is being done as unsigned.

A

Wait what that I thought if I understood that you said saturate meant that it uses the bounds of the input type, and that would be the high bid is prohibiting out of my example of left shift. 7F I one would be 7e well.

C

Yes, if the saturation was being done with a signed input, the way this works is it take. It does a left shift taking on a signed input. It converts that result into an unsigned result, saturates, it and then assigns the result back out.

C

Okay, and what does that mean? Saturate means that if the the infinitely precise value is over the max, then you cap it to max rather than truncating, so so in max value, plus 1 is int dot max value, not zero.

A

C

All you are naked.

A

A

So if it's doing saturate based on the after the unsigned conversion- and that would mean all negative numbers turn into zero.

A

But if it's doing saturate on the sign conversion, then it would mean they stay negative and then they just turned into a unsigned representation of that negative number. There's.

C

An intermediate here that is more precise than the total sum of bits you can represent. Okay,.

A

But if, if the so I guess, the question is, is the saturation done on the signed type or the unsigned type? Because if it's on the sign type, it should be left of the word unsigned and if it's on the unsigned type, it should be on the right.

C

The the shift is signed in the saturation is unsigned.

A

To be shift, no because then it would sound like chef, illogical, unsigned, okay, it's fine! No one will understand this move on the next thing.

B

Beautiful bird mistake, I think that's the conclusion here to.

A

Ask a silly question: emo. Is this what you feel like when I bring up crypto things pretty.

B

Much I mean most of the time is just like. As you said, you just combine many inverts and then you ask trying to ask questions.

A

Before you've been like, this is crypto, no one will understand it. Let's move on and I feel like I got very close to something that you'd said previously. With this once.

C

So this next one is shift right, logical and then it returns a result that is half the width of the input.

B

Is that all we call it before, I mean I, think I've seen lower before um much of a narrow.

C

Right in this case, it's lower because it returns the the lower half of of the of the result. I.

A

Think I understand this one. So.

B

What is narrowing in this context mean because you, basically because because you're cutting the tie basically around right.

C

Rather than returning short, it returns s, bite versus widening, which would take s bite and return short and all.

A

The vector one twenty eighths become vector 64, so they don't change their index counts in and out of the operation for things went in for things come out, they're, just half the size when they come out, I get it.

B

Yeah I think that's one I can follow as well you you know we have a Roman version of that and I.

A

Assume we're saying lower here, because there's somewhere that does narrow upper not yet necessarily on the shift, but just like in this universe. Yes,.

C

There's a shift right, logical and narrow upper okay.

A

So yeah I think that that name is very clear and I don't mean that sarcastically no.

B

No I mean most of what you work on his not names like that, and.

C

Then here's the shift left version which widens.

C

King vector sixty-four input returning vector, 128 output, Y.

A

Would widen need lower vs. upper.

C

Because we're returning something that's twice the number of bits so so.

B

You have to stay where the bits go right, basically, but.

G

In this operation will occur, a target to 128 is back and will only read upper part of the Poynting crazy stuff.

A

Like it, so, if I understood the, if I understand the order of operations that Oh ah like this would do the shift left as vector 64 of s bite and then, after it's done with that, it will essentially just widen copy it to a vector 128 of short, which means there was never an upper to take into account. Unless this is on the weird infinitely precise version of things in.

C

Which case they're all they're, all basically infinitely precise. But aside from that, the the upper version takes a vector 128.

A

Okay, so we're naming we're naming the 64 lower so that it's an overload of the 128 lower, so it's different than the 128 upper. Yes,.

C

Okay, cool because we have to differentiate.

A

Yeah, okay I was, as this vector 64 going to the 128 with the widening. It's like I, don't I, don't see where you need the lower versus upper, because there are no upper bits, but if it comes from the vector, 128 and all I told ya, it's.

C

For consistency across the total group of methods for here.

D

Good with me and.

C

Then shift right, logical and narrow, saturate, lower half and the.

B

Quite a name yeah I.

C

I think these the shift intrinsics have the most interesting name combinations, since they are various combinations of regular rounding and saturating I. Think there's another term used in the manual on some places.

B

You should write a book tanner intrinsic sianeth, headed reference or something where we have the full graph of all the api's. And then you get to put random comments on api's I.

C

Thought that's. What recording in live streaming to YouTube was.

B

We still have 21 viewers to my to my shock and surprise.

B

Shipwide, arithmetic and narrow, set rate lower.

B

That makes sense too.

B

And then shift writer with and never running, saturate lower.

F

C

For the parts where we're getting in iron 64, it was pointed out that, due to the way that arm 32 encodes its registers, many of these, specifically the upper versions, should actually be on the base arm class.

C

Rather than underarms 64, specifically.

C

So that's just a number of these should be underarm thirty-two rather under the general arm, rather than underarm sixty-four I. Don't think we have a complete list of them today, but I don't think API review largely cares, as long as the names are correct. Is that right that.

B

It's a very fair assessment. Yes,.

B

I mean the general injustice also care about you know, consistency and that people can predict what it means when things under certain types right. So it's so long. We are consistent in that regards. It's fine by me, I mean. Let me know any better where stuff shifts into me, where were they actually available or not? Oh I,.

A

Feel like I've asked this before, but I forget the answer. If somebody regularly writes things with arm assembly- and they know that they're looking for squish horn too, they have a good way of figuring out what we called squish horn.

C

So today they can go to source dotnet, go type in advance, sim, D and then type in squish horn and they'll find it Egor Bois wrote a tool for x64 that map's the names between the two of them I'm likely going to ping him and see. If he's willing to extend that to support arm as well, I believe it's open source, so I could probably even submit a PR there, but that's what people are largely using today.

C

There's been requests for a helper library that uses the C++ names but I, don't think that's something that belongs in dotnet. One.

B

Thing we could be doing that crazy idea. I would not actually do that, but you know that in in Visual, Studio and I think vs code is that there's snippets, which is so, for example, if you say for and then you tap, we generate a full loop for you. You could imagine that we have snippets for all the instructions. So when you say it squish one tab, we would actually extend this to shift, write, arithmetic and narrow round a set rate lower, for example, that one would be very easy to.

C

Has anyone tested es with 4000 Tippit's, no.

B

But like I mean there's always a first for something right and.

A

Really you'd want it to be like armed squish horn and then.

C

It expands to the bright static call on things well and then you'd have to have variants for the arm, intrinsic name, which may not be squish for him right right anyway.

A

Just I know that we like that when we started doing the intrinsic sweet, we said we wanted this. You know semantic names instead of just the yeah assembly names, but as long as we've thought about the scenario where somebody's more familiar with the assembly name and- and we have a story or we at least think that in the future, we'll want a better story than that I'm, just making sure we thought of it honestly.

B

I, don't think it's nipples will be that bad, because even if you could say arm 64 dot, I mean you can still do the same thing. Wait. Maybe you don't get to say dot, but maybe you have to say arm 64 or something why we could come up with some convention where we could make this lipid saying right.

B

I, just think it should be more of an editor thing. I think shipping elaborate might be a bit too heavyweight for that answer, because it's mostly editing experience, because the other thing is also what's nice about. It is that you teach people what the actual names are.

B

Helps with these names formally but I mean, presumably when you write code like this, you probably have like I, don't know it's certain set of instructions that you do a lot and so probably as you're doing that eventually you'll, you know to just use the word again. You would saturate whatever knowledge you need to have to be successful.

B

A

Would narrow, saturate lower at the knowledge gap.

B

I'm 64, so that's it I guess these are the same things as before, but for different data types again that fair.

C

Yes, largely, except for the upper variants which, like I mentioned, probably belong on the advanced MD class yeah.

B

Maybe I should write a note, so we don't forget this. Can you okay, so basically which one the upper variants belong? Make me yeah.

C

Most, but not necessarily all of the upper variants should be on the be advanced in B class rather than arm 64.

G

So shift across I think all of the other can be implemented on arms as it were as well.

B

B

Here we go I'm 64, VOB I, almost halfway through it's, not that bad. Only.

C

600 dishes.

B

Shift, arithmetic around, etc, scaler.

C

Yeah, so these ones are actually think a couple of these Igor called out. Aren't ballad, overloads, I misread the encoding, and it's actually only supported on long nu long right.

B

C

B

Care less about like it's just you know, yeah.

C

So the planning.

B

C

G

If your store are really non situating, questions are not really.

C

Okay, so it's valid for saturate, it's not valid for the or the rounded ones.

G

Magic scaler as well.

C

Yeah, so the the first two groups are fine in the second two groups on the page. There we need to draw.

C

B

You you admire your optimism. I just saw your message in chat via said after we have time or like if we still have time, I.

A

B

A

That at some point, all of these, like that, there's going to be a jet test or whatever that makes sure that all of these get encoded to the right thing, and at that point, we'd notice. This instruction doesn't exist or this form.

C

A

Exist, we just removed them, which is.

C

A

C

Add we add, emit tests that validate the encoding and then we also add tests that call all of these methods from c-sharp using various input types, including fields, locals class variables, addresses, etc. We've got hundreds of thousands, maybe even close to a million lines of tests now covering all of X, 64 and armed school, just yeah. So.

A

I mean at that point I, don't think any of us would have any like. Oh, but we approved this thing. It's like whatever it didn't exist, don't care we're not really I mean we're only looking at the shapes of things.

A

Just saying, if you're removing these because they don't exist, then that's fine right.

B

B

So let me just aggressively keep scrolling down shift. Arithmetic, saturates, Kaler looks familiar.

B

Take around a skater, he was also familiar.

B

Gather it doesn't sound time media, but it probably should because it's a shorter version of it, shivved logical, rounded, saturated scaler,.

B

Did you actually ride them, whether to use a Markov chain like that seems like a.

B

C

Many many hours and lots of lots of mountain dew, reviewing things API and the manual and trying to get them right.

B

She logical saturates, killer. She confounded scaler, cheap, logical, scaler,.

B

Okay, these one looking you sign, extend and widen lower people. He revealed something like this before so.

C

Igor pointed out that for sign and zero extend, they don't take a shift. These would largely be convenience overloads if we exposed them, they can be achieved by using shift left with zero. I believe is the actual instruction alias so whether we expose them as just a question of do. We want to provide that convenience to end-users.

B

A

Does that mean that the JIT is gonna understand that you called shift left logical and widened lower with the constant, zero and omit six tool because it's shorter? It's.

C

Actually, the same instruction six toll is encoded as signed shift left long with a zero immediate.

B

C

Actually, this it's in it's an alias at the assembler level, but it's the same encoding in Hardware, okay,.

A

So if you, if you disassembled it, it would be disassembler convenience to decide that zero meant show six tool instead of sll zero right.

C

There's actually a comment that says: sx6 stool is equivalent to Churchill and the end six stool is the preferred disassembly when, when the immediate is zero, okay,.

A

A

So so this is not really, but it is a an alien instruction, alias that they talked about. So yes, if someone thinks in those terms then I think having it here is fine, but then the bite shift parameter just completely disappears. All.

C

Right bite shift would drop.

A

And same with zero extend it's just a leus instruction, yes, yeah I think the name is fine and the signature needs to match the instruction and, assuming that these summaries are making it somewhere into Docs. You know if they should also be correct.

B

I really need is a voiceover commentary from 10 every pronounces, all the instructions I.

A

Think so far I'm the one making up all the pronunciations I'm happy to let somebody else come up with squish run.

C

Continuing just being the pattern of concatenative our terms together in super long sequences, we've got shift right at arithmetic, unsigned, enero saturate, lower.

B

Yes, sir, like the does you comment for a sign, extending widened or also apply to the zero extend when lower yes, so they also are not required. Yeah.

C

They're not required, and if we did expose them we would drop the shift parameter.

B

I see, okay, all right. The Markov chain shift right, mathematic unsigned and now it's actually lower seems.

B

Consists of what we had before.

A

I mean you: can you can insert the phrase I want to in front of it and it makes the sentence.

B

And then unarmed 64.

F

B

So in shift big unsigned and they were around the red, lower.

B

E

Does it, though,.

B

Well, I mean to me the naming make sense in the sense that it seems consistent permutations of what we had before.

F

I hate to ask those questions: I think it's been answered before, but just the size. All these names have an impact on metadata size or like or jet stream size, its or something.

B

Probably metadata size because I don't think we are smart enough to split names apart a minute at home. I, don't think it's supported it. Yeah.

C

I think it impacts a string table.

B

I mean that's a gentlemen question that I asked Tennant I. Think a while ago was like what's the matter that I impact of you know three and a half thousand or five thousand intrinsic.

C

Well, so, strictly speaking, we do have the reference assembly and we previously had JIT support for recognizing a external assembly for system numerix in particular in supporting intrinsics on it. So we could, if it becomes a problem, move them out of core lib and into another assembly.

C

B

C

Sure the first Acosta read.

B

You're not really eliminating the cost.

A

Or lib still needs them, because we have implementations that are using intrinsics already all.

B

Right you just get away with this upset, though right I mean that's I'm, saying you're kind of deferring it just to the party that actually needs them, but like the the overall encoding, is still the same size, probably even slightly larger. If you have to split it because you have to shift it across the assembly, boundaries I think metadata is smart enough that if you use the same string for like hundreds of methods, I think the string is only encoded once, but given that we have these Markov chains, there's no reuse right.

B

That's the downside, I think.

C

Would be would be one entry for each unique name right.

B

And to make matters worse, I think metadata is utf-16.

B

C

Think the type names are utf-8 rather than 16, but I might be wrong.

B

C

There's two different tables: there's one: that's utf-16 and one that's utf-8 I think it's user string is 16 and Jamie's.

B

Room yeah, I think you're right.

B

Yeah, it's not pretty I mean I mean that's something that we need to consider but outside at this point, I, don't know what to do about it, because at this point we're already halfway pregnant right, like me, already have very long names and all the other instruction sets so there's not much. We can do probably.

C

Something that could be done, but I'm not sure if it's necessarily a good idea due to how we support fall, backs for not immediate, but many of these are essentially the same instruction, but with a flag for each different variant. So the underlying encoding between them is is the same and there's basically a question mark for a rounded versus saturate versus null right. So we could do it as a flag.

F

So anyway, and I'm not suggesting that there's that we need to do anything, I was and- and maybe there's not actually a problem, and so we don't necessarily have to solve for a potential problem. But it might be something done to understand at some point. I think.

C

The only thing I've seen with two large strings is there's like Roslin for their tests, since they use source or they use strings for all of their test. Compilation sources they've hit the like the heap limit for user strings, but I'm, not I, don't think we're near hitting that for core Lib for names here.

B

I mean I actually like your idea of, like maybe reducing the number of unique names by effectively taking parameters. That's actually not unreasonable.

C

The potential issue there is, with the with how we support fall backs.

C

You essentially we'd have a lot more overloads that that they're soft they're there, indirect invocation fallback is a job table right.

B

I mean like I, think for the most part, the expectations people will have them as literals right, in which case they wouldn't I, mean they. This of course, cost in digit to support. You know the fallback moves on tables, but and.

C

And then the other consideration is not all over loads of the instructions support all combinations of the flag, so some of them might only support rounding. Some might only support saturation. Some might support both right and taking a bool is less than ideal right.

B

I mean like, let me just take the issue here and write it actually down was just said: I think we I have this suspicion. That is really pushing this thing further and further. Eventually, we will hit the point where we like now the size is a problem.

F

Well, this there's been discussion recently about avx-512 and if we you know, if we go that route now or now we're talking another 5,000, api's and so forth, so.

C

Just make quarrel, if not bottom, of the stack.

B

Yeah you, let's ship in your platform, a smaller condom.

B

Last time we did. This is very really well.

B

All right so then there's a few more names, shipped right and logical, narrow around it. Upper yuppers.

B

And widen lower, throw invite Napoleon sign, extended, wide number. Zero extend invite an upper.

B

I guess also the same arguments as before: right they're, not strictly speaking required here.

C

Right and if we do expose them, they drop the shift parameter.

C

C

B

B

B

One Markov chains here, I.

A

Guess it helps for my mute state matches what I think it should so why, in these three that are on the screen right now, that say upper is the first variable named lower and in the it's not always.

C

What do you mean? It's not always I feel.

A

Like I just started, seeing lower up here, yes, like zero, extend and widen upper, took value, zero shift right, logical and narrow, saturate upper took lower.

B

It seems most of you to name.

G

It has a value value.

B

Is that intention that is lower? We should do.

C

It it's intentional that it's lower because it's the the so the the vector 128, that's returned. It's writing the result to the upper 64 bits and lower represents the lower half of that result. So it's the lower 64 bits of the return vector so.

A

It's the operation based on value and count or lower effectively right, okay and should lower be the first argument or the last argument. We've.

C

Been matching the instruction ordering, in which case it's the it's.

A

The first okay, so all these things that take a extra vector called lower is what to do with the the lower bits in an instruction named upper. But the ones named lower didn't take an upper because and they just set it to zero right.

C

Because the the upper bits are always zeroed, okay,.

D

C

You use you use both instructions to construct a full vector when you need twice as many bits for the result. Okay,.

A

And there's no.

A

Shift right, logical and narrow, saturate upper vector, sixty-four vector sixty-four like there's. No, it does stuff and then moves it to the high bits and moves into the vector 128 right.

C

Because it's going to be reading the upper the upper half of value, whereas the one, whereas the lower version, only took a vector 64, because it always reads only of extra 64. Okay,.

A

About stop my questions. We can move on now.

B

You all right, then,.

B

B

They'll go consistent with what we had before.

B

You holy I think you just made it to the end.

B

I believe we did it.

C

Igor's comment that he laughed for if we could still review it is fairly small, so it should be it's. The glue will either be able to finish in the next 5 minutes or we won't. Since it's a previously reviewed API, and there was a question about the names.

A

Tautologies are so tight, illogical, yeah.

B

I was a teacher. He won't.

B

But before we do anything, they let me actually paste my notes, which is only like one kilobyte of text only I think.

C

We actually got slightly over half of the API use of the remaining AP Irish reviewed as well. So maybe we can finish small in the next session.

B

You I'm glad your record I said.

E

E

E

E

B

To open the Roman, oh okay,.

C

So we had named them.

C

Let me find the right group where we named them: I think we ended up, naming them uhh, add returning high narrow upper and Igor. Had a comment about the names might not be, might not be correct and calling them add. Upper returning, lower and AD upper rounded returning upper would be clearer.

G

You, what will the broken AAP promote the.

C

Name you copied into the last comment was add returning high narrow, lower you.

B

B

Think the rationale makes sense to me because again we are ordering it in order of execution, so I would think that would he go so just make sense to me yeah, but what's.

A

Slightly weird to me, just pointing it out is reading the name. Add up ur returning lower.

A

Because I'm, the lower is gonna, get the result of adding the uppers right like it's not only the lower I guess it is the lower portion of adding the upper halves.

A

It's not going to spill into a let's call it six seventeenth bit so.

A

Okay, I guess it makes it just thinking of the the order of operations. In my mind, is take the two upper halves. Add them together in a metaphysical concept and then only take the lower half of that operation. Actually.

G

I came up with better name in mechanic's scroll down a bit. Don't so the name I used the implementation of its issue, its add returning higher or upper returning, higher or lower at.

B

Least one here, atacama yeah.

G

You was named after discussion with.

A

Wouldn't but it isn't it more at hi returning narrow upper and that hi returning narrow, lower guess what instruction does if I remember right it.

G

Adds and be actors elements and take the upper high, narrow part whistle takes upper part, narrow it down to the smaller side and put it into upper or lower part, depending on the instruction.

A

Because if the ad takes all the bits into account, then it does vehicle. We.

G

A

Returning high narrow upper is right, but the earlier description I thought it said it took only the upper half of each of the operands and then added them together. So there's a question of if II, essentially the rounding that would come from both operands having the highest low bit set I.

G

Can I can read instruction? Basically, instruction adds each vector element and the first source, the floating point register to the corresponding vector element of the second source register places the most significant half of the result in projector and write the vector to the lower or upper half or destination.

A

Okay, so then, based on that description, I agree, add returning high narrow upper describes the order of operations correctly or.

C

Multiply that does the same. We just call it multiply high, rather than multiply returned being high.

A

So you just want had high narrow upper.

C

That would match the name that we've shipped for x86 for multiply, high and I. Think we've already approved for multiply high forearm, because we didn't call it multiply. Returning high, we just said: multiply high okay.

A

Are there any so are there any instructions that would only operate on the high half of a thing where the, where the word returning wind would make a difference that you know of.

C

Not that I can think of.

A

So then, then, then, if it matches the semantics of multiply, then I can add high narrow upper I think the word returning makes it act makes it more clear. But if we have a consistency argument that we have a consistency, argument yeah.

C

I agree, I think it's more clear. It's I'm just calling it out for consistency with the other api's we've exposed and approved.

G

So what would be the final name at high narrow upper.

E

A

You like to have an opinion, email.

B

Well I say this mine already like to me: it's it's all within the realm of slightly better slightly worse, oh, yes, my care level is not that high, because I mean you can make arguments for either of them right and it just kind of depends on how you choose to think about it, which is very hard to predict right.

B

So I mean I can go either way like to me. The biggest thing is we should try to be consistent with what we have, but they be known reinvent this, but that seems generally hard because there's like so much new ones right for every single instruction. So that's.

A

Have we used the word returning in any of the intrinsics anywhere.

B

Are you sure, cuz that seems very familiar, I could swear? We had his name used, I.

C

Think it's because we spend like half an hour debating the names on this issue.

B

Because if returning.

A

Is not currently in our Markov chain of names, then then I think that we should be consistent and not add it here, even though it makes the name super clear. All.

G

Right I checked, and there is no returning and connects it to States and for armed 64, only those it's already named them. This way name three drinks.

B

Oakland I mean maybe we talked about returning in another review, but I mean I swear to god, I've seen that before, and then it wasn't just in the last 20 minutes.

B

A

Yeah, if this, so if we've never otherwise used the word returning, then then I can support at high narrow upper and that high narrow, lower.

A

Matches multiplied and doesn't introduce a new term and saves.

A

14 bytes out of the metadata table.

A

That's called spin control.

B

All right, then I guess this is not an issue. There was a lot of discussion, so I'm not sure what to do with that in terms of sign-off, but I can't just do the or not depends yeah.

B

All right, so that means after this one there's only these three tabs left all.

C

Those three tabs plus there's the two that you.

B

Said movie witty yeah.

C

So oh I guess that that covers all three of them. The middle one is still pending. The last one was made ready for review and then I think, based on my to-do doc. I've got on my desktop here.

C

There's a handful of miscellaneous ones, which were widening or saturating that were missed.

G

Using bubbling good photo as action to double the results.

C

G

C

There was some float to integer conversion. Api switch I, actually think I got up a proposal for alright.

C

B

Another solid two hours just estrellas.

B

Let me book the time and then.

B

See you Thursday for the back, lock, review, we say backlog but I think we never get to the backlog. It's that we just keep piling new things. On top.

B

All right, then, unless there's more questions- and this is it for today thank.

G

B