studying compilers every day until i land a compiler role (day 221)

[00:00:00]and we're live. Um, even if a little bit late. Um, ignore the fact that I've like pushed the stream time back half an hour across the last well half hour. Um, anyways, hello all hello world. This is day 221 of studying compilers every day and studying compilers every day until I land a compiler role. Um, yeah, last time we did more reading about value numbering. Um, we kind of figured out what we were supposed to do for like the hash implementation. So, this time I think we're going to try and implement it. Um, yeah, it should be it should be a pretty good time. Um, yeah. So, if we go to our transforms, we have this nice little GBN thing. Uh, what I want to do is I want to make two GBN passes. Uh, one of them will be like the hashbased one and the other one will be the partition based one because I think it'd be interesting to learn about both and both have like different advantages over the other. So, uh, yeah, we're going to we're going to give it a try. I'm going to we're going to figure out how to like structure it and it's going to be it's going to be interesting. Um, yeah.

[00:01:11]Also, something I was thinking about is like if we wanted to split up inst combine into like different passes as well. Um, yeah, there's like there's some like interesting stuff we could do here.

[00:01:26]Um, yeah, something I was thinking about is literally just like we like tried to make these like separate passes at one point and it didn't really work. But I'm kind of curious if we can just like if we can kind of do that again and just like store the different passes inside like the big inst combine pass. Um it might be interesting, it might not be.

[00:01:46]We'll see. We'll see how it ends up working, but that's not the focus for now. Uh for now, we're just focused on GVN. So we're going to we're going to give it a shot.

[00:01:57]Um yeah, so I posted my Discord last time.

[00:02:01]We have a big like we have like our big hashbased reference here. So this is like how we're going to be implementing it. I'm going to have this up on my second monitor, but it won't be up on like it won't be up on like the primary monitor at least. It'll just be up on the side. Um although actually maybe if I just open this.

[00:02:21]Yeah. Okay. We could have that.

[00:02:24]Uh what's a fire emblem? Thank you for being an inspiration to me. Um I I appreciate it. Um, thank you for thank you for being here as well because obviously streaming would be a lot less enjoyable for me if it was just me yapping to myself.

[00:02:40]Um, okay. Let's let's give this a shot.

[00:02:45]So, uh, where am I? I'm here.

[00:02:51]Um, also I should probably open up the PDF again.

[00:02:55]Let's see. Where does this live?

[00:02:58]Here it is.

[00:03:00]Okay.

[00:03:04]So, we're doing hashbased right now.

[00:03:09]Let me water.

[00:03:19]Okay.

[00:03:23]So, let's let's get into it.

[00:03:26]So, I guess we could kind of just like we can kind of just like try to oneshot it off of this, though.

[00:03:34]Inspire to stay consistent with all I do like you are. Um, I appreciate it. Um, I think it's important to take breaks every now and then, especially when you're like when you're like feeling a little bit burnt out or like if you're just like generally a little bit tired.

[00:03:48]Like it's important to be ambitious, but it's also important to like at least be somewhat balanced with it. Um, in terms of compiler stuff, um, if you've like seen my recommendations, I think that'd probably be a really good place to start at least.

[00:04:03]Um, okay, let's let's figure out how to do this.

[00:04:09]Oh man.

[00:04:13]Yeah, we're going to need to like traverse this like in some way.

[00:04:18]How do we set up like traversals again?

[00:04:21]I think we Yeah, we did something like that in me to regge or we have like utils traversal.

[00:04:32]Yeah. Okay.

[00:04:36]Uh so we can do like Oh man.

[00:04:40]I think we should we should implement this like DVNT function.

[00:04:45]Yeah. So we'll we'll do that real quick.

[00:04:48]I think that's a good first step.

[00:04:51]So, we should do Oh, man.

[00:04:56]Uh, let's do like void dvnt.

[00:05:04]And then we take mr basic block star basic block. We'll do that.

[00:05:12]And then let's paste this down here somewhere.

[00:05:18]Also, is this is this the correct order in the header that I wanted? No, definitely not.

[00:05:26]Yeah. Okay. So, let's fix that as well real quick. Let's do that.

[00:05:35]Um, actually, when we register, do we want that? How do we want to format this? How do we want to be consistent?

[00:05:44]I guess we could put it below. I think it's but it's like a helper for this. So like it feels wrong. I don't know. Let's let's fix this formatting as well. I think so. We have that. We have that. That's fine. That's fine.

[00:06:02]That's fine.

[00:06:05]Okay. So we want this to go like here then.

[00:06:09]So we'll we'll implement it like that.

[00:06:11]And that should be clean enough.

[00:06:16]We'll do that.

[00:06:19]Oh man, this is this is scary.

[00:06:25]Um, I think we necessarily insert the fees at the start. So, we could probably just like iterate through it. Um, I don't think it's like a hard-coded constraint. So, maybe we should just like we should be careful with it.

[00:06:38]Um, I guess they they should be at the start anyways if we're like constructing it correctly.

[00:06:44]So, I think we should try to preserve that.

[00:06:50]So, we can do uh make this out of order fee safe.

[00:07:06]Yeah, we'll do that, I guess. So, hi in basic block get instructions.

[00:07:14]We can do something there. Is this a ref? Yeah, cuz that's a unique pointer. Okay.

[00:07:23]Um, so we want a dynamic cast fee dynamic cast to MR fee or construction fee star.

[00:07:40]Yeah, we can do that.

[00:07:43]Then if it's a fee, then we can Oh, Jesus.

[00:07:50]Uh, we can do something with this.

[00:07:54]Uh, we need to figure out redundant slash meaningless.

[00:07:59]Um, okay.

[00:08:06]Well, we'll worry about this in a second.

[00:08:12]Or redundant map or insert into map.

[00:08:22]else uh number and add wait what into N.

[00:08:47]Wait.

[00:08:49]Oh, I see. Okay.

[00:08:52]So we should if it meaningless if it's meaningless or redundant then we map to uh map to equivalent I guess uh insert and number I guess make new value number insert I guess we'll do we'll do that I I think that's how I want to structure it. Um, over here, let's see what other instructions do we have at least.

[00:09:31]We have binary op.

[00:09:36]So, we want we can actually just yank that line.

[00:09:42]We do that.

[00:09:44]Binary op. We do that.

[00:09:51]Uh maybe we should h I kind of want to pull out I.Git. I don't know what my standard for that is though. We might do it in some places.

[00:10:03]We might not.

[00:10:05]We definitely did it like I think. What is a good place to look for that?

[00:10:11]Probably surely in combine, right? Surely we did like some stuff here.

[00:10:20]So instructions.

[00:10:25]Oh, I see. We have iterator.

[00:10:28]Um H.

[00:10:33]Right. Cuz we do replacement at the end, right?

[00:10:38]So this should be fine then in theory.

[00:10:43]Yeah, we should we should try to do the get thing and do let's just do that maybe.

[00:11:04]Yeah, we can do that. That cleans it up a little bit.

[00:11:11]Um, okay. So then if bin op then we want to do something here.

[00:11:21]What other types of instructions do we have with calls? I don't think we can number those cuz those might have side effects.

[00:11:31]Allocate I don't think we should load. I don't think we should. Store we shouldn't. fees. We already handled parallel copy should not exist at this point and everything else doesn't really make sense. So I think we could kind of just do this and this should be sufficient.

[00:11:46]Um yeah, maybe in the future we might do like intrinsics once we implement them, but I'm not sure what that'll look like.

[00:11:55]It might be interesting.

[00:11:57]Um yeah, so let's let's let's give this a shot.

[00:12:03]Um, so want to replace operands.

[00:12:12]Uh, we can't overwrite it though, right?

[00:12:18]What what did the thing what did the paper say about uh what's it called? the unified hash table.

[00:12:32]Um, oh, that's a fun deal. Uh, how many interviews have you already done for compilers roles? Um, honestly, not a lot because this this upcoming summer I have an internship. Um, so in that sense, I've like not really been recruiting for full-time, but I'm going to be starting that fairly soon at least. So, I'll I'll keep you updated at least.

[00:12:59]Uh, yeah, most of most of this has just been like skills building, though, so that's kind of that's kind of my life at least.

[00:13:12]Um, okay.

[00:13:14]Placements cannot be performed online.

[00:13:21]Okay. So that also means we h that has implications for like this thing uh this like overwrite thing we can't overwrite.

[00:13:35]Um maybe we need to like make a new expression.

[00:13:41]That's like really awkward at least. I don't really like it.

[00:13:50]Yeah, that's kind of gross actually.

[00:13:53]We might just have to like I think this is this goes back to like the hashing thing.

[00:14:00]Um yeah, there's not a great way to do this at least. Um how difficult do you find going to resources like those papers? Um it's like fine. I think I just have to like do a lot of translation on the fly, which is like admittedly part of the learning at least, but it feels a little bit like an engineering task, which is kind of the fun part of writing code.

[00:14:28]Um, I think we should we should make two hashmaps.

[00:14:34]I think one of them should be like or actually h Yeah. How do we want to map this?

[00:14:50]We need like a we need like a second layer of indirection, right? Cuz it's like I guess I could draw this out. At least what I'm thinking. Where is my paint donut? There it is.

[00:15:03]So, we want like one map at least. So, this one is like the required map.

[00:15:13]So we go from like a variable or let's just like let's just go like here and then we can insert the other one here.

[00:15:20]We have like a uh instruction and then we want like uh I guess canonicalized or like numbered version of instruction like value. I guess maybe this should just be like bal.

[00:15:48]So we at least want like some sort of mapping here. But then the question is like how do we do how do we actually like make this work? Um if we have like two instructions that are two instructions that are like identical construction like how do we how do we like do this mapping? So I think we want like another layer of indirection somewhere here which is like a value number and then we have like one mapping from a value to its value number and another from a value number to like an equivalent value. I think that's like the least awful way to do it but I think we kind of we kind of just got to deal with it.

[00:16:27]It's a little bit scary but I'm sure it's fine.

[00:16:33]Um yeah.

[00:16:46]So let's do like we can kind of just like handwave it for now and then we can figure out the concrete implementation later.

[00:16:57]We want to make the equivalent expression somehow.

[00:17:02]If found map to equivalent else insert new value number.

[00:17:15]So we want to do that.

[00:17:17]So after all of that.

[00:17:20]So then we've walked we've walked all the instructions and then we want to walk the successors.

[00:17:31]So we want basic block accessories. This is basic block edges.

[00:17:40]Uh unique edges and then we want to adjust the inputs.

[00:17:56]Yeah. So we want to do that. We want to do like replacement there. I think I want to do dot here.

[00:18:06]And then so we want child in DT.

[00:18:19]Oh, we need the children in the dominator tree. Why don't I have a thing for this? That's really annoying.

[00:18:28]Uh, how do we how do we do that?

[00:18:34]Yeah, we're going to need to update our dominator tree then.

[00:18:41]Get children of basic block. At least that's how we want to implement it.

[00:18:47]Then we went to DVNT of I guess child.

[00:18:56]This is this should be a putter. So that should be good, right? And then that should be good.

[00:19:06]And then we do all the replacement at the end.

[00:19:12]So what is DVNT stand for again?

[00:19:20]Um do value numbering.

[00:19:25]Wait, where did it go? Technique. Okay.

[00:19:34]Okay. So, this should just be the numbering and then we do like the replacement after. I think I think that is how it's supposed to be done at least with like this type of hash setup.

[00:19:47]Um, okay.

[00:19:54]Let's see.

[00:19:57]What do we want to do from here? Let's Let's implement the dominator tree get children thing because we need that.

[00:20:05]Save those and then we could do this.

[00:20:16]Is this actually just is that just the get children implementation?

[00:20:25]Wait.

[00:20:37]Wait a second.

[00:20:43]Where is the tree?

[00:20:51]Oh, okay. So, just immediate dominates.

[00:20:54]Okay. So, I should I need to change this name. This is like really stupid actually.

[00:21:03]Yeah. Let's rename that.

[00:21:08]Right.

[00:21:11]What is this? Yeah. Okay.

[00:21:15]Let's just rename it like that.

[00:21:17]Actually, I don't even know if that name is that wrong, though.

[00:21:26]We'll just we'll just use that for now.

[00:21:28]I'm lazy.

[00:21:31]Okay. Uh we have those in harpoon still.

[00:21:34]Let's get rid of those.

[00:21:38]Okay.

[00:21:40]So, we want we can do that.

[00:21:50]That should be correct at least. I'm actually not sure if we construct it in that way. I don't I don't remember documenting enough of this. So, we're going to need to check this um each pair.

[00:22:07]Okay. Yeah. So it is it is immediate which is good.

[00:22:14]So we can we can just do that. I think that's fine.

[00:22:21]Yeah, we'll do that. Um all right. Now we can let's add a commit real quick.

[00:22:31]Uh actually let's just do star mem to regge update header function order formatting build out gvn hash version more okay now we got to figure out what to do here this is Scary. This is really scary.

[00:23:04]We can read through this at least.

[00:23:09]So, fees require special treatment. Must have previously assigned value numbers to all the inputs.

[00:23:16]Um, yeah. Okay.

[00:23:25]How do we skip that?

[00:23:37]And then we can decide if eliminatable.

[00:23:39]Okay. So we should also check if like if there are back edges, right?

[00:23:50]Wait, what?

[00:23:56]Oh man.

[00:24:03]Reversibly reverse reverse post order.

[00:24:11]Okay.

[00:24:19]Uh meaningless. We can definitely just replace I think. Yeah, that makes sense.

[00:24:29]How do we want to map this though? How do we want to design the data structures? I think we do want two maps.

[00:24:34]Um, but how do we want to how do we want to set this up? We definitely want a value number to like value number to a value somewhere.

[00:24:47]So, we should do that.

[00:24:49]Let's add that somewhere here.

[00:24:52]got an uned map from let's just do like we could do a literal value number.

[00:25:01]So a that to a value star uh num to value I guess.

[00:25:14]And then we want some sort of a map which is not going to make me very happy.

[00:25:22]Oh man.

[00:25:25]Do we want like uh value type and then Oh man, this is a little ridiculous.

[00:25:50]How do we hash this?

[00:26:01]Okay, let's look this up. GBN hashing recursive hashing.

[00:26:21]Rolling hash. That's what it is, right?

[00:26:30]Um, that's really annoying.

[00:26:43]There's got to be a better way for this.

[00:26:44]I think this is probably it.

[00:26:49]Um, structure hashing. What is happening here?

[00:26:55]Oh, we're using strings. Gh, yuck.

[00:27:00]Oh, we can do bits. Okay, that might be funny. We could definitely do that. I think that might be fun.

[00:27:07]Um, okay.

[00:27:13]Uh, how do we want to encode this though? This is going to be so ugly if we do it that way.

[00:27:20]I'm like kind of I'm kind of scared.

[00:27:22]Let's see. Let's see what LVM's docs say for this.

[00:27:31]Um let's see what is happening here.

[00:27:43]Is this the Okay, this is new GBN.

[00:27:53]So, this is also partition based it looks like.

[00:28:02]Um, yeah, I want to implement this eventually, but it scares me. So, we're going to do that later.

[00:28:17]Um, herm hush.

[00:28:41]H. That's not helpful.

[00:28:46]I'll see you.

[00:28:59]What the hell?

[00:29:06]What if I just like hashed the two string or like made some sort of a gross thing with that?

[00:29:17]Um, oh man, hashing is hard. Hashing is very difficult.

[00:29:28]Okay. Um, structure hashing. Is this the same? That's the same link.

[00:29:36]What is happening here?

[00:29:41]Oh god, why is it so slow?

[00:29:51]Oh man. Okay, that's that's great.

[00:30:01]Uh, okay.

[00:30:04]How is this usually done?

[00:30:16]How do you like combine hashes?

[00:30:27]I've heard of Exor.

[00:30:34]But I don't think this is enough of a guarantee. I think you'd need to do a stronger guarantee.

[00:30:43]At least if we're exing multiple things.

[00:30:49]Uh it should not be symmetric as well.

[00:30:57]Um, oh god.

[00:31:14]Yeah, this is not a great this is not great.

[00:31:22]So m times a hash plus the other hash.

[00:31:40]Yeah. How do we how do we even want to combine things for the hash? Right.

[00:31:48]So many design decisions. That's This is like the one of the big challenges of this. I don't know how I want to do this.

[00:31:54]Uh we definitely want value to numb and we want something.

[00:32:01]So Mr. Valley value star to like I don't think it will be this simple unfortunately.

[00:32:10]Um, yeah.

[00:32:16]How do we even like implement a proper hash for this?

[00:32:27]Um, what is what is here?

[00:32:54]There is an implementation.

[00:32:59]Oh, yeah. I I'm going to read this eventually, I think.

[00:33:06]Um, yeah. Let's look at this.

[00:33:12]This is This is our other This is the one that like we were looking at at least before.

[00:33:19]Um.

[00:33:27]Ah.

[00:33:29]Yeah. Okay.

[00:33:31]The following value name is a save variable name.

[00:33:37]Yeah, that makes sense.

[00:33:40]Oh, actually that makes a lot of sense.

[00:33:44]Yeah.

[00:33:47]Okay.

[00:33:50]Uh okay. We might we might do it that way. We might not.

[00:33:57]Um let's see.

[00:34:10]Yeah, I guess we could try to do it the simple way first and then we can optimize it at some other point. I kind of want to just like do it the better way though first.

[00:34:20]Um, all that changes just like how we do this, right?

[00:34:26]At least if we look back here with this unified hasht thing.

[00:34:37]Okay.

[00:34:50]No hasht entries are removed when using a unified table.

[00:34:58]Yeah. So we cannot immediately remove things which makes sense.

[00:35:08]So then yeah, we can we need a second pass which should be nice.

[00:35:17]Um yeah, let's just let's give it a try.

[00:35:20]I think this might be interesting. Let's Let's see what we can do with it.

[00:35:27]So, I kind of like the pseudo code. I think this is kind of what we're doing.

[00:35:35]Um, so we set value numbers.

[00:35:42]Oh man.

[00:36:04]Yeah, I also don't know how we're going to do this as well. That kind of scares me a little bit.

[00:36:11]Uh what's up, friend gamer?

[00:36:17]Yeah, genuinely how do we how do we I guess do this properly?

[00:36:27]How do we value number this?

[00:36:31]I guess if we're getting value numbers for the operands, we can just like this is this is really awkward. We could make like one map for like fees and one map for binary ops.

[00:36:48]We might do that. I think that might be the least awful way to do this.

[00:36:54]Um, oh man, I'm really scared. I'm really scared of this. I also think there might be like an interesting uniqueness thing that happens, but we'll figure that out.

[00:37:13]So we want like uh next none I guess we can do that and then hopefully we don't run out of numbers there.

[00:37:25]So, we want what? Fee to numb. And then we want bin op to numb. And then we probably we probably want like more.

[00:37:39]Um.

[00:37:41]Oh man.

[00:37:45]Yeah. I think the only other numberable things are like literally values, right?

[00:37:50]Or just like uh numbers. Like literally numbers.

[00:38:02]Yeah.

[00:38:05]Um a this is such a headache. What What are we even numbering here?

[00:38:16]Value numbers for each operand.

[00:38:35]This is difficult. I can't give a person a break after one pet dies. Damn.

[00:38:40]Another That's That is very unfortunate.

[00:38:42]Um I'm sorry.

[00:38:47]Um, and Scoliosis. Damn, that is that is very unfortunate.

[00:38:58]Um, yeah, I don't even know how to map this, but I'm I'm sorry if I like at the end of the day, I don't think I'm like particularly like as a streamer, I don't think my role is necessarily supposed to be like support. So, I'm not really like I can't really comment too too much on that. Um, yeah, that does that does suck, but I I hope you also have like other people that you can talk with about this as well.

[00:39:29]Um, yeah, this is actually like kind of difficult.

[00:39:40]This is kind of difficult to I guess implement.

[00:39:46]Where is their implementation of this?

[00:39:55]Um, surely they've put it somewhere, right?

[00:40:04]Oh, I should implement FSBuzz as a test.

[00:40:05]That might be fun.

[00:40:12]Yeah, these might be fun.

[00:40:15]These might be fun benchmarks.

[00:40:21]Let me write that down before I forget.

[00:40:24]Uh, what the hell is on this sticky note? I see broad stuff.

[00:40:29]Uh, where' my pen go? There it is.

[00:40:41]Okay.

[00:40:45]Do they have their implementation anywhere?

[00:40:48]I hope they do.

[00:40:50]That might be helpful to look at at least.

[00:40:57]Doesn't look like they do. That's unlucky.

[00:41:04]Um, yeah, I guess we'll figure this out as we go. We definitely want like this like numb to bow thing.

[00:41:21]I don't really know what to do with it though.

[00:41:27]Uh we also want a constructor as well because we need to initialize next num.

[00:41:38]Yeah. So let's do that real quick.

[00:41:45]Next num gets zero.

[00:41:51]Yeah, we can do that.

[00:41:55]Oh man.

[00:42:01]Yeah. Okay. So then if you just do like H.

[00:42:13]So if it's meaningless then we should just like Yeah, I guess either way we're doing a mapping, right? So we want How do we how do we define meaningless?

[00:42:27]I also think we want to like skip processing fees at some point, right?

[00:42:36]uh hash GVN unified hasht. table.

[00:43:08]This is so annoying.

[00:43:11]Maybe we shouldn't do it that way. Is there even like a performance improvement there? I guess this matters for like the partial thing, right? Yeah, partial redundancy elimination.

[00:43:28]Um, oh man, interesting.

[00:43:50]Yeah. Okay.

[00:43:52]I want to I want to do this. I really want to implement that.

[00:43:57]I don't even know how I would go about implementing this.

[00:44:04]How do we hash these?

[00:44:09]Surely this is something explained earlier, right?

[00:44:21]Uh probably equal.

[00:44:30]Okay. Wait. Two arrays.

[00:44:35]So variable names to value numbers and then value numbers to variable names. Okay.

[00:44:52]Yeah, I mean that's simple enough. At least we could do we could think about that.

[00:45:03]Uh where is like is there like a hash explanation?

[00:45:39]God damn it. Um, I guess we could have like a default expert hash, right?

[00:45:52]We just need to like we just need to modify the hash specifically for like um specifically for binary binary ops at least.

[00:46:06]And just pray there's no collision.

[00:46:10]Uh how do we feel about entering the GCC mines on Monday? I'm I'm a little bit scared. Um, I don't I don't even know if like there will be any interesting compiler stuff to do or if I'll just be like doing like quant work, which is also like fine by the way. But like, yeah, we'll we'll see how all that goes.

[00:46:26]Um, it's going to be a good time though, ideally.

[00:46:34]Uh, made some progress and got a mod for Minecraft Neoforge 26.1.2.

[00:46:38]Hell yeah, that's nice.

[00:46:46]What is the hashing scheme here? I still don't understand the hashing scheme we want to generate trade. I mean like I just want to make code go fast. Low key I do not care a lot about like finance. I just want to make code fast and I think that is a pretty good place to make code fast.

[00:47:18]Um, what's happening here?

[00:47:41]Yeah, I s What is the hashing scheme?

[00:47:44]What is the hashing scheme that they like encourage for this?

[00:47:49]Try for similar. Yeah, I think I think that's a pretty reasonable place to end up.

[00:47:55]Uh it's I think it's like particularly ripe for uh for hardware as well, right?

[00:48:00]So if you wanted to like get into that side of it, I think that would be a great place to go.

[00:48:07]Bonza IMC. Yeah, I could see that. I very much could see that happening.

[00:48:25]Uh, maybe I should make like a utilities library.

[00:48:32]That might be funny.

[00:48:45]H is it possible to like combine three hashes? Um, are you applying to places already? I'm like clean I'm in like cleaning up resume right now or cleaning up resume sort of land. Um I'll probably start applying like Friday I think.

[00:49:04]Yeah. I I don't even want to think about doing week code. That's that scares me a lot.

[00:49:10]That's not going to be fun.

[00:49:16]Multi-et discrimination. What is happening here?

[00:49:27]Um, oh man.

[00:49:36]So, what is what is the you I don't think it like is there like an artifact maybe I can look at.

[00:49:43]No.

[00:49:46]Great.

[00:49:52]That's not helpful.

[00:49:59]Um, G.

[00:50:13]Okay.

[00:50:15]Um, combine hashes.

[00:50:19]Three hashes or multiple hashes.

[00:50:33]Yeah, this is scary.

[00:50:42]Hash combine.

[00:50:57]What a what a comment.

[00:51:01]That's pretty funny.

[00:51:06]Um yeah, we should What is the best way to combine multiple hashes?

[00:51:25]Uh is there anything interesting here?

[00:51:31]Let's make this dark mode. Sure.

[00:51:37]So that makes sense. We just do that.

[00:51:43]Yeah. So that's that's like what I want at least.

[00:51:53]Hash next door is bad.

[00:52:02]Yeah. Okay.

[00:52:04]So then concatenation.

[00:52:29]Oh, I see. Okay. I mean, that should work.

[00:52:34]But then we have like this problem.

[00:52:42]Oh, I see. Sure.

[00:52:48]T's difficult.

[00:53:00]Um. Oh yeah, that is the problem.

[00:53:07]Serialization.

[00:53:10]Do that. I see.

[00:53:14]Okay. Well, this is going to be awful. This is going to be so awful.

[00:53:24]I think we're just going to have to like do some like crazy string hashing [ __ ] unfortunately.

[00:53:31]But yeah, we're going to need to figure this out. Um, how the hell do we generate a hash?

[00:53:40]I guess we could just use that as like the number, right? We don't need two tables then if we're doing it that way, right? So, ah, no, we do need two val we do we do need two tables, but we can simplify it a little bit.

[00:53:58]Um, C++ hash stood hash. Oh god, that's not readable.

[00:54:12]Why is it so small?

[00:54:18]Uh what even is this even useful for us stood hash or do we just want to like make a thing for it?

[00:54:39]I think we should just like make a we should just make a type right. So, let's let's make a thing.

[00:54:47]Uh, and then we'll do like class or we should probably make like a GVN hash thing and then we can use that as well in there. I don't know what this should look like. I don't know if we even want it to be a class. I think we could get away with just making UT 64 on it and just like pray that everything is fine.

[00:55:17]I don't I don't know. I don't know how I don't know how to design hashes. This is like really scary.

[00:55:25]So, what is the C++ hash thing?

[00:55:30]I guess we could just like hash the string and that would be fine, right? We we might want to do that.

[00:55:41]So, can we just like stood hash string?

[00:55:43]Is that a thing?

[00:55:49]And then what else is here?

[00:55:56]Uh, this really sucks.

[00:56:08]All right, we'll figure this out next time. Let's just like let's just leave it at this.

[00:56:14]Hashell GBN whip day 221. 221 221.

[00:56:28]Yeah, let's just push. We'll just call it a day here. Um I'm tired, so we're we're calling the stream here. Uh thank you all so much for showing up today.

[00:56:36]There's a lot of thinking that to be done and currently being done. Um, if you like the stream, like the stream. If you like the channel, sub to the channel. Um, check out the description.

[00:56:46]My Discord community is linked there.

[00:56:48]You should join it. Um, you get pinged there when I go live and you can stay connected with everyone else. It's very nice. Um, there's a bunch of other goodies down there. You should add me on those or don't. It's up to you. Uh, I'm going to go I'm going to go eat some more food now. Uh, take care y'all. Take it easy and I will see you all tomorrow.