Multiplatform C game engine from scratch | Day 56 [Pooling Work]

Added: 2026-05-10

[00:00:01]Good evening everyone.

[00:00:04]I don't have any particular plans today I think.

[00:00:08]But what I was thinking about working on today was scheduling some of these threads to do some more work for me. So you might remember if we are running the game and we just break somewhere.

[00:00:32]I guess not there.

[00:00:35]Hello.

[00:00:36]Oh, right. If we just break somewhere, we can look at the threads here and you will see that we are having a bunch of threads here and pretty much all of them are just sleeping. There is one that is doing graphics and I'm actually not sure which one right now. I'm I'm a little bit surprised that all of them are just sleeping.

[00:01:16]Oh.

[00:01:19]Oh, interesting.

[00:01:24]Why did that happen?

[00:01:30]I just paused for a second.

[00:01:37]Okay.

[00:01:39]I'm not sure why that [laughter] happens, but uh that's not my focus right now. I wanted to take a look at uh do we not have graphics here.

[00:02:04]Oh, not the not the header.

[00:02:24]Now I'm really confused.

[00:02:29]Where is graphics? OpenGL C draw.

[00:02:43]Here we go.

[00:02:50]Okay, so this one is actually running.

[00:02:55]Am I still sleeping in the game?

[00:03:09]I am well that that uh tells me why it was sleeping when I was just uh stopping randomly.

[00:03:21]So now we can pause at a random place here and you will see that it's in graphic straw and for some reason it's doing that.

[00:03:47]Oh, interesting.

[00:03:51]So, yeah, I guess we're having some uh bugs that we can take care of.

[00:03:57]Cuz that shouldn't happen.

[00:04:00][laughter] Looks like it's inverted.

[00:04:10]It's using the width for the height and vice versa or something like that.

[00:04:18]Um, we will take care of that at some point.

[00:04:22]But yeah, we are having a bunch of threads that are doing nothing except sleeping right now because they're not scheduled to do anything. This is the game threads.

[00:04:36]So I would like to take care of that.

[00:04:40]Now all of them should have access to some pool.

[00:04:48]We can take a look at that.

[00:05:26]Okay. No, I'm just assigning it. So then my idea would be we create another queue here.

[00:05:48]And there's a couple of ways of tackling this issue.

[00:05:54]What we're doing right now is we're doing game updates and then we go through all the prefabs and then if they exist because we might have holes, right?

[00:06:12]If they exist, we call the function and then we do the same thing for their children.

[00:06:21]uh we update their previous upset offset and later on we are calculating the physics.

[00:06:36]Now this entire thing is probably the bulk unless there's some function like I haven't added any function that would be super heavy right now.

[00:06:51]But there's two ways of tackling this.

[00:06:54]So let's just go over that quickly.

[00:06:59]One way is that we're having this entire array. We can think of it as a block of work that needs to be done.

[00:07:08]So we can just look at the count here, this count, and we can say, well, we're having seven worker threads. So we will divide it into a bunch of blocks.

[00:07:26]I don't know how many that is. One, two, three, four, five, six, seven, eight. I want because Each one of these can have its own thread assigned to it. 1 2 3 4 5 6 7 and 8. And you're thinking, why are there eight blocks when we're having seven threads? Well, we were having the main thread also. So, let's not have that just idling around. We can actually use it.

[00:08:08]the alternative to this and that would be in particular if we're doing these function calls somewhere.

[00:08:26]If we're doing these function calls, you know, you you could imagine that one function takes a microscond and then another function takes 100 microsconds.

[00:08:37]So it might not actually be u prudent to just divide it straight up.

[00:08:45]You might actually want to schedule each prefab to have a thread Q task assigned to it. Now, one issue with that is that you're kind of destroying the um coherency, the the memory cohesion.

[00:09:10]So one job you're doing one task and then the next job it might be several uh array indexes down and then you have to throw out the entire cache that you have and uh start over. So that's inherently going to be slower just because of that, but it also minimizes the factor of one function taking way longer than any other. But I don't suspect that we're going to uh come into that issue a lot.

[00:09:55]Um, so yeah, I think I I don't really see any negatives with doing this approach.

[00:10:03]So I think I'm going to go ahead and do that.

[00:10:07]Now, we're not going to get perfect.

[00:10:12]Uh, we're not going to be able to divide this perfectly, especially if we only have a couple of objects. You know, let's say you have five prefabs here that you need to update, but you have seven threads. Uh, I guess each prefab just gets its own thread and then the other ones don't.

[00:10:36]So we need to think about the logic here.

[00:10:50]We have a total count and we would like to divide it [snorts] by the number of threads that we have. Do we have the number of threads saved? I believe so.

[00:11:12]Thread count.

[00:11:22]So this can be an uh integer divide.

[00:11:38]And what do we call this? A prefabs to per thread, right? Because we're including the main thread.

[00:12:09]So now this might It might be six, it might be eight, it could even be nine.

[00:12:13]Uh, I'm not really sure. And this one could be zero because imagine that we're having less prefabs than threads.

[00:12:24]So then we say if prefabs per thread is equal to zero then we schedule each prefab its own thread.

[00:12:57]else it could be one.

[00:13:04]So actually let's say less than or equal to one or no no no because this is an integer divide.

[00:13:20]So this could be like 1.99 and it would be rounded down to nine rounded down to one.

[00:13:28]But actually we want two prefabs per per thread.

[00:13:58]I think the logic just works even if it's one.

[00:14:04]So then we we need to create a job for it to to do.

[00:14:11]So we are giving it uh probably we need a new new function for this because this is just kind of part of the game update.

[00:14:21]So let's put it in prefab actually.

[00:14:35]Prefab create. What we have here?

[00:14:39]Destroy.

[00:15:10]count maybe. So we would give it a starting index start index and then we give it a number of prefabs to actually update.

[00:15:27]Makes sense. Yeah.

[00:15:35]See, let's just throw it on the bottom.

[00:15:41]And I think this actually should be TFL return for result.

[00:15:53]And then we do basically everything that is in here. So we start and we end.

[00:16:05]And we can disable this.

[00:16:32]So the prefab we get is start index plus I and we do it I times uh count times and then we do all this of why is it equal success means oh because it's an assert I Maybe we just do an if here.

[00:17:44]No, let's let's keep the assert because I I want to immediately deal with this and because I have a count I I am not checking for success every time.

[00:18:00]Then we go through the children. Okay.

[00:18:02]So, we can I guess it's just a void.

[00:18:51]Now I am not assigning a I'm not assigning a specific thread a specific job.

[00:19:02]I want them to share the work Q.

[00:19:23]So I think I can just throw the work in there.

[00:19:31]So while or do while jobs left to do is the count and then while jobs left to do is larger than zero.

[00:20:06]We do this loop.

[00:20:08]And what is the loop? The loop is red task uh how did I how do I do it?

[00:20:28]Task push.

[00:20:34]Which Q? Well, it's the Q physics Q.

[00:20:43]Maybe I will call it worker Q.

[00:20:58]The function is the one we just made.

[00:21:04]Prefab update.

[00:21:15]Start index.

[00:21:21]It would be zero.

[00:21:50]count.

[00:21:56]Wait, these are the parameters for prefab update.

[00:22:19]uh the stride is for the arguments. So, so we need to add this.

[00:22:42]I don't need a line on everyone. I'm almost certain.

[00:22:49]But I guess we'll find out the hard way.

[00:22:53]So we call this a prefab update.

[00:23:39]Start index is job index and count Is this?

[00:24:02]So we push that stride is okay. It is relevant.

[00:25:16]incompatible.

[00:25:20]I see.

[00:25:52]Yep.

[00:26:03]Now you could have a two functions. What am I doing?

[00:26:12]One that is the original function and one that is the thread function to call.

[00:26:24]But I don't think really we're going to need need to do that.

[00:26:59]It's a little bit annoying to type it, but I don't think we're going to need to type it very often.

[00:27:09]So, that should be fine except we need to res uh return uh success.

[00:27:49]So now we should be scheduling something but we need to still process it.

[00:28:02]So that's done down here.

[00:28:08]And this is part of the bigger thread run.

[00:28:14]I might just uh pull it out because I want the main thread to also be able to just pop in there and uh do the same thing essentially.

[00:28:27]And possibly we want uh this also, but it's so short. Maybe it's not necessary.

[00:28:59]Do we need this OS or anything?

[00:29:03]I don't think so.

[00:29:08]See a third game.

[00:30:07]So, we need to do the same thing as here.

[00:30:22]We're getting a task. It's coming from the work queue.

[00:30:28]If we found a job, we process that, it's going to be this.

[00:30:46]And then I guess we don't need to call anything afterwards.

[00:31:03]Maybe we'll just call it process thread Q.

[00:32:10]And you might see that actually here we can also do the same thing.

[00:32:17]But When we do this Yeah, that seems good.

[00:32:53]So now I think the cues are uh the I think the threads are doing the work.

[00:33:02]But of course, like I said, we want to use the work uh we want to use the main thread as well.

[00:33:33]and job index plus equal prefabs per thread.

[00:33:53]So I don't think we need this The question is we could um there's a chance that we are having an uneven amount of work to do.

[00:34:17]So for example we have I don't know let's say we are having uh 20 jobs but we are having 21 if we would schedule everything everything would be scheduled uh on uh seven.

[00:34:41]So we we schedule we schedule seven jobs and then seven jobs and then seven jobs and the last one overshoots. So instead of having 20 total jobs, we would get schedule 21. So the last job would be out of bounds.

[00:35:02]So we can prevent that.

[00:36:32]Hold on.

[00:36:54]This doesn't work.

[00:37:03]We need to do this first.

[00:37:31]I think this logic is sound. So we are starting at zero.

[00:37:36]Let's say we are adding four and we are having five.

[00:37:41]So 0 0 plus four is not larger than count.

[00:37:55]So this doesn't happen. So we say zero and four and then we push that and then we add four to it. So we get four. Next time 4 + 4 is eight which is larger. So we change this to be one and then we start at four and we do one job update we get five and then we quit the loop right make sense and then lastly for you.

[00:38:51]Maybe this should be part of the reds library.

[00:39:12]or Hey, maybe process. Oh, Sure.

[00:40:44]So if I only want one task, I can just pop it. If I want to process all of the tasks, then I can run run this one. That that makes sense.

[00:40:56]So yeah, we are joining the task force.

[00:41:17]And if I did that correctly, I should not see any difference except that everything should run faster.

[00:41:34]Now something is going on here.

[00:41:38]Make something super low level like Python.

[00:41:42]Um, sure.

[00:41:47]Maybe not. Now what is going on here?

[00:41:55]That is not what I expected.

[00:42:02]All right, hold on. I need to grab some more water. So, I'll be back in one just one second.

[00:42:22]See, I don't even know if you can see it on the stream. Let me take a look.

[00:42:30]You You can't see what I'm seeing. Uh I am seeing much more uh psychedelic than uh than what what you do.

[00:42:41]But that is surprising to me.

[00:42:46]So, let's maybe take a look what at what's going on.

[00:42:58]Uh, update was it here.

[00:43:24]So this is the beginning of a new frame.

[00:43:28]We are having 1,02.

[00:43:36]We get 125 prefabs per thread.

[00:43:47]which I guess makes sense.

[00:43:54]Now one thing I should say I am not sure that I have I'm not sure that the this is memory safe. So it might be that the couple of uh objects that are updating and flickering like that are that they are just happen to be on the boundary and the threads are like overwriting. But I wouldn't expect that because all of them are starting at the beginning of the index and working their way down. By the time it gets to the 125th object, the the other thread should have been way past that.

[00:44:51]So I'm not sure.

[00:44:56]Uh it's definitely not zero.

[00:44:59]We start at zero.

[00:45:03]This is not more than the maximum.

[00:45:07]We say arcs job index. Oh.

[00:45:12]Well then, that's an issue. [laughter] Hypo.

[00:45:29]Okay. So the the only thing was that typo, I guess. Now everything looks normal.

[00:45:42]Beautiful. Now I think we're still like kind of spinning the other Well, not spinning. The the the issue is that I am just sleeping for 100 milliseconds.

[00:45:55]Uh down here somewhere.

[00:45:57]this one after I have processed for one frame. So the main thread goes to the next frame after uh 33 milliseconds. So it will be alone the next time the the next two three frames and then it gets the help from the other threads and then you know again they're sleeping. So actually we need to continue this. We are I want to do the right now we did the um function calls later we will do the uh now we will do the physics and lastly all these threads needs to be having a sleep work right so really what I want to do is I want to delete delete this all together. And now we're going to be uh utilizing a lot of uh C CPU just to do this.

[00:47:03]So it looks the same.

[00:47:05]Maybe even the stream is struggling because I'm probably using a lot of uh resources.

[00:47:17]Yeah, a lot.

[00:47:19]I I can't tell you the exact value, but it's it's definitely a lot.

[00:47:25]You're trying to teach yourself several physics algorithms, but making game engines are way out of your league.

[00:47:32]Well, the the good thing about physics in games is that like most of it is fairly simple. If you want to get like really deep into it with light and stuff like that, then you you can get very gnarly. But all of the physics that I'm using here so far is just very simple like multiplication of vectors and most of it I'm using uh I'm using a math library for it anyway.

[00:48:07]But you know I went through university I did my matrix multiplications by hand for two years. So like I've been through the pain.

[00:48:17]So I I I would consider myself uh being able to use it in good conscience.

[00:48:26]If I pay for 100% of the CPU, I'm going to use 100% of the CPU. Exactly. Well, 100% of the CPU, I would like the OBS to be using some of it. So developing the game, I want to I want to limit the game so that I can do other things but still use 100%. Uh anyway, so I would say this seems like it's working.

[00:48:58]So we're going to do the same thing for this one. I can just do on the main thread. I I don't see a reason why we would do it. Um why we would divide it, at least not now. We can we could think about profiling this and see if it actually matters, but I'm I'm going to ignore it for the moment. So then we do regular prefabs, not including UI, and we're doing physics here.

[00:49:31]So I'm going to add this also to my prefab functions.

[00:49:41]Now it's important I'm having these uh function calls and then I'm doing delete and then I'm doing physics. I could throw this in here, but it means that if the prefab is deleted by the function, then it's not really necessary anymore. And see, here's the thing.

[00:50:16]I throw all of this work on the C on the thread Q and each function maybe it will spawn another entity and that could be fine I think but what you don't want to do is you want you don't want to delete something in the middle of something being worked on. So that's why I separated the function calls initially.

[00:50:54]But if you are limiting the function here to be something that can't spawn prefabs, then you I guess you could just uh throw it on there.

[00:51:10]I'm going to keep it separated for now.

[00:51:23]Or maybe see this is an interesting problem. This is why maybe sometimes you don't want to do it like that because I want to batch everything as much as possible.

[00:51:57]But I could have just the main thread go through one entity, right?

[00:52:05]No, that wouldn't work either. It would be the same problem actually. It wouldn't solve anything to process each entity or prefab individually.

[00:52:17]I am a little bit scared about the consequences of this.

[00:52:32]It should work as long as I'm only pushing things and deleting them afterwards because let's say I have a hole in here.

[00:52:48]Let's say these are just entities 1 2 3 4 and I happen to have a hole right there.

[00:52:56]So uh actually this would be the one.

[00:53:05]So this is seven. Here's six here.

[00:53:10]Here's five.

[00:53:13]So let's say I happen to have a hole here. Suddenly one entity is pushing another entity eight here in in the free hole. And I have my thread. It's going through its uh you know assigned memory and it just happens to uh allocate this before it gets there then that's fine.

[00:53:37]If it happens to be a hole here and it goes through then it just skips it over and continues. That's also fine.

[00:53:47]The issue would be I think what I'm getting at is that if I create or delete entities, I need to do that after I have done all the updates.

[00:54:03]So I cue all of the creation and deletion to another step entirely and any updates to the entity creation or deletion will be on the next frame.

[00:54:21]Make sense?

[00:54:26]So that means that actually we should run the physics in the same thread.

[00:54:44]So where is this? down here.

[00:54:50]Yeah.

[00:54:55]If there's a function, we do this. If there's children, we do that.

[00:55:30]cell size.

[00:55:33]Oh, Okay, cool. So, I'm I'm I'm a little bit scared of creating and deleting entities with multi-threading because it means that they need to be assigned an um like okay, you could say that creating a prefab or entity is a scheduled task, but the main thread is the one who is deciding the uh index where it goes.

[00:57:00]So that would be fine I think.

[00:57:09][sighs and gasps] But I wonder about this uh if I screwed this up.

[00:57:18]Should be fine. And we we will notice it if something is wrong.

[00:57:25]What's this error? Ah yeah.

[00:57:31]Cool.

[00:57:33]And then we have UI components. Let's ignore that for now.

[00:57:49]And here again we we need to allocate all of this stuff.

[00:57:54]So let's ignore this also.

[00:57:57]Maybe we just see what's going on.

[00:58:02]I feel like it should be the same as before.

[00:58:08]Oh yes, but it's stuttering.

[00:58:15]Why is it stuttering?

[00:58:26]Let me try something.

[00:58:49]You see it right?

[00:58:57]Uh what am I working on right now?

[00:58:59]General thread jobs. So I have a library that I wrote for pushing tasks, popping tasks off the queue. And then I also have this function process all which is just running the task pop function infinitely until uh there's no more tasks.

[00:59:20]And at the beginning of the game, I create as many threats as I count as as many threats as I can. I I um I reserve one task to be my graphics uh thread and the rest for now are worker threads for me.

[00:59:44]And I'm trying to just go through all of the prefabs which I it's basically like an object or node or you know something like this.

[00:59:55]So a prefab it's it's like something that has a position and then it has components inside or entities that that can be uh meshes and things like this.

[01:00:07]So I'm going through all of those and they can have functions assigned to them. So maybe I run the functions and then I'm going through the children who might also have you know here a mesh or another function again.

[01:00:25]And then later I'm doing a physics update. So I'm just trying to schedule.

[01:00:33]This is all of my prefabs and there's about a thousand of them. So I'm slicing it up into uh 125 because I have eight threads with the main thread.

[01:00:45]So these are 125 entities and was scheduling that as a task to process all of those as a chunk.

[01:00:53]And I do that eight times. And the last one is for the main thread to process.

[01:01:00]And what I'm doing right now is I am going to add the sleep to the threads because at the very end of the game uh loop I'm locking a mutx and then I'm copying over some indexes and memory uh to swap the memory with a gra graphics thread.

[01:01:32]Then I'm measuring the time to synchronize and I get this uh left to wait. This this is how many well this is how many seconds to wait. I have this milliseconds to sleep. I guess I also need to push that to each thread.

[01:01:52]So, I'm wondering, is it safe to just push seven sleeps?

[01:02:08]Oh, also I just realized My thread count is not actually eight because I have the special thread. So the the number of worker threads I should actually add that Recount.

[01:03:39]So this should be six right now.

[01:03:54]Let's double check that.

[01:04:05]Yes.

[01:04:06]Very good.

[01:04:12]See, I want to put all of my worker threats to sleep.

[01:04:20]So, I think all I need to do is add a job for each of I need to make this a function somewhere.

[01:07:21]I guess I don't need to do that myself.

[01:07:29]Had I use KB text shape for font rendering?

[01:07:33]Well, I'm using I am using KB text shape for text shaping.

[01:07:41]So you can see it in my dependencies here.

[01:07:44]KB text shape and then I'm using um uh STB true type for rendering the font or rasterizing the font rather. And then when it when I have the shape and I have the raster, then I am uh I can draw it using OpenGL. if you want to check that out because I I spent like an entire week or two on it.

[01:08:25]But on my YouTube, you can scroll down and I am doing it here I guess.

[01:08:49]No text layout.

[01:08:53]I'm doing text layout. Text layout. So all of these are me learning and using text KB text shape.

[01:09:08]Uh, I haven't noticed any slowdown, but I am also just I'm running it once and then I'm using the same settings for any shaping that I need to do later.

[01:09:24]Uh, yeah. So, we are doing a 4 count work threads.

[01:09:43]arts.

[01:10:01]So, I actually need to use this is very annoying. I was talking about this yesterday, but I think there's some issue with my with my motherboard possibly.

[01:10:18]But I have this issue and I had it during multiple installs where my CPU is always running at like 99 to 100. It's not actually running at 100%.

[01:10:29]It's just reported erroneously. It's It's wrong. Something something in Windows is broken. And when I reinstall Windows, it works for a while and then after a couple months, it just comes back. And I'm not installing anything weird. I I just have, you know, Firefox, VS Codium, Steam games, couple of Steam games or something like that. Like I'm not downloading anything pirated or anything like this. So I I really don't think it's a virus or like Bitcoin miner. And when I open up open hardware, how how do I open it?

[01:11:24]Is it not installed? I installed it yesterday. No.

[01:11:28]Open.

[01:11:36]Yeah, I need to use open hardware monitor to get the true uh load on my CPU.

[01:11:49]Here we go. For some reason, it's not showing up on my uh install programs, but okay, here we go. So, here we have open hardware monitor. It's running.

[01:12:04]It's saying h is it 20 or is it 90 16? That makes sense. 20%.

[01:12:15]So, yeah, hover around 20%.

[01:12:18]And then we can run the game and see if it stays there. Oh, no. I'm definitely uh not staying staying at 20. Did I even compile it?

[01:12:43]I did not compile it because I have an error.

[01:12:51]Thread sleep. Huh?

[01:13:01]Is it conflicting types? Yeah. Am I even using this anywhere?

[01:13:12]Uh, no. I I don't think I'm using this. I think that was something I wrote once and never used.

[01:13:25]So that's gone.

[01:13:29]Threads sleep.

[01:13:40]You are gone.

[01:13:57]Why can I not just call sleep?

[01:14:11]Why is it poisoned?

[01:14:26]Sleepy time.

[01:14:37]Uh.

[01:14:41]Oh, I I know now.

[01:14:49]I I do need thread sleep, but now I have conflicts.

[01:15:05]So I I do need it, but I need So I need to give this a different name.

[01:15:27]Mhm.

[01:15:36]So you can go in here. Yeah.

[01:16:08]in global. No, that's true.

[01:16:11]But doesn't need to be a global almost guys.

[01:16:59]Nonvoid does not return a value.

[01:17:15]Okay.

[01:17:18]Still linker error. Thread process all.

[01:17:21]Oh no.

[01:17:46]Wait, what?

[01:17:53]Did I delete this?

[01:18:03]It was right here.

[01:18:06]Oh no.

[01:18:13]Um. Whoops.

[01:18:19]And I can't go back.

[01:18:22]Crap.

[01:18:28]Uh. Whoops. I've never had that happen before. That's a little bit annoying.

[01:18:36]So, I guess I have to uh go to the uh get and just grab it again.

[01:18:49]Whoops.

[01:18:51]Game bread run something.

[01:19:01]It's just this Okay, it's stuttering and well, it's not blasting my CPU.

[01:20:40]But it started to stutter and I I think actually I know why.

[01:20:47]So I'm guessing the reason why is because in the game what what I did essentially is I added multi-threading on my game update.

[01:21:01]So, I'm pushing all this uh prefab update function calls, which again, I take all of my prefabs and I chunk them into slices and I push those and then I update them. But then before I actually verify that all of the threads are done and ready, I just proceed.

[01:21:24]And I think that's the issue. What I need to do is make sure that all of the worker threads are done.

[01:21:38]Or actually I have the thread Q and I have a read and write index.

[01:21:57]So maybe we can do atomic read.

[01:22:27]read index.

[01:22:33]Same for rights.

[01:22:39]And we check if We we do this because when we are popping when we're pushing the thread uh when we're pushing the task what do we do? we reserve a write index and when we are popping a task we reserve a read index.

[01:23:23]But if it if the queue is empty, the read index is the same as the write index.

[01:23:34]So, I can just sit here and wait until those are the same because no one else is pushing work on the queue.

[01:23:54]And I can actually do it like this. So, while there's still work, we process.

[01:24:01]And then I make sure that they're all done.

[01:24:09]See, but it should still have worked because in this process all we're already having an infinite loop and then we break when there's no tasks.

[01:24:30]So I already I should have already accounted for 632 632 we break immediately.

[01:25:07]So, that can't be the issue.

[01:25:13]It's definitely stuttering.

[01:25:16]Let me see on the stream if you can see it.

[01:25:22]I think you can see it. Yeah.

[01:25:42]Maybe we need Tracy for this and see if we see any spikes.

[01:26:07]So, how did I use Tracy again?

[01:28:12]I should mention it was buttery smooth until I added the multi-threading for the worker threads.

[01:28:23]Unused variable.

[01:28:29]Sure.

[01:28:47]unknown argument. That's fine.

[01:28:55]So Tracy H.

[01:30:00]Tracy, give me Tracy. I'm looking for Tracy. It's in dependencies. Okay.

[01:30:21]profiler.

[01:30:27]Uh crap.

[01:30:43]I I completely forget. I I built it and I forget where the Tracy client is.

[01:31:13]I'm dumb. It's It's right here.

[01:31:17]Now, is it capture or profiler? I think it's profiler.

[01:31:24]Connect. Here we go.

[01:31:34]So, what's going on here?

[01:32:03]43 milliseconds.

[01:32:11]Yeah, you can see that there's lag spikes for some reason.

[01:32:16]82 milliseconds. What is going on here?

[01:32:34]Wait, I think these frames are wrong.

[01:32:46]Uh Hold on.

[01:33:21]Uh, that couldn't be. That's fine.

[01:33:35]Profile framework.

[01:33:56]This one is unnecessary.

[01:34:38]So for those familiar this is the main window loop or for those not familiar this is the main windows loop. We are processing windows messages.

[01:34:50]Then we call game run and then we mark the end of the frame.

[01:34:58]And what does game run do? Again, we are updating the game, drawing prefabs, drawing UI, and then we're doing this mutx swap to swap the memory that the graphics thread is using.

[01:35:25]And then we do the synchronization to sleep for a given number of milliseconds. And let me actually just look at the output here.

[01:35:36]And you can see that this is fairly consistent. But for some reason, seven five we did not have that issue yesterday.

[01:35:51]And I can't see why adding more threads to do more work would cause more slowdown.

[01:36:28]See? Yeah. Let's I think that you have a good uh a good point. Iron Iron Nev. Is that good? I think you have a point.

[01:36:42]One thing that we can do to test this is to go into the game and I want to disable these uh not those actually.

[01:36:54]Let's go to the thread process all call.

[01:37:06]Let's just disable this one.

[01:37:15]Now again, we're going to proceed before all the stuff is running, but it should take care of the lag. But it doesn't.

[01:37:28]You see?

[01:37:52]So what we found yesterday is that doing all of this with one thread takes about two and a half milliseconds.

[01:38:05]I am dividing the work so that each thread has 125 entities to update and that makes the entire thing overshoot I guess.

[01:38:26]Time in seconds. Wait.

[01:39:13]Let's print this.

[01:39:43]6F.

[01:39:59]because I I would be very surprised if we don't reach this earlier.

[01:40:19]So all I'm doing now is I'm printing the time when we reach this u end of the frame and then I'm also printing the time after the synchronization and I need a slashn So what we got there? The time actual work is 1.6 6 milliseconds 1.8 2.3 3.9 Is it growing 6.3 3.6 six. I don't see any particular pattern with it. It's a little bit unstable, but you know that might just be because again the they are fighting for the same objects or something like that.

[01:41:38]But then the weight is completely out of whack.

[01:42:05]32 31 No, wait.

[01:42:14]That's still less stable than I would like it to be.

[01:42:43]No, it's still saw that here. It's almost 5 40.

[01:42:56]There's a lot of frames where it's just randomly stalling.

[01:43:01]So why would that be?

[01:43:22]Did I change something in the sleep?

[01:43:44]No.

[01:43:46]So to reiterate the issue right now when we get here it only took 2 3 milliseconds sometimes a little bit more but that's never mind because when we get here we still need to wait until 33 milliseconds and I'm doing nothing like I am do literally doing nothing. I'm only doing the same thing that I was doing before.

[01:44:18]Actually, let me try something.

[01:44:22]I'm doing the same thing that I was doing before, but the the threads should do nothing. They should be maybe spinning in the background, but like that's it.

[01:44:43]Uh let me do something.

[01:44:47]This is essentially disabling what I have done the entire evening.

[01:44:55]So we have we are scheduling all of the things at once and then we never push it or well we can push it but I'm going to disable in pain.

[01:45:32]So now we should have zero worker threads or rather I would like to disable them here.

[01:45:56]They're doing nothing and only the main thread processes the queue and then it comes here and it sleeps. So it should be identical to what we were doing before completely stable was like one that was Huh.

[01:46:31]I don't like that.

[01:46:39]But overall very stable.

[01:46:47]So that's what I would like to see. So I don't understand if I do this Nothing is different.

[01:47:16]That's exactly the same.

[01:47:23]Yeah, I'm h I'm having some other bugs.

[01:47:29]I I don't know how this happens but so this is completely stable.

[01:47:38]I mean as stable as you can do with sleep.

[01:47:47]And the only difference is that we're scheduling everything as a single job rather than multiple jobs.

[01:48:07]Oh, I don't know. I was thinking about something, but I I lost it.

[01:48:50]Yeah, completely unstable. Let me check this again.

[01:49:04]Or maybe Even So now everything will be on on one line. It's stuttering like like trash.

[01:50:24]And let's see.

[01:50:28]we are having well for for one it's less stable overall but is there a pattern here so this is 33 it took two milliseconds here it also took 33 but for whatever reason it took 15 milliseconds to get there and this one is 46 it took 14 milliseconds So definitely I'm doing something screwy with the threads and they are fighting for the work or something and uh that's causing delays. Now, why it's causing delays when I'm sleeping?

[01:51:12]Possibly Windows is not returning my thread on time because I'm using too many resources and I'm not letting them sleep. Or even if I am letting them sleep, something is going on. Maybe not all of them are sleeping.

[01:51:30]Maybe one thread takes two of the sleeps and then another one doesn't get one. I I don't know.

[01:51:37]This is not a good way of doing it. I should just like have a way of telling each individual thread to sleep.

[01:51:44]But I was thinking that I was being smart. But you can't outsmart the computer sometimes.

[01:51:58]Yeah, that's better. Maybe until you start spinning around. Uh, so when the the when the threads are sleeping, it's better, but it's still not good.

[01:52:12]And there's still spikes that go like 40.

[01:52:16]So yeah, I think I'm going to have to call it the night there. Uh, so thank you guys for watching.

[01:52:22]We will be working on this uh further.

[01:52:31]But yeah, thank you for watching and uh I'll see you good night.