So sánh JIT của Python 3.14 và 3.15: Bước tiến vượt bậc nhưng không phải vạn năng

Python 3.15 mang đến một trình biên dịch JIT (Just-In-Time) được xây dựng lại gần như hoàn toàn so với phiên bản 3.14. Câu hỏi đặt ra là: liệu việc chạy đúng đoạn mã cũ trên phiên bản mới có tạo ra khác biệt thực sự?

Biểu đồ so sánh hiệu năng JIT Python 3.14 và 3.15

Hồi đầu năm nay, tôi đã thử nghiệm trình biên dịch JIT thử nghiệm đi kèm với Python 3.14. Hai trong ba tác vụ kiểm thử trở nên nhanh hơn rõ rệt: tính toán Mandelbrot nhanh hơn khoảng 25%, tính khoảng cách Levenshtein nhanh hơn 27%, trong khi tìm đường Dijkstra gần như không cải thiện.

Đó là khởi đầu đầy hứa hẹn, dù JIT trên 3.14 vẫn còn khá hạn chế. Python 3.15 đã tái cấu trúc nó đáng kể, vì vậy tôi quyết định chạy lại chính xác đoạn code cũ để xem điều gì đã thay đổi.

Bốn cấu hình kiểm thử

Tôi tiến hành đo đạc trên bốn cấu hình khác nhau:

• Python 3.14 với JIT tắt
• Python 3.14 với JIT bật
• Python 3.15 với JIT tắt
• Python 3.15 với JIT bật

Cách tiếp cận này quan trọng vì so sánh đơn thuần 3.14 với 3.15 dễ gây nhầm lẫn. Bản thân Python 3.15 đã có nhiều cải tiến ở tầng interpreter (trình thông dịch) nằm ngoài JIT, bao gồm cả thay đổi về interpreter được dùng trong các bản dựng Windows 64-bit chính thức.

Việc chạy cả bốn cấu hình cho phép tách bạch hai yếu tố: bản thân 3.15 có nhanh hơn không, và JIT của nó có đóng góp thêm gì hay không.

JIT của Python 3.15 khác gì?

JIT trên 3.14 cố gắng dự đoán các đường đi khả dĩ qua chuỗi bytecode. Sang 3.15, một tracing front end mới sẽ ghi lại đường đi thực tế mà chương trình thực hiện, nhờ đó có thể theo dõi nhiều luồng điều khiển hơn và biên dịch được phạm vi mã Python rộng hơn.

Bộ tối ưu của JIT cũng trưởng thành hơn hẳn. Python 3.15 bổ sung cấp phát thanh ghi (register allocation) cơ bản, lan truyền hằng số (constant propagation) nhiều hơn, và có thể loại bỏ một số thao tác đếm tham chiếu khi chứng minh được chúng là không cần thiết. Nó cũng theo dõi được các số nguyên và số thực chỉ có một tham chiếu duy nhất, cho phép một số phép toán cập nhật tại chỗ thay vì cấp phát đối tượng mới.

Việc sinh mã cho kiến trúc x86-64 và AArch64 cũng được cải thiện, đồng thời mã máy sinh ra tiêu tốn ít bộ nhớ hơn. Theo báo cáo từ nhóm phát hành Python, bộ benchmark trên Linux x86-64 đạt mức cải thiện trung bình hình học 7-8% so với interpreter tiêu chuẩn, còn trên macOS AArch64 là 11-12%.

Kết quả đo đạc thực tế

Tôi chạy thử nghiệm trên Windows 11, chip Intel Core i9-13900K thế hệ 13, RAM 64 GB, dùng Python 3.14.7 và Python 3.15.0. Bảng dưới đây là trung vị của 10 lần chạy trong tiến trình mới hoàn toàn, nhằm tránh một lần gián đoạn làm méo kết quả.

Tác vụ	3.14 JIT tắt	3.14 JIT bật	3.15 JIT tắt	3.15 JIT bật	Mức tăng nhờ JIT 3.15
Mandelbrot	7,207 s	5,250 s	5,313 s	2,471 s	53,5%
Dijkstra	0,241 s	0,241 s	0,198 s	0,202 s	-1,6%
Levenshtein	2,192 s	1,676 s	1,547 s	1,385 s	10,4%

Cột cuối so sánh 3.15 với chính nó khi bật và tắt JIT — đây là cách đánh giá JIT thuần túy, không lẫn với các cải tiến khác của interpreter.

Mandelbrot: thắng lợi lớn

Tác vụ Mandelbrot mất 5,25 giây với JIT 3.14 và chỉ còn 2,471 giây với JIT 3.15 — giảm 53%. Một phần thành tích này thuộc về các cải tiến khác của 3.15: ngay cả khi tắt JIT, phiên bản mới vẫn hoàn thành trong 5,313 giây, nhanh hơn 26% so với 3.14.

Đây là tác vụ có lợi thế đặc biệt: phần lớn thời gian nằm trong một khối vòng lặp Python dễ đoán, thực hiện số học trên các biến cục bộ. Tracing front end thấy cùng một đường đi lặp đi lặp lại, và bộ tối ưu mới loại bỏ được nhiều thao tác quản lý đối tượng lẫn interpreter.

Dijkstra: vẫn nên tắt JIT

Dijkstra tiếp tục là ca khó xử. Trên 3.14, bật JIT không thay đổi gì (vẫn 0,241 giây). Trên 3.15, bật JIT thậm chí còn làm chậm đi đôi chút.

Điểm tích cực là Python 3.15 vẫn chạy tác vụ này nhanh hơn khoảng 16% so với 3.14 khi tắt JIT. Điều đó cho thấy bản nâng cấp phiên bản mới là thứ giúp ích, chứ không phải JIT. Việc tạo đồ thị, cấp phát tuple, sinh số ngẫu nhiên và gọi vào thư viện heapq không giống một vòng lặp số học chặt chẽ như Mandelbrot.

Levenshtein: nhanh hơn nhưng phần JIT đóng góp ít hơn

Tác vụ Levenshtein giảm từ 1,676 giây (JIT 3.14) xuống 1,385 giây (JIT 3.15), tức nhanh hơn 18,6%. Nhưng riêng 3.15 khi tắt JIT đã đạt 1,553 giây, nên phần đóng góp thêm của JIT chỉ khoảng 10,5%.

Đây chính là lý do việc so sánh bốn cột thực sự có giá trị. Nói “JIT 3.15 nhanh hơn JIT 3.14 18,6%” là đúng, nhưng cách diễn đạt đó gán cho JIT cả những cải thiện vốn xuất hiện ngay cả khi JIT tắt.

Có nên bật JIT không?

Tôi sẽ không bật JIT tràn lan chỉ dựa trên ba bài kiểm thử tổng hợp. Tôi sẽ thử nó với các chương trình tính toán nặng chủ yếu do CPU và bị chi phối bởi vòng lặp Python, đặc biệt nếu chương trình chạy đủ lâu để các đường đi nóng phát huy tác dụng.

Mandelbrot cho thấy mức trần lợi ích giờ có thể lớn đến đâu. Dijkstra lại cho thấy trong một số tình huống, việc bật JIT có thể làm giảm hiệu năng.

Tổng kết

Với các lập trình viên Việt Nam đang cân nhắc nâng cấp lên Python 3.15, đây là vài lưu ý thực tế:

• Hãy đo trên chính ứng dụng bạn đang chạy, với dữ liệu đầu vào đại diện cho môi trường thực tế.
• Theo dõi cả thời gian thực thi, bộ nhớ và độ trễ, chứ không chỉ một con số thông lượng duy nhất.
• Luôn giữ phiên bản chạy không JIT làm mốc so sánh, và đừng nhầm lẫn cải thiện chung của 3.15 với cải thiện nhờ JIT.

Kết luận lớn nhất là JIT thử nghiệm của Python đã tiến bộ đáng kể kể từ 3.14. Ở bài kiểm thử cũ, nó chỉ giúp hai chương trình vòng lặp nặng nhanh hơn khoảng một phần tư. Sang 3.15, một trong hai chương trình đó nhanh hơn gấp đôi khi bật JIT, chương trình còn lại tăng 10,5%, còn tác vụ đồ thị vẫn “lắc đầu từ chối”.

JIT đang bắt đầu tạo ra khác biệt lớn với những đoạn mã mà nó thực sự hiểu — nhưng hãy đo đạc thay vì tin tưởng ngay từ cái nhìn đầu tiên và bật nó bừa bãi.