Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
It was a good way to start the class, right? Just kind of like the music guide out. All right. But a round of applause for DJ Cash. Thank you so much.
Đó là một cách khởi động buổi học hay đấy chứ? Kiểu như dẫn nhạc mở màn vậy. Được rồi. Xin một tràng pháo tay dành cho DJ Cash. Cảm ơn bạn rất nhiều.
A lot to cover, plus we have a speaker today. So let's just jump right into this. All right. So today we're going to talk about the second half of material on query execution.
Hôm nay có nhiều nội dung cần học, và còn có một diễn giả khách mời nữa. Vậy chúng ta vào thẳng vấn đề nhé. Được rồi. Hôm nay chúng ta sẽ nói về nửa sau của phần thực thi truy vấn.
So we'll pick up where we left off last class. But for you guys in the class, again, things to cover: project two, due this Sunday coming up.
Chúng ta sẽ tiếp tục từ chỗ đã dừng ở buổi trước. Nhưng trước hết, với các bạn trong lớp, có một số việc cần nhắc: project 2 hạn nộp là Chủ nhật này.
The recitation link is available there, and then the special office hours will be this Saturday at 3 o'clock in Gates Building.
Liên kết buổi thảo luận có ở đó, và buổi office hours đặc biệt sẽ diễn ra vào thứ Bảy này lúc 3 giờ tại tòa nhà Gates.
Midterm, you can come after class at 4 o'clock and come to my office hours and check out your grading and look at a solution.
Về bài thi giữa kỳ, các bạn có thể đến sau giờ học lúc 4 giờ và đến office hours của tôi để xem điểm chấm cũng như xem lời giải.
Homework four will be released today, and that'll be due on Sunday, November 2nd.
Bài tập về nhà 4 sẽ được đăng hôm nay và hạn nộp là Chủ nhật, ngày 2 tháng 11.
And then project three will also be released today, and that'll be due on November 16th, and then we'll announce the recitation for that project. That'll be sometime next week, okay? Okay.
Project 3 cũng sẽ được đăng hôm nay, và hạn nộp là ngày 16 tháng 11, sau đó chúng tôi sẽ thông báo buổi thảo luận cho project này. Việc đó sẽ diễn ra vào tuần sau, được chứ? Được rồi.
I had an animation that I blew up. Let me fix it for you real quickly.
Tôi có một hoạt ảnh bị hỏng. Để tôi sửa nhanh cho các bạn.
So there was a major outage in the internet on Monday in class.
Hôm thứ Hai trong lớp, đã có một sự cố lớn trên internet.
Everybody hear what caused it? DynamoDB. Exactly right. The database went down, and that broke a bunch of stuff, right? Now, the database itself didn't go down because DNS getting to it went down.
Mọi người có nghe nguyên nhân là gì không? DynamoDB. Chính xác. Cơ sở dữ liệu bị sập, và điều đó làm hỏng hàng loạt thứ, đúng không? Thật ra bản thân cơ sở dữ liệu không sập, mà là DNS dẫn tới nó bị sập.
But again, I want to emphasize how important databases are and why this class is important because it's the backbone for pretty much everything, any modern application, any modern system.
Nhưng tôi muốn nhấn mạnh một lần nữa cơ sở dữ liệu quan trọng đến mức nào và vì sao môn học này quan trọng, vì nó là xương sống của hầu như mọi thứ, mọi ứng dụng hiện đại, mọi hệ thống hiện đại.
At the end of the day, there's going to be a database. And if that goes down, then you're screwed.
Rốt cuộc thì ở đâu cũng sẽ có một cơ sở dữ liệu. Và nếu nó sập thì coi như hỏng bét.
So one database goes down, and that takes down basically half the internet, so that's pretty wild.
Chỉ một cơ sở dữ liệu sập mà kéo theo gần một nửa internet, thật là điên rồ.
And so we'll cover DynamoDB, and DynamoDB is a distributed key value store, distributed document store that uses consistent hashing. We'll cover that later in the semester. It's a very influential system.
Chúng ta sẽ học về DynamoDB, DynamoDB là một kho khóa-giá trị phân tán, một kho tài liệu phân tán sử dụng consistent hashing. Chúng ta sẽ học phần đó sau trong học kỳ. Đây là một hệ thống rất có ảnh hưởng.
All right, so last class we were talking about query execution.
Được rồi, buổi trước chúng ta đã nói về thực thi truy vấn.
And we were talking about how there's these operators in our query plan that all implement the same API, whether it's the get next or the way they're going to be passing tuples between each other.
Và chúng ta đã nói rằng trong kế hoạch truy vấn có các toán tử cùng cài đặt một API giống nhau, chẳng hạn hàm get next, hay cách chúng truyền các tuple cho nhau.
It allows us to compose query plans, in that any possible query plan could have, because we can change the order of any of these operators and the data will still flow through them correctly.
Điều đó cho phép chúng ta ghép các kế hoạch truy vấn, tức là bất kỳ kế hoạch truy vấn nào có thể có, vì ta có thể thay đổi thứ tự của các toán tử này mà dữ liệu vẫn chảy qua chúng một cách đúng đắn.
Now, if we change the order of operators, they might produce an incorrect query. The results might be wrong, but that's a separate issue we'll cover next class.
Tuy nhiên, nếu đổi thứ tự các toán tử, chúng có thể tạo ra một truy vấn sai. Kết quả có thể sai, nhưng đó là vấn đề khác mà chúng ta sẽ học ở buổi sau.
But it's really, again, I have these implementation operators, implementations for these operators, and I can move them around.
Nhưng điểm chính là, tôi có các cài đặt cho những toán tử này, và tôi có thể sắp xếp chúng lại.
And I end up with a query plan that produces the final result at the top that we send back to the application.
Và tôi có được một kế hoạch truy vấn tạo ra kết quả cuối cùng ở trên cùng mà chúng ta gửi trả lại cho ứng dụng.
So there was a brief question last class about what if I have multiple threads or workers processing the query at the same time?
Vậy là ở buổi trước có một câu hỏi ngắn về việc nếu có nhiều luồng hoặc worker cùng xử lý truy vấn một lúc thì sao?
And I sort of punted on that and said, that's not what we want to talk about just yet, because you basically don't understand how we execute queries at a high level.
Và tôi đã tạm gác chuyện đó lại và nói rằng, đó chưa phải điều chúng ta muốn bàn lúc này, vì về cơ bản các bạn chưa hiểu cách chúng ta thực thi truy vấn ở mức tổng quan.
So that's what today's class is about.
Đó chính là nội dung của buổi học hôm nay.
Today's class is to say, how do I take one of these query plans and now break it up across multiple workers so that I can run things in parallel?
Hôm nay ta sẽ xem làm thế nào để lấy một kế hoạch truy vấn như thế này và chia nhỏ nó ra cho nhiều worker để có thể chạy song song các phần?
And this also then segues for us into, at the end of the semester, when we talk about distributed queries, running across multiple machines.
Và điều này cũng dẫn chúng ta tới phần cuối học kỳ, khi bàn về các truy vấn phân tán, chạy trên nhiều máy.
Today we're talking about running on a single machine, but the same techniques and same concepts, same ideas that we're going to do today for doing parallel execution on a single box will still apply when we start scaling out across multiple machines.
Hôm nay chúng ta nói về chạy trên một máy duy nhất, nhưng các kỹ thuật, khái niệm và ý tưởng mà hôm nay ta dùng để thực thi song song trên một máy đơn lẻ vẫn sẽ áp dụng được khi ta mở rộng ra nhiều máy.
So the basic idea of parallel query execution is that we're going to have our database, The physical database itself will be split across multiple resources.
Ý tưởng cơ bản của thực thi truy vấn song song là ta sẽ có cơ sở dữ liệu của mình, cơ sở dữ liệu vật lý này sẽ được chia ra trên nhiều tài nguyên.
And I'm not really defining what a resource is yet. It could be physical machines, it could be different disks, it could be different regions of memory running on a single box.
Và tôi chưa định nghĩa cụ thể tài nguyên là gì. Đó có thể là các máy vật lý, các ổ đĩa khác nhau, hoặc các vùng bộ nhớ khác nhau trên cùng một máy.
But it doesn't matter just yet.
Nhưng hiện giờ điều đó chưa quan trọng.
And so the idea is that we want to be able to handle databases that are too big for a single CPU core or a single disk or a single region of memory or a single machine.
Ý tưởng là ta muốn xử lý được những cơ sở dữ liệu quá lớn đối với một lõi CPU, một ổ đĩa, một vùng bộ nhớ hay một máy duy nhất.
And we want to be able to scale things out and scale things up so that we can get better performance, and in some cases we'll get better fault tolerance and redundancy, because now the database can be replicated across multiple machines or multiple disks.
Và ta muốn có thể mở rộng quy mô theo chiều ngang và theo chiều dọc để đạt hiệu năng tốt hơn, và trong một số trường hợp còn có khả năng chịu lỗi và dự phòng tốt hơn, vì lúc này cơ sở dữ liệu có thể được sao chép trên nhiều máy hoặc nhiều ổ đĩa.
And so if one of those machines goes down, then we have a backup.
Nên nếu một trong các máy đó hỏng thì ta vẫn có bản dự phòng.
Of course, if you treat, like, you know, the critical infrastructure is running off DynamoDB and DynamoDB goes down, then, you know, you could have redundant systems outside of AWS to avoid that problem.
Tất nhiên, nếu bạn coi như là, hạ tầng trọng yếu chạy trên DynamoDB và DynamoDB sập, thì bạn có thể đặt các hệ thống dự phòng bên ngoài AWS để tránh vấn đề đó.
But most people don't do that because it's expensive and it's hard. Right.
Nhưng hầu hết mọi người không làm vậy vì nó tốn kém và khó khăn.
But the key thing to understand, and this is going to go back to what we talked about at the beginning of the semester when we talked about SQL being this declarative language where I'm not defining exactly how I want to physically execute my query.
Nhưng điều then chốt cần hiểu, và nó quay lại với những gì ta đã nói ở đầu học kỳ khi nói về việc SQL là một ngôn ngữ khai báo mà ở đó tôi không định nghĩa chính xác cách thực thi truy vấn về mặt vật lý.
The great thing about having a declarative SQL is that the same query that I would write running for a database running on a single machine or a single disk or a single CPU or whatever, that same query in theory should work if I then scale it up across multiple cores, multiple CPUs or across multiple disks or multiple machines.
Điểm hay của SQL khai báo là cùng một truy vấn mà tôi viết cho cơ sở dữ liệu chạy trên một máy hay một ổ đĩa, một CPU hay bất cứ thứ gì, về lý thuyết vẫn chạy được khi tôi mở rộng ra nhiều lõi, nhiều CPU, nhiều ổ đĩa hoặc nhiều máy.
Right. We don't have to define, like, send data here, send data there. Right.
Ta không phải quy định kiểu như gửi dữ liệu đến đây, gửi dữ liệu đến kia.
In our query plan, or sorry, in our query, the query plan that we generated from our SQL query will define those steps for us.
Trong kế hoạch truy vấn của ta, à xin lỗi, trong truy vấn của ta, kế hoạch truy vấn được sinh ra từ câu truy vấn SQL sẽ xác định các bước đó cho ta.
So it abstracts it all away and we still get the benefit of improving the system.
Vì vậy nó trừu tượng hóa tất cả những điều đó và chúng ta vẫn được hưởng lợi từ việc cải thiện hệ thống.
So a very common setup is going to be, like, you as a developer, when you're building your application, you'll have a little test database, maybe running SQLite or Postgres locally on your laptop.
Một thiết lập rất phổ biến là, chẳng hạn, bạn là một lập trình viên, khi bạn đang xây dựng ứng dụng của mình, bạn sẽ có một cơ sở dữ liệu thử nghiệm nhỏ, có thể chạy SQLite hoặc Postgres ngay trên laptop của bạn.
But then when you want to run on, and you would write SQL queries against that.
Nhưng rồi khi bạn muốn chạy trên, và bạn sẽ viết các truy vấn SQL trên đó.
And ideally what you want to have is, when you then push your code into production, now the database may be this behemoth distributed system or running on a much larger machine than your laptop.
Và điều lý tưởng là, khi bạn đưa mã của mình lên môi trường production, thì cơ sở dữ liệu lúc đó có thể là một hệ phân tán khổng lồ hoặc chạy trên một máy lớn hơn nhiều so với laptop của bạn.
And my same SQL query will still work in that production environment. Right?
Và cùng câu truy vấn SQL đó của tôi vẫn chạy được trong môi trường production. Đúng không?
Because again, from our perspective, when we're writing SQL queries and the application is writing SQL queries, it sees a single logical database, doesn't know that it may be physically broken up into different pieces.
Bởi vì, một lần nữa, từ góc nhìn của chúng ta, khi chúng ta viết các truy vấn SQL và ứng dụng viết các truy vấn SQL, nó thấy một cơ sở dữ liệu logic duy nhất, và không biết rằng về mặt vật lý nó có thể được chia thành nhiều phần khác nhau.
So the thing we want to talk about today, today's class, we really focus on what we call a parallel database, where this is where these resources that we have, again, where this computational resources, memory or storage, that they're gonna be physically close to each other.
Vậy điều chúng ta muốn nói hôm nay, trong buổi học hôm nay, chúng ta thực sự tập trung vào cái gọi là cơ sở dữ liệu song song, trong đó các tài nguyên mà chúng ta có, một lần nữa, tức là các tài nguyên tính toán, bộ nhớ hoặc lưu trữ, nằm gần nhau về mặt vật lý.
And for today's class, just assume it's running on the same machine, the same box, the same unit in a rack. Right?
Và với buổi học hôm nay, cứ giả định nó chạy trên cùng một máy, cùng một thùng máy, cùng một đơn vị trong một rack. Đúng không?
And so that means that the communication between our different resources is gonna be really, really fast, like reading things from memory or reading things from different disks that are on the same PCI Express bus or whatever.
Và điều đó có nghĩa là giao tiếp giữa các tài nguyên khác nhau của chúng ta sẽ rất, rất nhanh, chẳng hạn như đọc dữ liệu từ bộ nhớ hoặc đọc từ các ổ đĩa khác nhau nằm trên cùng một bus PCI Express hay gì đó tương tự.
Right? And that this communication be fast and it's gonna be reliable and cheap for us to do.
Đúng không? Và giao tiếp này nhanh, đáng tin cậy và chi phí thực hiện rẻ.
It's reliable, meaning, like, if I go try to read something from disk, unless the disk is burning down and there's, you know, it's on fire and I can't do anything.
Đáng tin cậy nghĩa là, nếu tôi thử đọc một thứ gì đó từ đĩa, trừ khi ổ đĩa đang cháy rụi và, bạn biết đấy, nó bốc cháy và tôi không làm gì được.
Right? When I send a message or try to get some data, I expect to get that data back. Right.
Đúng không? Khi tôi gửi một thông điệp hoặc cố lấy một số dữ liệu, tôi kỳ vọng sẽ nhận lại được dữ liệu đó. Đúng.
In a distributed system, this again, we'll cover this at the end of the semester, but this will be when the resources in our database system are not assumed to be physically close to each other, like different racks in the same data center, different availability zones or regions, or different data centers in different parts of the country or different parts of the world.
Còn trong một hệ phân tán, phần này chúng ta sẽ học vào cuối học kỳ, là khi các tài nguyên trong hệ cơ sở dữ liệu của chúng ta không được giả định là nằm gần nhau về mặt vật lý, như các rack khác nhau trong cùng một trung tâm dữ liệu, các vùng khả dụng hoặc khu vực khác nhau, hoặc các trung tâm dữ liệu khác nhau ở những nơi khác nhau trong nước hoặc trên thế giới.
Worst case scenario, data centers running in space. Right. That was NVIDIA's announcement yesterday or today. Star Cloud, they want to put GPUs up in space now. Right.
Trường hợp xấu nhất là các trung tâm dữ liệu chạy ngoài không gian. Đúng vậy. Đó là thông báo của NVIDIA hôm qua hoặc hôm nay. Star Cloud, họ giờ muốn đưa GPU lên không gian. Đúng vậy.
So now the latency between sending, you know, sending between different machines, one's in space and one's back here on Earth. Right. That's gonna be super high and it's not guaranteed to be reliable.
Vậy thì độ trễ khi gửi, bạn biết đấy, khi gửi giữa các máy khác nhau, một máy ở ngoài không gian và một máy ở đây trên Trái Đất. Đúng. Độ trễ đó sẽ rất cao và không được đảm bảo là đáng tin cậy.
And so in our database system, we're gonna have to account for the fact that, you know, any message we send or data we try to retrieve may not actually arrive or show up.
Và vì vậy trong hệ cơ sở dữ liệu của mình, chúng ta sẽ phải tính đến việc bất kỳ thông điệp nào chúng ta gửi hoặc dữ liệu nào chúng ta cố truy xuất đều có thể thực sự đến nơi hoặc xuất hiện.
And therefore, our system has to account for that. In today's class, we're not going to worry about it.
Vì vậy, hệ thống của chúng ta phải tính đến điều đó. Trong buổi học hôm nay, chúng ta sẽ không lo về chuyện này.
We're going to assume that we can read and write to different workers and they're guaranteed to get that message. Right. It makes our lives a lot easier. All right.
Chúng ta sẽ giả định rằng mình có thể đọc và ghi tới các worker khác nhau và chúng chắc chắn sẽ nhận được thông điệp đó. Như vậy mọi việc dễ dàng hơn nhiều. Được rồi.
So beginning, we're going to talk about different process models. These are going to be the way you sort of architect the system itself to have different workers and run in parallel.
Đầu tiên, chúng ta sẽ nói về các mô hình tiến trình khác nhau. Đây là cách bạn thiết kế kiến trúc cho chính hệ thống để có nhiều worker khác nhau và chạy song song.
And then we'll talk about the different types of parallelism you could have within a query plan or across query plans. And then we'll finish up talking about how to get parallelism with I/O.
Sau đó chúng ta sẽ nói về các loại song song hóa mà bạn có thể có bên trong một kế hoạch truy vấn hoặc giữa nhiều kế hoạch truy vấn. Và cuối cùng, chúng ta sẽ nói về cách đạt được song song hóa với I/O.
We saw a little bit of this in project one when you built sort of asynchronous buffer pool or the disk manager. But we can see how now we can parallelize this even further.
Chúng ta đã thấy một chút về điều này trong project một khi các bạn xây dựng buffer pool bất đồng bộ hoặc disk manager. Nhưng giờ chúng ta sẽ thấy có thể song song hóa điều này hơn nữa.
And then we'll finish up with a flash talk from the SpiralDB guy who's gonna talk about the Vortex file format. The same speaker that gave a seminar talk with us last semester.
Và chúng ta sẽ kết thúc bằng một buổi nói chuyện chớp nhoáng của anh chàng ở SpiralDB, người sẽ nói về định dạng tệp Vortex. Cũng là diễn giả đã có buổi hội thảo với chúng ta học kỳ trước.
But if you didn't, sorry, last week, if you missed that, this will be a condensed version of that. All right.
Nhưng nếu các bạn không tham dự, xin lỗi, tuần trước, nếu bạn bỏ lỡ, thì đây sẽ là phiên bản cô đọng của buổi đó. Được rồi.
So as I said, the process model is going to be, essentially, the definition of the way in which we've built our database system to allow for concurrent requests, or concurrent operations, or concurrent queries across multiple workers.
Như tôi đã nói, mô hình tiến trình về cơ bản sẽ là định nghĩa về cách chúng ta xây dựng hệ thống cơ sở dữ liệu để cho phép các yêu cầu đồng thời, hay các thao tác đồng thời, hay các truy vấn đồng thời trên nhiều worker.
And the worker is going to be this computational unit of our database system that is going to be able to execute tasks on behalf of the higher-level manager of the system.
Worker là đơn vị tính toán của hệ thống cơ sở dữ liệu có thể thực thi các tác vụ thay mặt cho trình quản lý cấp cao hơn của hệ thống.
And they know how to do whatever it is that request is being asked for, and then return results to whoever asked for it.
Và chúng biết cách làm bất cứ điều gì mà yêu cầu đó đòi hỏi, rồi trả kết quả cho bên đã yêu cầu.
So you can just think of this like it's a bunch of workers that could execute queries for you, but the workers also could be doing internal maintenance tasks that are sort of running in the background to maintain whatever it is you need in the system.
Bạn có thể hình dung như một nhóm worker có thể thực thi truy vấn cho bạn, nhưng các worker cũng có thể làm các tác vụ bảo trì nội bộ chạy ngầm ở chế độ nền để duy trì bất cứ thứ gì bạn cần trong hệ thống.
We saw this before when we talked about the log-structured storage.
Chúng ta đã thấy điều này khi nói về lưu trữ log-structured.
We said there was this compaction thread, or compaction thing, that then runs in the background and starts coalescing up the SSTables and combining them into new ones. Right. That would be a background worker.
Chúng ta nói có một compaction thread, hay một thứ làm compaction, chạy ngầm và bắt đầu gộp các SSTable lại và kết hợp chúng thành các SSTable mới. Đúng vậy. Đó sẽ là một worker chạy nền.
But it's still, the worker still is a computational unit that the database system has to reason about and understand when it wants to start scheduling tasks.
Nhưng worker vẫn là một đơn vị tính toán mà hệ thống cơ sở dữ liệu phải xem xét và hiểu rõ khi muốn bắt đầu lập lịch các tác vụ.
But for this class, we just assume that we'll be executing queries with workers.
Nhưng trong lớp này, chúng ta chỉ giả định rằng sẽ thực thi truy vấn bằng các worker.
And the reason why I'm saying workers and not saying threads, although sometimes I'll slip up and say threads, right, because there's different implementations of these process models that can have different computational units for workers.
Và lý do tôi nói worker chứ không nói thread, dù đôi khi tôi lỡ miệng nói thread, là vì có nhiều cách triển khai khác nhau của các mô hình tiến trình này có thể dùng các đơn vị tính toán khác nhau làm worker.
The two most common ones is have one worker per process, like an OS process, and one worker per thread.
Hai cách phổ biến nhất là một worker cho mỗi tiến trình, tức tiến trình của hệ điều hành, và một worker cho mỗi thread.
Most systems are going to, the most modern systems are going to implement the second one, not the first one, but we'll see why people did the first one.
Hầu hết các hệ thống sẽ, các hệ thống hiện đại nhất sẽ cài đặt cách thứ hai, chứ không phải cách đầu tiên, nhưng chúng ta sẽ xem vì sao người ta từng làm cách đầu tiên.
Postgres does the first one.
Postgres làm theo cách đầu tiên.
And then it's not exactly a process model, but it's sort of, it is a design decision or design approach for building a data system, is to do what is called an embedded system, where now the data system is not responsible for getting workers from, like, the OS or whatever.
Và còn một cách không hẳn là mô hình tiến trình, nhưng đại loại là, đó là một quyết định thiết kế hay một hướng tiếp cận để xây dựng một hệ thống dữ liệu, là làm cái gọi là hệ thống nhúng (embedded system), trong đó hệ thống dữ liệu không còn chịu trách nhiệm lấy các worker từ, chẳng hạn, hệ điều hành hay đâu đó nữa.
The application that's going to be invoking the data system hands off the workers to the system to run. Right. So this middle one here is most common.
Ứng dụng gọi hệ thống dữ liệu sẽ giao các worker cho hệ thống để chạy. Đúng rồi. Vậy cách ở giữa này là phổ biến nhất.
The second one, sorry, the third one, it will be, or we'll say it's like a SQLite or embedded data systems we'll talk about. And this top one is mostly for, like, the older systems.
Cách thứ hai, xin lỗi, cách thứ ba, sẽ là, hay có thể nói là giống SQLite hoặc các hệ thống dữ liệu nhúng mà chúng ta sẽ nói đến. Còn cách ở trên cùng này chủ yếu dành cho các hệ thống cũ hơn.
The enterprise systems, for historical reasons, do this. Again, we'll go each of these one by one. So the first one, the first process model approach is called process per worker.
Các hệ thống doanh nghiệp làm như vậy vì lý do lịch sử. Một lần nữa, chúng ta sẽ đi qua từng cách một. Cách đầu tiên, cách tiếp cận mô hình tiến trình đầu tiên, gọi là mỗi worker một tiến trình (process per worker).
And the basic idea is that for every single worker that I have in my system, it's going to be its own standalone OS process.
Ý tưởng cơ bản là với mỗi worker trong hệ thống của tôi, nó sẽ là một tiến trình hệ điều hành độc lập.
Like, I've got to call fork on the OS, or exec, whatever it is, to start a new process.
Tức là tôi phải gọi fork trên hệ điều hành, hoặc exec, hay gì đó, để khởi động một tiến trình mới.
And that's going to have its own address space for its code, own address space for memory.
Và tiến trình đó sẽ có không gian địa chỉ riêng cho mã của nó, và không gian địa chỉ riêng cho bộ nhớ.
And it's going to rely on an operating system construct like, you know, like fork to then dispatch these different workers.
Nó sẽ dựa vào một cấu trúc của hệ điều hành như, bạn biết đấy, như fork để điều phối các worker khác nhau này.
And then in some cases also be responsible for scheduling them, because I don't have sort of fine-grained control over what my workers are going to execute or not.
Và trong một số trường hợp còn chịu trách nhiệm lập lịch cho chúng, vì tôi không có quyền kiểm soát chi tiết việc worker nào sẽ thực thi hay không.
The OS is going to handle that, because it just sees a bunch of processes and runs it for you.
Hệ điều hành sẽ lo việc đó, vì nó chỉ thấy một loạt tiến trình và chạy chúng cho bạn.
You can play games about, like, going to sleep and things like that, but it's, that's a bit more work.
Bạn có thể bày trò như cho chúng ngủ và những việc tương tự, nhưng như vậy tốn công hơn một chút.
So the basic idea is that you're, the application doesn't know that there's a bunch of workers, a bunch of processes. It just communicates with whatever this front end dispatcher is. Right?
Vậy ý tưởng cơ bản là, ứng dụng không biết có một loạt worker, một loạt tiến trình ở đó. Nó chỉ giao tiếp với bộ điều phối ở phía trước này. Đúng không?
In Postgres, this is called the Postmaster. If you ever run Postgres on your laptop, you'll see a bunch of processes, one will be called the Postmaster.
Trong Postgres, nó được gọi là Postmaster. Nếu bạn từng chạy Postgres trên laptop, bạn sẽ thấy một loạt tiến trình, trong đó có một cái tên là Postmaster.
That's the front end thing that everyone connects to when you want to connect to the database system. Right. And then the dispatcher says, OK, well, I have a new connection coming in.
Đó là thành phần phía trước mà mọi người kết nối tới khi muốn kết nối với hệ thống cơ sở dữ liệu. Đúng. Rồi bộ điều phối nói: được, tôi có một kết nối mới đến.
They want to do some queries. Let me pick one of my workers in my process pool that I know about.
Họ muốn thực hiện vài truy vấn. Để tôi chọn một worker trong nhóm tiến trình mà tôi quản lý.
I hand back that information to the application and say, here's an IP address or port number for some worker you can go talk to.
Tôi trả thông tin đó lại cho ứng dụng và nói: đây là địa chỉ IP hoặc số cổng của một worker mà bạn có thể đến trao đổi.
And then now the application reconnects to the worker, and it can send SQL commands and have that worker execute things for you.
Và bây giờ ứng dụng kết nối lại với worker đó, rồi có thể gửi các lệnh SQL và để worker đó thực thi giúp bạn.
And the workers can still communicate with each other, when we talk about different types of parallelism in a second.
Và các worker vẫn có thể giao tiếp với nhau, khi chúng ta nói về các kiểu song song khác nhau trong giây lát.
But they have to do this through either shared memory or, worst case scenario, IPC, or inter-process communication, things like pipes and signals, to send data between or communicate between them.
Nhưng chúng phải làm việc này thông qua bộ nhớ dùng chung hoặc, trong trường hợp xấu nhất là IPC, tức giao tiếp liên tiến trình, như pipe và signal, để gửi dữ liệu hoặc giao tiếp với nhau.
In the case of Postgres, they use shared memory. Different systems do different things. Right. So this is how people built parallel database systems in the old days, like the 80s and the 90s.
Với Postgres, họ dùng bộ nhớ dùng chung. Mỗi hệ thống làm một kiểu khác nhau. Đúng không. Vậy đây là cách người ta xây dựng các hệ cơ sở dữ liệu song song ngày xưa, tức là những năm 80 và 90.
I want you to take a guess why they did this instead of threads. All right. In Linux now, when you create a thread, you spawn a thread, what are you actually calling?
Các em thử đoán xem vì sao họ làm vậy thay vì dùng thread. Nào. Trong Linux bây giờ, khi bạn tạo một thread, khi bạn sinh ra một thread, thực chất bạn đang gọi hàm gì?
What do you get? Like pthread_create, right? Right. What is, what does the P in pthread mean? POSIX, right? So the POSIX API in our Unix and Linux.
Các em có gì? Như pthread_create, đúng không? Chữ P trong pthread nghĩa là gì? POSIX, đúng không? Tức là API POSIX trong Unix và Linux của chúng ta.
That's been standardized for threads, probably late 90s, right? Mid 90s, right? Before some of you guys were even born. Prior to that, all the different versions of Unix that were out there, right?
API đó được chuẩn hóa cho thread khoảng cuối những năm 90, hay giữa những năm 90 nhỉ? Trước cả khi một số em ra đời. Trước đó, có đủ các phiên bản Unix khác nhau, đúng không?
Like before Linux was the dominant one. But there was, you know, it was BSD. There was HPUX, there was AIX, there was Solaris. All these different Unices had their own threading packages.
Như trước khi Linux trở thành hệ thống thống trị. Thì có BSD. Có HPUX, có AIX, có Solaris. Tất cả các Unix đó đều có gói thread riêng của mình.
And so it had slightly different APIs or different semantics of what it means to have a thread.
Vì vậy API của chúng khác nhau đôi chút hoặc ngữ nghĩa của việc có một thread cũng khác nhau.
So if you wanted to support multithreading on different Unices, you had to basically rewrite your thread scheduler and thread implementation across all the different libraries.
Nên nếu muốn hỗ trợ đa luồng trên các Unix khác nhau, về cơ bản bạn phải viết lại bộ lập lịch thread và phần cài đặt thread trên tất cả các thư viện khác nhau.
And they made the code less portable, whereas POSIX had basically fork, close, wait, join, had basic commands to fork processes.
Điều đó làm mã kém khả chuyển, trong khi POSIX về cơ bản có fork, close, wait, join, có các lệnh cơ bản để fork tiến trình.
So therefore, all the data systems from the 70s, most of the 80s and early 90s, they're all going to be doing this approach because at least that was standardized across different systems.
Vì vậy, tất cả các hệ dữ liệu từ thập niên 70, phần lớn thập niên 80 và đầu thập niên 90 đều dùng cách tiếp cận này, vì ít nhất nó được chuẩn hóa trên các hệ thống khác nhau.
If you ever look at the Postgres code, the Postgres code has a bunch of pound, you know, pound defines or ifdefs based on what version of Unix you're running on.
Nếu các em từng xem mã nguồn Postgres, mã Postgres có cả đống pound, tức #define hay #ifdef tùy theo phiên bản Unix bạn đang chạy.
And they make different calls for, you know, different OS commands. But at the end of the day, an OS process on Linux is basically performed the same way it does on AIX.
Và họ gọi các lệnh hệ điều hành khác nhau cho từng loại. Nhưng rốt cuộc, một tiến trình hệ điều hành trên Linux về cơ bản hoạt động giống như trên AIX.
So you have basically the same semantics across all these things. So any system that's a fork of Postgres, which I'm trying to think if there's anybody that's done this.
Vậy là về cơ bản bạn có cùng ngữ nghĩa trên tất cả những hệ này. Vì thế, bất kỳ hệ thống nào là bản fork của Postgres, mà tôi đang nghĩ xem có ai đã làm vậy chưa.
You know, pretty much anybody that is a system today that's a fork of Postgres is going to be using this because Postgres uses this.
Thì hầu như bất kỳ hệ thống nào hiện nay là bản fork của Postgres đều sẽ dùng cách này vì Postgres dùng cách này.
And it'd be a major rewrite to strip out the threading stuff and replace it with, sorry, strip out the process stuff and replace it with threading. Right.
Và sẽ phải viết lại lớn để loại bỏ phần thread và thay bằng, xin lỗi, loại bỏ phần tiến trình và thay bằng thread. Đúng không.
The modern approach is to do, as one would expect today, using a single process with multiple threads. Right. They just call it spawning pthread or whatever the Windows 32 create thread is.
Cách tiếp cận hiện đại, như người ta mong đợi ngày nay, là dùng một tiến trình duy nhất với nhiều thread. Đúng không. Họ chỉ gọi là sinh pthread hoặc hàm create thread của Windows 32, tùy hệ.
Right. And now all your worker threads are running in the same address space.
Đúng vậy. Và giờ tất cả các worker thread của bạn chạy trong cùng một không gian địa chỉ.
It's easy for them to communicate with each other because it's all just, they're in, you know, they can read and write memory to each other.
Chúng dễ dàng giao tiếp với nhau vì tất cả chúng đều ở trong, bạn biết đấy, chúng có thể đọc và ghi vào bộ nhớ của nhau.
You still have to use latching, all the stuff we talked about before, because they're shared data structures and you don't want the different threads breaking, you know, causing problems with each other.
Bạn vẫn phải dùng latching, tất cả những thứ chúng ta đã nói trước đây, vì đây là các cấu trúc dữ liệu dùng chung và bạn không muốn các luồng khác nhau làm hỏng, bạn biết đấy, gây ra vấn đề cho nhau.
But the basic setup is still the same. Right.
Nhưng cách thiết lập cơ bản vẫn như cũ. Đúng vậy.
The application sends something to a dispatcher, and either the dispatcher can just forward the request directly to these many worker threads, or in some cases, to remove the bottleneck of having to go through a centralized dispatcher, you can still do the same thing we did before, where having the dispatcher sends back to the application, hey, here's a port number where you can communicate to a worker that's dedicated to you to run queries, queries for you.
Ứng dụng gửi một yêu cầu đến dispatcher, và dispatcher có thể chuyển tiếp yêu cầu đó trực tiếp đến một trong nhiều worker thread này, hoặc trong một số trường hợp, để loại bỏ nút thắt cổ chai khi phải đi qua một dispatcher tập trung, bạn vẫn có thể làm giống như trước đây, khi dispatcher gửi lại cho ứng dụng, này, đây là số cổng để bạn giao tiếp với một worker dành riêng cho bạn để chạy các truy vấn của bạn.
And then the application is reconnected and does that. But the key thing is that all the dispatcher, the worker threads, all this is running in the same process.
Sau đó ứng dụng kết nối lại và làm như vậy. Nhưng điểm mấu chốt là dispatcher, các worker thread, tất cả đều chạy trong cùng một tiến trình.
So your question is, when I say that it's using zone scheduling, that you're not, you could be using a thread pool and not calling pthread create?
Câu hỏi của bạn là, khi tôi nói nó dùng lập lịch theo vùng, thì bạn không, bạn có thể dùng một thread pool mà không gọi pthread create?
Yeah, statement is, would I be calling pthread create every time a new command comes in? No, you would have a thread pool.
Vâng, ý của câu hỏi là, liệu tôi có gọi pthread create mỗi khi có một lệnh mới đến không? Không, bạn sẽ có một thread pool.
But then you can still now, you still can do this on a process level, but it's a little bit more difficult.
Nhưng bạn vẫn có thể làm điều này ở mức tiến trình, chỉ là khó hơn một chút.
But like, and most of the process, the process model systems don't do their own scheduling.
Nhưng mà, và hầu hết các hệ thống theo mô hình tiến trình không tự lập lịch.
Now that I have my own threads, I can do like my own non-preemptive threading, have Them yield and go back to a thread scheduler to decide what to run next, basically using coroutines.
Giờ khi đã có các luồng riêng, tôi có thể tự làm đa luồng không có quyền chiếm, cho chúng nhường quyền và quay lại bộ lập lịch luồng để quyết định chạy cái nào tiếp theo, về cơ bản là dùng coroutine.
You could have, you know, it's easier to pause a thread, right? And then versus, like, pausing a process, it's more heavyweight, right?
Bạn biết đấy, tạm dừng một luồng dễ hơn, đúng không? So với việc tạm dừng một tiến trình, vốn nặng nề hơn, đúng không?
It's just, it's more, it's a more lightweight, it's more lightweight and easier to have complete control of what the threads are doing than you would in the process model.
Nó nhẹ hơn, nhẹ hơn và dễ hơn để kiểm soát hoàn toàn các luồng đang làm gì so với mô hình tiến trình.
Now, you can do it with processes, sure, but it's just, it's more machinery because you're kind of fighting the OS. Yes.
Tất nhiên, bạn vẫn có thể làm với tiến trình, nhưng cần nhiều cơ chế hơn vì bạn phải chống lại hệ điều hành. Vâng.
And this question is, in these examples, am I assuming the database is one node? This lecture today, we're assuming the database system is on one node, right?
Và câu hỏi này là, trong các ví dụ này, tôi có giả định cơ sở dữ liệu chỉ có một nút không? Bài giảng hôm nay giả định hệ cơ sở dữ liệu nằm trên một nút, đúng vậy.
So we're jumping ahead, but in a distributed system, you could still have, you know, either process per worker or thread per worker.
Nên chúng ta đang nhảy cóc, nhưng trong một hệ phân tán, bạn vẫn có thể dùng một tiến trình cho mỗi worker hoặc một luồng cho mỗi worker.
But now every node is running their own, you know, set of threads, a set of workers, right? For our purposes here, you know, this is just some disk file, whatever.
Nhưng giờ mỗi nút chạy một tập các luồng, một tập các worker của riêng nó. Với mục đích của chúng ta ở đây, đây chỉ là một tệp trên đĩa, gì cũng được.
It's all the same.
Tất cả đều như nhau.
It's not, we'll get there.
Chúng ta sẽ nói tới phần đó sau.
But it's basically saying, am I saying this is a parallel database because I have a bunch of worker threads? Yes, but we don't, we haven't defined what the worker threads are doing per query.
Nhưng về cơ bản nó đang nói rằng, liệu tôi có đang nói đây là một cơ sở dữ liệu song song vì tôi có một loạt luồng worker không? Có, nhưng chúng ta chưa định nghĩa các luồng worker đang làm gì cho mỗi truy vấn.
I'm just showing lines coming in. Like, are they all executing the same query, or is it one query per thread, right? Like, a few more slides, we'll get there.
Tôi chỉ đang vẽ các đường đi vào. Ví dụ, có phải tất cả chúng đều thực thi cùng một truy vấn, hay là mỗi luồng một truy vấn, đúng không? Vài slide nữa là chúng ta sẽ đến phần đó.
So Oracle started off doing the process per model, process model, process per worker back in the 80s or 70s where they started.
Oracle ban đầu dùng mô hình tiến trình, mô hình process, mỗi worker một tiến trình, từ những năm 80 hoặc 70 khi họ mới bắt đầu.
And then in 2014, they switched over to now by default, they'll run with multi-threading, right?
Rồi đến năm 2014, họ chuyển sang mặc định là chạy với đa luồng, đúng không?
And again, every newer system today would use this approach is because the threading libraries are so standardized and everyone's running off Linux anyway, so everything works. All right.
Và một lần nữa, mọi hệ thống mới ngày nay đều dùng cách này vì các thư viện luồng đã được chuẩn hóa rất tốt và dù sao ai cũng chạy trên Linux, nên mọi thứ đều hoạt động. Được rồi.
So this is not exactly a process model where you have these thinking out in terms of, like, Threads versus processes.
Vậy đây không hẳn là mô hình tiến trình mà bạn nghĩ theo kiểu, luồng so với tiến trình.
This is just a different approach, but it's very common where the database system is not responsible for calling pthread create or forking a process.
Đây chỉ là một cách tiếp cận khác, nhưng rất phổ biến, trong đó hệ quản trị cơ sở dữ liệu không chịu trách nhiệm gọi pthread create hay fork một tiến trình.
Any computational unit or computational worker has to be given to it from an application that's going to embed the database system. Right.
Bất kỳ đơn vị tính toán hay worker tính toán nào đều phải được cấp từ một ứng dụng nhúng hệ quản trị cơ sở dữ liệu đó. Đúng không.
So I know if you're a player like SQLite, DuckDB, like when you, when you like open up a DuckDB from the command line, it opens up a DuckDB database, like the DuckDB command line, that is the application.
Ví dụ với SQLite, DuckDB, khi bạn mở DuckDB từ dòng lệnh, nó mở một cơ sở dữ liệu DuckDB, thì dòng lệnh DuckDB đó chính là ứng dụng.
Right. And then it's making calls to the library to do things in the database system. But like in the case of something like SQLite, I would embed the SQLite library in my application.
Đúng không. Và nó gọi vào thư viện để thực hiện các việc trong hệ quản trị cơ sở dữ liệu. Còn với trường hợp như SQLite, tôi sẽ nhúng thư viện SQLite vào ứng dụng của mình.
Now the application is going to have its own threads to do whatever it wants to do. Right.
Khi đó ứng dụng sẽ có các luồng riêng để làm bất cứ việc gì nó muốn. Đúng không.
Think of like a web server where requests are coming in, but the database server is not on a separate machine.
Hãy nghĩ đến một web server nhận các yêu cầu gửi tới, nhưng máy chủ cơ sở dữ liệu không nằm trên một máy riêng.
It's just running as a SQLite program in the same address space as the application.
Nó chỉ chạy như một chương trình SQLite trong cùng không gian địa chỉ với ứng dụng.
So when requests come along, the application has, you know, one its own thread or worker saying, I want to read this data from the database, and then it makes a request to the database.
Vậy khi có yêu cầu đến, ứng dụng có một luồng hay worker của riêng nó nói rằng, tôi muốn đọc dữ liệu này từ cơ sở dữ liệu, và rồi nó gửi một yêu cầu đến cơ sở dữ liệu.
Then that's a library call. Well, now that thread is going into the SQLite library or whatever the embedded database system library.
Đó là một lời gọi thư viện. Lúc này luồng đó đi vào thư viện SQLite hoặc bất kỳ thư viện hệ quản trị cơ sở dữ liệu nhúng nào.
And then that is the worker that's going to then read and write data from the database itself.
Và đó chính là worker sẽ đọc và ghi dữ liệu của chính cơ sở dữ liệu.
And then when it gets a result, then it gives back, you know, the thread goes back up the stack to the application calling it.
Rồi khi nhận được kết quả, nó trả lại, luồng đó quay ngược lên ngăn xếp về phía ứng dụng đã gọi nó.
And now the database system doesn't have a notion of a worker, doesn't have a bunch of pool of workers that it can call upon.
Và bây giờ hệ quản trị cơ sở dữ liệu không có khái niệm về worker, không có một nhóm worker nào để nó có thể gọi đến.
Right. It only is given workers when the application goes inside of it. Right. BerkeleyDB was one of the first systems to do this.
Đúng không. Nó chỉ được cấp worker khi ứng dụng đi vào bên trong nó. Đúng vậy. BerkeleyDB là một trong những hệ thống đầu tiên làm như vậy.
That obviously came out of UC Berkeley and Oracle bought that in the 2000, 2006.
Hệ thống đó rõ ràng xuất phát từ UC Berkeley, và Oracle đã mua lại vào khoảng năm 2006.
But like RocksDB, LevelDB, all these other systems on the side here, they essentially work the same way where they don't have their own notion of threads or workers.
Nhưng như RocksDB, LevelDB, và tất cả các hệ thống khác ở bên này, về cơ bản chúng hoạt động theo cùng một cách, tức là chúng không có khái niệm riêng về thread hay worker.
They can only be given workers when the application calls inside of it. In that case, in DuckDB, you can tell it to spawn its own threads as well.
Chúng chỉ được cấp worker khi ứng dụng gọi vào bên trong chúng. Với DuckDB thì bạn có thể bảo nó tự tạo các thread của riêng nó.
But like that's, you know, so it's not exactly in the way I'm describing here. But this is what, basically, SQLite works. Like, SQLite doesn't have background workers.
Nên nó không hẳn giống như cách tôi đang mô tả ở đây. Nhưng về cơ bản, đây là cách SQLite hoạt động. SQLite không có các worker chạy nền.
The only workers it has is the ones that the application uses when it invokes SQLite libraries.
Worker duy nhất nó có là những worker mà ứng dụng sử dụng khi nó gọi các thư viện SQLite.
All right. So one of the things we're going to briefly talk about, too, is how are we going to schedule these things?
Được rồi. Vậy một điều chúng ta sẽ nói qua một chút nữa là chúng ta sẽ lập lịch những thứ này như thế nào?
Again, we haven't quite got into what the parallelism looks like, but basically, if I have a bunch of workers, the DBMS has to decide where, you know, any request worker, some task to run, when should they run it and how they're going to execute it.
Một lần nữa, chúng ta chưa đi vào chuyện tính song song trông như thế nào, nhưng về cơ bản, nếu tôi có một loạt worker, DBMS phải quyết định ở đâu, tức là với bất kỳ worker nào yêu cầu một tác vụ để chạy, thì khi nào nên chạy và chạy bằng cách nào.
So things like if a query shows up and I could use multiple workers to execute that query, it has to decide what is that degree of parallelism?
Chẳng hạn nếu một truy vấn đến và tôi có thể dùng nhiều worker để thực thi truy vấn đó, thì nó phải quyết định mức độ song song là bao nhiêu?
How many workers do I want to use for that?
Tôi muốn dùng bao nhiêu worker cho việc đó?
And these decisions it'll make based on how many queries are running at the same time, where's the data, how slow is the disk to go get that data, right?
Và nó sẽ đưa ra các quyết định này dựa trên có bao nhiêu truy vấn đang chạy cùng lúc, dữ liệu nằm ở đâu, đĩa chậm đến mức nào khi lấy dữ liệu đó, đúng không?
And so there's a bunch of these things that a system can figure out.
Vậy là có nhiều yếu tố như thế mà hệ thống có thể tự xác định.
And this is why you don't want the OS to try to schedule anything for you, because since the DBMS knows what the query is or the tasks are that it has to execute, it knows what resources are available to it.
Và đó là lý do bạn không muốn hệ điều hành cố gắng lập lịch bất cứ thứ gì cho bạn, bởi vì DBMS biết các truy vấn hay các tác vụ mà nó phải thực thi là gì, nó biết có những tài nguyên nào sẵn có.
It's always, again, in a better position to decide what it should actually do to schedule these things. And that we should never rely on the OS to do any of this.
Một lần nữa, nó luôn ở vị thế tốt hơn để quyết định nó thực sự nên làm gì để lập lịch những thứ này. Và chúng ta không bao giờ nên dựa vào hệ điều hành để làm bất kỳ việc nào trong số này.
The high-end expensive enterprise systems, so the Oracles, the SQL Servers, the DB2s, they will do all of this up above and be very sophisticated with scheduling.
Các hệ thống doanh nghiệp cao cấp đắt tiền, như Oracle, SQL Server, DB2, sẽ làm tất cả những việc này ở tầng trên và lập lịch rất tinh vi.
Things like Postgres just lets the OS take the wheel and lets the OS schedule everything for you.
Còn những hệ thống như Postgres thì để hệ điều hành cầm lái và để hệ điều hành lập lịch mọi thứ cho bạn.
MySQL doesn't do parallelism in the way that we'll talk about in a second, but they pretty much, again, let the OS do everything.
MySQL không xử lý song song theo cách chúng ta sẽ nói đến ngay sau đây, nhưng về cơ bản, họ cũng để hệ điều hành làm mọi thứ.
All right, so the advantage of using a multi-threaded architecture, that's the second approach, should be pretty obvious. That's the modern way to build concurrent or parallel applications.
Được rồi, vậy ưu điểm của việc dùng kiến trúc đa luồng, tức là cách tiếp cận thứ hai, hẳn là khá rõ ràng. Đó là cách hiện đại để xây dựng các ứng dụng đồng thời hoặc song song.
There's less overhead of having multiple threads versus multiple processes.
Chi phí phụ trội khi có nhiều thread thấp hơn so với nhiều tiến trình.
You know, you don't have to manage the shared memory, which is, again, relying on OS primitives to communicate or share data across the different workers.
Bạn không phải quản lý bộ nhớ chia sẻ, mà một lần nữa, việc đó dựa vào các primitive của hệ điều hành để giao tiếp hoặc chia sẻ dữ liệu giữa các worker khác nhau.
Now, of course, the downside is if one of those workers has a segfault or does something it shouldn't be doing and it crashes in a multi-threaded application, that takes down all the threads, that takes down the entire process.
Tất nhiên, nhược điểm là nếu một trong các worker đó bị segfault hoặc làm điều gì đó không được phép và bị crash trong một ứng dụng đa luồng, thì tất cả các luồng đều chết theo, cả tiến trình bị sập.
So that, in theory, could make your data system more brittle or more susceptible to failure. Because if one thread goes down, that takes everyone down.
Nên về lý thuyết, điều đó có thể khiến hệ thống dữ liệu của bạn dễ vỡ hơn hoặc dễ gặp lỗi hơn. Vì nếu một luồng chết thì kéo theo tất cả.
Whereas in Postgres, if one process goes down, who cares? The postmaster just forks another one and picks up where it left off.
Còn trong Postgres, nếu một tiến trình chết thì cũng chẳng sao. Postmaster chỉ việc fork một tiến trình khác và tiếp tục từ chỗ nó dừng.
So you obviously don't write bugs in your data system so you don't crash. But that's easier said than done.
Tất nhiên bạn không viết ra lỗi trong hệ thống dữ liệu nên nó sẽ không crash. Nhưng nói thì dễ hơn làm.
There's pros and cons to this, but most systems are going to choose the multi-threaded architecture because the engineering overhead, the burden, is much less and the performance is a lot more.
Cách nào cũng có ưu và nhược điểm, nhưng hầu hết các hệ thống sẽ chọn kiến trúc đa luồng vì chi phí kỹ thuật, gánh nặng, ít hơn nhiều và hiệu năng thì cao hơn nhiều.
And unless you're a fork of Postgres or a fork of Redis, which they're using a single process or the process model, most systems in the last 25 years will be using threads.
Và trừ khi bạn là một bản fork của Postgres hay của Redis, những hệ thống dùng mô hình một tiến trình hoặc mô hình tiến trình, thì hầu hết các hệ thống trong 25 năm qua đều dùng luồng.
Say it again? Is it inadvisable to use both? His question is, is it inadvisable to use both? I think there's talk in Postgres where you can now have threads per process.
Bạn nói lại được không? Dùng cả hai có không nên không? Câu hỏi của bạn ấy là: dùng cả hai có không nên không? Tôi nghĩ trong Postgres đang có bàn đến việc giờ đây có thể có các luồng trong mỗi tiến trình.
I don't know what they're using it for.
Tôi không biết họ dùng nó để làm gì.
I would say yes, it's inadvisable to do both.
Tôi sẽ nói là có, không nên dùng cả hai.
I mean, you could do some decoupling where you would have the dispatcher could be a separate process and then there's another process that has all the workers inside the same thing.
Ý tôi là, bạn có thể tách riêng ra, trong đó bộ điều phối là một tiến trình riêng và có một tiến trình khác chứa tất cả các worker bên trong.
There's some systems that could do that, but that gives you the ability to now move where the front-end dispatcher runs.
Có một số hệ thống làm như vậy, vì nó cho bạn khả năng di chuyển nơi chạy bộ điều phối ở phía trước.
You could actually put that on another machine now and have the worker do the same thing. Different systems do different things. In general, for single-node systems, no one's going to mix it.
Thực tế bạn có thể đặt nó trên một máy khác và để worker làm tương tự. Mỗi hệ thống làm một kiểu khác nhau. Nói chung, với các hệ thống một nút, không ai trộn cả hai.
They're always going to do the thread per worker.
Họ luôn dùng mô hình một luồng cho mỗi worker.
All right, so now let's get into what he was alluding about. Like, okay, what does this mean to actually execute in queries?
Được rồi, giờ ta đi vào điều bạn ấy vừa nhắc tới. Vậy việc thực thi truy vấn thực sự có nghĩa là gì?
And so there's going to be different types of parallelism we're going to talk about that are going to have different trade-offs and different performance characteristics. And most of the systems, when you think about...
Sẽ có nhiều loại song song hóa khác nhau mà ta sẽ nói tới, với những đánh đổi khác nhau và đặc tính hiệu năng khác nhau. Và hầu hết các hệ thống, khi bạn nghĩ về...
Most systems will always do this first approach. The second one is going to be harder because it's going to be different levels of intra-query parallelism.
Hầu hết các hệ thống luôn làm theo cách đầu tiên này. Cách thứ hai sẽ khó hơn vì nó có nhiều mức song song hóa nội truy vấn khác nhau.
But when people say, I have a parallel database, they usually think of the second one. The first one still is a valid category for query parallelism. I'm sorry, yeah, for query parallelism, right?
Nhưng khi người ta nói, tôi có một cơ sở dữ liệu song song, thì họ thường nghĩ đến cách thứ hai. Cách đầu tiên vẫn là một loại hợp lệ của song song hóa truy vấn. Xin lỗi, đúng vậy, là song song hóa truy vấn.
So the idea is that the data set is going to execute these multiple workers at the same time.
Ý tưởng là tập dữ liệu sẽ được thực thi bởi nhiều worker này cùng một lúc.
Because we want to be able to improve the performance of the system or improve its utilization of the hardware that's available to us.
Vì ta muốn cải thiện hiệu năng của hệ thống hoặc cải thiện mức độ tận dụng phần cứng mà chúng ta có.
Most modern CPUs, or pretty much all modern CPUs at the server level, or even your laptops, are going to have multiple cores. Like, every laptop basically has, what, eight cores per CPU.
Hầu hết các CPU hiện đại, hay gần như tất cả CPU hiện đại ở cấp máy chủ, thậm chí cả laptop của các em, đều có nhiều nhân. Ví dụ, laptop nào về cơ bản cũng có, ừm, tám nhân cho mỗi CPU.
On the higher-end AMD boxes, you now have hundreds of cores. So we want to be able to take advantage of all that.
Trên các máy AMD cao cấp hơn, giờ đây có đến hàng trăm nhân. Vì vậy chúng ta muốn tận dụng tất cả những thứ đó.
And all the approaches that we'll talk about today are still, from this point forward, it doesn't actually matter whether we're doing process per worker or thread per worker.
Và tất cả các cách tiếp cận mà hôm nay chúng ta sẽ nói đến vẫn là như vậy, từ đây trở đi, thực ra không quan trọng là chúng ta đang dùng mô hình process per worker hay thread per worker.
Again, the high-level concepts are still the same.
Một lần nữa, các khái niệm ở mức cao vẫn giống nhau.
The way we're going to parallelize things and coalesce results at the right point in the query plan, all these still work no matter what process model you're using, or even if you're running on multiple machines, right?
Cách chúng ta song song hóa mọi thứ và gộp kết quả lại tại đúng điểm trong kế hoạch truy vấn, tất cả những điều này vẫn áp dụng được cho dù em dùng mô hình tiến trình nào, hoặc thậm chí khi chạy trên nhiều máy, đúng không?
All right, so we're going to talk about inter-query parallelism, and then we'll talk about, again, more detailed intra-query parallelism. Inter-query parallelism is pretty obvious.
Được rồi, vậy chúng ta sẽ nói về song song liên truy vấn (inter-query parallelism), rồi sau đó sẽ nói chi tiết hơn về song song nội truy vấn (intra-query parallelism). Song song liên truy vấn khá hiển nhiên.
It basically says, if I have multiple workers, I can take multiple requests for queries, and I can execute those queries in parallel.
Về cơ bản nó nói rằng, nếu tôi có nhiều worker, tôi có thể nhận nhiều yêu cầu truy vấn, và thực thi các truy vấn đó song song.
Meaning, like, one worker could execute query one. Another worker could execute query two. Right? And they don't need to communicate. They don't need to interfere with each other, right?
Nghĩa là, chẳng hạn một worker có thể thực thi truy vấn một. Một worker khác thực thi truy vấn hai. Đúng không? Và chúng không cần giao tiếp với nhau. Chúng không cần can thiệp lẫn nhau, đúng không?
For scheduling-wise to do this, again, most systems are going to use a really simple scheduling policy. First come, first serve. Like, whenever a query shows up first, I'll start running that right away.
Về mặt lập lịch để làm điều này, một lần nữa, hầu hết các hệ thống sẽ dùng một chính sách lập lịch rất đơn giản. Đến trước phục vụ trước. Tức là, truy vấn nào đến trước thì tôi bắt đầu chạy nó ngay.
Things get a little more complicated when you start doing transactions and concurrency control, which we'll cover in a few weeks.
Mọi thứ phức tạp hơn một chút khi bắt đầu có giao dịch và điều khiển đồng thời, mà chúng ta sẽ học trong vài tuần nữa.
But you can start scheduling things based on, you know, if you're in a transaction, how many queries have they executed before this new query?
Nhưng em có thể bắt đầu lập lịch dựa trên việc, nếu đang ở trong một giao dịch, giao dịch đó đã thực thi bao nhiêu truy vấn trước truy vấn mới này?
And maybe that gets a higher priority or a lower priority based on whatever policy you're using.
Và có thể truy vấn đó được ưu tiên cao hơn hoặc thấp hơn tùy theo chính sách mà em đang dùng.
So if every query you're executing is read-only, then this is really easy to do because you don't have to worry about, you know, coordinating between the different queries.
Vậy nếu mọi truy vấn em thực thi đều chỉ đọc, thì việc này rất dễ làm vì em không phải lo về việc điều phối giữa các truy vấn khác nhau.
You still want to maybe do latching on your internal data structures because you don't want queries to break things or interfere with each other.
Em vẫn có thể muốn dùng latch trên các cấu trúc dữ liệu nội bộ vì không muốn các truy vấn làm hỏng dữ liệu hoặc can thiệp lẫn nhau.
But in general, read-only databases are the easiest thing to implement because the coordination level is... The amount of coordination you have to do is pretty minimal.
Nhưng nói chung, cơ sở dữ liệu chỉ đọc là loại dễ triển khai nhất vì mức độ điều phối... Lượng điều phối mà em phải làm là khá ít.
Like, once the queries start running, you don't have to worry about them sending data back and forth between each other or understanding what one query is doing versus another query is doing.
Chẳng hạn, một khi các truy vấn bắt đầu chạy, em không phải lo chuyện chúng gửi dữ liệu qua lại với nhau hay phải hiểu truy vấn này đang làm gì so với truy vấn kia.
And then if you now want to make sure that, like, I can get parallelism by, like, or reduce the amount of wasted I/O, the buffer pool manager can do all the scan sharing or all the...
Và nếu bây giờ em muốn đảm bảo rằng, em có thể đạt được song song bằng cách, hoặc giảm lượng I/O lãng phí, thì buffer pool manager có thể thực hiện toàn bộ việc chia sẻ quét (scan sharing) hoặc toàn bộ...
all the other cursor sharing techniques we talked about before because that's the central point that everyone's communicating with. But again, that's... We've already covered how to do that.
tất cả các kỹ thuật chia sẻ con trỏ khác mà chúng ta đã nói trước đó vì đó là điểm trung tâm mà mọi thành phần đều giao tiếp với. Nhưng một lần nữa, cái đó... Chúng ta đã nói cách làm rồi.
If queries have been updated at the same time, now you've got to worry about, like, who writes what and who can read whatever's been written. That we'll cover in two weeks.
Nếu các truy vấn được cập nhật cùng một lúc, thì bây giờ bạn phải lo về việc ai ghi cái gì và ai có thể đọc những gì đã được ghi. Phần đó chúng ta sẽ học trong hai tuần nữa.
We'll pick that up on Lecture 17. We'll spend two weeks discussing how to handle this, starting then.
Chúng ta sẽ tiếp tục ở Bài giảng 17. Chúng ta sẽ dành hai tuần để bàn về cách xử lý vấn đề này, bắt đầu từ lúc đó.
I would say also, too, that just because a database system can execute multiple queries in parallel at the same time, it doesn't mean necessarily that each query itself will also run in parallel within itself.
Tôi cũng muốn nói thêm rằng việc một hệ quản trị cơ sở dữ liệu có thể thực thi nhiều truy vấn song song cùng một lúc không nhất thiết có nghĩa là bản thân mỗi truy vấn cũng được chạy song song bên trong chính nó.
Like, so MySQL will be an interquery parallelism system. Like, it can take multiple query requests and run each of those at the same time.
Chẳng hạn MySQL là một hệ thống song song liên truy vấn (interquery parallelism). Nó có thể nhận nhiều yêu cầu truy vấn và chạy từng yêu cầu đó cùng một lúc.
But for each individual query request, that's only going to run on one worker.
Nhưng với mỗi yêu cầu truy vấn riêng lẻ, nó chỉ chạy trên một worker.
So if I run one query in MySQL and I have 1,000 cores, at the end of the day, it's still going to run on one core.
Vậy nếu tôi chạy một truy vấn trong MySQL và có 1.000 lõi, rốt cuộc nó vẫn chỉ chạy trên một lõi.
So that type of parallelism is called interquery parallelism. And these aren't mutually exclusive. I can have an interquery... I can have my database system support interquery parallelism, but it also supports intra-query parallelism.
Loại song song đó gọi là song song liên truy vấn (interquery parallelism). Và hai loại này không loại trừ lẫn nhau. Tôi có thể có liên truy vấn... Tôi có thể có hệ quản trị cơ sở dữ liệu hỗ trợ song song liên truy vấn, nhưng đồng thời cũng hỗ trợ song song nội truy vấn (intra-query parallelism).
So Postgres can do this. Postgres can run multiple queries at the same time, and each of those queries can run on multiple workers at the same time.
Postgres làm được điều này. Postgres có thể chạy nhiều truy vấn cùng một lúc, và mỗi truy vấn đó có thể chạy trên nhiều worker cùng một lúc.
So if you're familiar with, like, the producer-consumer model, you have, basically, in a query plan, you have different workers, actually in different parts of the query plan, producing results that it's pushing up or moving up to the query plan.
Nếu bạn đã quen với mô hình producer-consumer, thì về cơ bản bạn có trong một kế hoạch truy vấn, các worker khác nhau, thực ra ở những phần khác nhau của kế hoạch truy vấn, tạo ra các kết quả rồi đẩy lên hoặc chuyển lên phía trên của kế hoạch truy vấn.
And then depending on how I break things up in my pipelines, I could have different workers consuming those results and maybe running those in parallel or waiting for all the results to be finished before I can go off and execute the next pipeline.
Và tùy cách tôi chia nhỏ các đường ống (pipeline), tôi có thể có các worker khác nhau tiêu thụ những kết quả đó và có thể chạy chúng song song hoặc chờ cho tất cả kết quả hoàn tất trước khi có thể đi thực thi đường ống tiếp theo.
But the high-level idea is going to be still the same. It's still going to be this producer-consumer approach. So the first type of parallelism we'll talk about is intra-operator parallelism.
Nhưng ý tưởng ở mức cao vẫn như nhau. Vẫn là cách tiếp cận producer-consumer này. Loại song song đầu tiên chúng ta sẽ nói là song song nội toán tử (intra-operator parallelism).
So this would be horizontal parallelism. So allowing different workers to execute the same pipeline or different portions of the pipeline at the same time.
Đây là song song theo chiều ngang. Tức là cho phép các worker khác nhau thực thi cùng một đường ống hoặc các phần khác nhau của đường ống cùng một lúc.
Sorry, same pipeline, but different segments of the data or different inputs at the same time. And that's super common.
Xin lỗi, cùng một đường ống, nhưng trên các phân đoạn dữ liệu khác nhau hoặc các đầu vào khác nhau cùng một lúc. Và cách này rất phổ biến.
The other type of parallelism is called inter-operator parallelism, where I could have different workers execute different portions of the query plan simultaneously at the same time.
Loại song song còn lại gọi là song song liên toán tử (inter-operator parallelism), trong đó tôi có thể cho các worker khác nhau thực thi các phần khác nhau của kế hoạch truy vấn đồng thời cùng một lúc.
And that's less common because, obviously, if you have pipelines, I can't maybe execute something at the top before something at the bottom finishes, so it doesn't make sense to have something up above spinning and waiting for results that are never going to arrive yet.
Và cách này ít phổ biến hơn vì rõ ràng, nếu bạn có các đường ống, thì có thể tôi không thể thực thi thứ ở trên cùng trước khi thứ ở dưới cùng kết thúc, nên không có ý nghĩa gì khi để một thứ ở phía trên cứ quay vòng và chờ những kết quả mà chưa hề đến.
So there are going to be parallel versions of pretty much every operator that's out there.
Vì vậy sẽ có các phiên bản song song của hầu như mọi toán tử hiện có.
Basically, all the algorithms that we talked about so far in the semester, you can easily, or not easily, you can parallelize them in some way by using that divide-and-conquer approach that we talked about before that allow you to split the input up for your algorithm into different segments or different buckets or whatever, how we defined it before.
Về cơ bản, tất cả các thuật toán mà chúng ta đã nói tới từ đầu học kỳ đến giờ, bạn có thể dễ dàng, hoặc không dễ lắm, song song hóa chúng theo một cách nào đó bằng cách dùng cách tiếp cận chia để trị mà chúng ta đã nói trước đây, cho phép bạn chia đầu vào của thuật toán thành các đoạn, các bucket khác nhau hay gì đó, tùy cách chúng ta đã định nghĩa trước đó.
And now, instead of having one worker go through each bucket or each partition one at a time, you have multiple workers each handle a different partition at the same time.
Và bây giờ, thay vì để một worker đi qua từng bucket hay từng phân vùng một lần lượt, bạn để nhiều worker, mỗi worker xử lý một phân vùng khác nhau cùng lúc.
So we go back to that parallel hash join, the Grace hash join we talked about before, the partition hash join, where we would do sort of one pass through the data and hash the data and build up these sort of levels in our hash tables or different segments.
Vậy hãy quay lại parallel hash join, Grace hash join mà chúng ta đã nói trước đây, partition hash join, trong đó ta duyệt qua dữ liệu một lượt và băm dữ liệu, rồi xây dựng các tầng trong bảng băm hay các đoạn khác nhau.
But instead of having, again, one worker handle each of these levels, once I sort of do my first pass, which I can also do in parallel, we'll see that in a second, but now when I want to do my join, I have one worker be responsible for level one, sorry, level zero, one worker responsible for level one, and so forth.
Nhưng thay vì, một lần nữa, để một worker xử lý từng tầng như vậy, sau khi tôi làm xong lượt đầu tiên, lượt này cũng có thể làm song song, lát nữa ta sẽ thấy, thì khi tôi muốn thực hiện phép join, tôi cho một worker phụ trách tầng một, xin lỗi, tầng không, một worker phụ trách tầng một, và cứ thế.
And because I know I've partitioned my data by doing the hashing step first, I don't have to communicate between different workers to do this. Right?
Và vì tôi biết mình đã phân vùng dữ liệu bằng cách băm trước, nên không cần trao đổi giữa các worker khác nhau để làm việc này. Đúng không?
Now, you could do this either by having one giant hash table or you could partition to have individual hash tables. It doesn't matter, but the high-level concept is still the same.
Bạn có thể làm việc này bằng một bảng băm khổng lồ duy nhất hoặc phân vùng để có các bảng băm riêng lẻ. Không quan trọng, ý tưởng ở mức tổng quát vẫn như nhau.
All right, so we'll go through what interoperator parallelism is. It's the horizontal one. And then the interoperator parallelism would have different portions running at the same time. That's vertical.
Được rồi, vậy ta sẽ xem song song liên toán tử là gì. Đó là kiểu theo chiều ngang. Còn song song nội toán tử thì có các phần khác nhau chạy cùng lúc. Đó là kiểu theo chiều dọc.
And then the textbook talks about this thing called bushy parallelism. They make it sound like it's its own separate thing, but it's just a combination of the two of them at the same time.
Và sách giáo trình còn nói về thứ gọi là bushy parallelism. Họ nói như thể nó là một thứ riêng biệt, nhưng thực ra nó chỉ là sự kết hợp của cả hai kiểu cùng lúc.
So the first one is the most common one.
Kiểu đầu tiên là phổ biến nhất.
Anytime someone says they have a parallel database system, they're 9 times out of 10 or 99 times out of 100, they're doing the first one, the horizontal parallelism.
Bất cứ khi nào ai đó nói họ có một hệ cơ sở dữ liệu song song, thì 9 trên 10 lần, hoặc 99 trên 100 lần, họ đang dùng kiểu đầu tiên, song song theo chiều ngang.
And then the second one is less common. We'll look at it briefly.
Kiểu thứ hai ít phổ biến hơn. Ta sẽ xem qua một chút.
And then the bushy parallelism, that's in, again, the enterprise high-end systems that cost millions of dollars, like SQL Server, like DB2, and like Oracle.
Còn bushy parallelism thì có trong các hệ thống doanh nghiệp cao cấp có giá hàng triệu đô la, như SQL Server, DB2 và Oracle.
But the top one, the horizontal one, is the most common one. And again, because SQL is declarative, I don't have to specify in my query which one of these I want, right?
Nhưng kiểu trên cùng, theo chiều ngang, là phổ biến nhất. Và một lần nữa, vì SQL là ngôn ngữ khai báo, tôi không phải chỉ rõ trong truy vấn là muốn kiểu nào, đúng không?
The database just figures it out based on the hardware it has available to do it, what your query actually wants to do. It can decide which of these approaches it wants to use.
Cơ sở dữ liệu tự tìm ra dựa trên phần cứng nó có sẵn để thực hiện, và dựa trên điều truy vấn của bạn thực sự muốn làm. Nó có thể quyết định dùng cách tiếp cận nào trong số này.
All right, so the most common one is horizontal parallelism or intraoperator parallelism.
Được rồi, cách phổ biến nhất là song song hóa theo chiều ngang hay còn gọi là song song hóa trong toán tử (intraoperator parallelism).
And the idea is that I'm going to take my data that I'm processing and I'm going to break it up into disjoint subsets, right?
Ý tưởng là tôi sẽ lấy dữ liệu mà mình đang xử lý và chia nó thành các tập con rời nhau, đúng không?
Either by just saying, you know, you read these pages, I'll read these pages, or doing something more explicit, like dividing it based on values and columns. It doesn't matter.
Có thể chỉ đơn giản là nói, bạn đọc các trang này, tôi đọc các trang kia, hoặc làm theo cách tường minh hơn, như chia dựa trên giá trị và các cột. Cách nào cũng được.
And then now the operators are going to be, have different independent instantiations of them that can each run on a different worker that are going to be processing the data that they're assigned to, the inputs, in a disjoint subset of the datum.
Và khi đó các toán tử sẽ có những bản thể độc lập khác nhau mà mỗi bản có thể chạy trên một worker khác nhau, xử lý phần dữ liệu được giao cho chúng, tức là đầu vào, nằm trong một tập con rời nhau của dữ liệu.
And then they're going to be crunching on that, producing results that I then move up into the query plan.
Rồi chúng sẽ miệt mài xử lý phần đó, tạo ra kết quả để tôi chuyển lên trên trong kế hoạch truy vấn.
But then at some point I need to make sure that I process all the data from these different pipelines or instantiations of the pipelines of the different workers.
Nhưng đến một lúc nào đó tôi cần đảm bảo rằng mình đã xử lý hết dữ liệu từ các đường ống khác nhau này, hay các bản thể của đường ống thuộc những worker khác nhau.
And so now I want to introduce a barrier operator that says, don't proceed in my query plan until I get all the results from everybody below me that I'm expecting to produce results for me.
Vì vậy giờ tôi muốn đưa vào một toán tử rào chắn (barrier) có nghĩa là: đừng đi tiếp trong kế hoạch truy vấn cho đến khi nhận đủ kết quả từ tất cả các toán tử bên dưới mà tôi đang mong đợi sẽ tạo kết quả cho mình.
So this is going to be called, and database is called the exchange operator.
Toán tử này được gọi, trong cơ sở dữ liệu, là toán tử exchange.
And it's basically, you know, there's no notion of this, so there's no mapping of this to the relational model, relational algebra.
Về cơ bản thì không có khái niệm này, nên không có phép ánh xạ nào của nó sang mô hình quan hệ hay đại số quan hệ.
This is something we're going to introduce in our implementation to allow us to do this, achieve this parallelism.
Đây là thứ chúng ta đưa vào trong phần triển khai của mình để có thể làm được việc này, đạt được sự song song hóa này.
Again, just think of it like a barrier where it blocks the output or sending a signal to up above to say you can start processing the data I've finished.
Một lần nữa, cứ hình dung nó như một rào chắn chặn đầu ra hoặc gửi tín hiệu lên phía trên để báo rằng bạn có thể bắt đầu xử lý dữ liệu, tôi đã xong rồi.
Until it gets all the results it expects to get from its children operators.
Cho đến khi nó nhận đủ mọi kết quả mà nó cần từ các toán tử con.
So if you're familiar in programming languages, I think they call this a merge operator or a gather, right, or scatter gather. It's basically the same idea. Postgres calls these gather, gather merge.
Nếu các bạn quen với ngôn ngữ lập trình, tôi nghĩ người ta gọi đây là toán tử merge hoặc gather, hay scatter gather. Về cơ bản là cùng một ý tưởng. Postgres gọi chúng là gather, gather merge.
And you're just combining the different results from the child operators and producing them as a final result that goes up above. Yes?
Bạn chỉ đang kết hợp các kết quả khác nhau từ các toán tử con và tạo ra kết quả cuối cùng chuyển lên phía trên. Bạn hỏi gì?
This question is, why does it have to be a barrier where I block things? Isn't it, in some cases, where I can send partial results up?
Câu hỏi là: tại sao nó phải là rào chắn khiến mọi thứ bị chặn lại? Chẳng phải có trường hợp ta có thể gửi kết quả từng phần lên trên sao?
Yeah, but again, think of it like the pipeline breaker. There's some places where I can't proceed until I get all the results. In that case, you wouldn't use the exchange operator.
Đúng, nhưng hãy nghĩ nó giống như pipeline breaker. Có những chỗ tôi không thể đi tiếp cho đến khi có đủ kết quả. Trong trường hợp đó, bạn sẽ không dùng toán tử exchange.
Just keep going. Sometimes you can, sometimes you can't.
Cứ tiếp tục thôi. Đôi khi được, đôi khi không.
Yeah, so he's correct. There are some cases where I don't have to block until I get all the results. You can send some results up. For simplicity, assume that we're blocking it.
Vâng, bạn ấy nói đúng. Có những trường hợp tôi không cần chặn cho đến khi có đủ kết quả. Bạn có thể gửi một số kết quả lên. Để đơn giản, hãy giả sử ta chặn nó.
Assume this is the pipeline breaker. Then I'll show different versions of exchange operators that don't have to do what you're saying. Starting with the basic one, it blocks. But then we'll relax that.
Giả sử đây là pipeline breaker. Sau đó tôi sẽ trình bày các phiên bản khác của toán tử exchange không cần làm như bạn nói. Bắt đầu với bản cơ bản, nó chặn. Nhưng sau đó ta sẽ nới lỏng điều đó.
All right, so here's our query we're going to do. We're going to join A and B, right? And we have a filter, some value for each of these tables.
Được rồi, đây là truy vấn mà chúng ta sẽ xử lý. Chúng ta sẽ join A và B, đúng không? Và chúng ta có một bộ lọc, với một giá trị nào đó cho mỗi bảng này.
I do a join, and then I have a projection at the top. So say I want to do the processing on table A first. So I've partitioned table A into three disjoint subsets.
Tôi thực hiện phép join, và ở trên cùng có một phép chiếu. Giả sử tôi muốn xử lý bảng A trước. Vậy tôi đã phân hoạch bảng A thành ba tập con rời nhau.
Now, it can be page-based or range-based. It can be based on the value because I've hashed whatever my join key is. It doesn't matter.
Việc này có thể dựa trên trang hoặc dựa trên khoảng giá trị. Nó cũng có thể dựa trên giá trị, vì tôi đã băm khóa join, bất kể đó là gì. Điều đó không quan trọng.
I'm going to assign those three subsets of A to my three workers, right?
Tôi sẽ giao ba tập con này của A cho ba worker của tôi, đúng không?
And each of them are going to run, basically, up the pipeline that I have and run in parallel because they're processing different portions of the table.
Và mỗi worker về cơ bản sẽ chạy lên theo đường ống mà tôi có và chạy song song vì chúng xử lý những phần khác nhau của bảng.
They don't need to communicate with each other, so they can run independently of the others.
Chúng không cần giao tiếp với nhau, nên chúng có thể chạy độc lập với nhau.
So they're all going to do the filter, and then now they're all going to do this side of the hash join to build the hash table, right?
Vậy tất cả sẽ thực hiện bộ lọc, rồi tất cả sẽ thực hiện phía này của hash join để xây dựng bảng băm, đúng không?
And so now I have an exchange operator up above that says this pipeline, or this portion of the query plan, is not finished until all three of my workers down below me come up and tell me that they're done.
Và bây giờ ở phía trên tôi có một toán tử exchange cho biết đường ống này, hay phần này của kế hoạch truy vấn, chưa kết thúc cho đến khi cả ba worker của tôi ở bên dưới báo lên rằng chúng đã xong.
So maybe it should be a black line for control and some data.
Có lẽ nên vẽ một đường màu đen cho điều khiển và một ít dữ liệu.
So I'm not really moving data for this case here into my exchange operator, because this build hash table thing is kind of, assume there's some hash table.
Trong trường hợp này tôi thực ra không chuyển dữ liệu vào toán tử exchange, vì bước xây dựng bảng băm này, giả sử là có một bảng băm nào đó.
It's a global hash table. They're all updating.
Đó là một bảng băm toàn cục. Tất cả đều cập nhật nó.
But my exchange operator needs to know that they're all done processing their portion of table A before I can proceed with the next part of the query plan.
Nhưng toán tử exchange của tôi cần biết rằng tất cả đã xử lý xong phần bảng A của mình trước khi tôi có thể tiếp tục với phần tiếp theo của kế hoạch truy vấn.
So they're all generating data for this hash table here.
Vậy tất cả đang tạo dữ liệu cho bảng băm này.
And then now, once I know this is done, I can then schedule three other workers, or three of the same workers, just now running different portions of the query plan.
Và khi biết phần này đã xong, tôi có thể lên lịch cho ba worker khác, hoặc chính ba worker đó, chỉ là bây giờ chạy các phần khác của kế hoạch truy vấn.
Now they're processing table B, which I've broken up into three subsets as well, and do the same thing. They're going to do a filter in parallel.
Bây giờ chúng xử lý bảng B, mà tôi cũng đã chia thành ba tập con, và làm điều tương tự. Chúng sẽ thực hiện bộ lọc song song.
And then now they're going to do the probe of the hash table in parallel. Again, it's a single hash table. They're all reading into and looking for results.
Và sau đó chúng sẽ thực hiện việc dò bảng băm song song. Một lần nữa, đó là một bảng băm duy nhất. Tất cả đều đọc vào và tìm kết quả.
And then if any two match, they then do the projection.
Và nếu có hai bản ghi khớp nhau, chúng sẽ thực hiện phép chiếu.
But then above that, I have another exchange operator that says I can't produce the final result for this query until I know that my three workers down below me, running these portions of the pipeline, that they've all finished processing the data that they have.
Nhưng ở phía trên đó, tôi có một toán tử exchange khác cho biết tôi không thể tạo ra kết quả cuối cùng cho truy vấn này cho đến khi tôi biết rằng ba worker ở bên dưới tôi, đang chạy các phần này của đường ống, đều đã xử lý xong dữ liệu mà chúng có.
So going back to his point here, These exchange operators are blocking because I don't want to start doing the probe in the hash table here on the probe side for table B until I know that all three workers that were building the hash table have completed, because I don't want to get a false negative.
Quay lại ý của bạn ấy ở đây, các toán tử exchange này có tính chặn vì tôi không muốn bắt đầu dò trong bảng băm ở đây ở phía dò của bảng B cho đến khi tôi biết rằng cả ba worker xây dựng bảng băm đã hoàn thành, vì tôi không muốn bị âm tính giả.
I don't want to probe into the hash table looking for a match, but the worker that is responsible for putting my match into the hash table hasn't completed yet.
Tôi không muốn dò vào bảng băm để tìm kết quả khớp, nhưng worker chịu trách nhiệm đưa kết quả khớp của tôi vào bảng băm vẫn chưa hoàn thành.
So in this case here, again, the exchange operator is blocking, is a barrier. It doesn't necessarily have to do that.
Vậy trong trường hợp này, toán tử exchange là toán tử chặn, là một rào chắn (barrier). Không nhất thiết lúc nào nó cũng phải làm vậy.
And then the, I'm not showing here, but there's some metadata in my query plan that keeps track of these pipelines and keeps track of these dependencies and would know I want to schedule the workers that process table A segments first before I jump to anything on table B.
Và sau đó, ở đây tôi không trình bày, nhưng trong kế hoạch truy vấn của tôi có một số siêu dữ liệu theo dõi các đường ống này và theo dõi các phụ thuộc này và sẽ biết rằng tôi muốn lập lịch các worker xử lý các segment của bảng A trước, rồi mới chuyển sang bất cứ thứ gì của bảng B.
So again, this is the most common and most basic type of exchange operator. It's doing a gather. It's combining results from multiple workers and producing as a single output stream.
Vậy nên, đây là loại toán tử exchange phổ biến và cơ bản nhất. Nó thực hiện một gather. Nó kết hợp kết quả từ nhiều worker và tạo ra một luồng đầu ra duy nhất.
And again, depending on whether or not I'm allowed to process the data at the same time or not, whether it's a blocking exchange or it's just producing a single exchange, again, depends on what the operator is actually doing below me.
Và một lần nữa, việc tôi có được phép xử lý dữ liệu đồng thời hay không, tức là nó là exchange chặn hay chỉ tạo ra một luồng exchange duy nhất, còn phụ thuộc vào việc toán tử bên dưới tôi thực sự đang làm gì.
And the data system would know how to do that. Another type of exchange operator is to do what's called a distribute. And for this here, I'm using the SQL Server's terminology for this.
Và hệ thống dữ liệu sẽ biết cách làm điều đó. Một loại toán tử exchange khác là thực hiện cái gọi là distribute. Ở đây, tôi dùng thuật ngữ của SQL Server cho việc này.
Different data systems might call it different things, but the high-level ideas are still the same.
Các hệ thống dữ liệu khác nhau có thể gọi nó bằng những tên khác nhau, nhưng ý tưởng ở mức cao vẫn như nhau.
With a distribute exchange operator, is that I'm taking a single input stream from some operator down below me, which again, I don't care what it is below me because I know that I'm getting tuples up from below and passing them up.
Với toán tử exchange distribute, tôi lấy một luồng đầu vào duy nhất từ một toán tử nào đó bên dưới tôi, mà tôi cũng không quan tâm nó là gì, vì tôi biết rằng tôi nhận các tuple từ bên dưới lên và chuyển tiếp lên trên.
And then now I'm going to redistribute or repartition that data across different operators that I can run in parallel at the same time, different workers. And the last one is called repartition.
Rồi bây giờ tôi sẽ phân phối lại hoặc phân vùng lại dữ liệu đó cho các toán tử khác nhau có thể chạy song song cùng lúc, tức là các worker khác nhau. Và loại cuối cùng gọi là repartition.
And that's just a combination of the top one and the middle one, where I could take multiple input streams from different operators down below me, and then I'm going to produce multiple output streams.
Đó chỉ là sự kết hợp của loại trên cùng và loại ở giữa, trong đó tôi có thể lấy nhiều luồng đầu vào từ các toán tử khác nhau bên dưới, rồi tạo ra nhiều luồng đầu ra.
But it doesn't need to be a one-to-one correspondence between the number of streams coming in and the number of streams coming out.
Nhưng không cần có sự tương ứng một-một giữa số luồng đi vào và số luồng đi ra.
I may decide that I want to use a lot of parallelism because I have a lot of data down below me. But then up above, I may want to only run on two workers.
Tôi có thể quyết định dùng nhiều song song vì bên dưới tôi có rất nhiều dữ liệu. Nhưng ở phía trên, tôi có thể chỉ muốn chạy trên hai worker.
So I'll coalesce the three streams into two output streams and only have two workers run them in parallel. Because the coordination costs, or sending data between different nodes, is not for free.
Nên tôi sẽ gộp ba luồng thành hai luồng đầu ra và chỉ để hai worker chạy chúng song song. Bởi vì chi phí điều phối, hay việc gửi dữ liệu giữa các nút khác nhau, không phải là miễn phí.
And so there's a trade-off between how much parallelism I have versus how much communication cost I'm willing to pay to send data around.
Và do đó có sự đánh đổi giữa mức độ song song tôi có và chi phí giao tiếp tôi sẵn sàng trả để gửi dữ liệu đi.
So some data systems, like Google's BigQuery or Dremel, it's the same system, they'll always do this for every single pipeline, every single stage of query execution.
Một số hệ thống dữ liệu, như BigQuery hay Dremel của Google, thực chất là cùng một hệ thống, sẽ luôn làm điều này cho mọi đường ống, mọi giai đoạn của quá trình thực thi truy vấn.
And this allows them to get to, basically, on the fly decide: do I want to scale up or scale down the number of nodes I'm going to use to process my query?
Điều này cho phép chúng về cơ bản quyết định ngay tức thời: tôi muốn tăng hay giảm số lượng nút sẽ dùng để xử lý truy vấn của mình?
Again, that's distributed data. We'll cover that later. But you can do the same thing on a single node thing. Say, I want to run this portion of my query plan with 10 workers.
Một lần nữa, đó là dữ liệu phân tán. Chúng ta sẽ học sau. Nhưng bạn cũng có thể làm điều tương tự trên một nút đơn. Chẳng hạn, tôi muốn chạy phần này của kế hoạch truy vấn với 10 worker.
But then, since I'm doing a bunch of filters and whittling down how much data I have at this exchange operator here, I only want to have two output streams, because I only want two workers to process the remaining results.
Nhưng sau đó, vì tôi áp dụng hàng loạt bộ lọc và thu hẹp dần lượng dữ liệu còn lại tại toán tử exchange này, nên tôi chỉ muốn có hai luồng đầu ra, vì tôi chỉ cần hai worker xử lý các kết quả còn lại.
Is this clear? And again, to his point, does it need to be a barrier or not?
Rõ chưa? Và như bạn ấy hỏi, nó có cần phải là một barrier hay không?
Depends on what the operator is doing up above and below, depending on whether you need to see all the results or you can start seeing the results as they arrive.
Điều đó tùy thuộc vào toán tử phía trên và phía dưới đang làm gì, tùy việc bạn có cần thấy toàn bộ kết quả hay không, hay có thể bắt đầu xử lý các kết quả ngay khi chúng đến.
If you can start processing the results as they arrive, this allows you to do what's called interoperator parallelism, or vertical parallelism, where I'm going to have different operations in my query plan actually execute at the same time.
Nếu bạn có thể bắt đầu xử lý kết quả ngay khi chúng đến, thì bạn có thể thực hiện cái gọi là song song liên toán tử (interoperator parallelism), hay song song dọc (vertical parallelism), trong đó các phép toán khác nhau trong kế hoạch truy vấn thực sự thực thi cùng một lúc.
That will allow me to basically get pipeline data between them without having to materialize results or stage them for transfer from one operator to the next.
Điều đó về cơ bản cho phép tôi chuyển dữ liệu qua đường ống giữa chúng mà không phải vật chất hóa kết quả hay lưu tạm để chuyển từ toán tử này sang toán tử tiếp theo.
And you typically see this in what are called streaming systems, streaming database systems, where it isn't like I have a table that's a fixed size and I run my query and I produce whatever the result is at that moment that I run the query.
Bạn thường thấy điều này ở cái gọi là hệ thống streaming, hệ cơ sở dữ liệu streaming, nơi mà không phải là tôi có một bảng kích thước cố định rồi chạy truy vấn và tạo ra kết quả tại thời điểm tôi chạy truy vấn đó.
In a streaming system, it's like a continuous update, a continuous insert stream of new data coming in, and I want to run this query forever, continuously.
Trong hệ thống streaming, nó giống như một luồng cập nhật liên tục, một luồng insert liên tục của dữ liệu mới đổ vào, và tôi muốn chạy truy vấn này mãi mãi, liên tục.
And it can then produce results on a schedule: every five seconds, produce a new result, whatever it's seen before.
Nó có thể tạo kết quả theo lịch: cứ năm giây lại tạo một kết quả mới, dựa trên mọi thứ đã thấy trước đó.
Or if there's some trigger mechanism, say if I see a stock price that goes above $100, then output a result. There's a bunch of mechanisms you can use to produce results.
Hoặc theo một cơ chế kích hoạt nào đó, chẳng hạn nếu tôi thấy giá cổ phiếu vượt quá $100 thì xuất ra một kết quả. Có nhiều cơ chế bạn có thể dùng để tạo kết quả.
But the thing is, there's this data always coming in, and I want to be able to run these things in parallel, because I don't have to wait for maybe all the data to show up, because it'll go to infinity.
Nhưng vấn đề là dữ liệu luôn đổ vào, và tôi muốn chạy các thứ này song song, vì tôi không thể chờ toàn bộ dữ liệu xuất hiện, vì nó sẽ kéo dài đến vô tận.
The new data is going to come in forever. So let's look at a contrived example here.
Dữ liệu mới sẽ đến mãi mãi. Vậy hãy xem một ví dụ giả định ở đây.
So say now I'm doing the same join I had before, but now I have this UDF, or function, I'm calling on the data.
Giả sử bây giờ tôi thực hiện cùng phép join như trước, nhưng giờ có thêm UDF, hay một hàm, mà tôi gọi trên dữ liệu.
Think of, like, hashing of a hash of a hash, some real expensive operation that I'm doing for my data.
Hãy nghĩ như băm của băm của băm, một phép toán rất tốn kém mà tôi thực hiện trên dữ liệu.
And so what I want to be able to do is not wait for all the results of this join to finish before I start calling that UDF, because that's going to be expensive.
Và điều tôi muốn là không phải chờ toàn bộ kết quả của phép join này hoàn tất rồi mới bắt đầu gọi UDF đó, vì việc đó sẽ rất tốn kém.
And I want to put that on a separate worker to have that run in parallel.
Tôi muốn đặt nó lên một worker riêng để chạy song song.
So I'll have one worker responsible for doing the join, and then it's going to sort of emit tuples out as it finds matches.
Vậy tôi có một worker phụ trách phép join, và nó sẽ phát ra các tuple khi tìm thấy kết quả khớp.
And that's just going to pass it up to now as my second worker that's going to just continually read this input stream incoming, and then compute whatever that UDF or that function call is and produce output that way.
Và nó chỉ việc chuyển lên cho worker thứ hai của tôi, worker này liên tục đọc luồng đầu vào đến, rồi tính xem UDF hay lời gọi hàm đó cho kết quả gì và tạo đầu ra theo cách đó.
So now I can have this thread just sort of rip through the join, and then immediately hand off the result to some other thread that's going to rip through and compute whatever the hashing function that I want to compute.
Như vậy, giờ tôi có thể để luồng này chạy vèo qua phép join, rồi lập tức chuyển kết quả cho một thread khác, thread đó sẽ chạy hết tốc lực và tính bất kỳ hàm băm nào mà tôi muốn tính.
And then, of course, now, if at some point it completes the incoming, it's processed all the tuples that it's seen so far, but the bottom guy is still running, it just blocks and waits for the bottom guy to notify him that there's no result for you.
Và tất nhiên, nếu đến một lúc nào đó nó đã xử lý xong dữ liệu đầu vào, tức là đã xử lý hết tất cả các tuple mà nó thấy cho đến giờ, nhưng thread ở dưới vẫn đang chạy, thì nó sẽ bị chặn và chờ thread ở dưới thông báo rằng không còn kết quả nào cho nó nữa.
This is a pipeline, yes.
Đây là một đường ống, đúng vậy.
But in theory, you could have the, I'm just trying to say that the function call, the projection, could be inside this thing here, but I want to be able to separate them.
Nhưng về lý thuyết, bạn có thể có, tôi chỉ muốn nói rằng lời gọi hàm, phép chiếu, có thể nằm ngay bên trong chỗ này, nhưng tôi muốn có thể tách chúng ra.
But again, it doesn't come for free. I've got to communicate and send data up. I've got to copy data.
Nhưng một lần nữa, điều này không miễn phí. Tôi phải giao tiếp và gửi dữ liệu lên trên. Tôi phải sao chép dữ liệu.
So it's more expensive to do than just fusing everything all together inside the for loop. But I can, by breaking it up, I allow it to suffocate parallelism that way.
Vì vậy cách này tốn kém hơn so với việc gộp tất cả lại với nhau bên trong vòng lặp for. Nhưng bằng cách tách nhỏ ra, tôi cho phép khai thác tính song song theo cách đó.
OK, so the last one is bushy parallelism.
Được rồi, cái cuối cùng là song song dạng bushy.
And as I said, this is just a combination of intra and interoperative parallelism, where you have different workers running on different portions of the data at the same time, and different workers are running on different segments of the query plan at the same time.
Và như tôi đã nói, đây chỉ là sự kết hợp của song song nội toán tử và song song liên toán tử, trong đó có các worker khác nhau chạy trên các phần dữ liệu khác nhau cùng một lúc, và các worker khác nhau cũng chạy trên các đoạn khác nhau của kế hoạch truy vấn cùng một lúc.
So this is a contrived example. I'm doing a Cartesian product or cross join between four tables, A, B, C, and D.
Đây là một ví dụ giả định. Tôi đang thực hiện tích Descartes hay cross join giữa bốn bảng A, B, C và D.
But I could have the bottom part here doing a join, and that can just run in separate workers, and that's just crunching through and computing results.
Nhưng tôi có thể cho phần dưới ở đây thực hiện một phép join, và phép đó có thể chạy trong các worker riêng biệt, cứ thế xử lý và tính ra kết quả.
And then as they get output, I could have another set of workers building the hash tables and then doing joins, and all these can run in parallel to produce my final result.
Và khi chúng có đầu ra, tôi có thể có một nhóm worker khác xây dựng các bảng băm rồi thực hiện các phép join, và tất cả những thứ này có thể chạy song song để tạo ra kết quả cuối cùng.
Again, so I'm getting the, going back here, this bottom portion here is the intraoperative parallelism. So within my query plan, I'm having different portions operate on the same thing.
Một lần nữa, quay lại chỗ này, phần dưới ở đây là song song nội toán tử. Vậy trong kế hoạch truy vấn của tôi, các phần khác nhau cùng thao tác trên cùng một thứ.
And each of these ones, I could fork out multiple times.
Và với mỗi phần như vậy, tôi có thể tách ra nhiều lần.
And then within the same query plan, I can also scale up the number of workers that are running at the same time for different parts of the query plan.
Và trong cùng một kế hoạch truy vấn, tôi cũng có thể tăng số lượng worker chạy cùng lúc cho các phần khác nhau của kế hoạch truy vấn.
So that's the vertical parallelism.
Đó là song song theo chiều dọc.
The question is, is this, sorry, this is doing Cartesian products. So I take join of A, B, and it's going to produce all combinations of A and B.
Câu hỏi là, xin lỗi, ở đây đang thực hiện tích Descartes. Tôi lấy phép join của A, B, và nó sẽ tạo ra mọi tổ hợp của A và B.
And this would take all combinations of C and D, and now you produce all combinations all together.
Còn phép này sẽ lấy mọi tổ hợp của C và D, rồi bạn tạo ra mọi tổ hợp của tất cả với nhau.
So the question is, is this an optimized query plan? Is this an optimal query plan? It depends on the data.
Vậy câu hỏi là, đây có phải là một kế hoạch truy vấn đã được tối ưu không? Đây có phải là kế hoạch truy vấn tối ưu không? Điều đó tùy vào dữ liệu.
It may be better to join A, B, followed by joining C, and then followed by joining D. This is called a bushy join. We'll see this in the next class.
Có thể tốt hơn nếu join A, B, rồi join với C, và sau đó join với D. Cái này gọi là bushy join. Chúng ta sẽ thấy nó trong buổi học sau.
In some cases, sometimes this is better. Most systems will actually not give you a query plan that looks like this. They'll give you left deep join.
Trong một số trường hợp, đôi khi cách này tốt hơn. Thực ra hầu hết các hệ thống sẽ không đưa cho bạn một kế hoạch truy vấn trông như thế này. Chúng sẽ đưa ra left deep join.
So I'll join A, B, take the output of that, join C, then join D. Because the computational complexity of searching for this plan is super high, so people don't do it.
Tức là tôi join A, B, lấy kết quả đầu ra đó, join với C, rồi join với D. Bởi vì độ phức tạp tính toán của việc tìm kiếm kế hoạch này rất cao, nên người ta không làm vậy.
Let's see if the camera wants to look at him, not me. Let's see if that works. OK. All right. Other questions? All right.
Xem camera có muốn quay bạn ấy thay vì tôi không. Xem có được không nhé. OK. Được rồi. Còn câu hỏi nào khác không? Được rồi.
So we know how to use multiple works now, execute queries in parallel. And this is great if we have a lot of CPU resources and we're CPU bound.
Vậy là giờ chúng ta đã biết cách dùng nhiều worker để thực thi truy vấn song song. Và điều này rất tốt nếu ta có nhiều tài nguyên CPU và đang bị giới hạn bởi CPU.
But oftentimes, we're not going to be CPU bound. And what's going to be the slowest thing? Disk. Now, in the modern era, disks have gotten really, really fast in the last five years.
Nhưng thường thì chúng ta sẽ không bị giới hạn bởi CPU. Và thứ chậm nhất sẽ là gì? Đĩa. Tuy nhiên, trong thời đại hiện nay, đĩa đã trở nên rất, rất nhanh trong năm năm qua.
So many times, CPU is going to be the bottleneck for us.
Nên nhiều khi CPU sẽ là nút thắt cổ chai của chúng ta.
But depending on where our data is actually being stored, if it's on S3, like some remote storage, that's always going to be way slower than anything we can do on the CPU side.
Nhưng tùy vào nơi dữ liệu thực sự được lưu trữ, nếu nó nằm trên S3, tức là một dạng lưu trữ từ xa, thì nó luôn chậm hơn rất nhiều so với bất cứ thứ gì ta làm được ở phía CPU.
So just because we have multiple workers, we may still not get the parallelism and the performance improvement we want.
Vì vậy, chỉ vì ta có nhiều worker thì vẫn có thể không đạt được độ song song và mức cải thiện hiệu năng mong muốn.
Because at the end of the day, we're reading and writing pages from disk, and that's going to be super slow. So this is where IO parallelism comes in.
Bởi vì cuối cùng thì ta vẫn đọc và ghi các trang từ đĩa, và việc đó sẽ rất chậm. Đây là chỗ IO parallelism xuất hiện.
And the idea is that we want to split our database, or databases, plural, across multiple storage devices so that we can get the benefit of improved bandwidth to disk because we're reading from multiple devices.
Ý tưởng là ta muốn chia cơ sở dữ liệu, hoặc nhiều cơ sở dữ liệu, ra nhiều thiết bị lưu trữ để có thể hưởng lợi từ băng thông truy cập đĩa được cải thiện, vì ta đọc từ nhiều thiết bị.
So there's a bunch of ways we can do this. We can have multiple disks per database. So again, it looks like a single logical database, but it's split across multiple physical disks.
Có nhiều cách để làm điều này. Ta có thể dùng nhiều đĩa cho mỗi cơ sở dữ liệu. Tức là nó vẫn trông như một cơ sở dữ liệu logic duy nhất, nhưng được chia ra nhiều đĩa vật lý.
We can do one database per disk, one table per disk. Or we can take a single table and split across multiple disks.
Ta có thể dùng một cơ sở dữ liệu cho mỗi đĩa, một bảng cho mỗi đĩa. Hoặc ta có thể lấy một bảng duy nhất và chia ra nhiều đĩa.
The high-end systems will let you have complete control of all of these different factors. Like in Oracle, you can specify exactly the location of data for tables.
Các hệ thống cao cấp cho phép bạn kiểm soát hoàn toàn tất cả các yếu tố khác nhau này. Ví dụ trong Oracle, bạn có thể chỉ định chính xác vị trí dữ liệu của các bảng.
You can specify where you want the write-ahead log, which we haven't covered yet, but that's basically the thing of the recovery log.
Bạn có thể chỉ định nơi đặt write-ahead log, mà chúng ta chưa học, nhưng về cơ bản nó là nhật ký khôi phục.
I can put that on one disk and put the database itself, the actual tables themselves, on another disk. So I get the parallelism that way.
Tôi có thể đặt nó trên một đĩa và đặt chính cơ sở dữ liệu, tức là các bảng thực sự, trên một đĩa khác. Như vậy tôi có được tính song song theo cách đó.
Postgres systems control this a little bit with what they call table spaces. But oftentimes, the lower-end systems, like MySQL, for example, they don't have a notion of physical locations of the data.
Hệ thống Postgres kiểm soát điều này phần nào bằng thứ gọi là table space. Nhưng thường thì các hệ thống cấp thấp hơn, như MySQL chẳng hạn, không có khái niệm về vị trí vật lý của dữ liệu.
But you can basically do the same thing at the administrative level by using sim links and things like that to put files in different devices.
Nhưng về cơ bản bạn vẫn có thể làm điều tương tự ở cấp quản trị bằng cách dùng symlink và những thứ tương tự để đặt các tệp trên các thiết bị khác nhau.
But the dataset itself is not aware of the characteristics of the disk that it's reading from or writing from. It just sees a single disk location. It just sees a single logical file system.
Nhưng bản thân hệ cơ sở dữ liệu không biết các đặc tính của đĩa mà nó đang đọc hoặc ghi. Nó chỉ thấy một vị trí đĩa duy nhất. Nó chỉ thấy một hệ thống tệp logic duy nhất.
So it should be obvious where we want to do this, but now there's a bunch of trade-offs we have to consider.
Vậy nên rõ ràng là ta muốn làm điều này ở đâu, nhưng giờ có một loạt đánh đổi mà ta phải cân nhắc.
Where do we want to start splitting our database and putting it on different files or different locations on disk?
Ta muốn bắt đầu chia cơ sở dữ liệu ở đâu và đặt nó vào các tệp khác nhau hoặc các vị trí khác nhau trên đĩa?
And it's very similar to the trade-offs we'll see in a distributed system of where we start putting the data across multiple nodes.
Điều này rất giống với những đánh đổi ta sẽ thấy trong một hệ phân tán, tức là ta bắt đầu đặt dữ liệu lên nhiều nút ở chỗ nào.
Because sometimes, it'll make things go faster, but we'll have less guarantees about the durability and safety of our data.
Vì đôi khi nó sẽ làm mọi thứ chạy nhanh hơn, nhưng ta có ít bảo đảm hơn về độ bền và độ an toàn của dữ liệu.
Or we could have great durability and safety of our data, but now things are going to go a lot slower because now I've got to make sure everybody is synchronized and up to date.
Hoặc ta có thể có độ bền và độ an toàn dữ liệu rất tốt, nhưng lúc này mọi thứ sẽ chậm hơn nhiều vì tôi phải bảo đảm mọi bên đều được đồng bộ và cập nhật.
So let's say a really trivial example. I have six pages, and this is what we just see at the logical level. I have six pages.
Hãy lấy một ví dụ thật đơn giản. Tôi có sáu trang, và đây là những gì ta thấy ở mức logic. Tôi có sáu trang.
I don't really know where they're being stored, but I know I can address each of them.
Tôi không thực sự biết chúng được lưu ở đâu, nhưng tôi biết mình có thể đánh địa chỉ từng trang.
And so now if I want to split this across, say, three disks, I want to start away so the two extremes would be mirroring it everywhere versus striping the data.
Giờ nếu tôi muốn chia dữ liệu này ra, giả sử, ba đĩa, thì hai thái cực sẽ là phản chiếu (mirroring) dữ liệu ra mọi nơi so với dải hóa (striping) dữ liệu.
And in practice, you can do something in between the two of them.
Và trong thực tế, bạn có thể làm một giải pháp nằm giữa hai cách đó.
So if you're familiar with RAID, the way you, redundant array of independent disks, RAID 0 level is where you're just striping, where I'll basically do round-robin writing of the data.
Nếu bạn quen với RAID, tức là mảng dư thừa các đĩa độc lập, thì mức RAID 0 là khi bạn chỉ dải hóa dữ liệu, về cơ bản tôi sẽ ghi dữ liệu theo kiểu round-robin.
So page 1 goes to the first disk. Page 2 goes to the second disk. Page 3 and so forth. So each page only exists in one physical disk at any time.
Trang 1 đi vào đĩa thứ nhất. Trang 2 đi vào đĩa thứ hai. Trang 3 và cứ thế tiếp tục. Như vậy mỗi trang chỉ tồn tại trên một đĩa vật lý tại mọi thời điểm.
So now anytime I want to read data, I go to one disk and I can get the page that I want.
Vậy nên bất cứ khi nào tôi muốn đọc dữ liệu, tôi đến một đĩa và lấy được trang mình cần.
And if I have to write the data, I go to one disk and write that data.
Và nếu phải ghi dữ liệu, tôi đến một đĩa và ghi dữ liệu đó.
And if I have multiple queries and multiple workers trying to rewrite data at the same time, I get the parallelism that I want across different disks, because one worker could be going to this first disk, another worker could go to the second disk.
Và nếu có nhiều truy vấn và nhiều worker cùng cố ghi lại dữ liệu cùng lúc, tôi có được tính song song mong muốn trên các đĩa khác nhau, vì một worker có thể đi đến đĩa đầu tiên này, còn một worker khác có thể đi đến đĩa thứ hai.
Ignoring bandwidth issues of getting data up to memory, we ignore that for now. But I get the parallelism I want, because now these things are completely independent of each other.
Tạm bỏ qua vấn đề băng thông khi đưa dữ liệu lên bộ nhớ, giờ ta bỏ qua điều đó. Nhưng tôi có được tính song song mong muốn, vì lúc này các thứ này hoàn toàn độc lập với nhau.
Of course, the downside is that if I lose one disk, then I lose one third of my database. And that could be catastrophic. If it's your bank account on that disk, you care.
Tất nhiên, nhược điểm là nếu tôi mất một đĩa, thì tôi mất một phần ba cơ sở dữ liệu. Và điều đó có thể là thảm họa. Nếu đó là tài khoản ngân hàng của bạn trên đĩa ấy, bạn sẽ quan tâm.
The other extreme is called RAID 1 or mirroring. Well, that's where for every single disk page, I'm going to write that to all my disks, complete copy of it.
Thái cực còn lại gọi là RAID 1, hay phản chiếu. Đó là khi với mỗi trang đĩa, tôi sẽ ghi nó vào tất cả các đĩa, một bản sao hoàn chỉnh.
And then I don't report back to the data server, the disk manager, that my data is successfully being written until I successfully fsync across all three storage devices.
Và tôi không báo lại cho máy chủ dữ liệu, tức bộ quản lý đĩa, rằng dữ liệu đã được ghi thành công cho đến khi tôi fsync thành công trên cả ba thiết bị lưu trữ.
So this makes reads go really great, because I can read any page I want from any disk. And now I can have a load balance above this deciding what disk I want to have.
Cách này làm việc đọc chạy rất tốt, vì tôi có thể đọc bất kỳ trang nào từ bất kỳ đĩa nào. Và giờ tôi có thể đặt một bộ cân bằng tải phía trên để quyết định dùng đĩa nào.
So I maximize bandwidth across all of them.
Nhờ đó tôi tối đa hóa băng thông trên tất cả các đĩa.
But of course, this makes writes go bad or grow slowly, because now I've got to update the same page across three different disks and make sure they're all in sync before I report back to the application that I've successfully stored the data you asked us to.
Nhưng tất nhiên, điều này làm cho việc ghi trở nên tệ đi, hay nói cách khác là chậm hơn, vì bây giờ tôi phải cập nhật cùng một trang trên ba đĩa khác nhau và đảm bảo tất cả chúng đều đồng bộ trước khi báo lại cho ứng dụng rằng tôi đã lưu thành công dữ liệu mà bạn yêu cầu.
So two different ways to do this. One is that you can buy storage devices that have a built-in I-O controller that can do this mirroring for you.
Vậy có hai cách khác nhau để làm việc này. Một là bạn có thể mua các thiết bị lưu trữ có sẵn bộ điều khiển I/O tích hợp để thực hiện việc sao lưu gương (mirroring) này cho bạn.
But this actually would be transparent to the database system, because it'll look like a single logical file system. Underneath the covers, it's storing the data across different ways.
Nhưng cách này thực ra là trong suốt đối với hệ quản trị cơ sở dữ liệu, vì nó trông như một hệ thống tệp logic duy nhất. Bên dưới lớp vỏ đó, dữ liệu được lưu trữ theo nhiều cách khác nhau.
A better approach, and what most systems are going to do, is sort of software-based. So I don't mean like software RAID, where it's at the file system level.
Một cách tốt hơn, và là cách mà hầu hết các hệ thống sẽ làm, là dựa trên phần mềm. Ý tôi không phải là RAID phần mềm, tức là ở mức hệ thống tệp.
But now inside the database system itself, I basically have code that can do the different types of these storage layouts inside my own data system, because now I know where the data is being stored.
Mà là ngay bên trong chính hệ quản trị cơ sở dữ liệu, tôi có mã nguồn có thể thực hiện các kiểu bố trí lưu trữ này bên trong hệ thống dữ liệu của mình, vì lúc này tôi biết dữ liệu đang được lưu ở đâu.
I know the implications of losing one disk versus another disk. I have all complete management of everything. And again, this is what the high-end systems will do for you.
Tôi biết hệ quả của việc mất đĩa này so với đĩa khác. Tôi toàn quyền quản lý mọi thứ. Và một lần nữa, đây là điều mà các hệ thống cao cấp sẽ làm cho bạn.
Oracle has a bunch of capabilities in this space. It's faster. It's more flexible than just relying on, again, transparent RAID or transparent hardware to do this for you.
Oracle có hàng loạt khả năng trong mảng này. Nó nhanh hơn. Nó linh hoạt hơn so với việc chỉ dựa vào RAID trong suốt hay phần cứng trong suốt để làm việc này cho bạn.
But again, you only see the software one to do all this kind of stuff in the expensive systems.
Nhưng một lần nữa, bạn chỉ thấy cách dùng phần mềm để làm tất cả những việc này trong các hệ thống đắt tiền.
So there's this trade-off between how fast I want my data systems to be, how safe or durable I want my data to be, and then my storage capacity.
Vì vậy có một sự đánh đổi giữa việc tôi muốn hệ thống dữ liệu nhanh đến đâu, dữ liệu an toàn hay bền vững đến đâu, và dung lượng lưu trữ của tôi.
Because I have to buy more disks now if I'm mirroring everything and having complete copies of my database, because if my database is one terabyte, I can't use a bunch of smaller disks and get the composite one terabyte I need.
Bởi vì giờ tôi phải mua thêm đĩa nếu sao lưu gương mọi thứ và giữ các bản sao đầy đủ của cơ sở dữ liệu, vì nếu cơ sở dữ liệu của tôi là một terabyte, tôi không thể dùng nhiều đĩa nhỏ hơn rồi gộp lại thành một terabyte cần thiết.
I have to have one terabyte per disk because I need to copy the whole thing, the whole database, inside that disk at a time.
Tôi phải có một terabyte cho mỗi đĩa vì tôi cần sao chép toàn bộ, toàn bộ cơ sở dữ liệu, vào mỗi đĩa.
So in the database world, if you really care about data and you don't want to lose data, chances are you usually have money. And so you don't go cheap on your database system.
Vì vậy trong thế giới cơ sở dữ liệu, nếu bạn thật sự quan tâm đến dữ liệu và không muốn mất dữ liệu, thì nhiều khả năng là bạn có tiền. Và vì thế bạn không tiết kiệm cho hệ thống cơ sở dữ liệu của mình.
And so capacity is less of an issue. It's more of the trade-off between durability and performance, because you just throw more money at it to get more capacity.
Và do đó dung lượng ít là vấn đề hơn. Điều quan trọng hơn là sự đánh đổi giữa độ bền vững và hiệu năng, vì bạn chỉ cần bỏ thêm tiền ra để có thêm dung lượng.
I say that, but 99 of the databases are running on the same box as the web server, which you're not supposed to do, but everyone does, because if it's WordPress, who cares?
Tôi nói vậy, nhưng 99 cơ sở dữ liệu đang chạy trên cùng một máy với máy chủ web, điều mà bạn không nên làm, nhưng ai cũng làm, vì nếu là WordPress thì ai quan tâm chứ?
But think of your bank. Think of Visa, MasterCard, big financial companies. They have infinite money, and they really care about those two factors. Capacity is less of an issue.
Nhưng hãy nghĩ đến ngân hàng của bạn. Hãy nghĩ đến Visa, MasterCard, các công ty tài chính lớn. Họ có tiền vô hạn, và họ thực sự quan tâm đến hai yếu tố đó. Dung lượng ít là vấn đề hơn.
Of course, now this means your database system is running on expensive hardware, and you don't want to put a lot of data in it stupidly, because then it makes it even more expensive, and you run out of capacity, and you have to manage it that way.
Tất nhiên, điều này nghĩa là hệ thống cơ sở dữ liệu của bạn chạy trên phần cứng đắt tiền, và bạn không muốn nhét nhiều dữ liệu vào đó một cách ngớ ngẩn, vì như vậy sẽ càng đắt hơn, và bạn sẽ hết dung lượng, và phải quản lý theo cách đó.
That's a separate issue. This is mostly an issue for transactional workloads. In the cloud now, everyone just runs on S3, and that's infinite capacity, and they'll handle the durability for you.
Đó là một vấn đề riêng. Vấn đề này chủ yếu xảy ra với các workload giao dịch. Trên đám mây hiện nay, ai cũng chỉ chạy trên S3, và đó là dung lượng vô hạn, và họ sẽ lo phần độ bền dữ liệu cho bạn.
Performance depends on how much parallelism you can get reading data out, how much you want to cache things on the local side. That's a distributed database problem. We'll cover that later.
Hiệu năng phụ thuộc vào mức song song mà bạn đạt được khi đọc dữ liệu ra, và bạn muốn cache bao nhiêu thứ ở phía cục bộ. Đó là bài toán của cơ sở dữ liệu phân tán. Chúng ta sẽ học sau.
So another thing we were handily about today as well is partitioning. Basically, again, take a single table or a database, and you want to split it up into these disjoint subsets.
Một điều nữa mà hôm nay tôi cũng chỉ nói qua loa là phân vùng (partitioning). Về cơ bản, một lần nữa, lấy một bảng hoặc một cơ sở dữ liệu, và bạn muốn chia nó thành các tập con rời nhau.
And I was being handily about it, saying, oh, you could just split them based on ranges of pages, or you could hash a value, like we did in the Divide and Conquer stuff with hash tables, to split things up.
Tôi đã nói qua loa về nó, rằng là, bạn có thể chia dựa trên các khoảng trang, hoặc bạn có thể băm một giá trị, như chúng ta đã làm với phần chia để trị với bảng băm, để chia nhỏ dữ liệu ra.
I'm being handily about that because we'll cover that more in a few weeks.
Tôi nói qua loa vì vài tuần nữa chúng ta sẽ học kỹ hơn.
But the database, again, has complete control over where it's writing data to and understands that there's this disk there, and there's that disk there, and this data needs to go to this disk versus that disk.
Nhưng cơ sở dữ liệu, một lần nữa, có toàn quyền kiểm soát nơi nó ghi dữ liệu và hiểu rằng có đĩa này ở đây, và đĩa kia ở đó, và dữ liệu này cần đi vào đĩa này chứ không phải đĩa kia.
It can make better decisions about how it wants to split things up. And partitioning is one of the ways that it's going to be able to do this for us.
Nó có thể đưa ra quyết định tốt hơn về cách chia nhỏ dữ liệu. Và phân vùng là một trong những cách giúp nó làm được điều đó.
And we'll see different types of partitioning, where we can now take a single logical table and then split it up into these disjoint subsets that we can then route to different storage devices separately.
Và chúng ta sẽ thấy các kiểu phân vùng khác nhau, trong đó ta có thể lấy một bảng logic duy nhất rồi chia nó thành các tập con rời nhau mà sau đó ta có thể định tuyến riêng đến các thiết bị lưu trữ khác nhau.
And again, we don't have to rewrite anything in our application code at the SQL level because we're just accessing tables.
Và một lần nữa, ta không phải viết lại gì trong mã ứng dụng ở mức SQL vì ta chỉ đang truy cập các bảng.
We don't know how things are actually being physically split up and how things would be running parallel. All of that is hidden for us, ideally. Most systems, that's the case.
Ta không biết dữ liệu thực sự được chia nhỏ về mặt vật lý như thế nào và việc chạy song song diễn ra ra sao. Tất cả những điều đó được ẩn đi với ta, lý tưởng là vậy. Hầu hết các hệ thống đều như thế.
We saw this before when we talked about column stores versus row stores.
Chúng ta đã thấy điều này trước đây khi nói về column store so với row store.
Row store was taking all the data for a single tuple, and they were just contiguous with each other in a single page.
Row store lấy toàn bộ dữ liệu của một tuple, và chúng nằm liền kề nhau trong một trang.
And then with the column store, we were saying, oh, take just the data for one column across all the tuples in a table and store that in a separate page.
Còn với column store, chúng ta nói rằng, hãy lấy chỉ dữ liệu của một cột trên tất cả các tuple trong bảng và lưu nó vào một trang riêng.
That's basically the same thing as vertical partitioning. I'm splitting my table up, my record up, into different pieces based on the columns.
Về cơ bản đó chính là phân vùng dọc. Tôi chia bảng của mình, bản ghi của mình, thành các phần khác nhau dựa trên các cột.
And I can now store them in separate files, separate pages, separate storage devices.
Và giờ tôi có thể lưu chúng trong các tệp riêng, các trang riêng, các thiết bị lưu trữ riêng.
So we've seen this technique before, but we'll see it more explicitly when we talk about distributed databases because that's going to be how they're going to scale out across multiple machines.
Vậy là chúng ta đã thấy kỹ thuật này trước đây, nhưng sẽ thấy nó rõ ràng hơn khi nói về cơ sở dữ liệu phân tán vì đó sẽ là cách chúng mở rộng quy mô trên nhiều máy.
So to finish up, parallel execution is super common.
Để kết thúc, thực thi song song là rất phổ biến.
And it's how the JSON is going to be able to get the better performance, taking advantage of the additional computational resources and storage resources that are now available to us in the modern world.
Và đó là cách hệ thống có thể đạt hiệu năng tốt hơn, tận dụng các tài nguyên tính toán bổ sung và tài nguyên lưu trữ hiện có trong thế giới hiện đại ngày nay.
Your cell phone has more threads or more CPU cores than the database systems from the 1980s.
Điện thoại của bạn có nhiều luồng hay nhiều lõi CPU hơn các hệ quản trị cơ sở dữ liệu của thập niên 1980.
It's infinitely faster, but it has just more computational power, more threads, more cores that they can take advantage of.
Nó nhanh hơn vô cùng, nhưng nó có nhiều sức mạnh tính toán hơn, nhiều luồng hơn, nhiều lõi hơn mà chúng ta có thể tận dụng.
So you need to design your data system to be able to use all these things.
Vì vậy bạn cần thiết kế hệ thống dữ liệu của mình để có thể dùng tất cả những thứ này.
We'll see this later on, but the multiple workers are also going to allow us to do not just hide the disk latency. Like, I've got to do something with disk from across the network.
Chúng ta sẽ thấy điều này sau, nhưng nhiều worker cũng sẽ cho phép chúng ta làm không chỉ là che giấu độ trễ của đĩa. Ví dụ, tôi phải làm gì đó với đĩa ở bên kia mạng.
I can have other workers keep running while my worker is paused. But we're going to be able to do the same thing now when we run multiple queries.
Tôi có thể để các worker khác tiếp tục chạy trong khi worker của tôi bị tạm dừng. Nhưng giờ chúng ta cũng có thể làm điều tương tự khi chạy nhiều truy vấn.
I'm going to update the dataset at the same time in parallel because now I can basically control who can run what and when.
Tôi sẽ cập nhật tập dữ liệu cùng lúc, song song, vì giờ về cơ bản tôi có thể kiểm soát ai được chạy cái gì và khi nào.
And I would know that this worker for this query is waiting for this other query to finish, commit whatever changes this made before my query can start running.
Và tôi sẽ biết rằng worker này của truy vấn này đang chờ truy vấn kia kết thúc, commit mọi thay đổi mà nó đã thực hiện trước khi truy vấn của tôi có thể bắt đầu chạy.
Hello. Sorry. Can you pause that? All right, sorry.
Xin chào. Xin lỗi. Bạn tạm dừng cái đó được không? Được rồi, xin lỗi.
So I can run these multiple workers at the same time, and I can have complete control of who's allowed to run when based on the data they want to modify and the data that other queries have modified.
Vậy tôi có thể chạy nhiều worker này cùng lúc, và tôi có toàn quyền kiểm soát ai được phép chạy khi nào dựa trên dữ liệu họ muốn sửa đổi và dữ liệu mà các truy vấn khác đã sửa đổi.
So we have complete control of everything in our database system, and we know exactly what every query wants to do. We can then make the best decision on how to parallelize things.
Như vậy chúng ta có toàn quyền kiểm soát mọi thứ trong hệ quản trị cơ sở dữ liệu, và chúng ta biết chính xác mỗi truy vấn muốn làm gì. Từ đó chúng ta có thể đưa ra quyết định tốt nhất về cách song song hóa.
Instead of just letting OS take the wheel and do whatever it wants. Because it doesn't know what the queries actually want to do. OK. All right.
Thay vì để hệ điều hành nắm quyền và muốn làm gì thì làm. Vì nó không biết các truy vấn thực sự muốn làm gì. Được rồi.
So next class will be us beginning the discussion about how do we, again, take a SQL query and generate that physical plan that we then can actually execute.
Buổi sau chúng ta sẽ bắt đầu thảo luận về việc làm thế nào để, một lần nữa, lấy một truy vấn SQL và tạo ra kế hoạch vật lý mà sau đó chúng ta có thể thực thi.
And it's not just deciding what the shape of the query pan looks like.
Và nó không chỉ là quyết định hình dạng của kế hoạch truy vấn trông như thế nào.
So he was asking, I showed what I call a bushy joins, where I'm joining with A and B and C and D, and they run a parallel, and they take the output of those and joins them together.
Bạn ấy đã hỏi, tôi đã cho xem cái mà tôi gọi là bushy join, nơi tôi join A với B và C với D, và chúng chạy song song, rồi lấy đầu ra của chúng và join lại với nhau.
Do I generate plans that look like that? Or do I join A and B first, followed by C, followed by D? Or do I join B first, A first?
Tôi có tạo ra các kế hoạch trông như thế không? Hay tôi join A và B trước, rồi đến C, rồi đến D? Hay tôi join B trước, hay A trước?
All those decisions of what the actual physical plan is going to look like, that's what we'll start talking about on Monday next week.
Tất cả những quyết định về kế hoạch vật lý thực sự trông như thế nào, đó là điều chúng ta sẽ bắt đầu nói vào thứ Hai tuần sau.
And again, I fully admit, this is going to be the hardest part about database systems, do query optimization.
Và một lần nữa, tôi hoàn toàn thừa nhận, đây sẽ là phần khó nhất của hệ cơ sở dữ liệu: tối ưu hóa truy vấn.
So we'll go through it at a high level first about how we're actually going to search for different plans.
Vì vậy trước tiên chúng ta sẽ đi qua ở mức tổng quan về cách chúng ta thực sự tìm kiếm các kế hoạch khác nhau.
And then on Wednesday next week, we'll talk about how we cost them to decide whether one plan is actually better than another.
Và rồi vào thứ Tư tuần sau, chúng ta sẽ nói về cách tính chi phí của chúng để quyết định liệu kế hoạch này có thực sự tốt hơn kế hoạch kia hay không.
And the dirty secret's going to be... it's not a dirty secret. It's well known. Everybody's query optimizer is terrible. Everybody does a terrible job at this.
Và bí mật không hay ho sẽ là... mà không phải bí mật đâu. Ai cũng biết. Bộ tối ưu hóa truy vấn của ai cũng tệ. Ai cũng làm việc này rất tệ.
The question is, how worse are you compared to other database systems? And the challenge is going to be, because you're basically making decisions on incomplete data.
Câu hỏi là, bạn tệ hơn các hệ cơ sở dữ liệu khác đến mức nào? Và thách thức sẽ là, vì về cơ bản bạn đang đưa ra quyết định dựa trên dữ liệu không đầy đủ.
Like, I can't know exactly what the query's going to do until I run it. But I've got to decide what I'm going to do before I run it.
Chẳng hạn, tôi không thể biết chính xác truy vấn sẽ làm gì cho đến khi chạy nó. Nhưng tôi phải quyết định mình sẽ làm gì trước khi chạy nó.
And so they'll have these summaries and statistics to try to extrapolate what the data actually looks like. But everyone's going to be terrible at this.
Vì vậy họ sẽ có những bản tóm tắt và thống kê để cố suy ra dữ liệu thực sự trông như thế nào. Nhưng ai cũng sẽ làm việc này rất tệ.
And so we'll understand why more next week on Wednesday. But Monday's class will be mostly about how do we actually structure these things. OK? Thanks for having me.
Và chúng ta sẽ hiểu rõ hơn lý do vào thứ Tư tuần sau. Nhưng buổi học thứ Hai chủ yếu sẽ nói về việc chúng ta thực sự cấu trúc những thứ này như thế nào. Được chứ? Cảm ơn đã mời tôi.
If you saw my talk a week and a half ago, some of this will overlap. I'm seeing a spiral.
Nếu các bạn đã xem bài nói của tôi một tuần rưỡi trước, một phần nội dung sẽ trùng lặp. Tôi thấy có người đang xoay ghế.
Before that, I guess the most relevant thing is I was one of the key people behind Foundry, the Palantir. So this is hopefully my second successful exabyte scale database thing.
Trước đó, tôi nghĩ điều liên quan nhất là tôi từng là một trong những người chủ chốt đằng sau Foundry, của Palantir. Vì vậy hy vọng đây là sản phẩm cơ sở dữ liệu quy mô exabyte thành công thứ hai của tôi.
I'm actually going to start with a bit of a history lesson, ancient history. I guess most of you are undergrads. You don't even remember 2005, probably. Anyway, 2005 was about when Dennard scaling ended.
Thật ra tôi sẽ bắt đầu bằng một chút bài học lịch sử, lịch sử xa xưa. Tôi đoán phần lớn các bạn là sinh viên đại học. Có lẽ các bạn còn không nhớ năm 2005. Dù sao thì khoảng năm 2005 là lúc Dennard scaling kết thúc.
So that was the end of cores get faster. Like CPUs today are kind of the same gigahertz-ish as CPUs from 20 years ago.
Tức là kết thúc thời kỳ lõi ngày càng nhanh hơn. Chẳng hạn CPU ngày nay có xung nhịp cỡ gigahertz, gần giống CPU của 20 năm trước.
But Moore's Law continued because we moved to sort of multiprocessor CPUs. This is hardware from 2005. If you need a reference point, we all play the same cell phone game.
Nhưng định luật Moore vẫn tiếp tục vì chúng ta chuyển sang các CPU đa xử lý. Đây là phần cứng năm 2005. Nếu cần một mốc tham chiếu, thì ai cũng chơi chung một trò chơi trên điện thoại.
This is exactly what I'm saying. You can see the sort of shift around 2005. To now there are two cores, but the black line represents clock speed.
Đúng là điều tôi đang nói. Các bạn có thể thấy bước chuyển quanh năm 2005. Đến nay có hai lõi, nhưng đường màu đen biểu diễn tốc độ xung nhịp.
And there was a real switch over. See what I'm saying? Moore's Law, though, continued up into the right. Hardware in 2015 was actually, I think, still sort of reckoning with this.
Và đã có một sự chuyển đổi thực sự. Các bạn hiểu ý tôi chứ? Tuy nhiên, định luật Moore vẫn tiếp tục đi lên về phía bên phải. Tôi nghĩ phần cứng năm 2015 thực sự vẫn đang phải đối mặt với điều này.
Like, we moved from single cores that were really fast to lots of cores.
Chúng ta chuyển từ các lõi đơn rất nhanh sang rất nhiều lõi.
And so if you think of the era of Hadoop or Mesos and later Kubernetes, that was sort of like, how do I manage lots of cores and eventually lots of machines that are sort of providing yet more cores?
Và nếu nghĩ đến thời đại của Hadoop hay Mesos và sau này là Kubernetes, thì đó giống như câu hỏi: làm sao quản lý nhiều lõi và rồi nhiều máy để cung cấp thêm nhiều lõi nữa?
It was all about managing these large, homogenous pools of resources. There was sort of a speed hierarchy. RAM was faster than the disk. Disk was faster than the network.
Tất cả xoay quanh việc quản lý những nhóm tài nguyên lớn, đồng nhất. Có một thứ bậc về tốc độ. RAM nhanh hơn đĩa. Đĩa nhanh hơn mạng.
There was an ongoing move migrating from on-prem to the cloud. Again, showing my age, I definitely remember racking servers in weird places. And then now that's a bit less common. This is Mesos.
Khi đó đang diễn ra quá trình chuyển từ máy chủ tại chỗ lên đám mây. Lại để lộ tuổi tác, tôi chắc chắn nhớ việc lắp máy chủ vào giá ở những nơi kỳ lạ. Còn bây giờ thì ít phổ biến hơn. Đây là Mesos.
This actually, fun bit of trivia, was out of the same lab that produced Spark. And actually Spark was meant to be a proof of concept of how to run stuff on Mesos.
Một chuyện vui nhỏ: nó ra đời từ cùng phòng thí nghiệm đã tạo ra Spark. Và thực ra Spark được dự định là bản chứng minh khái niệm về cách chạy các thứ trên Mesos.
But then now Mesos is pretty much dead. And Spark went on to eat the world. What's different now, 2025, computers heterogeneous. So sort of GPU compute is probably here to stay.
Nhưng giờ Mesos gần như đã chết. Còn Spark thì đã thống trị thế giới. Điều khác biệt bây giờ, năm 2025, là máy tính không đồng nhất. Tức là tính toán bằng GPU có lẽ sẽ còn ở lại.
All your money goes to Jensen Huang, if you get the meme reference of all your base server belong to us.
Tất cả tiền của bạn đều chảy về Jensen Huang, nếu bạn hiểu meme “all your base are belong to us”.
The other thing is that that speed hierarchy I talked about still holds for latency, but doesn't hold any more for bandwidth or throughput. So network cards have dramatically more bandwidth than a PCIe bus.
Một điều nữa là thứ bậc tốc độ mà tôi nói vẫn đúng với độ trễ, nhưng không còn đúng với băng thông hay thông lượng. Card mạng có băng thông lớn hơn rất nhiều so với bus PCIe.
So that's to say that copying from RAM to the GPU has potentially much less bandwidth than copying over the network. And storage generally is both faster and slower.
Nghĩa là việc sao chép từ RAM sang GPU có có thể có băng thông thấp hơn nhiều so với việc sao chép qua mạng. Còn lưu trữ nói chung thì vừa nhanh hơn lại vừa chậm hơn.
So I think there's been a bifurcation away from hard disks, like physically spinning HDDs, towards object storage, which are backed by physically spinning HDDs, typically, and NVMe, which is sort of ultra fast.
Tôi nghĩ đã có sự phân hóa, rời xa ổ cứng, tức là các ổ HDD quay vật lý, để chuyển sang object storage, mà thường vẫn được hỗ trợ bởi các ổ HDD quay vật lý, và NVMe, loại cực kỳ nhanh.
That actually stands for basically non-volatile memory express, effectively, that's the thing. They're ultra fast disks on local device.
Thực ra nó là viết tắt của non-volatile memory express, về cơ bản thì đó chính là nó. Chúng là những ổ đĩa cực nhanh gắn trên thiết bị cục bộ.
And then now we're seeing multicloud setups are prevalent, especially amongst those, the various AI players or anyone doing GPUs, because they essentially need multiple providers.
Và giờ chúng ta thấy các mô hình multicloud đang phổ biến, đặc biệt là trong số các hãng AI khác nhau hoặc bất kỳ ai dùng GPU, vì về cơ bản họ cần nhiều nhà cung cấp.
And so starting to see on-premise kind of coming back, their Neo clouds, like CoreWeave, are having a bit of a moment.
Và bắt đầu thấy mô hình on-premise quay trở lại, các Neo cloud như CoreWeave đang có một thời điểm nổi bật.
Paralleling all of that is what I usually talked about, sort of three areas of databases.
Song song với tất cả những điều đó là điều tôi thường nói tới, ba mảng của cơ sở dữ liệu.
Postgres actually predates all of us, but you can think of it as even some of the decisions in Postgres around process per connection predate to when its cores were getting faster.
Thực ra Postgres có trước tất cả chúng ta, nhưng bạn có thể coi như một số quyết định trong Postgres về mô hình một tiến trình cho mỗi kết nối có từ thời lõi CPU đang ngày càng nhanh hơn.
But Postgres was designed originally for human-scale data in and human-scale data out. It's like, you might look at your profile, which is a row, and update the email address.
Nhưng ban đầu Postgres được thiết kế cho dữ liệu vào và dữ liệu ra ở quy mô con người. Ví dụ, bạn có thể xem hồ sơ của mình, vốn là một hàng, và cập nhật địa chỉ email.
And it's sort of, I think, Postgres, while it's expanded beyond that, as I say, it's the king of databases, is still fundamentally row-oriented, and it's sort of archetypically an application database.
Và tôi nghĩ Postgres, dù đã mở rộng ra ngoài phạm vi đó, như tôi nói, nó là vua của các cơ sở dữ liệu, về cơ bản vẫn hướng hàng, và là một cơ sở dữ liệu ứng dụng điển hình.
Afterwards, around all the stuff I said about Hadoop, Mesos, multicore processors, big data, that was the late aughts through most of the 2010s, was where we automated data collection.
Sau đó, xoay quanh những thứ tôi đã nói về Hadoop, Mesos, bộ xử lý đa lõi, dữ liệu lớn, đó là cuối những năm 2000 đến hết phần lớn thập niên 2010, khi chúng ta tự động hóa việc thu thập dữ liệu.
And so there were sort of the, we still had like machine, what I would call machine-scale data in, but human-scale outputs. You might distill terabytes into a chart or a table in a dashboard.
Và khi đó vẫn còn, cái mà tôi gọi là dữ liệu vào ở quy mô máy, nhưng đầu ra ở quy mô con người. Bạn có thể chắt lọc hàng terabyte thành một biểu đồ hay một bảng trên dashboard.
And I think Andy and Michael Stonebraker had a really great paper sort of talking about this whole era.
Và tôi nghĩ Andy và Michael Stonebraker có một bài báo rất hay nói về toàn bộ kỷ nguyên này.
And it's like, you know, a lot of it was, let's throw out all the stuff we think we know, all the Postgres things, all the tables.
Và nó kiểu như, phần lớn là, hãy vứt bỏ hết những gì ta nghĩ là mình biết, mọi thứ của Postgres, mọi bảng.
The future is MapReduce and Data Lakes and NoSQL. And all of that was really, those were strategies of dealing with, I think, in many ways, the shift in the underlying hardware.
Tương lai là MapReduce, Data Lake và NoSQL. Và tất cả những thứ đó thực chất là các chiến lược để đối phó với, theo nhiều cách, sự thay đổi của phần cứng bên dưới.
So moving from sort of like single CPU to many CPU. And so we had to manage this multicore parallelism.
Tức là chuyển từ một CPU sang nhiều CPU. Và vì vậy chúng ta phải quản lý tính song song đa lõi này.
And these sort of revolutionaries, for lack of a better way to put it, unlocked a lot of short-term scale. I like to make fun of web scale as a concept.
Và những nhà cách mạng này, tôi không biết nói thế nào hơn, đã mở ra rất nhiều khả năng mở rộng ngắn hạn. Tôi hay đem web scale ra làm trò đùa.
But in the end, they came back around to sort of tables are useful after all. And that's what people refer to today as the lake house.
Nhưng cuối cùng họ lại quay về với quan điểm rằng rốt cuộc các bảng vẫn hữu ích. Và đó là thứ ngày nay người ta gọi là lakehouse.
This is how I feel roughly about everything, not just Hive, but the entire lake house concept, which is someone decided to take a bee and an elephant and somehow hybridize them in a weird way.
Đại khái đó là cảm nhận của tôi về mọi thứ, không chỉ Hive, mà cả toàn bộ khái niệm lake house, tức là có ai đó quyết định lấy một con ong và một con voi rồi bằng cách nào đó lai ghép chúng theo một kiểu kỳ quặc.
It's like lake house tables, I think, more like duct-typed and duct-taped together.
Tôi nghĩ các bảng lake house giống như được ghép bằng duck typing và dán lại bằng băng keo với nhau hơn.
We're now in what I describe as the machine consumer era. So we're starting to see a demand for databases where the output is massive.
Giờ chúng ta đang ở trong thời đại mà tôi gọi là kỷ nguyên người dùng là máy. Nên chúng ta bắt đầu thấy nhu cầu về các cơ sở dữ liệu có đầu ra cực lớn.
And so, you know, you get machine scale data in, and we have queries where the results that might be sort of need to be set to terabits per second.
Và như vậy, bạn đưa dữ liệu quy mô máy vào, và chúng ta có những truy vấn mà kết quả có thể cần được truyền với tốc độ hàng terabit mỗi giây.
Like the results that can be many terabytes, egressing the system. And so this is pretty different. The most obvious case is something like GPU data loading.
Như kiểu kết quả có thể lên đến nhiều terabyte, thoát ra khỏi hệ thống. Và điều này khá khác biệt. Trường hợp rõ ràng nhất là việc nạp dữ liệu cho GPU.
GPUs happily consume terabits per second, but it leads to sort of different database design, including around like hybrid compute, for example, becomes the default. And this is where Spiral sits.
GPU sẵn sàng tiêu thụ hàng terabit mỗi giây, nhưng điều đó dẫn đến thiết kế cơ sở dữ liệu khác đi, bao gồm chẳng hạn hybrid compute trở thành mặc định. Và đây là chỗ Spiral đứng.
I sometimes describe Spiral as building for complex data at machine scale. And so what I mean by complex data is actually unstructured, I think, is a misnomer.
Đôi khi tôi mô tả Spiral là xây dựng cho dữ liệu phức tạp ở quy mô máy. Và khi tôi nói dữ liệu phức tạp thì thật ra tôi nghĩ gọi là phi cấu trúc là không chính xác.
So images are highly structured. Audio, video, highly structured. Vectors and tensors, insanely structured.
Hình ảnh có cấu trúc rất cao. Âm thanh, video cũng có cấu trúc rất cao. Vectơ và tensor thì có cấu trúc cực kỳ chặt chẽ.
Typically not well-served by classical database systems. I think, you know, I put this paper here from TUM, which is like, why files if you have a DBMS?
Thường không được các hệ cơ sở dữ liệu cổ điển phục vụ tốt. Tôi đưa bài báo này của TUM vào đây, với tiêu đề kiểu như: tại sao dùng tệp nếu bạn có một DBMS?
It's like, I think files are strictly inferior to a DBMS. It's just that existing DBMSs have sort of not served a bunch of use cases.
Tôi nghĩ tệp hoàn toàn kém hơn một DBMS. Chỉ là các DBMS hiện có chưa phục vụ được nhiều trường hợp sử dụng.
So practitioners fall back down to the lowest common denominator. So Spiral is an object store native, multimodal column store with primary keys and indexes.
Nên những người làm thực tế lùi về mẫu số chung thấp nhất. Spiral là một hệ lưu trữ cột đa phương thức, native trên object store, có khóa chính và chỉ mục.
There's a lot there to unpack. We're not going to get to all of it today. But we optimize for throughput.
Có rất nhiều điều cần phân tích ở đây. Hôm nay chúng ta sẽ không đi hết được. Nhưng chúng tôi tối ưu cho thông lượng.
So like I said, you know, my party trick is I can actually run a dynamic query where I get more bytes or tokens per second loaded into a GPU than if you pre-materialize the results of that query as Parquet on local disk, which is kind of, I think, mind-bending to a lot of people.
Như tôi đã nói, chiêu trò của tôi là có thể chạy một truy vấn động mà nạp vào GPU được nhiều byte hay token mỗi giây hơn so với việc bạn materialize trước kết quả truy vấn đó thành Parquet trên đĩa cục bộ, điều mà tôi nghĩ là khiến nhiều người phải kinh ngạc.
And like I say, it has to support hybrid compute across many fronts. So PyTorch is pretty important for the GPU use case.
Và như tôi nói, nó phải hỗ trợ hybrid compute trên nhiều mặt. PyTorch khá quan trọng cho trường hợp dùng GPU.
But we also need to be able to support things like Polars or DuckDB. Because actually in practice, there's a lot of data exploration that happens on basically any data set.
Nhưng chúng tôi cũng cần hỗ trợ những thứ như Polars hay DuckDB. Vì trên thực tế, có rất nhiều hoạt động khám phá dữ liệu diễn ra trên hầu như mọi tập dữ liệu.
And people want to inspect some working set locally. They say here, example workloads. There's classic columnar analytics.
Và mọi người muốn xem xét một tập làm việc nào đó ngay trên máy cục bộ. Ở đây họ nêu các workload ví dụ. Có phân tích theo cột cổ điển.
Even for these sort of AI-oriented workflows, I think filters are really important. Index lookups. Anytime someone talks about a vector database, it's really just a server that holds a vector index.
Ngay cả với các quy trình hướng AI như thế này, tôi nghĩ bộ lọc rất quan trọng. Tra cứu chỉ mục. Mỗi khi có ai nói về cơ sở dữ liệu vectơ, thực chất nó chỉ là một máy chủ giữ một chỉ mục vectơ.
I think in general, that's not the only kind of index. You know, there are inverted indices. There's also secondary indices. We maintain those. And you have two lookups.
Tôi nghĩ nhìn chung, đó không phải là loại chỉ mục duy nhất. Bạn biết đấy, có các chỉ mục đảo ngược (inverted index). Cũng có các chỉ mục phụ (secondary index). Chúng tôi duy trì những chỉ mục đó. Và bạn có hai lần tra cứu.
That's particularly relevant sometimes. The third one, which breaks the world, is pre-training, which will be like filter by this 50 density mask.
Điều đó đôi khi đặc biệt quan trọng. Trường hợp thứ ba, trường hợp phá vỡ mọi thứ, là pre-training, tức là kiểu lọc theo một mặt nạ mật độ 50 này.
So literally I need half the rows, but a very specific half of the rows. And I need those to be sharded and then shuffled, so sort of grouped together.
Nghĩa là theo đúng nghĩa đen, tôi cần một nửa số hàng, nhưng là một nửa rất cụ thể của các hàng. Và tôi cần chúng được chia shard rồi xáo trộn, tức là được nhóm lại với nhau.
And then a sense where each group is loaded in deterministic or reproducible order. So it's no longer a bag of rows.
Và sau đó theo nghĩa là mỗi nhóm được nạp theo một thứ tự xác định hoặc có thể tái lập. Vì vậy nó không còn là một túi các hàng nữa.
Because that's how sort of these things work when you go through various epochs of curriculum training.
Bởi vì đó là cách những thứ này hoạt động khi bạn đi qua nhiều epoch của curriculum training.
Anyway, the only, as I said, for my party trick of loading more tokens per second into a GPU than a pre-materialized result, the only practical way is to actually stream bytes straight from object storage.
Dù sao thì, như tôi đã nói, để thực hiện màn trình diễn nạp nhiều token hơn mỗi giây vào GPU so với một kết quả được vật chất hóa sẵn, cách khả thi duy nhất là truyền trực tiếp các byte từ object storage.
Because object stores like S3 give you actually effectively infinite throughput. So you can get, you know, the goal is, can you saturate the network card, which has more bandwidth than the PCIe bus?
Bởi vì các object store như S3 thực tế cho bạn thông lượng gần như vô hạn. Vậy nên mục tiêu là, bạn có thể làm bão hòa card mạng hay không, vốn có băng thông lớn hơn cả bus PCIe?
And then the file format in S3 defines how the bytes are actually stored. So QED, we care a lot about file formats. This is mostly a teaser.
Và định dạng tệp trong S3 quy định cách các byte thực sự được lưu trữ. Do đó, điều phải chứng minh, chúng tôi rất quan tâm đến định dạng tệp. Đây chủ yếu chỉ là phần giới thiệu sơ lược.
I gave a longer talk in Andy's sort of like future data systems seminar last week. If you didn't see it, you can see it on YouTube. Here's my teaser about Vortex.
Tôi đã có một buổi nói chuyện dài hơn trong hội thảo về hệ thống dữ liệu tương lai của Andy tuần trước. Nếu bạn chưa xem, bạn có thể xem trên YouTube. Đây là phần giới thiệu sơ lược của tôi về Vortex.
This is why we made a file format. A lot of work we do at the company is around this file format.
Đây là lý do chúng tôi tạo ra một định dạng tệp. Rất nhiều công việc chúng tôi làm ở công ty xoay quanh định dạng tệp này.
It's actually a Linux Foundation project now, so it doesn't belong to the company.
Thực ra giờ nó là một dự án của Linux Foundation, nên không còn thuộc về công ty nữa.
But, you know, it turns out we're not the only ones that kind of want to replace Parquet, which is the de facto standard. And so, you know, naturally, well, this XKCD comes to mind.
Nhưng hóa ra chúng tôi không phải là những người duy nhất muốn thay thế Parquet, vốn là tiêu chuẩn trên thực tế. Và tự nhiên, bạn sẽ nghĩ ngay đến bức tranh XKCD này.
And it turns out that's exactly what happened. There are lots of new file formats, because it turns out that Parquet is a pretty crusty, slow standard that needs lots of improvement.
Và hóa ra đó chính xác là điều đã xảy ra. Có rất nhiều định dạng tệp mới, bởi vì hóa ra Parquet là một tiêu chuẩn khá cũ kỹ, chậm và cần cải thiện rất nhiều.
And this is from Andy on Hacker News two weeks ago. I usually put my thing, I think we're in the sweet spot. I'm biased. You know, we have open governance and industrial strength implementation.
Và đây là bình luận của Andy trên Hacker News hai tuần trước. Tôi thường đưa ra quan điểm của mình, rằng chúng tôi đang ở điểm cân bằng tốt nhất. Tôi có thiên kiến. Bạn biết đấy, chúng tôi có quản trị mở và một bản triển khai đạt chuẩn công nghiệp.
And then we're at the cutting edge. And I think there are lots of other ones. I can say that the work on FastLanes and F3 and Nimble are all very much cutting edge.
Và chúng tôi ở tuyến đầu công nghệ. Và tôi nghĩ còn nhiều định dạng khác nữa. Tôi có thể nói rằng công trình về FastLanes và F3 cũng như Nimble đều rất tiên tiến.
But, you know, it's like, how do you get the intersection of all these things? That's my pitch for Vortex in a single slide.
Nhưng vấn đề là làm thế nào để có được phần giao của tất cả những thứ này? Đó là lời chào hàng của tôi cho Vortex trong một slide duy nhất.
The teaser, because I know this seminar today, like the last one, was about query execution. A unique thing about Vortex is we implement a scan operator that's highly optimized.
Phần giới thiệu sơ lược, vì tôi biết hội thảo hôm nay, giống như buổi trước, nói về thực thi truy vấn. Một điểm độc đáo của Vortex là chúng tôi triển khai một toán tử scan được tối ưu hóa cao.
So it has components of a query engine with lots of types of pushdown. And then we compile that for execution, or compiles maybe not quite the right word.
Vì vậy nó có các thành phần của một query engine với nhiều loại pushdown. Và sau đó chúng tôi biên dịch nó để thực thi, hoặc có lẽ "biên dịch" không hẳn là từ chính xác.
It's correct for GPUs, but not for CPUs, to handle either a vectorized sort of implementation on CPUs or actual direct SIMD execution on GPUs.
Nó đúng với GPU, nhưng không đúng với CPU, để xử lý hoặc một bản triển khai kiểu vector hóa trên CPU hoặc thực thi SIMD trực tiếp trên GPU.
So if you are not tired of the topic and you haven't seen the talk, you can go see it or dig around the code base.
Nên nếu các bạn chưa chán chủ đề này và chưa xem bài nói chuyện đó, thì có thể đi xem, hoặc tìm hiểu trong codebase.
The other fun thing they say about Vortex, it's outrageously fast. So for random access, it's faster.
Điều thú vị khác họ nói về Vortex là nó nhanh một cách khó tin. Với truy cập ngẫu nhiên thì nó nhanh hơn.
It's more than a hundred times faster than Parquet, but it's even faster than Lance, which is specialized for random access, for sort of write speed and scan speed.
Nhanh hơn Parquet hơn một trăm lần, và thậm chí còn nhanh hơn Lance, vốn được chuyên biệt hóa cho truy cập ngẫu nhiên, xét về tốc độ ghi và tốc độ quét.
We're looking at five and 18, 17, 18 times faster than Parquet and roughly the same size, with a lot of variance.
Chúng ta đang nói đến năm và 18, 17, 18 lần nhanh hơn Parquet và kích thước xấp xỉ nhau, với độ biến thiên khá lớn.
And then my favorite fun fact about Vortex, for those who care about file formats, is that on ClickBench on NVMe, it is faster queried from DuckDB than DuckDB natives.
Và sự thật thú vị nhất của tôi về Vortex, dành cho ai quan tâm đến định dạng tệp, là trên ClickBench với NVMe, truy vấn từ DuckDB bằng Vortex còn nhanh hơn định dạng gốc của DuckDB.
It's also going to be shipped as a core extension in the next DuckDB release, which is kind of a fun other thing to announce.
Nó cũng sẽ được phát hành như một extension cốt lõi trong bản DuckDB tiếp theo, đây cũng là một tin vui nữa để thông báo.
So yeah, if you're really into file formats and databases and implementing research, hit me up. And as Andy said, you're hiring. Connor, who graduated CMU last year, is great and is with us.
Vậy nên nếu bạn thực sự yêu thích định dạng tệp và cơ sở dữ liệu cũng như triển khai nghiên cứu, hãy liên hệ với tôi. Và như Andy đã nói, bên tôi đang tuyển dụng. Connor, người tốt nghiệp CMU năm ngoái, rất giỏi và đang làm cùng chúng tôi.
And I love CMU students. Okay, round of applause.
Và tôi yêu sinh viên CMU. Nào, một tràng pháo tay.
For one question. Get back, yes. What's the difference between SpiralDB and Vortex?
Còn một câu hỏi. Mời bạn, vâng. SpiralDB và Vortex khác nhau như thế nào?
Yeah, Vortex is a file format and it's purely open source. Like a file format, you think of, like, how do I store bytes on disk?
Vortex là một định dạng tệp và hoàn toàn là mã nguồn mở. Với định dạng tệp, bạn hãy nghĩ là làm sao lưu các byte lên đĩa.
SpiralDB is a hosted database product that is built on top of that file format.
SpiralDB là một sản phẩm cơ sở dữ liệu được lưu trữ dưới dạng dịch vụ, xây dựng trên định dạng tệp đó.
But there's a bunch of stuff it does around orchestrating transactions and indexes and query planning that is not included in the open source thing. One more question, go for it.
Nhưng nó làm nhiều việc khác xoay quanh điều phối giao dịch và chỉ mục và lập kế hoạch truy vấn mà phần mã nguồn mở không bao gồm. Thêm một câu hỏi nữa, mời bạn.
What were the biggest changes that you had to do to go from a CPU native site to a GPU native site? Like something that's separated from you, what did you change?
Thay đổi lớn nhất mà các bạn phải làm để chuyển từ phía gốc CPU sang phía gốc GPU là gì? Ví dụ điều gì đó tách biệt với bạn, bạn đã thay đổi cái gì?
So actually the main thing was designing, so a lot of this code actually is pretty classical because it turned out like, I don't know, having operators and pipelines are, I mean, not that new.
Thực ra điều chính là thiết kế, vì phần lớn mã này thực ra khá cổ điển, hóa ra là tôi không rõ nữa, việc có các toán tử và đường ống thì cũng không mới lắm.
I was corrected. It's not MonetDB, it's VectorWise, but like, you know, it's been around for 20 years conceptually, and I know you just did the lecture.
Tôi vừa được chỉnh lại. Không phải MonetDB, mà là VectorWise, nhưng về mặt khái niệm thì nó đã có hơn 20 năm rồi, và tôi biết các bạn vừa học bài giảng đó.
The main thing is that for GPUs, you really want to have fixed known output size.
Điều chính là với GPU, bạn thực sự muốn kích thước đầu ra cố định và biết trước.
And so it puts a little bit of extra constraint on how you think about like, what is a pipeline breaker and what do you need to know?
Vì vậy nó đặt thêm một chút ràng buộc lên cách bạn nghĩ về đâu là pipeline breaker và bạn cần biết những gì.
So we need to know the actual size of the output before executing a given operator.
Nên chúng tôi cần biết kích thước thực của đầu ra trước khi thực thi một toán tử nào đó.
So it turns out that constraint and like, you know, the other constraints, sort of lack of data dependencies, for example, are the same with CPU SIMD, but that one was a little special.
Hóa ra ràng buộc đó và các ràng buộc khác, chẳng hạn như thiếu phụ thuộc dữ liệu, thì giống với SIMD trên CPU, nhưng ràng buộc này thì hơi đặc biệt.
So we just had to design the whole like kind of query planning for executing operators around that extra constraint.
Vì vậy chúng tôi phải thiết kế toàn bộ việc lập kế hoạch truy vấn để thực thi các toán tử xoay quanh ràng buộc bổ sung đó.
I mean, to his point, like everything we talked about today, we talked about in the last class, whether you're on GPU, FPGAs, CPUs, whatever comes next, the core concepts are the same, just, you know, the hardware implementation is different.
Ý tôi là, theo ý của bạn ấy, mọi thứ chúng ta đã nói hôm nay, mà chúng ta đã nói ở buổi trước, dù là GPU, FPGA, CPU hay bất cứ thứ gì sắp tới, các khái niệm cốt lõi vẫn như nhau, chỉ là cách triển khai trên phần cứng khác nhau thôi.
I think that is the main thing is like, there are no new ideas under the sun under databases, but the hardware changes a lot.
Tôi nghĩ điều chính yếu là, trong cơ sở dữ liệu không có ý tưởng nào thực sự mới dưới ánh mặt trời, nhưng phần cứng thì thay đổi rất nhiều.
And that drives, you can think of like a database of, you know, it's a, I always think of the fundamental theorem of linear programming and, like, the simplex algorithm.
Và điều đó thúc đẩy, bạn có thể hình dung một cơ sở dữ liệu như là, tôi luôn nghĩ đến định lý cơ bản của quy hoạch tuyến tính và thuật toán simplex.
It's like, cool, a bunch of the constraints change because of hardware and it pushes you to a different vertex. Like, the answer, the optimum, is always in a vertex.
Kiểu như, hay đấy, một loạt ràng buộc thay đổi do phần cứng và nó đẩy bạn sang một đỉnh khác. Đáp án, tức là điểm tối ưu, luôn nằm ở một đỉnh.
And so it can be pretty different from stuff that existed before just because hardware shifted.
Vì vậy nó có thể khác khá nhiều so với những thứ đã có trước đây, chỉ vì phần cứng đã dịch chuyển.
Fortune. Fortune. Maintain.
Fortune. Fortune. Maintain.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.