Node.js Node-API Team, 8 Apr 2019

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Node.js N-API Team meeting - Apri 8 2019

Description

https://github.com/nodejs/bootstrap/issues/114

A

So welcome to the napi, a team meeting for April 8th 2019 um today we're going to take a little bit of a different approach than our usual meetings, we'll start off with there's any announcements or anything like that. But then we're gonna focus the rest of the meeting on an issue around a sink workers. So before we get started, does anybody have any announcements they'd like to make.

B

Ok, if not, then I'm going to open up the initial issue and find that.

B

Okay, sorry, that's the right one.

B

Sorry, I'm just doing a search to see if I can find the rate compute.

B

B

Maybe it's in the other hold on.

C

C

Can't hear in this.

B

Okay, so I'm pasting it in the chats in case people want.

D

B

Open it tonight we'll also share.

A

Okay, so this was the original issue that was opened. You know, I think what I'd suggest we could focus on today is to go through.

A

What are the next steps sort of priority things that we could work on and what are some of the next steps related that sound good.

E

Sounds good yes,.

A

Okay, so the first one here is unsafe: self-destructing, behavior.

F

You know I think we got that would suppress astruc right so.

A

That that covers at least one part which basically says hey, don't just don't destroy yourself right mm-hmm, but if you want to take advantage of having it destroy itself, there's still probably some issues that could be worked through right, yeah.

F

I, like make sure it's heap-allocated well.

A

Not heap-allocated right.

F

Well, no, if it destroys itself- and it should be heap-allocated, otherwise the pointer is.

A

Sorry yeah keep out right, do not stack allocated right, yeah.

F

That's right, yeah yeah, so I'm not sure how to do that, like. um How do you check if something is allocated? I mean.

A

I guess the thing is: is that so I'm sure we could restructure the like the the Constructors and stuff so that you could only create it through the heap? What makes basically, you know if there was no public constructor and then like.

D

Yeah? Yes, yes, something.

A

Like you could do it a couple ways like that you could, you know basically have something that says: no, you have to provide us yeah, you can. Oh here's a method. You can call we'll give you an answer. That means we know, we've always allocated it and therefore it's it. The delete can match that yeah, because.

E

There's the associated.

A

Thing, that's like you could say you. You know we could do documentation that says hey. This always needs to be allocated on the heap that doesn't completely solve the problem because you could use it with newer or malloc right. Yeah.

F

However, that that runs counter to to the usage of a sink worker, which is that you are expected to extend that right, subclass it. So then you know when you do subclass it you can. You know you can structure your constructors as you see fit right.

D

F

That's that raises a bit of a problem, because then we cannot enforce this sort of this sort of heap allocation, I'm, not sure beyond documentation, whether we can avoid right so uh doing anything or we can avoid. Having like stack allocated, one self-destruct right.

A

So the you know one approach to we could say we could dock that. Well, you have to keep allocate it if you want to have it be self destructed. If we did that, though, I think the other thing we need to do is figure out a pattern where they provide the destructor right instead, I think. Currently our cone goes and deletes it right. Yeah.

F

Yeah yeah, we have like a fixed yeah, a hard-coded destructor right.

A

So I think what we'd want is like: hey, you give us a method or something like that right, yeah.

F

Yeah yeah that's possible yeah and then the did well, but then the default behavior shall be which one like to destroy it. If we make the default behavior one of destroying it, then well I mean honestly.

F

Well, you can you can like override the the destructor. You know, I mean it's a it's a method. You can override it and then it won't self-destruct. So so then, what we need to document is that you must do this. Otherwise it'll self-destruct right.

A

Well, the dispersed.

F

The suppressed destruct says no, no, no! No! No! No like, if you don't, if you don't use, suppress destruct right right, yeah.

D

F

Then the destructor for for async worker is public virtual, so you can override it in your subclass with a method that does nothing, but you must, if you, if you wish for it, if you wish for it to behave otherwise like. If you wish to stack allocated, then you must override that come the destructor, otherwise it'll it'll destroy itself, and your memory too. So.

A

If you're doing that, when you just call some suppressed destruct.

G

F

Yeah I I get I guess the two are pretty much equivalent because then the stack would take care of itself when it done mines the stack for him anyway, oh well: okay, okay! No! No! No! No! No! Wait! A second! What's going on here on work.

B

Yeah and probably in here yes.

E

Okay, I think the problem is.

E

H

The suggestion to make suppress destruct more generic, that is, you, have a method called destroy, or something like that. That's virtual and the default implementation just calls delete, but instead of using suppression struct somebody could override it to do nothing.

G

F

Right, yes or just have it, have it be a call back.

F

Yeah, okay, because this substance is a threat the suppress destruct is for is for something else: the suppress destructors for for destroying itself on on work complete. So it calls the on okay Dion error and then it destroys itself. So, okay, whereas the destructor is, is a little bit later in the game. Okay, so yeah! That's that's a good point. We could. We could probably, instead of delete self, we could say like self arrow delete and then that could be a method that potentially does nothing.

G

Okay, yeah I'm I'd be I'd, be okay with that sorry, which.

F

G

Bringing up to speed, which.

F

So, instead of instead of delete self, we could say self arrow delete and then that method would well delete itself by default, but it could be over aidable to do something else.

B

F

Well, nappy in ol dot h, delete self is the only line that says delete self, so you can search by that, but otherwise it's three 6-2 6-3.

B

F

Yeah, that's the one so so, basically.

D

F

Of instead of delete self, we could say self arrow delete and then and then that method could, you know, could evaluates to something other than delete self. If somebody overrides it.

A

Right so that if they'd said now it, for example, they could.

F

Right, yeah, well, yeah, I, don't know we do it. Anybody use malloc with the class but but yeah. If they have something some other sort of allocator, then yeah, then then this would be. This would be more generic yeah, okay, I! That's that's a that's an item we can break out, have a more generic sort of leader.

A

So basically, we would dock that you need to, if you don't call suppress destruct, you need to. You need to allocate on the heat right. Yes,.

F

Yes, and if you use or if you use an alligator other than you, then you should. You should also provide a destructor right.

A

H

I mean providing this mechanism does make suppressed destruct somewhat superfluous, because you don't need to call suppress destruct if you're the delete function does nothing. On the other hand, this is a. This is somewhat of a foot gun right.

H

There's nothing preventing people from calling in multiple times and all of that.

F

Yeah yeah yeah calling it well, we could we could well, we could make it I mean if we made it like a protected method, then then you know it would be part of um the implementation of well no, never mind huh yeah.

H

I mean especially if they override it, there's no protection. They have.

F

Right right, yeah.

A

What other options are there? The other option would be to provide a like provide, a method that you can call sorry provide a method. You can call to give us the code to do the to do. The the free / delete right, yeah.

F

Yeah like like a function pointer, yeah.

F

Yeah, that's not really well actually,.

I

F

I was gonna, say it's not really the C++ way of doing things, but actually with with like lambdas. We can easily do that right. So you know you know. If you have provided such a such a function, then call it otherwise delete self.

F

J

Where things are passed like a finalizer, this would that be something that could be utilized here like I. Guess it's not the same context of like the the engine is freeing it but yeah. It's still a callback that is utilized, I. Think that makes sense to me.

A

J

A

Of still the same thing like the same ideas like, but you know, the final answer is the one I was thinking of us like hey an object when the objects no longer reference. We're gonna handle the deletion for you. This is like okay. When the work is complete, we will handle the deletion for you, hmm I guess the async work heard. We don't have a corresponding and that's probably not as good anyway like if we had a corresponding object. You could actually use something like a finalizar, but that's not I. Think.

D

A

Know the code is done with the work is done. We should just clean up ourselves and.

J

What was the problem with doing like a default implementation of delete, but then allowing them to override it.

F

That they can call delete on their own, and so.

J

F

People can end up with like double fries and stuff. What.

J

If then, it's like, we provide a you, provide a callback, but then the default callback is to delete and then therefore the callback is only ran once, which would be.

F

Like to finalize yeah yeah, exactly so so, basically, basically replace this line. That says: delete self with like with with basically like self arrow delete where delete is, is, uh is a function pointer or some sort of you know, lambda or whatever, like a C++ function pointer that was passed in you're in construction right.

F

So then, so then we still control when it gets called, but we no longer control what happens when it gets called and three.

D

F

Will be freed the right way right so so then so then we don't run into the problem of exposing an API which can potentially be called for the wrong reasons exactly so. What do you think he lamda there yeah.

H

I think that that makes sense I'm looking at the thread again and it looks like Eric's proposal- was a whole new class that was simpler than what we have today. Have you looked at his proposal? I.

F

Have at some point, but it's been a while a simple class for a sink worker right right.

H

So, rather than having this a sink worker thing, which is subclass able and so on, it's his proposal, this is a sink work class that just just one thing, which is manage the lifetime of the work right. So you it's not meant to be subclassed and so on. It's just as simple wrapper around grade.

D

H

Sink work deleting it it's.

A

The only thing: how does that play with the whole reason we had a sink worker was Fernan well.

F

Yeah Fernan look and feel sort of that's right, I think able to move over.

A

Right so that'd be my one concern with something completely different unless it's like an easy mapping from one to the other yeah.

F

I mean we well I, don't know. Could we implement a sink worker using this class? You know that we probably could that.

H

Seems to be the intent anyway behind this his proposal, yeah.

F

I mean quite understandably, he wants to.

F

He wants to improve the interfaces that we have and that's that's great right, but we do have to sort of pick up where nan left off and then start to improve, right and and we need to offer additional interface is not replacements, because people already have the code that they have right so so for now getting them to move over to to know that on API is probably a higher priority than than having the better interface, which is not to say that we shouldn't have one so I, don't know, maybe yeah.

F

Maybe if we implemented this, then we could rewrite async worker to use it. And then you know we would point people at this thing and and then sort of convey the message that if and when you get the time, then you know break the one on one or the one to one with with with man and and use a better interface yeah.

H

That makes sense how much of the problems did he points out with our async worker today, I mean I haven't looked at now, but how much of that is actually just problems in Nan's definition of a sink worker equivalent.

F

Right, I'm not actually sure I, don't think I've ever used a sink worker wooden hat.

F

So I couldn't answer that question. The.

K

Interface is very, very similar to API I I use it during the past. The very basic so ya know.

K

F

A does nan also have this self-destructing behavior.

F

Okay, well, then, then yeah, maybe they maybe they sort of skirted this entire issue by not implementing it.

F

Here we go nanny sink worker.

F

ha ha Look at that virtual Boyd's destroy.

F

Virtual voids, destroy I'm willing to bet that virtual void destroy is exactly what we were talking about, which is which is to expose a method and it's a public method which will destroy it too. You know so as to reverts. Whichever way you created it.

F

So so so I guess they went, they went with the they went with the you know, implement a virtual method for destruction solution. So I guess it is self-destructing.

A

Well, unless that destroy is the way you're supposed to destroy it yourself,.

F

Well, yeah, let me see, does it actually does? Does anybody actually call destroy? Let me go oh boy, I wonder where this is implemented. Man Bob.

E

F

Can't can't imagine where this might be implemented. I need to clone this.

H

Yeah it looks like an ASIC execute complete. They call worker, destroy mm-hmm.

K

F

Just like we do yeah and the default implementation of virtual void destroys delete this yep.

H

F

Know yeah so they're doing exactly the same thing that we are except they're there they're exposing it's also they did that extra extra step of of allowing people to override the way in which it gets destroyed, but they did so by by exposing this method.

A

System with nan yeah, that's the goal. We should. You start screaming. Yeah.

F

We should probably do the same thing yeah, even though it's not ideal I guess you know. If people have, if people have run into two to two multiple or multiple deletes, then they will have fixed it for now, one would hope so.

F

Okay, so I think yeah I think for now we should probably just go with with with with exposing this message just as Nanded and then and then maybe think about implementing this this class. That Eric was talking about this.

A

Allows the same alligator the same.

A

That seems like the right answer to me. Like you know, it's consistent, because we did it to be consistent with men. It dis fixes a problem. That's there and it's fairly low like it. Doesn't it's not cember at all right, assembler, minor, right, yeah, so a sembra minor, so I mean I, think that's. It closes the worst part of the gap. It is consistent with man. It seems like the right thing to me versus a like, there's still value in looking at like.

A

Is there something simpler or different, but that's kind of like us, a separate thing.

F

Yep yep yeah I mean yeah. The the C api's can be exposed in any number of ways, and some of them have more abstraction than others and yeah. It's definitely a choice.

B

Does that make sense, everybody.

F

Yeah: okay: let's, let's do this as a next step, yeah.

H

That makes sense to me I'm.

A

Just trying to okay, so let's go back though, and see what else that that addresses right number one so that one we know. Okay, you can fix that right. Yeah, that's done! Okay, the synchronicity from the callers lifetime in the object Carnival is a reference to sink, where any calls cancel right so being able to call cancel.

A

Basically, you can't call cancel if you've asked for it to destroy itself. I think this yeah right.

F

Like there's no way that you can really get around that right,.

A

F

Yeah yeah cuz yeah the the way in which the way in which these uh these callbacks execute that they are fired from the from the event loop may correct me if I'm wrong. If I understand this correctly, though, the way in which callbacks are executed from the event loop may result in the work complete being called or it may result in in the cancel being called after the work complete has already finished, in which case there will probably be a segmentation fault.

L

A

Once you launch the.

L

A

Can't tell when whether or not it's complete when you're calling cancer.

F

That's right, yeah, yeah, yeah and yeah, and there could be a cancel pending on the queue and and and you and the work and the complete is called well okay, but you know you know this is this is not necessarily within scope right, because I mean the the cancel call back.

F

The cancel callback has to account for the fact that that that the work may have completed right so so then, so then, the the on okay or on error callbacks are really responsible for force for setting a flag somewhere that inform that informs the cancel callback. Well, it's too late to cancel now right, because because this this can occur, I mean yeah.

H

F

H

You do that, when the thing that it checks is already deleted right.

F

Like that's the thing like the flag needs to be elsewhere, then then, in the instance. Alternatively,.

H

You just have to say that if there's a cancel callback pending, then you're not allowed to delete it. You just mark it as done, but.

F

We do not attach the cancel callback right. We simply, we simply accept the call to cancer.

L

Like there, it.

F

L

There, in the code, like you, can say, cancel.

A

That calls through to the underlying object right.

H

But maybe we should just set a flag on the work saying: yeah, there's a cancel. Now, that's pending no.

F

H

F

No, no, no! No! No! No bye-bye bye, okay, so basically considered consider the following scenario: okay, you you fire off the work right and the.

D

F

Work takes a long time right, but but just before the work finishes, you insert let's say an idol and Idol handler or like a one-time timeout into the event loop, the body of which says, cancel on this instance right. So now you have now. You have two two callbacks in the event loop right. The first one is the notification that the work has completed. I see I, see the second one is the cancel. So that's the problem that.

H

Is you don't know which what the callback that's in the queue is going to do exactly.

F

Yeah, you don't know in which order the two callbacks are present in the in the event loop. So that's yeah. So then the second one calls cancel on an object. That's already destroyed. So so, basically, basically, if you do cancel and if you do cancel asynchronously, then then you basically have to have to keep an object between the two that that has two references: 1 1 from the instance and and one from the callback and and then when, when both of those references are gone, then you delete the object.

F

So you have to have code inside your instance. That said in your destructor, for example, that says you know, am I. The only reference to this object then delete it, because that means the work was cancelled right and then, and then the the cancel callback has. A reference also has a pointer to this object and it checks the references and if, if, if there's only one reference, then it means okay. The work has completed it's too late to cancel unwrap the object and delete.

F

Otherwise, if there are two references that release my reference and call cancel, because we know that that the instance is still alive, which tells me that we should probably rest count. This thing.

A

ha I guess the other thing, though, is like should mean can't I don't see, cancel in I was looking in man.

H

Yeah I think the obvious question is: how does man deal with it looks like man just said: we don't give you the functionality, capsule right, I,.

A

Mean I think it's probably because it was possible and would be V to do a cancel, so we ended up having an app cancel. So in our async worker we have to cancel yeah. So if we were doing it today, we might just say sorry, there's.

M

No cancel but we've already allowed for cancel, so that would be a major API right, but I think.

A

Then you know maybe the caveat that you can only cancel if you use.

A

F

A

F

You know actually, actually this can be implemented in the subclass.

F

No, it can't nevermind well it it could be implemented in the subclass if we also expose the destroy, because because the subclass could implement ref and on ref right, but then where it, where essentially we're essentially coaching people on how to properly use this rather than giving them the tools to properly use it. So what I'm saying is if we expose destroy right, then the destroy could unrest this as in itself right and only destroy itself, if other.

F

If it has the last reference and then and then the cancel you know, then you could ref you. You would have to expose a function that says ref you know and then and then you know, we document that when there's.

D

F

Asynchronous cancer, if you wish to introduce an asynchronous cancel, then please read it before you put introducing.

A

But I think actually suppress destruct. Does the same thing right, because, basically, if you, if use then I'm going to use this press to suppress destruct like if you want to use cancel, you have to yeah, you have to use suppress just this suppress destruct every feelin all right and you basically you're in charge of doing it. So when it actually, we won't delete it once you've finished you're past the point where you think that you need to cancel it. Of course, the thing they're.

L

F

L

Know you know which.

F

Callback got called first, was it the on work, complete or was it to cancel right and then? And then you you? Can you can keep the ref count right there? You know you you, you, you set the initial ref count to and then and you suppress destruct and then you you dereference from cancel and you dereference from from from work, complete and then the last the last reference when it's gone you delete.

F

So basically, yes, the press destruct gives you the ability to delete whenever you want to, and it also takes care of this race condition. As a result, it's just it's not as nice, because you have to do the ref counting yourself. That's all, but we cannot do the ref counting for you, because we cannot know when you will call cancel right right.

A

And even if you call cancel, you would still be there, you will still have to delete it yourself, exactly yeah, but I I guess so. Suppress destruct today just says: don't call the destructor at all right.

A

Yeah, that's right!.

F

A

A

Made that increment to ref count 2 plus 1.

D

A

Plus 1, so if you say, suppress destruct the rest candidates to then when you call delete you know it decrements it to 1, then unless you called delete yourself again, you know, then you have to call delete, or else it doesn't go away right.

F

Thinking thinking.

A

And then, then you could actually so basically, if we I'm just thinking yeah a little bit if we made some suppress to strive to effectively make a ref camp of 2 instead of 1 delete decrement the ref count and and deletes that if it's 0 yeah that actually might be a simple way that says, if you say suppressor press destruct, you can then call cancel.

A

You could then call delete.

A

And well, no, that's probably not gonna work, but in fact, then, when on ok was called or or the other one, we would still do it delete right, but it would have fact. Yes that would effectively get us I. Think if I'm thinking it through carefully what you want right like you could call up to the point where you want to call cancel you, you don't call it delete once you call delete you're no longer allowed to call because.

E

A

Effectively deleted your reference to it actually.

F

A

Away yeah I think I.

F

Think, there's a there's: a distinction between cancelable or no there's a distinction between okay. No something has to happen in response to you're expressing the desire to to make this operation cancelable, because in response to you expressing your desire to make this operation cancel what we need to increment. The rest count well, but right, but.

A

But that is higher, but it's not so much cancelable like your suppress destruct, says: okay, don't just destroy yourself! You I want to tell you when to destroy.

L

Yes, yes, III mean yeah, so so, okay, but the challenge with the destroy is, is if you've cute something to run and.

A

You call destroy like how do you know I guess you you only know and you're on okay or on complete that you're done right.

F

Yes, yeah exactly yeah, so so I mean call. You know the the instant when on work. Complete is called back.

F

When you know that you can you can you can reduce the ref count by want for sure right right. So if, at that point the ref count is zero and nobody said suppress destruct, then you delete yeah right, but.

F

That will always be the case because you have no way to set the rev counter right.

A

Well, no, so that's what I was saying is it's suppressed. Destruct would be the increment draftkings.

F

So, okay, so let's say: okay, so let's say you say, suppress this rock okay I see what you're saying. Okay I see what you're saying so so, okay! So basically, what you're saying is: okay, suppress this okay, the ref count when you create the instance. Is one yeah you you, you call suppress destruct the ref count. Rises.

F

Yes, now on work, complete the ref count drops to one again: yeah okay, and then you either called delete yourself and, and you delete it with the ref count of one or you call cancel the ref count drops to zero and and the.

A

Balaji gets no I, wasn't thinking, cancel would affect it like you call cancel once your call to cancel is complete, then you call delete right.

F

Explicitly because you can't suppress this drug all right, okay, but can we accommodate? Can we accommodate an auto destructing one while still solving this and I think the only way we can do? That is if we, if we expose or if we create an API, whereby you inform that there's a there's, an asynchronous outstanding cancel that will potentially open.

A

Without looking, you right, I think if you just know, because I think I mean you create you, create it and call suppress to stuff destruct, and we now have so now we have our f cattitude right yeah. Then you can either at some time later say: okay, you can can't you can call, cancel or not, because I think the thing is you may or may not know that you want to cancel it, but up to a certain point you make you want to contain the option to try and cancel right yep after a certain.

A

After a certain point, you want to basically say: okay, I'm, not gonna, call cancel, at which point you call delete lake delete, calling delete would actually be. The I am no longer going to access this yeah yeah. You.

D

Know then, maybe.

A

There'll be other methods that want to do something similar, but like basically, I can't call anything on this, because I'm telling you I'm deleting right, yeah and then once you've done, that it goes down to one, and it means that if the on ok or on error has already run, it will be deleted immediately. Right.

E

If those are still.

A

Pending then, it will say: well wait a sec I've got stuff in flight if I actually delete it. Now, that's not gonna work.

F

Ok but but but suppress astruc means that it will not be deleted ever unless you explicitly call delete, meaning that that you're, your handler for on arrow on ok, must also include a delete right. So but but well, but no.

A

You need to call delete somewhere yeah, you do right, but it could be, but but with the reference counting, you could call it. You can basically call suppress, destruct immediately, call delete and you would get the self-destructing behavior and be ok.

A

Right, like suppress destruct, we could interpret, as you must call delete, to delete this. That doesn't mean the memory goes away when you call it the lead. Well, why.

F

Not I mean that's the point, because.

A

The lead isn't safe, like we're talking about delete, not being safe, because if you queue something to run and you actually delete the class and it's already queued to run. That was the problem. We were talking about site, that's not safe, because it could no.

F

No you're right right right, but but that's up yeah, if it's, if it's, uh if okay I see what you mean so so you basically you queue it and then you delete it right.

A

So you so you know, and if you didn't, if you want to retain the option to cancel, you, don't delete it until after you might have might want to call cancel.

F

Yeah, that's that's an interesting point. Ok did this is actually a different problem because, because I, how do we handle this? Even on the sea side like on the on the sea side, you you there's. Obviously there are objects in the background, but but the API doesn't allow you to actually delete those object. All it allows you to do is cancel the work like you have no control over the pointer on the sea side right because you have this and nappy async work.

F

A

Castle a sink work, so the dilute no well the Delete I think where's. The delete.

F

Yeah, it's just yeah.

A

F

Right look uh uh delete.

A

F

Right so you delete the a sink work in the destructor, a.

F

Well, yeah I mean that that makes sense. Yeah yeah you actually yeah, yeah I mean you delete the yeah, but so so so what happens? If like what happens to not be delete a sink work? If the work is is queued, I mean it probably will blow up yeah.

G

F

I think we need to test this like.

A

I I suspect that you know unless we have some reference counting in the C's code side of things, yeah.

F

I don't know, let's see.

A

huh Nope all it does is delete right. So it's it's basically that you can't delete it. You can't call like once you call delete you're out of luck right, yeah.

F

I'm, just thinking like okay, we need to do. We need to go deeper, because this music.

D

F

This subclass is so work is a subclass of async resource and thread pool work. Now what happens when you delete thread, pool work? What happens when you delete node async resource, you know? Does it clean.

D

F

Kill the thread and.

B

Let's look at what the dog.

B

A

It's in j/s assumed are as they sink work. Is that part of the note specific stuff yeah.

F

A

Api, okay,.

B

F

Circ api wow they're an api subdirectory now.

F

Async resource.

D

F

Wellokay, a sink, a sink resource, simply updates the hooks and then and then it it lets, go of the of the persistent reference to the object which serves as the context for the callback I. Think.

F

Okay. So so that that's just that's just bookkeeping at that point. It's not actually freeing any memory.

A

Read/Write, because we passed in the callbacks that are gonna, get called yeah anyway, right.

F

Yeah yeah yeah, so so so yeah I mean we're not gonna use that javascript object anymore. So it's not available anymore. That's, basically what we're saying but I'm not seeing anything. Actually, you know update the thread pool and all that stuff. You know removing remove removing handles from the event loop and all that stuff right. So that's still still gonna run well, maybe not! Let's where's the implementation of thread pool work.

F

What the heck! No the internals I guess, looks like it's in line.

F

Thread pool work.

B

Okay, wait a sec yeah. We have after thread all work.

F

Yeah we've got, there is no, nothing happens during the destruction of it, so, okay, so okay, so let me see I think that's. This is the only threat for work stuff here in node, internals, dot H. So so then so then they're no effort is being made to actually remove stuff from the queue it looks like.

A

Yeah because I don't think things are truly passable right like like. If you call well the not on a delete on a cancel, but even it cancels not guaranteed to cancel that's.

F

Right, yeah yeah, so so yeah, so you can't oh well in line virtual threat, tilde threat to work equals default. So what to do in the case of of destruction is left up to the implementer. Basically, so, let's see what some of these implementers do like, for example, you have note crypto, anodes adlib, and these guys, let's see if they provide.

F

They provide destructors.

L

I'm, just gonna be back in one minute: okay,.

E

E

M

E

: public thread work.

E

F

Yeah, so so there's there's nothing. You can really do except except cancel so, basically, basically you're you're, you're, basically a hostage until until the callback gets called like the the work done callback. You, you can't delete this I, don't think we can do anything in in in higher layers.

F

To to do that, to make that any better.

A

Sorry back yeah.

F

Yeah no worries I was just saying that I looked at look I looked at some of the classes like Zed, live and crypto. That.

D

F

Implement or that subclass this thread pool work, yeah.

D

F

It looks like once you've queued it, you pretty much cannot delete it until you've received some some feedback saying you know it has completed or not. You can cancel it and then that that will ultimately call UV cancel, but but that's a that's an operation that in that assumes the work is intact. So it cannot be part of the destruction of everything right.

F

So so then, so then yeah. So basically, this these instances are committed until until the work completes right.

F

So so we cannot cancel the work as part of destruction that that just doesn't work. No, no.

A

F

A

You know you know it's like if we use the rough count set.

L

L

Increments, when, what's it called suppress, destruct, suppress.

A

Struck just writing this down to see if it holds water struck, who knew delete, method or display method, scrolling method, decrement decrement, and only destroy zero.

C

Zero- all of this.

A

A

From the current, from the place from where we clean up.

B

Manner all right.

F

Gate one on construction, increment, okay, sir.

F

Yeah, so you called destroyed from on okay. Well, it's it's on work, complete on work, complete decides which which, which methyl.

E

Get on work, complete work.

F

On work, complete is the real call back coming in right, okay below so so, yeah ask John, okay, yeah and then.

L

If we actually assert.

A

That it that, if it's destroyed in the count, is not 0, that would give you at least some coverage for the case where people do it with they.

A

If you for the stock out sorry heat stack allocated yeah, then, if you, you know, if things are started, you're actually waiting, you stand, you should say I, guess just press destruct, because you're saying you'll destroy yourself is that right.

F

Yeah I mean if you, if you stack, allocate yeah, you should say so. This.

A

Is press destruct then, if you didn't, then we could throw an assertion right, saying: hey. You should have called.

C

You should have called suppressed destruct because yeah.

F

Okay, I see I, see what so what you're saying is yeah. If you, if you end up in the destructor with the ref count of two, then then, then that should throw an assertion exactly because wait.

A

A second we're not ready for this to go away yet yeah.

F

That's right: that's right! Yeah with the one, then that then yes, but with a definitely not yeah, that's good! That's good right!.

F

Okay, yeah, so so so this this takes care of explicit destruction.

A

F

A

Sounds like a good next step now, unfortunately, we're one minute left and I. There is another meeting, so we have to stop the stream and I have to go to it anyway. Yeah.

F

Yeah no worries, no worries, III think I, think we. We have some some next steps here. Okay, like like they like exposing this destroy method, there's a next step and the internal ref, counting it I think, and the assertion yeah I think this. Basically, what I've gotten this last.

A

Comment is the next yeah okay, because I think that would then you know again it's all sembra minor and it would make it safer and it's consistent with man. So yeah.

F

A

Okay, okay, I guess thanks and look at the hard-coded JavaScript function: callbacks, yep, okay, okay, thanks everybody! It was a good working session and we'll talk to everybody throughout the week or, if not next week, all.

D

Right just so everybody knows, I will not be able to be on the call next week, but I'll be I'll, be back in two weeks. Okay,.

A

Look forward to.

H

See you then, okay, great.

D

F

F