Profiling with ClangBuildAnalyzer

Oct 13, 2025 by talynt.org 30 views

YSQL Incremental PG Compilation Takes Too Long: A Deep Dive into the Issue

YSQL, a distributed relational database, has been gaining popularity due to its high performance and scalability. However, like any other complex system, it is not immune to performance issues. In this article, we will delve into the issue of incremental PG compilation taking too long in YSQL. We will explore the root cause of the problem, analyze the results of profiling with ClangBuildAnalyzer, and discuss possible solutions to improve the compilation efficiency of YSQL.

YSQL uses a modified version of PostgreSQL (PG) as its core database engine. The compilation process of YSQL involves several steps, including parsing, code generation, and linking. The yb_build.sh script is responsible for executing these steps. However, as mentioned in the Jira issue DB-15686, the make step of yb_build.sh takes an unexpectedly long time, even for simple changes.

Profiling with ClangBuildAnalyzer

To understand the root cause of the issue, we used ClangBuildAnalyzer to profile the compilation process. The results revealed that files that are completely divorced from the changed file's dependencies also get parsed and codegen'd. This means that even though the changed file has no dependencies on other files, the compilation process still tries to parse and codegen those files, resulting in unnecessary overhead.

Comparison with Vanilla PG

To put this issue into perspective, we compared the compilation time of YSQL with that of Vanilla PG. Vanilla PG takes less than 2 seconds to run make -j 10 even when it is modified to produce a shared library of the src/backend directory as YSQL does. This suggests that YSQL's compilation process is inefficient and needs to be optimized.

Based on the analysis, we can identify several possible solutions to improve the compilation efficiency of YSQL:

1. Dependency Analysis

One possible solution is to perform a dependency analysis on the changed file and its dependencies. This would help identify which files need to be parsed and codegen'd, and which files can be skipped. This would reduce the unnecessary overhead of parsing and codegen'ing files that are not relevant to the changed file.

2. Incremental Compilation

Another possible solution is to implement incremental compilation. This would involve keeping track of the changes made to the code and only recompiling the affected files. This would reduce the compilation time and improve the overall performance of YSQL.

3. Parallel Compilation

Finally, we can also explore the possibility of parallel compilation. This would involve dividing the compilation process into smaller tasks and executing them in parallel. This would take advantage of multi-core processors and improve the overall compilation time.

In conclusion, the issue of incremental PG compilation taking too long in YSQL is a complex problem that requires a deep understanding of the compilation process. By analyzing the results of profiling with ClangBuildAnalyzer and comparing the compilation time of YSQL with that of Vanilla PG, we can identify several possible solutions to improve the compilation efficiency of YSQL. These solutions include dependency analysis, incremental compilation, and parallel compilation. By implementing these solutions, we can improve the overall performance of YSQL and make it more efficient.

Based on the analysis, we recommend the following:

Perform a dependency analysis on the changed file and its dependencies to identify which files need to be parsed and codegen'd.
Implement incremental compilation to reduce the compilation time and improve the overall performance of YSQL.
Explore the possibility of parallel compilation to take advantage of multi-core processors and improve the overall compilation time.

Future work includes implementing the recommended solutions and testing their effectiveness. We also plan to continue profiling the compilation process to identify any other areas for improvement.

DB-15686
ClangBuildAnalyzer documentation
Vanilla PG documentation
YSQL Incremental PG Compilation Takes Too Long: A Q&A Article

In our previous article, we delved into the issue of incremental PG compilation taking too long in YSQL. We analyzed the results of profiling with ClangBuildAnalyzer and compared the compilation time of YSQL with that of Vanilla PG. In this article, we will answer some of the frequently asked questions related to this issue.

Q: What is the root cause of the issue?

A: The root cause of the issue is that files that are completely divorced from the changed file's dependencies also get parsed and codegen'd. This means that even though the changed file has no dependencies on other files, the compilation process still tries to parse and codegen those files, resulting in unnecessary overhead.

Q: Why does Vanilla PG take less than 2 seconds to compile?

A: Vanilla PG takes less than 2 seconds to compile because it has a more efficient compilation process. It uses a dependency analysis to identify which files need to be parsed and codegen'd, and only recompiles the affected files. This reduces the unnecessary overhead of parsing and codegen'ing files that are not relevant to the changed file.

Q: What are the possible solutions to improve the compilation efficiency of YSQL?

A: There are several possible solutions to improve the compilation efficiency of YSQL, including:

Dependency analysis: This involves performing a dependency analysis on the changed file and its dependencies to identify which files need to be parsed and codegen'd.
Incremental compilation: This involves implementing incremental compilation to reduce the compilation time and improve the overall performance of YSQL.
Parallel compilation: This involves exploring the possibility of parallel compilation to take advantage of multi-core processors and improve the overall compilation time.

Q: How can I implement dependency analysis in YSQL?

A: To implement dependency analysis in YSQL, you can use a tool like ClangBuildAnalyzer to analyze the dependencies of the changed file and its dependencies. You can then use this information to determine which files need to be parsed and codegen'd.

Q: How can I implement incremental compilation in YSQL?

A: To implement incremental compilation in YSQL, you can use a tool like ClangBuildAnalyzer to keep track of the changes made to the code and only recompile the affected files. You can then use this information to reduce the compilation time and improve the overall performance of YSQL.

Q: How can I implement parallel compilation in YSQL?

A: To implement parallel compilation in YSQL, you can use a tool like ClangBuildAnalyzer to divide the compilation process into smaller tasks and execute them in parallel. You can then use this information to take advantage of multi-core processors and improve the overall compilation time.

Q: What are the benefits of improving the compilation efficiency of YSQL?

A: The benefits of improving the compilation efficiency of YSQL include:

Reduced compilation time: By improving the compilation efficiency of YSQL, you can reduce the compilation time and improve the overall performance of the database.
Improved scalability: By improving the compilation efficiency of YSQL, you can improve the scalability of the database and handle larger workloads.
Better resource utilization: By improving the compilation efficiency of YSQL, you can improve the resource utilization of the database and reduce the overhead of compilation.

Based on the analysis, we recommend the following:

Perform a dependency analysis on the changed file and its dependencies to identify which files need to be parsed and codegen'd.
Implement incremental compilation to reduce the compilation time and improve the overall performance of YSQL.
Explore the possibility of parallel compilation to take advantage of multi-core processors and improve the overall compilation time.

Future work includes implementing the recommended solutions and testing their effectiveness. We also plan to continue profiling the compilation process to identify any other areas for improvement.