Eclipse OMR Architecture, 22 Sep 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: OMR Architecture Meeting 20220922

Description

Vector and mask IL proposal (@gita-omr)

A

Welcome everyone to the September, 22nd Omar architecture meeting uh today we have one topic to discuss so get a couple of us we'll be talking about uh some of the work that she's been doing recently with the vector and mask file. Op code changes, so I'll turn it over to Gia and uh please take us through it.

B

Yeah thanks Derek, so title of today's presentation is Vector and Moscow and it will cover some like implementation of some earlier proposals and also present new, like PR's new proposals.

B

So first I'll give you some background, then we'll talk about implementation of previous proposals for Vector types and opcodes, and then we'll talk about adding more like more recent work, adding mask types and opcodes, and then we'll summarize, all of that together, vector and mask of codes.

B

So in terms of background, the motivation, of course, is to exploit simply capabilities on various platforms, and we would like to sorry. We would like to support Vector operations Vector for various Vector lengths, like 64-bit 120, to 56, like 512, of course, maybe even bigger um for different element, types of those for those Vector lengths like all the sort of scalar or more types, starting from it a to double.

B

Then we would like also support, masks, Vector operations and operations on masks themselves because you can have like and or masks or all through any true and so on. I'll give more details in a bit so.

C

B

What happened earlier right? We had we presented a proposal on omr architecture, meeting last November and proposed to expand TR data types enum to present all Vector types and- and the key I think was the key part was that we would like to generate those types at runtime, not like list them. You know all combinations which also possible, and some compilers do that, but more like make them sort of hidden and generate them at runtime and encode.

B

Those parameters like vector length and element type into sort of various designated bits of an inner of this enum and and then generate Vector opcodes, using some like API specify like some sort of Channel Vector operation, for example the ADD and then also specify Vector length and Vector type element type, and at that time we did discuss masks so that will be new.

B

So this is the background. Sorry, um and as soon as we kind of more or less sort of agreed and discussed the proposal, we started implementing Vector types and the way it's we did it and it was like, maybe early this year or spring. Maybe first, we added that Vector length.

B

Enum, because it's here right so basically length is presented not like in terms of Beats but in terms of enorms, like sort of discrete values, right, uh 128 to 56 512, and then there is non-vector length supported and since some platforms support only one vector length, you can make it platform specific. Just to save space. You can still have 512 for everybody, but to save space so, for example, for a lot of platforms. It just only one vector length, 128 and for x86 is all this lengths are supported.

B

Also up to 512 is supported right now and we allocated space as we planned in uh data types like removed, all old Vector types and added like a basically and introduce non-scalar types enum, you know, remember, and then the non-vector element types and then computed non-vector types as number as a product of vector element, types and Vector length and an increase. Now all types by that value, num, Vector types so essentially allocated space between scalar types and now all types for Vector types that will be generated.

B

You know at using apis and just for convenience for different query queries. We have like first Vector type defined here and loss Vector type and and of course, that API create Vector type, that takes element type and length, and it will return enum like this enum.

B

That sort of will correspond to this combination kind of encoded but um yeah. But what was different from The Proposal we didn't use like beat Beats. We just did like kind of like a flat Matrix representation. Very simple. You know like first listing, for example, all like sorting them by length I think we started by length kind of like a flat and Matrix just using just basic arithmetic. No, like note beats it's more dense. It makes it more dense and using separate beats and kind of cleaner I think um so.

B

Yeah I mentioned that and this PR that were used to do this. They're merged they've been merged.

B

So this uh essentially adding Vector types, and then we move to adding Vector op codes and in order to add the vector, op codes, we introduce notion of vector operations, and this is very similar to opcode macros in a similar email. But we created new file with enums and listed all like General Vector operations.

B

So, instead of like opcode macro, we have Vector operational macro, but all the fields are very similar and because they will be used in all the same tables, that of code markers they used being expanded and the and yeah so here I wanted to show that there are vector operations that return vector and some and sometimes returns a scalar.

B

So, for example, V apps takes absolutely you know, value for each element and um the return select result and has only one child right and there's no type, because it's a vector of certain types, so we cannot, it's like API will tell us, which type is that for specific op code right for operation, We cannot put a type. So we add this very similar just that it has similar properties, there's like scale of codes, but it returns.

B

um Well sorry, it also returns back the result, and but it has two children, and then we have vectors to like vector operation, uh but it see it doesn't say: Vector result, which means it's scalar, like reduction returns. Scalar result.

B

So these are more typical, but we have much more. Of course, I will show all of them, but this is a typical Vector of codes and we use these three PRS to implement those.

B

So any questions so far on Vector types and Vector of codes.

B

We can always go back to it, so this work done, then we moved I'll show you keep forgetting yeah how we use this macro right.

B

So we listing here all Vector operations by simply kind of you know taking only operation from this macro, so this will be enum of all Vector operations and then we.

B

And also I need to mention that there are op codes that um have only one type. Like addition right, it takes source and result are the same, but, for example, conversion of code has two types like source and result. So we need to uh and we'll kind of separate in this list. We have that Mark rather saying which one is first, two type Vector operation and given all these enorms, we now can calculate how many Vector op codes we're going to have so uh number one.

B

That's a type operations is uh it's this enum, this value rate, then two type of calculations. That's all Vector minus the one that have only one type anyways, it's number of all Vector operations, and then we multiply number of the ones that have only one type by number of vector types and the ones that have two types like multiply twice, and this will give us all vector of codes right, all vector, opcodes, and so, instead of Nam, all I l of stitches, like old enum being just number of scale up. Cozy.

B

Add all this all these products. You know all these products for Vector of codes, which include, like simple, like uh you know, like add editions and like conversions.

B

So what is nice here is kind of all this type safety right like so now all these emails, all this generated, enums, will fit into this email. When you don't need to check like this.

C

B

This value is big enough. uh Those kind of type safety is preserved and uh and then of course, we have. This API create Vector op code with one type and create Vector of code with two types and what is important right, we all the Stables right like a like. You know, kind of properties. Now they don't have entries for all Vector op codes.

B

They only have entries for Vector operations, so we Define that function get table index which, for scalar op codes, will be just that op code itself, like usually how the reference all the property tables, but for Vector op codes. It will be the return Vector operation and will return sort of like a correct index like in in all the tables. They will have all this as usual scale of codes and followed by entries for Vector operations.

B

So, for example, uh like name right for, if we have like say op code, something like that, we add Vector 128 in 32. It will return entry for the add, because all of this, of course, essentially share the same properties.

B

uh So that's this type of that get table index sort of we use for accessing all the tables indexed by Il, op code opcodes, you know so so yeah I sort of talked about all of that, so there's a vector of codes and yes, so and now we are moving to mask types. So all of this is already done. Mask types It's relatively new and again we start with adding types into data types very similar to Vector types.

B

Add a number of mask types: it's the same as Vector test, because they always like sort of that one-to-one correspondence between them.

A

B

Will talk about it in a second and similarly, we have first mask and last month, and now we added we have scalar types, brexit types and mask types and and also we can now create mask type very similar to Vector type, giving element and length.

B

So it's important to have a even like say, platform platform doesn't have special like mask registers. It's important to have mask type I, think sort of logically, it kind of tells us that it will be operation on this type of mask will be, it will operate on this type of vector length and this element type and so even platform. For example. Power is the that they don't have a mask special like mask registers.

B

They will use mask types, but in addition, which is a little bit slightly, complicates things even on say, x86, where mask type dramask registers, if this adx 512- but we know that only at runtime right so we'll have all these mask types and we have like rope, codes of mask type and so on, um but only at runtime, we're gonna know we will use actually mask register like AVX, 512 must register or regular Vector register to represent mask and representation will be different and size will be different.

B

So it's a little bit problem similar to modifying like address size of address, type and I. Remember we used to then we kind of improved it, but it was always considered sort of a not a great thing like we when we modify different like properties tables at the compiling initialization time so which is not like very nice. So at the same time it's a bit. You know it's a. We need to think if we want to add compilation into get size. So what we did is to first time get size is called for.

B

Mask type use this red local value, comp and query whether mask registers are supported or not, but it's done only once it's expensive operation, but it's done only once using like local static initialization, so that because of that, we don't need to change that. Api, which is throughout, like it's everywhere I think, would be hard to change and I. Don't think it's very expensive because done only once.

B

So that's how we solve the tissue, and this isn't that pure.

B

So that's about types again. We can get to questions later and and then again like similar to vectors. As soon as we have Vector type, we can add Vector. So we have mask type now we can add mask of codes, but it's important to distinguish right. There are masked op codes and masked operations, for example like address mask, and there are operations on mask themselves, for example, is any value true in a mask. So this is this DM ad, it's a masked operation and it returns Vector result and it has three children.

B

A third child is, is a of mask type, so, basically yeah the op code will look like this and it will have three children, uh but I mean true. Is you see it doesn't have that property Vector mask because it's not masked it's just given one mask it checks. If any element is true and returns, scalar value- it's like you know, it's like Boolean, essentially Boolean value, true or false, but then uh operational mask can be masked itself like, for example, we can have mm in it true.

B

So when checking if any element, true, we will use mask and only apply that operation to elements that enabled by a mask. So this this operation has one shell, and this have two children last one. Second one will be a mask, so this is Vector masked, but the return still returns scale result and then also I sort of didn't have space. The reparations like um load, which return will have like mask result here like because they return mask.

B

So this uh new operations and.

B

From ask masks and mask and I also wanted to mention that, as I mentioned before, actually already masking Vector types have one-to-one correspondence that simplifies like internal sort of representation. We can use the same enums like vector operations, the same file because we never for any given opcode. We don't have to worry whether it's like mask or vector uh sort of semantics of Hope code will tell us, like the name.

B

Enum itself will tell like, oh actually, that that value right like mask will tell us it's masked or not, but it doesn't have to have like deal with yet another type so and we can use the same enums and kind of treat essentially treat mask operations. The same way we treat Vector operations, and but we know like from that property, we'll know whether it's actually a mosque, Returns Mask or not.

B

So it's a bit maybe complicated, but basically it simplifies implementations a little bit. The fact that this um you know we only so if we have Vector cells, this type we're only gonna use mask of this type, but not any other mask for, but you know, but doing some mask the duration on this type. Only you can use this mask.

B

um Just simplifies implementation, I would say, and.

B

And also you need to mention that that mask type, what it actually means, it's it's internal. If some variable has that type like mask type, it means internal mask representation, for example, on let's say power and Z.

B

It will be like a vector of like ones and zeros like uh representing masks for each element like if, if some element of vector is uh considered like set by mask it will have all ones in it and all zeros on AVX 512, it's like it's 64-bit Vector, it's just one bit per element, so different internal representation, but we assume that uh mask type this type, it's it's an internal representation and because of that, sometimes we need to convert to existing types. So because of that we adding this new OP codes or operations.

B

So it's the operations, the open, corresponding op codes like i2m, m2i, l2m, M2, L and so on, V to M, Vector, to mask mask to vector and so on, because or sometimes we need to convert like from existing like type or more type, to a mask representation.

B

So this work- all of this- that I talked about, is done in the spr's and this one already merged, and this is under review and um but there's still a bit of remaining work like a for example. um Those we already modified Trill to recognize um to recognize like a Vector of codes, and it will I think it will recognize my scope codes automatically, but we didn't handle yet like those two types of codes like they will look like this right. uh For example, if it's conversion it might be.

B

For example, conversion of factor 128 bit Vector of ins into 128 bit, Vector floats so kind of a long name, but that's what it is right. Conversion has two types source and Target and similar for this conversion, like v2m, for example, Vector to mask, we might see such of code.

C

B

Already can see that in a trace file, but the trill also has to recognize this and we'll be adding more up codes. I think on demand. So now to me, maybe perhaps make it a little bit more clear, like here's, a summary of all new vector and mask related op codes, so I would say more like operations, and so there are one type non-masked one type masks, masks and two type operations.

B

So one type known mask is like those regular like add and Compares loads Max mean and so then reduction. They return vectors. Then reductions return scalar, um then regular dragster, yes, return written. We already had before the set elements, plus basically names I, think speak for themselves, more or less, and then.

B

One type of yeah, and also one type, include the mask: operations on masks like a menu through loading, mask direct bloating, mask indirect uh App, Store and store I. Of course we need Emerick, load and Rec store, because we might use different registers for mask types right and all and those conversion of codes that I mentioned and then practically all of that, but masked version not all of them have mask version but, for example, still one type but mask like, for example, the apps and VM apps, like we add corresponding VM ad.

B

So not all of them have masked versions, but the one that you know apply we added here and here and as I mentioned, can be a mask operation like with the mask itself.

B

So this is one type operations and then two type is cost conversion and this Vector to mask and mask to vector.

B

So all of that being added all these operations and, of course, API out of this operations, you create actual op codes for specific Vector lengths and specific Vector element.

B

So that's I think all for now like uh please. All any questions are welcome.

C

So maybe I missed this, but uh when you were talking about the one is to one correspondence between.

B

With masking vectors, this.

C

One yeah, so I wasn't clear on why that was required, like maybe an example would help me at least get on the same yeah. What would go wrong if I just had mask 128, for example,.

B

We could um that's true, that's true. We could but I think sort of that's um okay. Why did you decide it's a good question? Why I'm, asking today to to be honest, it sort of was prompted by Vector API Library, which most of that work actually was prompted by Vector API library in Java, and it has that correspondence. It is true that, um strictly speaking, you don't need element type but um yeah. It's a good thing to remember why we decided to add element type.

B

It's um it's sort of. We I think we could have had just mask one. No, no, no I'm! Sorry, sorry! We have to know right. The 128 would not be enough right because we need to know that there are four elements like the mask is per element right. So it's true false per element. So this one has four elements, and this mask also has four elements. So for Simplicity, it's like much easier instead of saying like Moscow, four right just to have like full Vector type.

B

It's just I think simpler to do it that way so yeah 120, it would not be enough. We need to know how actually, how many elements.

C

But that does open the door to having a different like just specify. The number of elements then, like a.

B

Different type.

C

If it has four elements, could we do? You said something about Simplicity? Maybe I missed that.

B

To be honest, like the I I could have like, because mostly is because in that uh again.

B

Yeah, strictly speaking, it's I think it just discuss that I decided to do it that way, sort of to make them similar to like it kind of tells you on which Vector you I would say, you're right. It's a little bit redundant right now, but provides additional information on which factor it. It is working on to which Vector that mask is applied so kind of uh yeah. We don't know operation yet where we need to know actual type element type, but so there's some element of redundancy, but I think you definitely want to know yeah.

B

You definitely want to know Vector length like, for example, on Power and Z. Its mask is represented using Vector registers, and we need to know the length we don't know. We don't have example yet where we need to know the element type but kind of for completeness edit type and so for uniformity kind of like with Vector types, but.

C

B

Would say currently it's redundant but yeah.

C

Yeah, no, that's fine. I mean I'm trying to absorb the design myself so I.

B

C

Objecting or anything as such I'm just getting oriented myself thanks, yeah.

B

D

I'm I'm in a similar state, but also have a question on a different part. I was gonna. Ask about the um the choice to use to to kind of Define what a mask type is based on what the hardware has available to it and kind of emulating. What we do with address.

D

I wondered if you also considered and and rejected um kind of the same approach that you do with the vector length right like so having different mask types, but you don't necessarily have all of those different types present in the in the set of data types um in Iran.

D

So you'd have like a a mask type for for, like a bit field mask and a bit type for a byte array mask and then I know, you'd end up with more opcodes I guess, because then every alt code would have to have a bit field in a byte array variant, but you'd only need to Define one of those sets in in the in a run. If you know what I mean yeah.

B

Yeah I am basically have two two mask types right right.

D

Yeah yeah, which were then um sort of be a nice, possibly a nicer way to handle it if the third type ever kind of materialized from for some other platform right now, I assume all of the vector masked op codes have to have a conditional in them somewhere to say, am I this kind of mask or that kind of mask.

B

I think definitely considered definitely thought about it, but I think the issue was with, uh like, unfortunately, I didn't show it here, but here like, for example, if it was like M load, M load, we need to put the type that it's a mask right so and we don't know the table contains type and we don't want to modify. You know like we need to put something here that it's like similar to, for example. Here we have.

D

Like an M1 load, an M2 load, are you.

B

D

B

Yeah yeah, that's I, guess that's what the kind of I felt like. Maybe it would be too many yeah and then yeah have them, but I guess try to maybe wrongly or not I, don't know, but I sort of didn't want to I guess to expand number of operations for every internal representation, because there can be many representations right like uh so to have yeah I guess: try to avoid operation for every month, internal mask representation, I, would say yeah.

D

But you'd only have to Define one of those sets in a given run the same way you don't necessarily Define all of the vector lengths in a run.

B

No is this a different you see, operations are all defined, aesthetically, all of that aesthetically their size and element type like a determined runtime, and can we have various you know at the same round. You can have VM head of different lengths and different elements, but these operations are in a static or a similar to op codes and.

E

B

For example, if it was the address like Al ad, whatever, like regular other soap code, we would modify its size somewhere here, but then I think we improved it.

D

Sorry but I thought Vector add. Would you have a vector ad that was specific for each Vector length or no.

B

Vector uh there's.

D

Just a basic Vector ad.

B

It's basic Vector add like let's maybe go to back to non-mask known mask right. um We have basic what we call operation, it's kind of a general add, and then we have this create Vector opcode, given operation and Vector type. So we create we allocated um space for all the soap codes. You see now L types, but we we only create them at runtime, but um we don't need to know like we don't have. We don't need like compilation for that.

B

We don't need to ask oh what that Hardware, what kind of support that Hardware has for mask? We need to have a compilation, object at hand to see what size it is and what kind of mask we need to create.

B

So it's a bit different, yeah, I, I, think I, see what you mean like vector types has variable all this Optical like operations or they have variable length and element type, but we know it after we created it using the swap code. All this quick. We have queries on this op code. We can anyways, we we sort of when we create IL.

B

We we know what length and what element type we want to create, but and similar to masks but with masks like logically, we know with the same thing we know logically with Vector mask, but we don't know how it will be represented.

B

D

Isn't that going to be Target platform specific to like you're? Can a single like can x86 have both types of mask types to find.

B

Only one at a time and when we first time ask for its size, we're gonna ask compilation like that. That's.

D

My point right that isn't that, isn't that really just an x86 or a power or a 390 answer that you're gonna get I.E, it could also be determined by Terror Target.

B

For for power and Z, we know at real time that function gets size will return like 16, it's hardcore, it's hard-coded for power and z, and for Intel, since we don't know whether we have AVX support or not at runtime will determine so for power in Z, it's a fixed size mask.

D

Is fixed size X6 is. It is really a dynamic question whether which type of mask register will get used, because.

B

There is only one like there is no really mask register. There will be Vector register, uh but logically, we'll use like masked op codes and mask type, because I think it's nice to have IELTS the same kind of consistent. You know and mask operations will have mask type, even though underneath it actually will be Vector register and we know its length and so we'll return 16.

B

B

But will look like musk will still even on Power and Z we're going to have like a VM ad and The Mask. The.

C

B

Will be with mask type but um a little bit more complicated yeah on Intel, because it's not we don't know at build time right when we build it, we don't know how we can represent mask.

D

So on x86, if I'm looking at a log when do I I guess it's only when the instruction selection is happening, that I actually find out what type is being used for.

B

B

What Vector, we're going to use for mask will be only known at the code chain time yeah.

B

So, for example, yeah like Jerry right, like, for example, I added M, reg, yeah, emerald and braxter everybody going to use all platforms we'll be using camera cloud and Rec store, but uh the.

D

B

Will use, depending on AVX support, we'll do whatever is needed here and uh Power and Z, for example, we'll use actually Wilma pattern to kind of we'll use. Vector register, so they'll behave as this once.

B

um We considered other options. Yeah I think we sort of considered like uh what you were suggest you suggested but decided to keep it kind of reduced, yeah sort of keep like IL kind of on a logical level like and actual representation on a cogent level.

D

So to be to be clear, I'm not suggesting anything I'm, just.

B

Asking if you can see yeah yeah, yeah, yeah, yeah, yeah.

C

B

Understand yeah yeah: we can see I think we've thought about different things: yeah.

D

B

C

This isn't um about mask.

D

But I'm just curious what or unchecked.

C

B

I I expected that question.

C

B

Again, that was prompted by Vector API library in Java, and they use a shop code and it's actually uh or for for float and double I I think it's some kind of like not sure exactly but I sort of added it through completely completeness here um yeah there is such operation like or fluid and double, but if we find it's not needed like we'll remove it.

B

But for now I sort of wanted to know kind of not to forget about it like I, let it.

C

D

B

I think so, but to be completely honest, I'm still not 100 sure, like um I.

D

B

It's just a bit wise or yeah, but there's such such operation in the library so I edit it for now but uh sort of a bit of a to-do. I think I'm sure that it is a to-do to have a better understanding. I think I think it's just bit twice.

D

Okay, thanks yeah.

B

Sorry, yeah potato now.

B

Others I think previous self sort of explanatory do.

A

C

Have a question: yeah, uh hi, hi, uh so I think thank you for the presentation uh and I have just a question: how do uh do you have any guidelines, or maybe patch notes uh how to update how the projects that consumer should adapt to using the code you introduced because uh I think there's like there's a discussion and some issues, I, think 67 or not 09, specifically, that uh it kind of the introduction of these types uh results in some sort of breaking compatibility. Maybe.

B

Yeah yeah very good point I think in this one I kind of try to describe all steps that need to be taken in the first one in the very first one but uh I it's basically.

B

The intention was to change all the names, any anything that could cause functional problem uh sort of I change, the names so that it will break the build and bring the attention to the attention that something needs to be changed because uh you're right, like basically, we had like all Vector op codes somewhere here we moved them down, I think they were before like aggregate. Maybe so order has changed. A number of types have changed, and uh so some tables that indexed by this enum needs to be need to be adjusted and I.

B

Think, oh sorry, this one, this first period, I think here I described that, but so yeah.

C

Thanks I'll look into that yeah.

B

Yeah but please let me know if you have any questions.

C

Sure I will contact you after regarding, like the specific issue I'm having essentially for some reason, my compiler started, generating mask types on something that was working before August.

B

C

B

Okay, thanks yeah yeah.

E

To to follow up actually and gogi's point I think um the the issue he was referring to that. uh That I was one that I had introduced to um to Omar um uh on a similar issue and I. Think it's actually it's not a direct result of the um of the vector and the mask work. Exactly it's. It's more. The the vector in the mass work exposed a sort of fragility in in some of the places that the data types enum is being used, um at least that that's the way it came off.

E

uh That's the that's the that was the the symptom in our in our case where we we also began hitting this assert um um on a mask uh data type, but it's only um as we're walking through the enum right. So um there's one place in the uh I think only one place in the uh in the compiler, where we start um when we're looking for a conversion between uh between types.

E

So the there's, this decode conversion op code function and it tries to walk through the Genome of data types one by one and find find a conversion.

E

uh And if you don't, if you're, if you're, if you're a project that a downstream project that doesn't have um any additional data types uh you you can choke on on this, um this Loop, basically in decode conversion, op code, it's.

B

The code conversion trying to remember where is that the.

E

Code yeah, this is in um it's in omr. It's in uh what is this uh simplifier handlers? Simpler helpers, I should say.

B

um Well, yeah, maybe maybe you like open an issue like it's about probably started happening with this more recent this one. Probably this was adding. Oh sorry, I keep forgetting this one mask types. Probably since this one yeah.

E

Yeah I think that was the.

B

E

Yeah so there was originally. There was a kind of an issue with this that we um we introduced our kind of a workaround inside of that that Loop um this is. This is separate that was separate from the vector and and mass work um that wasn't part of the problem in that case, um but then you're right once the mask types were introduced, um then then we sort of began to hit the same problem again for a different reason. Right. Oh.

B

Yeah, please let me know yeah it's possible, but yeah.

E

So there so there's an issue, in fact I think is that yeah.

B

E

Yeah, so so, if people wanted to perhaps to that, where I sort of spelled it out easier to easier to read it, probably okay.

B

So it's in the chat you posted it in a shot. Yes,.

C

In the chat window there there are already mentioned 6709.

B

6709, okay, I'll take a look here. Definitely.

C

Yeah cool thanks.

B

Thanks for letting know, yeah.

B

So any other questions.

B

So yeah, like Alexa, has been there for a while and I I. Don't think they caused any major problems, although you I think you mentioned, there was something but uh Moscow, relatively new, we'll see like we sort of still kind of I would say experimenting with that with those, especially those conversions are kind of interesting right and the world is starting like like prototyping, like you know, Cogen and openg9. For those.

B

All right, I guess yeah, maybe.

A

I'll, give you Kevin I, didn't see, uh Sunday's comments that she added last week in into the agenda about wanting to discuss that issue 6709. Is that something that you wanna you wanna bring up? Now you think you have the Right audience to to discuss that too. Here.

E

A

E

If yeah I can I can give a little bit more a little bit more detail, and um that way we can. uh You know if folks have have uh feedback about how that how you want to go about it, because there's basically um uh yeah I can do that sure. Thanks.

A

Are you, are you uh yeah I.

B

Think if there's no other questions, yeah yeah, please share your script, which I think would be helpful.

E

It's green here.

E

Okay, can you all see that yep, okay um yeah? So the um the the issue that that we ran? There's there's kind of two issues, the first, the first of which was um uh we had.

E

We had this kind of work around added, so um the uh the first issue was that in in this, so here's this function, decode conversion, op code, uh it's one of the simplifier helpers um and- and you can see actually here that in the in the commented sort of notes um that this is only meant to be used with this uh conversion.

E

Map table, which seems to be seems to be the case that that seems to be how it is used um that table is, is here in omr, il apps, um and you can see that this basically covers, like the the what we would Now call the scalar types, but um and uh in any case, what what uh what we end up doing here is um in this. uh This Loop right we're walking through each of the uh values in the in the data types enum.

E

um Probably this this value is no longer the right one. um So part of the you know, it's probably it's to me a little bit of an open question. How we want to specify this I was thinking. I mean one way of one way of changing.

E

This would be to say that we take that we turn this into scalar types instead of number of all types, I, don't know if that's accurate for in all cases, though, so that's something that you know folks would have to weigh in on, um uh because it because if this is only meant to talk about the types that are dealt with in the conversion map table right, we don't want this to walk through um the vector and the mass types for example right.

E

um So uh so so that's actually that's sort of the most recent issue is this. We started hitting here um when we, when we get into get proper conversion at a certain point. This um the the eye, has incremented past the types that are relevant right in this uh in this function and we go try to take that eye and think of it as a source data type and go to get proper conversion.

E

um And when we do that, uh we're going to turn around and pass it again to get data type conversion.

E

And what that looks like here.

C

Is so there's handling.

E

Right in get data type conversion, presumably for the case of of other callers, to this function for the vectors. So we kind of that we're kind of okay with with the vector types here, um but if you don't have a um some other override of this function or whatever you're going to you're going to hit this a search right as soon as you get past the um number of omr types, which is to say that basically past the scalar types um so so, most recently when the mask types were introduced.

E

This is where we started uh hitting this assert. um Prior to that we were hitting this assert for a different reason, which was that um uh the? If, if you don't, have a Project, Specific definition of additional data types in this data types in an over in a project project level, data types enum.hp.

E

You would actually also hit that assert. When you are again walking through um the enum of data types, you get to number of omr types and it will. uh The same thing would happen right. So that was actually how this this came to this uh piece of code here came to be where we, where it's kind of a basically a workaround right for the fact that number of omr types is not a valid source data type.

E

um I, don't actually know if this I sort of began to wonder if this is actually even uh correct for other projects that do Define Project Specific um data types. I'm, not that's another question that other folks would have to weigh in on. um If, if that, if this is okay and doesn't have any issues for projects that do Define their additional data types Beyond, those that are provided in omr, then uh you know making this number of all types in making this just be.

E

For example, the scalar types might be all that's needed to be okay to kind of fix this. uh uh This this one kind of strange case right where we're walking through all of the data types in the Edom. uh But that's that's. Basically what I wanted to uh sort of present to folks to um to think about with us as we sort of try to come up with it with the solution to that.

B

I'm just curious: do you know if it's like recent code that Loop because I think when we were adding all this expanding alarm all types they sort of grabbed for all of the occurrences and I? Don't remember this one.

E

uh This one I think it's been around for a while I, don't.

B

E

B

So maybe something dismissed.

C

Here, because, uh here that we want to say, the situation is for Downstream projects, not every project has its own extended data types like for opengli.

C

We know yes, there's uh um plenty of uh extended tape types, but for our own project we don't have any additional data types that means in inside the in the data type header, the ending data type would be like Nam omr types following that would be a dummy header for the downstream project to add their extended type types and again ending that uh header there's another um name them scatter type, or something like that.

C

So there's a gap here for if, for the case, uh the projects had its own extended day types seems like not the issue, but for projects without their only extended data types. Then that's a issue.

A

Yeah I mean I think that one of the things that this is um shining a light on is we need to who we need to make sure that we understand what some of these special enum values are really meaning and and the code that's using so, for example, decode conversion, op code. What exactly is decode conversion op code supposed to be doing? Should it be considering the vector types?

A

Should it only be considering Vector types should I only care about the omr Primitive types, that sort of thing and um to be honest with you, I, don't I think that what we have to do is to consider um consider these pieces of code to try and um yeah and put this put the right semantics around them, so that the code can be written properly. That's one thing.

A

The other thing is to make sure that the enum values themselves make sense, um and um people understand that when they use something like num all types, they know exactly what it is that they're getting so I think in this particular case, just looking at decode conversion op code. If it's there are conversion off codes for Vector, there's conversion. Op codes gated just talked about for for the masking Vector off codes as well yeah.

A

One might realize that these should be part of this loop as well, um and obviously that they may be getting excluded from that, and that might mean that the table that's being consulted here needs to be expanded as well to capture those new vector conversion, op codes right so.

D

I'm saying weird that the more of our types as being specifically excluded, like not looked at at all,.

A

You know what that is, that's actually it's taking a it's. It's a there's, a placeholder in the E number in the enumeration for numb Omar types, I believe, and it's skipping over that right.

B

A

Own value in the table, which is.

D

Yeah I see yeah.

A

D

Project would Define its first scale or its first extension type as number one R types, but if there isn't one, then no more types is yeah. Okay. So for that, as you say, that's probably wrong in the case of somebody actually defining additional things.

D

Scalar types you're trying to iterate to in a way yeah, but skipping, the more and R types yeah.

E

And I wonder I wonder even if you know I mean one thing that that came to mind was that if you in the omr project, so this is this data type CNM is blank. It's just kind of a dummy in in the omr project. But if you uh just to find the.

C

E

Well, I, guess you couldn't call it just aggregate because then you'd be off. Actually that wouldn't be true.

C

Maybe we can just um inside that tummy header fire are defined, Omar types equal to scatter types, maybe, and for the uh Downstream project they can free to extend uh on their own.

E

Yeah, anyway, that's why I wanted to discuss it, because it's the it's not a totally straightforward.

E

A

Yeah I I mean thanks for raising this uh Kevin I think that there is something here that we need to clarify for sure. um Are there other places that you're aware of that you've encountered that? Maybe that we might need to consider as well I.

E

I believe this is the only one of this type uh of this kind that I've that I've that I've seen in anyway, um of course, it's possible that there are others that I haven't encountered, but um it uh this is the only the only place where, where this is um kind of, seems to be kind of this uh persistently kind of data types being prone to break okay, yeah.

C

That and I will just.

E

To I will note, by the way, just uh to throw this out there as well that that the this decode conversion op code, because I I had the same thought that you mentioned about you know the fact that there are conversions between vectors and masks and the other, the other types, not just the scalar types right um uh at the moment. At least this this uh function, this helper is only getting used in the ins.

E

Demote, simplifier I think yeah, two places there inside of the demote simplifier, um which is itself if I remember correctly, it's that itself is a helper to the uh uh uh yeah to some of these integer type, simplifiers.

D

Right being called on Vector conversion, op codes as well here.

E

D

E

At this point, at least it isn't, it doesn't appear to be sort of uh suited for for that use, although you may want to leave the door open to be able to use it in that context, potentially in the future. So I could see that too.

A

Right I mean again: that's it's partly a documentation, um responsibility here to make sure that the naming of the function and its operation are clearly described. Yeah.

A

A

So I'm trying to think if this should be. If we should address this as part of some of the some of the vector work, that's already ongoing because it seems to have um seems to have introduced this problem now or if this is something that we should just consider separately altogether and uh and let's say, use the issue that you've already created to come up with a solution for this.

E

Yeah yeah and I was what I was going to say related to. That, too is I mean they're. The part of the problem was reintroduced with the work on the uh when the mass types you know were introduced, but um but this issue with the number of omr types pre-exists, you know, predates the uh uh anything to do with the vectors right this we started hitting this simply because we started using uh uh using these these data types files, basically right, yeah.

B

Yeah or more types existed before Vector work or it was it.

E

B

Okay, so it's not no.

E

B

uh Yeah, we maybe need to sit like me. It has to be sort of. You know.

C

D

Not like special types.

B

D

It's almost like the the numbscaler types. Things needs to be a little bit more intelligent about whether or not Omar types is the same as like whether user types were added.

B

Yeah, it's kind of similar issue yeah, but.

D

That's tricky to do.

B

Static final and not close,.

E

um I know that uh you know with like the uh the IL um opcodes uh enum kind of instead of having some of these like number of omr. In that case, app codes, um IL, apps, I believe the way it's done there is to is to say you know. First, first omr op equals you know no type or whatever last omr type equals Aggregate. And then, if you want to know the number of them, you can kind of calculate it right. Yeah.

B

C

E

Another possibility.

B

A

Think it's important to.

B

Have this one like not all types rectified here, because then it's sort of like it kind of like defines a scope that either the size of the inner yeah, but it could be that once yeah we can the ones that are not needed for these calculations or future types. They can be just some separate static. Final variable.

E

Yeah yeah, so that's one. That's definitely a possibility. I.

D

Think you're right, Kevin, I. Think if you were to change this, to use the first Omar type last Omar type model, then you might be able to properly set what num scalar type should be. Mm-Hmm.

D

um Well, they might need to introduce a first and last Downstream that might be harder.

E

D

Maybe I'm wrong.

E

D

Right, that's true, you don't know how many Downstream products that could be in principle. It could be more than one Downstream project right pretty in trouble.

E

I, don't know I mean you know, I, don't know if the, if the presence, so if sort of doing a little bit of both is too complicated but I don't know if the number of scalar types in itself presents any issues elsewhere, I guess it leaves us in the same position so that later on it might, but um at the moment I don't know that it does uh such that we could still have this be an enum value. The way it is now and sort of.

D

Thing actually.

C

D

Know scale of types right now: what's that is anything actually using them. Scalar types right now, right, I, suspect, probably not really. uh First Vector type uses it. That's why you know where it's used to impute all the types.

E

Right so it's usually, you know.

A

Like the way that we've worked around that in other enumerations um in order to count the number of Downstream contributions or even architecture, contributions to an enum we'd have something. Let's say in this particular one you'd have at the beginning of the enum. You'd have like first scalar type in this enum and then you'd have all the omr ones and then you'd have your pound include like you.

A

Have it here, and then the next one after that would be last scalar right and then num scalar types is defined as last minus minus, first plus one okay right.

E

A

Are more tricks you can do with enums it?

A

It gets a little bit ugly, but it's certainly doable.

D

I think most of that craziness would need to be, and it would only need to be in the OR Phenom right, like it wouldn't be passed on, like you'd have Downstream just just adding more things into the enum and all the complexity of figuring out. What the right boundary values are would be in here, yeah I, think so yeah. You can paint and not passed along right.

B

So can I say that there are two issues right like one is cleaning up this enum and another one supporting like a mask type by Downstream projects, but but.

C

B

Project knows that it has multiply everything strangle it straight everywhere,.

C

Yeah yeah sorry.

E

C

Comment on that that my project does not use mask type and I would rather not see this SEC fault, because I really don't know what mask types even are. So it's just maybe fixing that Loop.

E

Yeah, what I was going to say is I, think I think actually cleaning up the the enum, and then we will have to consider somehow how we, you know what we want. The scope of this uh function really to be, and so on uh this this needs to be addressed somehow, but if we have the loop rather that you know uh sort of cleaned up so that we can properly say, then we can specify what I mean. What I mean to say is.

E

If we have cleaned up the data type CM, then we can specify exactly what we mean in here such that we're not walking over the edge uh into the into the types that we don't want here. I guess right so.

C

E

But they're related to it to one another.

A

Yeah and even making numb omr types I don't even know if that's something it needs to stand on its own, like it actually gets its own element in that enumeration, which I'm not sure if it should yeah.

E

A

Don't have to take over it, then right exactly yeah, because you have to know that it's this, because then you have to know that it's there to step over. You know someone else is writing new code that doesn't know that it's a value that needs to be treated specially then right, yeah.

D

I think the preference needs to be that there are no placeholder types in the enum if we can possibly avoid it like yeah that should be yeah.

D

It's the special thing that you have to deal with everywhere, as you.

A

Say Kevin: are you willing to take a shot at cleaning this up.

E

A

Terrific thanks appreciate.

C

A

E

And uh Gita I may enlist your help somewhere along it uh related to the mask and scalar.

B

Stuff yeah absolutely yeah, I'm thinking about it like like.

B

Let's see if you don't have mask type.

B

B

And it's all gonna happen automatically.

B

Basically, will there will be zero, Vector types and zero mask types.

A

um Yeah, uh this is also eventually leading into a discussion that I wanted to have at some point um as part of this architecture meeting not today, um but uh a discussion around how we can better test uh Downstream projects that are consuming omr so that they, so these kinds of breakages can be uh discovered sooner or um um or or we have immediate feedback that there is going to be a problem Downstream that we need to fix in omr.

A

um I think that openj9 is the biggest consumer at the moment and it gets a lot of testing. But there clearly are up-and-coming projects that need. We need to make sure that they don't break and um um I'm, not sure. If all my releases are the only way to to work around that, but uh but hopefully, with a bit of discussion, we can come up with um uh some ideas and some solutions. It'll be satisfactory for Downstream projects, so I'll work one of those under the agenda in the in the coming weeks.

D

Yeah, so it's not I mean it's not a complete answer to your question, but I guess one. One interesting question is: why didn't why didn't the jit Builder testing or the even the compiler testing, which defines a compiler a downstream compiler widen those ones find this problem because they don't Define their own types either.

A

Kevin, did you see this as a fun as a functional, runtime problem, or did it crash or build or not even build it? It did crash yeah, okay, so Georgie you, you were you had a seg Falls. You said.

C

It was not a sec fault, it was an assert uh thrown by Il, Optimizer, I, think or something uh it was essentially uh saying that mask 1, 8 128 type that I was not using, uh is outside of bad. It was marked as bad IL operation. Okay,.

A

I'm just wondering if the answer to Mark's question is that it's because whatever that optimization was that's consuming, this is not being run as part of shipbuilder, but.

D

It's simplifier it simplifier. It runs all the time during jit, Builder.

C

My sequence of Il operations that triggered that was uh unsigned conversion of int 8 type into in 32 type into N64 type somewhere there I don't have exact like I, cannot pointed exactly down, but it was as simple. There was like One op code that translated into three leaves of uh Isle Builder.

D

Right yeah, that was the other point that Yorkies Yorkies Downstream perfect is using Egypt Builder as well, so that he's consuming it in a in.

C

D

Didn't as a pain, we've been having discussions about that in another or we've had some discussions about that in another issue,.

D

We don't have really have a clear set of directions on how Downstream components are supposed to use cmake with something like jit Builder.

D

If you want to include the building of Omar in your project like if you want to use sorry, if you want to build your project as part like, you want to integrate the cmake files from Omar into the consuming project,.

D

Then it's not. We don't have clear directions on how to do that and and in such a way that all of the various environment variables that we care about get set appropriately, and so we end up with some kind of weird configuration settings. It can cause some of those problems.

C

The closest they've got was linking my libraries into jit Builder library to also provide to support the iPath or yeah, but I can share that. If anyone is interested later were.

D

You making changes to jetbuilder itself, Yorkie.

C

uh I'm trying to keep it as intact as possible. I have two to three calls to just that: I introduced to the API but I'm trying to uh do it as a downstream project that, by linking way, I'm actually modifying the jit Builder uh Target, but through cement system, not by adding files to omr.

D

Yeah yeah so I mean the typical way that I use it is to I, build the Builder Library using cmake and then I build something else using that just loads the library and uses it so.

C

That's not how I'm, using.

D

Yeah no I get it I. Just that's why the the model, the model that you're using, is not the anticipated model. Let's put it that way, so we have to figure that out I think too, and that that might be also um playing into the problem that you're seeing but the masked off codes.

E

One thing I was going to ask uh about the um to to your question: uh Mark about the shipbuilder testing is: uh is there any I haven't looked so uh I, don't know, but is there a um does? Jetbuilder have its own version of get data type conversion by any chance.

E

I believe so is that I know that the reason I mentioned that is because I I did I, did look at um at j9 just out of curiosity, because when I encountered, the problem I was like. Surely someone has either encountered this or not encountered it for some reason um and uh what.

C

E

That they, they have a get data type conversion that has a has an asserts that isn't for for the number of Omar types. So you wouldn't actually encounter the assert the same way.

D

You know: subject: folder doesn't have its own IL directory, so yeah, so I guess not yeah pretty much absorbing everything from from Walmart directly.

A

Okay, well I mean we can do a bit of Investigation Mark into why what the behavior is of building jit Builder as part of our PR testing or our sorry, our CI testing, to see um why this particular problem didn't manifest itself. There might give us a bit more Insight. Instead, what we can do to better test this.

D

But I certainly agree that the the work to clean up the enum is is warranted. I think that's a an excellent First Step. You know, regardless.

D

Okay, so thanks Kevin for offering to start that off sure.

E

E

Thank you. Thank you guys for that discussion, appreciate it.

A

All right any more uh discussion on this point or any further questions for Gita.

A

Okay, if not um thank you Guida for taking us through that, and thank you Kevin for uh talking us through that problem. um Our next uh architecture meeting will be in two weeks, so thank you. Everyone for attending we'll adjourn now. Thank you. Thank you. Bye.