Sirius: A GPU-Native SQL Engine (Xiangyao Yu)

Ajouté : 2026-04-29

[00:00:02][music] >> I don't give a [ __ ] about my sequel.

[00:00:07]I don't give a [ __ ] about Auto Go.

[00:00:11]>> [music] >> I don't give a [ __ ] ABOUT CLICKHOUSE.

[00:00:18]I'M POSTGRES.

[00:00:19]>> [screaming] >> I DON'T GIVE A [ __ ] ABOUT ANYBODY BUT ME.

[00:00:26]>> [music] >> It's the end of the semester last talk.

[00:00:28]We have Professor Xingyao Yu from the University of Wisconsin is here to talk about Sirius, the GPU native database system he's building for a while. I mean, Xingyao is super well known in databases. He did his PhD officially at MIT, but I will say and I'd like to say that Xingyao also did a second PhD with me at Carnegie Mellon in databases cuz he and I published a lot and then he did a post doc with Mike Stonebraker and then now he's esteemed faculty at uh at Wisconsin hired by Jignesh Patel who who I then stole from from Wisconsin. But that's that's another story. Xingyao, thank you so much for being here. If you have any questions for for while he's giving this talk, please feel free to unmute yourself and ask your question anytime and that way he's not talking to himself for an hour.

[00:01:06]And so, Xingyao, good to see you again.

[00:01:08]The floor is yours. Go for it.

[00:01:10]Thank you so much, Andy.

[00:01:12]And I'm so excited to be here to talk about the system we have been building.

[00:01:16]Sirius is a GPU native SQL engine.

[00:01:22]Okay. So, before I dive deep into the technical details, I want to give you a very quick overview of the system.

[00:01:31]So, Sirius is a a GPU accelerated SQL engine.

[00:01:36]Uh today is mainly accelerating DuckDB.

[00:01:39]And we actually officially announced that GTC last month that Sirius will become a core extension of DuckDB.

[00:01:48]Uh but Sirius can also accelerate several other database systems that we're going to talk about later.

[00:01:54]So, as of today, Sirius has already hit the number one on ClickBench. So, according to ClickBench, this is the fastest database in the world. Uh and on both the hot run and the combined run.

[00:02:08]So, the figure is only showing the hot run. You can see Sirius is actually the take the top two spots.

[00:02:15]And for those who don't know, ClickBench is a open benchmark mainly for analytical databases. It's hosted by ClickHouse. And it's pretty well known.

[00:02:25]It has maybe 60 plus systems there and like especially the fastest systems.

[00:02:33]Uh and Sirius is today developed in as through a partnership between UW Madison and Josh Patterson's team at Nvidia.

[00:02:42]There are probably 10 engineers at Nvidia also contributing to the system.

[00:02:47]And we also tightly work together with DuckDB and Vast Data who help tremendously testing and contributing back to the system. And meanwhile, we're also working with several other companies who are actively building POCs together with us.

[00:03:04]Either accelerating accelerating their existing engines or exploring new use cases.

[00:03:11]Okay. So, that's a extremely quick overview.

[00:03:14]And here is the outline of the talk today.

[00:03:18]I will first discuss why GPU is a great hardware platform for data analytics and why today is a good time to make this happen.

[00:03:29]Uh I will then talk about the architecture of Sirius and also some of some of the design principles behind the system.

[00:03:37]I'm going to show you a demo of how Sirius works.

[00:03:41]Uh and then I will dive deeper into the technical details like the key features of Sirius and some of the design details.

[00:03:49]Uh finally, I'm going to show you evaluation and our future plan.

[00:03:55]Okay.

[00:03:56]So, first um I want to tell you why we think GPU is a great platform uh for data analytics. Right? It's traditionally used mainly for AI, uh but it's also great for analytical databases. So, first, GPU is no longer a pure accelerator anymore. It's evolving into this general purpose computing platform.

[00:04:21]And more and more applications are benefiting uh from this this piece of hardware.

[00:04:26]And if you think about it, data analytics is actually a natural fit for GPU architecture. Right? Like a GPU is great for massively parallelism where you do very simple but the same operation across probably thousands and tens of thousands of data records. And that's exactly what database is about.

[00:04:46]We have a millions to billions of rows in a table and we want to apply the same operation to all of those rows. So, that's actually a perfect match for GPU hardware architecture.

[00:04:58]However, um as you probably know, uh people have been studying GPU databases for more than a decade now.

[00:05:07]But there has been some challenges both in hardware and software that stymies the wider adoption of of GPU databases.

[00:05:14]So, for example, the first challenge is uh although GPU is very fast but its native memory is usually very small. So, it's probably 10 times smaller than CPU memory.

[00:05:27]So, that means uh if you have a large data set, you cannot fit data into GPU memory.

[00:05:34]And the second challenge is um So, [snorts] although when data fits into GPU, it delivers great performance, but once GPU start to talk to about external world like talking to the CPU memory or talking to storage then this PCIE interconnect became a bottom neck between GPU and other devices.

[00:05:55]At least in traditional GPU systems and this is this scenario is improving today, but um but used to be a major bottom neck of GPU databases.

[00:06:04]And finally um writing a database from scratch is a lot of engineering effort. Um and writing GPU program is also pretty pretty challenging. So, if you want to build a GPU native database, there's just a lot of engineering complexity you have to go through.

[00:06:22]Okay. Um but today, we are seeing GPU data analytics is actually at an inflection point.

[00:06:30]So, the hardware and the software trends are making GPU databases more and more viable at scale. So, for for the first challenge, GPU memory capacity is small.

[00:06:41]But you can see the the HBM which is GPU local memory is getting larger and larger. It's exponentially growing in size.

[00:06:51]And the second hardware trend is that the interconnect between GPU and CPU is also improving substantially. Um so traditionally, PCIE is the bottom neck.

[00:07:02]It's improving in speed but not tremendously like not super super quickly.

[00:07:07]But there is this new interconnect technology at Nvidia called NVLink.

[00:07:12]And there is a specific version of NVLink C2C that connects GPU with CPU and the bandwidth of NVLink C2C is much higher than PCIE. So, I'm going to show you some numbers in in next few slides.

[00:07:26]>> [clears throat] >> And finally, for the engineering complexity, this is actually a software challenge. And we are seeing two trends in software that making it much easier to build a GPU database.

[00:07:39]Uh the first trend is nowadays, more and more database databases are adopting this composable or composability principle. So, in order to build a new database, you don't have to rewrite every layer in the database.

[00:07:56]So, different component components, you can just draw from for example, open source libraries like the front end, the SQL parsing um the query optimizer, you can you can take another one and maybe the execution engine.

[00:08:09]Uh you can you can take existing one finally the storage layer. So, each layer is composable. And to build a GPU engine, you just need to replace the GPU sorry, the execution engine, but you don't have to rebuild the rest uh components of your system.

[00:08:26]And the second software trend is that GPU libraries are getting more and more mature. Right? So, you when you build even when you build these SQL operators, you don't have to implement every operator from scratch. You can just leverage CUDA libraries especially cuDF.

[00:08:44]They implement a lot of libraries already. So, you can just use these libraries to build your system.

[00:08:51]>> [clears throat] >> So, just to show you some numbers to give you a sense of um how fast GPUs are or why this is a great fit for databases. So, the the GPU memory capacity has been increasing exponentially. So, now the latest the GPU already have 288 GB of memory.

[00:09:13]Which is a pretty decent, right? So, a server with this amount of memory is is not considered too small.

[00:09:21]Um although it's still smaller than the the high-end CPU servers, but this is a uh substantial improvement over over years and it's getting getting even better in the in the future.

[00:09:34]Uh and if you look at the bandwidth of this memory, this like is it's really really fast and it's insanely fast. Um so, the latest GPU model Rubin has 22 TB per second memory bandwidth.

[00:09:48]Um so, it's uh uh it's you can almost read the entire memory 100 times during 1 second like the 288 GB memory.

[00:09:59]Uh so, this is this is super fast and a big jump from the previous generation, which was just 2 years ago.

[00:10:08]Okay. So, the hot the second hardware trend is the the faster interconnect, right? So, this is the bottom neck I was talking about earlier that traditionally the the connect interconnect between CPU and GPU is PCIe. And the PCIe is is not fast enough, right? So, you can see the PCIe bandwidth at the bottom of the figure.

[00:10:29]Um so, it's improving. It's doubling almost every two to three years.

[00:10:35]Um but the fastest one is still like uh maybe 2 to 300 GB per second, and which is not yet widely available, but um but it it's probably going to be available very very soon.

[00:10:47]But if you look at the NVLink CDC uh bandwidth, that's that's order magnitude higher. So, um the latest generation already reaches 1.8 TB per second. So, this is a GPU can access the host CPU memory at 2 TB per second.

[00:11:09]Uh that is even faster than how the CPU can access its own memory.

[00:11:13]All right. So, this is uh with this technology basically, you can say uh the bottom neck between CPU and GPU actually disappears.

[00:11:25]Um and the same also happens for inter-GPU interconnect, right? So, uh if you use NVLink um to connect between GPUs then the the latest generation give you a bandwidth of 3.6 TB per second. So, this is also like much faster than how a traditional CPU can access the local memory or uh mostly while most widely available at CPU networks performance. So, this is uh um this this means if you have um multiple GPUs, they can talk to each other at this super fast speed, and that means it's much easier to build um the GPU database at scale. It's not just about a single node. You can also build a cluster that delivers great performance.

[00:12:16]Okay. So, I also want to say a few words about the cost because um this is one um big pushback that we hear from a lot of people.

[00:12:25]Um the GPUs are always very expensive.

[00:12:28]Like uh arguably more expensive than um CPUs.

[00:12:32]And sometimes it's also in short supply.

[00:12:34]So, even if you want to pay, you cannot even get the hardware because um a lot of big players they want to uh they want to get the hardware as well.

[00:12:42]So, I want to say there there are two points right about this. Uh two insights. Uh so, the first one is um it's more expensive, but if you can get large speed up like a fact if you if the acceleration is significantly enough then on GPU, you actually can get better performance per dollar.

[00:13:04]Right? Because it's more expensive, but it's also faster. So, in the end uh it it may actually be better in terms of performance per dollar.

[00:13:11]And this is already true for AI, right?

[00:13:13]Like that's why people use GPUs for AI.

[00:13:15]It's actually cheaper than running things on CPU.

[00:13:19]And it's generally true when workload can fit the hardware.

[00:13:24]Um and as I said earlier, um data analytics is workload that fits very well into GPU hardware.

[00:13:31]And uh I'm going to show you some numbers later like in the when I show the evaluation. Uh we do have some experiments on the performance per dollar comparison between Sirius and DuckDB.

[00:13:43]Okay. So, the second point I want to make is um although AI training, people want to use the latest generation of GPU hardware, but for data analytics, uh we don't have to use the latest generation, right? It's it's actually good enough if we use some older generations of GPU.

[00:14:01]Um and those GPUs are much more widely available at a reduced cost uh because I mean the the AI people they will pursue the the better GPU but after the new generation is released, they they they go for the new generation, but older generations um will be there will be a lot of those uh underutilized, and data analytics that are actually a perfect application that can leverage those older GPUs.

[00:14:35]Okay. So, uh next I'm going to show the uh Sirius architecture and design principle, but if there's any question, please feel free to ask um about the hardware trends.

[00:14:52]Um okay. So, on the left, you can see the high-level architecture of Sirius.

[00:14:59]So, you can see we are taking a very composable design, and that's actually our first design principle. We call it MICE.

[00:15:06]Uh it's modular, interoperable, composable, and extensible.

[00:15:11]Right. So, on the left, you can see on the very top are the systems we are trying to support. Like we we can support DuckDB uh today, and we also have some some support for Doris.

[00:15:23]Uh we are going to support StarRocks, and uh this this whole system design also allows us to support other additional systems um in the future.

[00:15:35]So, Sirius is not modifying the front end uh of the of your database. So, the database will take a SQL query uh will parse it, and it can run its local query optimization to produce an optimized plan.

[00:15:50]Uh it's a logical plan, and then Sirius will take the logical plan from these front end uh systems. So, for DuckDB, it will just directly take the logical plan uh and accelerate it. And then for Doris and StarRocks and other systems, we will translate this into a uh like today we translate to Substrate, which is the open-source query plan format.

[00:16:14]And then we we feed that into Sirius.

[00:16:17]And the rest of the execution will all be taken care of by Sirius. All right.

[00:16:21]So, it's just a fetch the data from the storage uh to local execution, and it will leverage NVIDIA libraries for uh operator implementation, memory management, networking, and also memory uh buffer management.

[00:16:40]So, I see there's a question.

[00:16:42]Matt, just unmute yourself. Go for it.

[00:16:44]Fishing out. Um do you have any way to cost these differently because different join implementations when you go to run them on a GPU could have different costs than what these other systems front ends might have accounted for. So, do you have a way to do that?

[00:16:57]Uh that's a great question. Uh so, I think the question is So, because GPU operators has a different cost model, should we take that into account when we build a query optimizer, right?

[00:17:09]So, uh you can definitely build a GPU native query optimizer. We are not doing that yet uh because that's a lot of effort. So, we just take the current optimized plan that's is probably tuned for CPU. And we just accelerate that, and that's already give us give us substantial speed up.

[00:17:29]So, if you make it GPU native, I'm sure you can see even bigger speed up.

[00:17:35]Of course, at the cost of more engineering effort.

[00:17:39]Um and at least in DuckDB, I think it's totally doable. Like DuckDB has this extension system. You can extend the system in many many different ways.

[00:17:48]Uh for example, you can have your own query optimizer or you don't have to you don't even have to rewrite the entire query optimizer. You can just uh they will optimize some steps, and you you take the optimized plan, you do some further optimizations. So, I think that allows you to build, say, a hardware uh native or hardware aware query optimizer. So, it's I think it's doable.

[00:18:12]We we we are not doing it yet, but this this should be doable.

[00:18:17]Sure. Thanks.

[00:18:20]Uh yeah. So, this this design or this architecture allows us to do job in acceleration uh with minimal modification to the host system. So, actually as I will see in the demo, when you use DuckDB uh versus DuckDB with Sirius accelerated, the user interface is almost identical.

[00:18:43]Um so, users don't even need to know that this actually GPU accelerated.

[00:18:49]Uh it's built on top of NVIDIA CUDA-X libraries that that's actually save a lot of engineering effort.

[00:18:55]Um because these libraries are highly optimized for GPU.

[00:19:00]And uh furthermore, we also design Sirius that to so that it's very extensible. So, for example, if you're not happy with uh libcudf operator, like you want to have a better join well, it's actually pretty easy uh to implement that that new join and hook that into Sirius and test performance. And in fact, we are already doing that for certain operators when um maybe we need some special feature or we need um performance for a specific workload pattern that the existing libraries are not good enough, then uh we are already replacing or we're adding new operators.

[00:19:38]So, this make it a very easy, especially for researchers. If you want to explore um I mean, different operator optimizations, you can just try that on this as a platform.

[00:19:48]So, Subesh asks, um it seems like that Sirius is the only execution engine that will do everything. Is that the case or are there are you letting DuckDB whatever system offload sub plans to it when those upper level systems decide that some portion of the query plan could be could be benefit from using GPUs. I guess is it all or nothing?

[00:20:07]That's a great question.

[00:20:09]It's today is all or nothing and that's a conscious decision we made.

[00:20:14]So let me go through this first and I come back to the question.

[00:20:18]Sirius today is a GPU native execution engine. So that means we will try to run the entire query on GPU. We will not try to break it into pieces and like a hot part of it run on CPU or part of it run on GPU. We just try to run everything on GPU.

[00:20:36]And if it doesn't work like maybe something we don't support or maybe for whatever reason we have a bug and crashes then we'll fall back to DuckDB.

[00:20:49]So so it's all or nothing. If it runs on GPU it will run there otherwise it will completely run on CPU back into DuckDB mode.

[00:20:58]So we made this decision because actually in early days when I was doing like a right while I was writing papers on GPU database we actually explored this idea of a hybrid execution engine like we decide which hardware to use for a particular operator in your entire query plan. And we actually published papers on that.

[00:21:21]But it turns out that that substantially increases the design complexity because you you you constantly to worry about oh where to run what and because any combination is possible then you you just have to like your communication policy must be bug free all the possible combinations of these operators.

[00:21:42]It turns out to be pretty complicated.

[00:21:46]In the end we realized a lot of the operators are great for GPU acceleration like even regex. It may sound counterintuitive because regex is supposed to be very slow on GPU but if you do code generation a regex can be pretty fast like we we saw this in ClickBench numbers. It can be pretty fast on GPU.

[00:22:06]So even those things can really be accelerated on GPU. I don't know about user defined functions so that's maybe a part which is a little bit easy but if you can do code gen I think even there maybe GPU can be pretty fast. So so that after that we decided okay by moving the entire query to GPU you substantially simplify the design.

[00:22:29]Um I can get better performance.

[00:22:32]And also you get very good compatibility because it doesn't matter what your database you're accelerating is because you just run the entire query on GPU. So but in in contrast if you take a design where let's say you start with a a GPU engine with the we call this a retro fit in the CPU solution. So you start with a CPU engine and you say oh which part of this query plan I can accelerate on GPU. So in that approach which actually a lot of systems take um it just the the design is more complex.

[00:23:07]Sometimes you cannot get all the performance because the you have to be backward compatible for the CPU engine and the CPU engine was not designed for GPU so there may be bottlenecks that are difficult to address.

[00:23:20]Um And finally there's a compatibility issue like if you're accelerating existing CPU engine it's harder to accelerate a different CPU engine.

[00:23:29]But in our case the the interface is very clean. Just give me the the logical plan.

[00:23:35]So in some sense it doesn't really matter what the CPU engine you're accelerating because the query plan should look very similar and we just just run that all or nothing.

[00:23:51]Okay so I can I can move on.

[00:23:54]Yeah. So this slide shows shows you the the life cycle of a query. It's very simple like in DuckDB you send a query to DuckDB front end optimizer produces a logical plan that got executed by DuckDB.

[00:24:11]But in Sirius it's just the same optimizer logical logical plan but that got executed by Sirius.

[00:24:19]And whenever the the query cannot run in Sirius we just fall back to DuckDB.

[00:24:28]Okay.

[00:24:29]So now let me show you a demo. This is a Okay so here I'm only running one query TPC-H query 9 with scale factor 1000. So the total amount of data is 1 terabyte.

[00:24:46]I'm going to show you like 1 terabyte run for all the TPC-H queries later but for the demo it's one query.

[00:24:55]And the data is stored in parquet format in this experiment.

[00:24:59]And we're comparing two instances like the CPU instance is a pretty big one in AWS.

[00:25:08]So this this instance has 384 cores almost a terabyte of memory and um like $21 per hour is a pretty good one.

[00:25:18]And for the GPU instance we're running on DGX station which is a single GP100 GPU. It's pretty also a pretty good one.

[00:25:27]Um yeah.

[00:25:31]Okay so here is the demo.

[00:25:34]So before I I start to run it I mean this is recorded video.

[00:25:38]Before I started run it on the left hand side is is DuckDB.

[00:25:45]On the right hand side is Sirius. Okay so in this demo in order to run Sirius you need to wrap your query with this function. You need to say call GPU execution and then you you put your query there.

[00:26:01]So the left and right do not look exactly the same.

[00:26:05]But this is already fixed in the latest in the latest code base. So this this demo was recorded a month ago.

[00:26:13]But in the latest code you don't need to do this. You just have you just have a configuration flag and you just say I forgot the exact term but something like a GPU acceleration on.

[00:26:26]And then after that you can just write the the query just like what's on the left.

[00:26:32]And and it would it would just work. So that's just much more convenient.

[00:26:37]Okay so let's start to run this query.

[00:26:45]Okay we start on the left then we start on the right.

[00:26:50]Okay so after maybe 2.5 seconds as query already finished in Sirius.

[00:26:59]And it's still running on the left.

[00:27:02]Okay now it's also done.

[00:27:04]It took 16 seconds in total.

[00:27:07]And you can see the results are identical. It's actually the same format because I mean as I said Sirius is only in charge of execution. So after execution the results are returned back to DuckDB so so DuckDB will just do the same way to format it and present to the to the user.

[00:27:26]Yeah so for this particular query it's about I don't know six seven times faster.

[00:27:31]Um right.

[00:27:36]I just want to understand the setup is that the parquet files are sitting on some local SSD and for DuckDB on the CPU DuckDB is going to read it in through the file system crunch on it and spit it out. In this case here for Sirius the GPU is going to suck it in from the SSD over NVLink and then crunch on it and spit out the result.

[00:27:54]A good question. This is actually a hot run. Okay okay.

[00:27:58]So here you can think of this we run it twice and we only report the second run on both instances so the data is already cached in memory.

[00:28:07]Got it. Okay. And for for cold run what is the what do the numbers look like?

[00:28:11]Um while we recorded this demo last month the cold run was not very fast because back then what we did was whenever we read data from SSD we actually let DuckDB to do it.

[00:28:25]Okay.

[00:28:25]>> Like DuckDB read the data from SSD and then we convert the intermediate format to to Sirius so it will be a little bit slower. I actually maybe a few times slower.

[00:28:36]But we we just fixed that in a PR uh last week I think like that everything is moving pretty fast. So what the way we fixed it is now GPU can directly read DuckDB data files. So we just ask DuckDB for the for the metadata like the catalog. I said okay where the data is.

[00:28:58]Okay these are the files you should read and the GPU will directly go read those data. So we bypass the DuckDB internals and that give us almost 10 times speed up for reading code data. So now Sirius directly reading code data is is also faster than DuckDB. But yeah that that will get merged I think pretty soon.

[00:29:20]Yeah.

[00:29:20]>> Nice. Okay. Thanks for asking asking that Andy because I was going to say like that's like should be almost 90 gigs of line item data coming in and I was confused how that was happening so it makes sense that it was a hot run.

[00:29:31]Yeah.

[00:29:33]Exactly. So a quick follow-up question on that. The database is it doesn't probably fit the entire database doesn't fit in the GPU memory right? So >> question. Yeah. So this is probably a lot of predicate push down happening in the parquet layer or how much is the how much is the GPU memory and how much of the database fits in that memory?

[00:29:55]Uh great question. So, first I don't know an exact number, but um So, when we cache it because we run it twice, the first time when we cache but I mean this query does not touch all the piece of data in the in the database anyway.

[00:30:10]Uh but it is the case that for query nine the data does not fit in GPU memory. So, we cache some of the data in GPU and we cache uh some of the data in CPU pin memory.

[00:30:22]Like we call that GPU talking to CPU memory is also pretty fast. So, then when we execute we will pull data from both GPU memory and the CPU pin memory.

[00:30:31]Got it. Okay.

[00:30:33]Cool.

[00:30:38]Uh Okay.

[00:30:41]Okay, so that's the demo.

[00:30:43]Um So, let me let me let me get uh a little bit deeper into the the technical details.

[00:30:52]So, Serpens has has many um key features.

[00:30:56]All right, so I will I'll just uh go through this uh quickly.

[00:30:59]Uh as I said there's when you use Serpens there's no no need to change the host system.

[00:31:05]Uh like in DuckDB's case the users uh hopefully will not see any difference when when Serpens is on or off.

[00:31:13]Um so, when the GPU cannot run a query we will fall back to CPU execution.

[00:31:18]Uh we also we also have we also have data spilling support. Like that's actually very important uh for for GPU database because the the memory is very small.

[00:31:27]So, spilling is actually the norm. Like in traditional CPU databases probably some some databases would treat this as afterthought.

[00:31:35]But in GPU database this is actually uh like a first class design principle.

[00:31:40]So, we have we have a there is a library a video library called Cook Cascade which is actually developed and maintained by the same team. Uh the team that contribute to Serpens.

[00:31:50]Um and we use Cook Cascade to manage the the memory. So, you can think of Cook Cascade as a uh GPU native buffer manager.

[00:32:00]Uh it's not based on pages though. So, I will talk about some details, but it is kind of like a buffer manager for GPU.

[00:32:07]Uh we can read parquet file with a GPU native parquet reader.

[00:32:12]And uh uh it Serpens is extensible with new database operators. It's very easy to to try out uh new implementations on Serpens.

[00:32:22]Uh we are working on supporting multiple GPUs. So, that has two parts. One is a single node multiple GPU.

[00:32:31]That's like a single CPU connected by connected to maybe four or eight GPUs.

[00:32:36]Um and another thing on our road map is to support distributed uh a system.

[00:32:41]So, this is like multiple nodes. Each node has its own uh GPU a single GPU or multiple GPU and we can also also accelerate that.

[00:32:54]Um okay, so technically uh like the one question what maybe this is more research question is when we build a GPU database how is that different from building a CPU database?

[00:33:10]Right, so over the decades like we know very well how a CPU database should be built. Like if we have this paging buffer manager a page based buffer manager and execution engine like we know how how it works.

[00:33:23]So, what's the key difference or the key new challenge other than the programming language, right? So, uh I think I I I I can think of these following two uh key observations that make it very different for building a GPU native uh SQL engine. The first one is a page based buffer management is not a great fit for GPU.

[00:33:48]It was a perfect fit for CPU.

[00:33:50]Right? And that's a lot of the CPU data maybe all the CPU databases were fundamentally built on top of paging.

[00:33:57]And the page is the unit of accessing disk for example and that's the unit of managing data.

[00:34:03]But in GPU uh that's not a great fit. Like in GPU when you process a lot of data you usually just uh allocate a large contiguous memory region and you just process on it and that region can be gigabytes or even 10 gigabytes.

[00:34:19]Like a hash table just a a giant hash table is not uh broken down to pages. And actually uh the libraries that we're using like cuDF they don't have paging uh built in. So, every time you do something it's just one chunk of memory and they just directly operate on that.

[00:34:37]So, that makes the buffer management a little different.

[00:34:41]And the second observation is that um data partitioning and spilling must be first class design concerns now.

[00:34:50]Um just to compare to CPU database the GPU memory is much smaller. It's probably 10 times smaller.

[00:34:57]Uh so, well as I said GPU memory is still so fast, right? Like even even though GPU accessing CPU memory is also fast, but when data fits in GPU memory is like 10 times faster. It's like 22 terabytes per second. So, you really want to leverage that that high bandwidth. So, you you want to be very very careful like what data fits in GPU memory and what data should be spilled to CPU or disk. Like you have to be very smart making that decision.

[00:35:26]Um So, that memory pressure is kind of more important or more significant in the GPU context.

[00:35:34]So, data partitioning and spilling cannot be a afterthought.

[00:35:39]Uh and it cannot be operator level. Like oh for hash join I I I will implement the spilling and partitioning.

[00:35:45]Well, for GPU it has to be like a built in to the execution model. It has it's a first class uh citizen. It's like uh for us it's almost the thing like uh you the first thing you do.

[00:35:57]Any any operator you want to do you have to do data partitioning first.

[00:36:01]Um because the you wanted the data you want the data to fit in memory and you don't want to consume a lot of memory because of multi-tenancy. Like a single query is not supposed to take over the entire GPU. So, you have to partition data and you have to spill um pretty frequently.

[00:36:21]>> [snorts] >> Yeah, so with that I I can um go through uh the design architecture in more details.

[00:36:29]Um Uh so, the front end is DuckDB.

[00:36:33]But I use DuckDB as an example.

[00:36:35]Uh so, it does the parsing optimizing optimization and it will produce a logical plan.

[00:36:43]So, the first thing Serpens will do is take the logical plan and do some conversion. Right? For example, adding partitioning uh and adding some spilling uh not not spilling but partitioning to the the query plan and there's some other modifications.

[00:36:59]Uh and then we have a task creator uh that will like basically every every node in the query plan will be translated into multiple tasks. Like each task will process a partition of data. Like this partition maybe the partition is like a few gigabytes one or two gigabytes.

[00:37:18]And you just a small lot of tasks and they're running parallel.

[00:37:22]And uh each task uh can be picked up like by a thread.

[00:37:29]Well, that's a CPU thread. But but the task will be executed by the executors.

[00:37:36]Right? So, one task will translate to like one executor and we'll use libcuDF to implement uh these executors. Like you don't have to do everything from scratch.

[00:37:47]Um and the the intermediate results like uh the input and output of the executors uh those are like those are the buffer management part of the system. So, those are stored in the uh data repository that is managed by Cook Cascade.

[00:38:04]And uh uh the data repository also takes care of downgrade. Like we we call downgrade is is just a spilling data from GPU memory to CPU and to disk.

[00:38:18]Yeah, so this is the the super high level uh architecture.

[00:38:24]It's probably also similar to uh how a CPU database works.

[00:38:28]Uh so, in terms of the the plan conversion um yeah, so we we take a DuckDB plan.

[00:38:36]Like DuckDB will translate the logical plan into pipelines.

[00:38:40]Uh and the Serpens will do something similar, but it will add a lot of these partitioning operators and we have uh we always have a pair of partition and concatenation. So, partition will will split the data and concatenation will uh optionally merge the the output partition. Like maybe after partition you do the filtering and each partition becomes the output of each partition becomes really really small.

[00:39:06]Uh then we will do the concatenation to merge them back into uh data chunks with the with a reasonable size. Like we call it data batches. Yeah, so the data batches of reasonable size. So, just uh have a lot of these partition uh and concatenation.

[00:39:23]Okay.

[00:39:24]>> In in your overview diagram you had you mentioned you had support for substrate.

[00:39:29]Uh yes. Can you talk a little bit like the pros and cons of what you've dealt with and is I'm assuming the the workflow of converting a substrate plan is the same as DuckDB?

[00:39:39]Yes, uh conceptually is the same. Like that for DuckDB uh originally we also tried to use the substrate even for DuckDB. And that that means the series just have a like one interface.

[00:39:51]Um there were some performance issue and also at some point DuckDB was not uh like fully supporting substrate.

[00:40:00]But they but then for performance reasons and and for ease of integration we just use uh DuckDB uh DuckDB's own logical plan.

[00:40:10]Um if you take substrate like when we integrate with Doris we take substrate and I I mean it's very similar. You take the logical plan just looks differently and then you do the conversion back to Sirius internal format and the rest is the same.

[00:40:23]So I the integration issues engineering challenges I totally buy that. But you mentioned performance issues. That's surprising. So you're saying the substrate plan was less optimal than the the the DuckDB logical plan?

[00:40:36]I think the plan Um I don't recall this precisely but I think at some point not all their not all DuckDB plans could be translated into uh substrate.

[00:40:51]I might be wrong on this.

[00:40:52]Um and also we there one more thing we did notice and we never figured out is whenever you use substrate in DuckDB there is always this performance overhead like a few milliseconds.

[00:41:05]Got it. Okay. Very small.

[00:41:06]And it's consistent. Uh it's small but for us is as big. Like a few milliseconds is actually hurts a lot.

[00:41:15]All right. Thanks.

[00:41:22]Right. So this is the the plan conversion.

[00:41:25]Um spilling with the cool cascade. Um so like as I said the the output of a pipeline is always stored or managed by the data repository.

[00:41:40]Right? So uh and it it's probably just as the output of the scan is in the data repository which is already stored in GPU memory and then it immediately got uh fed into the next operator. So this is it can be pretty lightweight.

[00:41:58]Um yeah and the data repository will just contain all of these data batches like we call them data batches which is really uh like uh the output of one task uh which is basically one partition of the output table. Right? Each task will process one partition uh of the input data.

[00:42:22]So these data batches um uh can have different formats. Right? So because as I said the data batch may be spilled from GPU memory to CPU memory and later to disk. Uh and it can use different format for it. Like if it's already in GPU memory and then usually we just use the CUDA of table format because well that's the what our executor or our operator executor can recognize so you don't need to do any further translation.

[00:42:51]But if the data is spilled to CPU memory then we want to do some conversion. Like we want to convert that into fixed size allocation. Like you can think of that as large pages.

[00:43:05]Um so that make it easier for the CPU side to manage memory because it's just all fixed fixed sizes.

[00:43:14]And the design of data repository also allows us to use custom data representation in the future. Like maybe uh you want to do some compression before like you can do compression even for the cached data in GPU because that will allow you to put more data in GPU memory uh or you can do compression when you spill the data to uh CPU or or SSD. So it's all customizable. Uh and uh like uh we can explore that in the future.

[00:43:46]Yeah and the downgrader will periodically uh look at all the data batches in the data repository and use different heuristics to decide uh what data batch should be downgraded and what data batches should stay in GPU memory.

[00:44:03]So you don't control any of this. This is all CUDA. Correct?

[00:44:07]Uh quick question. Uh All the control decisions are actually happening in CPU.

[00:44:17]But all the like the data movement or the processing happen in GPU. So that's all CUDA.

[00:44:23]Um but some of the decision like the downgrader which uh data batch should be spilled that logic actually runs on CPU.

[00:44:32]And then and then you provide that logic or or like CUDA's doing this for you?

[00:44:37]Uh we provide that logic. Got it. Okay.

[00:44:40]Yeah we we can that's another thing we can that's another extensible component.

[00:44:47]Right now we have very simple heuristics to decide uh what data batch to spill but like [snorts] you can design pretty complicated sophisticated uh policy to decide what to downgrade. And that's all controlled by Sirius. We are not leveraging CUDA to do that today.

[00:45:04]Okay. Okay. Thanks.

[00:45:07]Yeah.

[00:45:11]Okay.

[00:45:13]Uh yeah so uh Sirius can also work in a distributed environment. So the earlier I showed only the single node uh but we also build a a prototype with Doris which is a modern composable uh a distributed uh database.

[00:45:31]So it's very similar to how it connects with DuckDB. Right? So the query will come to Doris coordinator and then on the left the which is how Doris works the the query plan will be generated the query plan will be sent uh will be fragmented and then sent to all the the backend servers.

[00:45:50]Uh each server receives and do the execution. It will do local execution.

[00:45:54]It will do data exchange.

[00:45:56]Uh so that's how Doris works. So when you uh when we change it to Sirius engine so the front end is the same. It's still the Doris query parser query optimization and that will generate a query plan.

[00:46:12]And we just send the query plan to Sirius like if each node like it's also distributed so each node will get its own query plan.

[00:46:21]And the Sirius will take care of two things. One is it will um it will do handle the data exchange between different nodes.

[00:46:30]Because we we don't want to use the the traditional data exchange because that may not be fast enough. So um to maximize performance Sirius will handle data data exchange using Nvidia library called Nickel.

[00:46:45]Uh and the Sirius backend will also translate the query plan to substrate.

[00:46:51]So it's still a Doris query plan but we translate to substrate and then I just feed substrate into uh uh the the Sirius engine.

[00:46:59]So in this architecture ideally uh which [snorts] I also think that's happening today like we you don't need to make any code change to Doris.

[00:47:10]Like just just Doris zero change. I just change the configuration to to tell Doris you should send the logical plan to Sirius instead of its native engine.

[00:47:21]But you don't need to do major code change inside Doris.

[00:47:26]And you also don't need to make major code change to Sirius like single node Sirius.

[00:47:32]So the only thing we need to add is just a at least substrate translation also the data exchange.

[00:47:38]So that makes the design very very modular.

[00:47:46]Uh okay so let me show you some evaluation.

[00:47:50]So this is the uh a Sirius running on TVCH 1 terabyte.

[00:47:55]Uh the hardware is a DGX station with GB300.

[00:47:59]Um the data is stored in parquet format uh but we're only reporting the hot run.

[00:48:05]And this is like running the second time the data is is cached in GPU uh and if data if GPU is not big enough we cache that in CPU P memory.

[00:48:16]Uh and we are running DuckDB and Sirius on this same platform. So DuckDB is also running on GB300.

[00:48:24]But the GB300 actually have two components. There is the Grace chip CPU and there's Blackwell GPU. So we're running DuckDB on that um CPU on the the GB300 CPU.

[00:48:37]Uh that's actually a very good CPU. The the memory bandwidth is higher than a typical uh CPU server.

[00:48:45]So on average we see five times speed up.

[00:48:48]And if you look at the the sum on the right side um so Sirius can finish the entire run in 21.6 seconds.

[00:49:00]So if you're familiar with TVCH numbers the world record right now is actually uh more than this. So this is actually faster than the world record already.

[00:49:09]Uh of course this is not the officially audited run. So um not official nothing is official here but at least this shows the how fast it can be. It's really really really promising.

[00:49:21]Uh it's like faster than the world record and actually also the system here the hardware here is cheaper than the hardware that delivers the world record results.

[00:49:36]Okay so in this experiment we are sweeping the scale factor like the data size all the way from 10 gigabytes to 1 terabyte and on the same hardware also parquet format also hot run and we're showing the speed up over DuckDB with these different data size.

[00:49:56]And by the way, I forgot to mention on large data set spilling happens all the time.

[00:50:02]Like just the data doesn't fit so we we keep spilling data back to CPU memory. I just did all included in this figure. So in general we see the speed up actually increases as you have larger and larger data which is pretty interesting. Like it's it's not only give you speed up it actually more speed up as you have more and more data.

[00:50:23]The scale factor 1000 there's still something we we can optimize so but it's pretty close to the to the peak.

[00:50:31]I see there are some questions.

[00:50:36]Right. So Chris has asked Chris asked are the queries run sequentially?

[00:50:41]And then the next question is how does Serres handle data skew?

[00:50:46]Yes, the experiment runs sequentially so one query at at a time. We are working on multi-tenancy though so the architecture allows multi-tenancy. It just needs time to to get it stable.

[00:51:00]The second question is Maybe for the for the sequential queries like say the ones that that take a long time like Q21 like what What is the what is the utilization of the GPU? Is it like are you blasting the query out on all possible warps and threads so that like it's running 100% utilized or is it is it a large chunk of it still idle cuz it's just so fast?

[00:51:23]I think I don't have that data for individual queries but I guess the GPU utilization should be pretty high.

[00:51:31]Partly because the data is very big so there's a lot of data and also if you don't fully utilize it you are not going to get this performance so But I mean it's pretty high. At some point you have to coalesce things right? The concatenation piece that were like you know the there's certain pipeline breakers that have to run single threaded but I I think the next question is how does Serres handle data skew?

[00:51:54]Um >> [snorts] >> So we do we do use similar techniques as DuckDB like min-max filtering.

[00:52:06]Um I I don't know whether that's the that's what you mean by skew. So min-max filtering will actually prune a lot of data we don't need to process everything.

[00:52:18]And there may also be skew in terms of duplicate values.

[00:52:22]Like you you join two tables but actually a lot of duplicates so when you actually do the join you suddenly get a quadratic number of rows.

[00:52:31]Um We also have solution for that but that's just a uh like I don't know whether that's the question but we we also have solution for that like you have partition data into smaller pieces and then you just like concatenate outputting together like it become a huge output but but it can work.

[00:52:56]>> [snorts] >> Okay.

[00:53:01]Yeah, so the next experiment is cost normalized. So because people complain about the cost like GPUs can be very expensive. Well, not all the GPUs are super super expensive like in this experiment we are running this is not 1 terabyte anymore this is 300 gigabytes.

[00:53:17]Um so we are choosing Okay, you can decide whether it's a fair comparison yourself.

[00:53:25]The CPU instance is from AWS it's about $2 per hour.

[00:53:29]The GPU instance is from Lambda Labs.

[00:53:32]Okay, it's different cloud.

[00:53:34]Uh as G200 is also $2 per hour.

[00:53:39]And same data format warm run.

[00:53:42]And here we show that um the normalized performance like performance per dollar Serres is actually nine times better.

[00:53:54]Yeah, well of course this these two hardware is like two different clouds like G200 is not the latest generation G200 yeah it's but it's pretty cheap.

[00:54:04]Um yeah, but this is the number we got on these two piece of hardware.

[00:54:09]All right, so Wes asked is the memory overhead from intermediate results a concern when running on GPUs? Are you modifying the operators or execution plans to decrease the that overhead?

[00:54:18]The memory overhead is definitely one issue and the way we handle that is we just spill the data a lot. Like the intermediate result we spill that back to CPU if we think it's not going to be used immediately.

[00:54:30]Um so that's the way we handle that.

[00:54:33]Like spilling is a first class citizen in Serres.

[00:54:36]The intermediate results are uncompressed right?

[00:54:40]Uh that's a configurable. Today we don't compress it just because we we are we're not there yet but you can compress it.

[00:54:47]You can say whenever I spill I will first do lightweight compression and then I spill. Like GPU that is a trade-off like lightweight compression still takes some computation but you can you can it becomes smaller to spill.

[00:55:02]Um yeah.

[00:55:04]But I mean maybe another way to say it is like you're you're you're compute bound on these queries right? Like the the the bandwidth is so high that you can shove things in and off.

[00:55:14]Now you're reading from memory so you you can get things spilled out of memory very quickly but if you have to write to disk that's the bottleneck.

[00:55:21]Right?

[00:55:23]Uh if you really got to disk yeah that can that can be slow depending on your hardware.

[00:55:30]Getting to CPU memory is not too bad.

[00:55:32]You see your memory is pretty big actually. So getting spilling the data to CPU memory is not too bad.

[00:55:38]Okay. And actually your your previous point we we realized the major bottleneck is probably not compute not memory bandwidth. The major bottleneck of the whole system is memory capacity.

[00:55:50]That's a little surprising. It's GPU memory capacity is the number one bottleneck. So you actually design the system around that you just say oh what data should stay in GPU memory and what data should spill and that really affects performance in a very big way.

[00:56:06]>> [snorts] >> But I mean but but related to that is like because you don't have enough memory you got to spill spill to somewhere else and that becomes you know that's essentially the bottleneck how fast can you get the things out of memory to to reclaim the space. Yeah, kind of yeah.

[00:56:21]Okay. All right, keep going.

[00:56:25]Okay. Yeah, so this is some experiments on the distributed setting.

[00:56:30]Uh we compare Serres accelerated Doris with Doris native Doris and the ClickHouse.

[00:56:37]And yeah, it's four node cluster and we show that depending on the query I mean this is only three TPCH queries with scale factor 100 and we can get a speed up between 2.4 and 12.5. We're actually working on accelerating the Doris so I think this maybe we'll have a more stable version within a few weeks.

[00:57:00]Yeah, and yeah as I said earlier um we we run ClickBench and Serres is actually now the world number one in ClickBench.

[00:57:09]On hot run you can see on the top and also combined run. The combined run they consider both the hot run and the cold run and the loading.

[00:57:18]So because the hot run is so fast and the cold run we we also optimize a little bit so it becomes the number one in both. I think if you go to ClickBench website today I checked a few minutes ago before the talk so it should still be there it's still the the number one.

[00:57:34]And there is a Nvidia developer blog post talking about this this whole thing so if you are curious about the technical details feel free to to read the blog post. And one more thing to note that is we achieve this performance actually using cheaper hardware.

[00:57:51]So this is we're running on G200.

[00:57:54]With the G200 is really cheaper. The other experiment in the second place Serres we are running on H100. And that one is actually AWS and that is similar cost not expensive but but similar cost. But G200 is like three times cheaper.

[00:58:10]Um And the main difference is G200 has this NVLink C2C connect interconnect but but the H100 is they are using PCIe so Yeah, finally some future plan. We're actively developing the system is moving pretty fast and it will become a core extension of DuckDB. We are working on multi-node distributed disk spilling like right now spilling mainly for CPU memory and we need to add disk.

[00:58:42]Adding remote data sources um better data format and compression etc. So a lot of things happening.

[00:58:50]Uh this is a major partners of this project are like Nvidia, UW Madison, DuckDB and Vast Data and we're welcoming contributions from both academia and industry.

[00:59:02]Um Yeah, finally um this is my final slide summarizes everything. We actually have a list of papers. So if you want to check out maybe you can look at the first two. The first paper talks about Serres in general. The second paper is actually from Thesis the the Voltron data people they published this paper and a lot of those engineers that are actually working on Serres now at Nvidia.

[00:59:29]We have website GitHub page and here is the QR code to join our Slack channel.

[00:59:34]You can also email us.

[00:59:36]Yeah, I'm happy to to take more questions. Thank you very much.

[00:59:40]All right, Shinya, I will clap on behalf of the audience. That was phenomenal. We have time for a few questions. If you can ask your question first, go for it.

[00:59:46]Yeah, Shinya, really nice talk. I I know the Voltron data guys worked on a bunch of these things before.

[00:59:52]>> Oh, yeah. Um and it's so awesome to see this come through and really amazing.

[00:59:58]A question is uh you talked a little bit about the data spilling and how important that is.

[01:00:05]If you're in the middle of a uh join tree and you have to decide on the partitioning that you need to do for the next join in the stage, uh there because it is very data dependent, if you end up with a partition that is really really large, this is I think the skew question that Chris was maybe trying to ask. Mhm.

[01:00:24]How do you deal with that? That that was a huge nightmare uh uh when the Voltron guys were trying to attack that. And is does the CPU spilling take over and start to deal with that? Or like how far or is it new set of algorithms when you start to have one partition just overflow by a lot? Cuz then you have to deal with it in the next point either by repartitioning or doing something else.

[01:00:47]So, uh can you say a little bit about how you deal with that? Because cool cascades won't handle it, right? So, you'll have to do something outside the database engine.

[01:00:55]>> Uh great question. So, the honest answer is I don't think we have 100% complete solution on that yet. Like this is uh ongoing.

[01:01:05]But, I would say one possible solution is as I said, we have this partitioning operator everywhere.

[01:01:11]Uh and the partitioning and concatenation are inserted everywhere. They may not be doing the work. Like maybe we may decide just to skip it.

[01:01:19]But, they are there as placeholders. So, I think what you said is if the intermediate suddenly got so much bigger, uh we have a partition operator right there.

[01:01:30]And we just partition that into smaller pieces.

[01:01:33]So, it's always the partitioning and concatenation come in pairs almost.

[01:01:37]Like we just say, oh is it too big? We partition. Is it too small? We concatenate.

[01:01:42]But, if it's right size, we just skip these two things. We just do nothing.

[01:01:46]Got it. Great. Thank you. Awesome work.

[01:01:50]Thanks.

[01:01:51]Uh question from the audience.

[01:01:59]All right, so I guess my two last questions are um I guess my my one question I have I think you sort of talked a little bit about this when you had these sort of custom logic that you would implement in the CPU that you then plug into uh CUDA libraries. But, I guess have there been any other challenges or what have been the challenges or deficiencies you found in the CUDA library where you wish that you could have full control over something in Sirius, but you have to offload it to CUDA because it's some proprietary Nvidia thing?

[01:02:31]Oh, that's a very good question.

[01:02:34]Um Oh, by the way, our video libraries they're all open source.

[01:02:40]Uh so, well, it's probably take it's probably not easy to convince these people or propose a change that they accept. But, um it's actually possible to to make changes.

[01:02:52]I think I cannot think of a architectural problem there.

[01:02:59]I think it's very nicely designed and at a high level, I don't think there is the issue. Maybe if you say, oh maybe the memory management is an issue because they they don't allow data spilling. Well, but the cool cascade kind of solved that problem, right? So, it's very it fits really nice together.

[01:03:21]Uh I think the problem we encounter are mostly for individual uh operators.

[01:03:26]Like uh we don't have a problem with the join, but you can assume, oh maybe the the regex like for example, we saw the regex operator is very slow.

[01:03:36]Uh so, we have to do code gen, which is like a different a different tool, different library. We use code gen to to make that fast.

[01:03:43]And some other operators like maybe interesting like for example, the distinct aggregation with distinct.

[01:03:53]That's very slow.

[01:03:54]Yeah. Okay. Why? Like why? Oh, well, that's for some detailed technical reasons.

[01:04:01]Um So, you you can potentially accelerate it. Like strings, sometimes strings can be slow.

[01:04:06]It's not fundamental. It's just a uh it it can be improved.

[01:04:11]Um but, I don't see problem at that architectural level.

[01:04:15]But, it it would be improved in the CUDA library. So, in the same way if like if Amazon makes S3 faster, all these systems that are built on top of S3 get that for free in quotes, free in quotes.

[01:04:25]The same way if you then give feedback to the CUDA people and say, hey look, this sucks, make this better, then you don't have to really potentially change any part of the core system of Sirius Sirius. Like you just get that for free because you get you upgrade to the next version of of CUDA.

[01:04:39]Exactly. So, we actually doing that. We are working closely with the uh with the CUDA app team.

[01:04:46]Mhm.

[01:04:47]>> Um So, the way we tested is when we have a new idea, we usually test it on Sirius first because it's like it's very convenient.

[01:04:55]Uh we try this new operator. We replace the previous operator. We show the speed up and then we use that to talk to them.

[01:05:02]Like maybe they're interested in integrating this into uh their code base as well. I think this this is already happening. Like you already see this pipeline. Um so, in that sense, Sirius is like a test bed for CUDA app before they more officially accept um the optimization. Got it. All right, so my last is one quick question. Uh is the distinct slow because the GPU wants GPU warps to need to sync on some global state?

[01:05:28]Um I You can partition distinct, right?

[01:05:33]It's not Yeah, it's not fundamental. Like I'm I'm sure um some smart people can go ahead and say, oh yeah, this this shouldn't be slow. Like I would implement the distinct that it is fast. I think it's totally possible. It's just a it's just like uh it's not there yet.

[01:05:50]Got it. Okay. Or maybe it's already there today, but at least the back then a few months ago that was that was one bottleneck.

[01:05:59]All right, my last question and this will be sort of tied into the the overall theme of the seminar series.

[01:06:03]Um Obviously, this is written from scratch on CUDA and then you you you linked it in with DuckDB. At any point did you consider integrating this with Postgres? And if yes, why didn't you why did why did you pursue DuckDB instead of Postgres?

[01:06:19]We actually had a long debate at the beginning of this project. Okay. Which one to choose?

[01:06:25]Um In the end, we chose DuckDB just to >> [laughter] >> reason um one big reason is that I I it's a it's easier to work with the code base.

[01:06:35]It's just shorter, right?

[01:06:37]Um Yes.

[01:06:39]That's actually as a because it was a research project back then. Like that's actually a big reason.

[01:06:45]Um And it's more modular.

[01:06:49]Like they designed it to be more modular. It's easier to add extension.

[01:06:53]Actually, you know what? Sirius is a DuckDB extension.

[01:06:56]Mhm. Like that's how it works. It's just just pure extension.

[01:07:00]Um it was harder for to for Postgres to get started. For example, it's row store and it's more complex code base. It's harder to uh to make it work. Maybe it could be it could work. We we didn't we didn't try.

[01:07:17]I mean, there's PG [snorts] Strom out of Japan, but I I've never met anybody using that. So, that makes sense.