: Refactoring in order to reduce Git’s global state
PATCH 1/1 : Refactoring in order to reduce Git’s global state
Hello,
This is my GSoC 2025 proposal for the project "Refactoring in order to reduce Git’s global state". You can view docs version here:
https://docs.google.com/document/d/1tJrtWxo1UGKChB3hu5eZ-ljm0FtU_fsv0TnIRwu3EKY/edit?usp=sharing
---------
Refactoring in order to reduce git’s state
My Information:
---------------
Name: Ayush Chandekar
Email: [email protected]
Mobile No: (+91) 9372496874
Education: UG Sophomore, IIT Roorkee
Github: https://github.com/ayu-ch
Blog: https://ayu-ch.github.io
About me:
---------
I'm Ayush Chandekar, a UG Sophomore studying at Indian Institute of Technology, Roorkee. I like participating in various software development and tech-development endeavors, usually hackathons, CTFs, and projects at SDSLabs. SDSLabs is a student-run technical group that includes passionate developers and designers interested in various fields and involved in multiple software development projects that aim to foster a software development culture on campus. Being a part of this group has exposed me to different software development methodologies, tools and frameworks and helped me become comfortable contributing to an open-source project with multiple contributors. Some open-source contributions I made here are: [1], [2] & [3]
I see this project as a meaningful opportunity to deepen my involvement in the Git community and to build a foundation for continued contributions to open source development in the future.
Overview:
---------
Git currently uses a global object called the_repository, which refers to a single instance of struct repository. Many internal functions rely on this global object rather than accepting a struct repository as an explicit parameter. This design inherently assumes a single active repository, making it difficult to support multi-repository use cases and obstructing the long-term goal of libification of Git.
A key architectural limitation is that while struct repository encapsulates some repository-specific information, many important environment variables and configuration settings that logically belong to a repository are still stored as global variables, primarily in environment.c, not within the repository struct. As a result, even if multiple repositories were to exist concurrently, they would still share this global state, leading to incorrect behavior, race conditions, or subtle bugs.
This project aims to refactor Git’s environment handling by relocating these global variables into appropriate local contexts primarily into struct repository and struct repo_settings. This change will not only make the environment state repository-specific, but also improve the modularity and maintainability of the codebase. The work involves identifying environment-related global variables, designing a suitable structure to house them within the repository context, and updating all affected code paths accordingly.
The difficulty of this project is medium, and it is estimated to take 175 to 350 hours.
Pre-GSOC:
---------
I started exploring Git’s codebase and documentation around the end of January, familiarizing myself with its structure and development practices. I submitted a microproject, which helped me navigate the code and contribution workflow.
After selecting the project on refactoring Git’s state, I studied the surrounding code and reviewed past patches ([4], [5], [6], [7], [8] & [9]) to understand the reasoning behind previous changes. To better prepare for the GSoC timeline, I also submitted a patch related to the project, gaining hands-on experience with both the implementation details and the submission process.
Patches:
--------
+ (Microproject) t6423: fix suppression of Git’s exit code in tests
Thread:
https://public-inbox.org/git/[email protected]/
Status: Merged into master
Commit Hash: 7c1d34fe5d1229362f2c3ecf2d493167a1f555a2
Description: Instead of executing a Git command as the upstream component of
a pipe, which can result in the exit status being lost, redirect its output to a file and then process that file in two steps to ensure the exit status is properly preserved.
+ midx: implement progress reporting for QSORT operation
Thread:
https://public-inbox.org/git/[email protected]/
Status: Dropped
Description: Add progress reporting during the QSORT operation in
multi-pack-index verification. While going through the code, I found this TODO, which I thought was interesting however my approach assumed that the qsort() operation processes elements in a structured order, which isn't guaranteed.
+ Stop depending on the_repository for core.attributesfile
Thread:
https://public-inbox.org/git/[email protected]/
Status: WIP, needs more discussion.
Description: This patch refactors access to the core.attributesfiles
configuration by moving it into the repo_settings struct. It eliminates the global variable git_attributes_file and updates relevant code paths to pass the struct repository as a parameter.
Proposed Plan:
--------------
I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined config.c and cross-referenced it with environment.c to see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into repository-specific settings. This involves:
- Identifying all occurrences of these global variables.
- Removing dependencies on the_repository.
- Updating function signatures to pass struct repository explicitly.
- Replacing global variable references with repository-scoped configurations.
Instead of adding all variables directly into repo_settings, we can group related variables into specialized structs (e.g., performance_config, behaviour_config, whitespace_config) and embed these within repo_settings. This approach ensures a more modular and maintainable design while keeping repo_settings manageable.
I have also created a diagram explaining this structure in [10].
With this approach, I can structure the patch series by grouping the refactoring of related variables within specific structs. This will help maintain a clean and organized codebase while also making the development and review process more systematic and efficient.
One key challenge is determining which variables should be part of repo_settings and which should remain separate. While working on the patch to refactor access to core.attributesfile, I received feedback from Junio that not all global variables should be blindly moved into the repo_settings struct. This reinforced the need to carefully assess which variables belong in repo_settings and which should be handled differently.
This plan is flexible and may be refined through multiple iterations as I receive feedback from the community and reviewers.
Timeline:
---------
Pre-GSOC:
(Until 8 May)
- Explore the codebase more, focusing on environment-related code paths.
- Document how each global variable is used and how it can be moved to
repository settings.
- Study Git’s Coding Guidelines and the Pro Git Book to align with best practices.
----------
Community Bonding:
(May 8 - June 1)
- Engage with mentors to discuss different environment variables, their
dependencies, and the best approach for refactoring.
- Finalize an implementation plan based on discussions.
- Since I will be on summer vacation, I can start coding early and make progress
on the project.
----------
Coding Period:
(June 2 - August 25)
- Refactor global variables, replacing them with repository-scoped
configurations.
- Modify function signatures to pass struct repository explicitly instead
of relying on the_repository.
- Categorize variables into specialized structs to improve modularity and
maintainability.
- Continuously submit patches for review and incorporate feedback from mentors
and the community.
- I plan to write weekly blogs which will document what I did in the whole
week.
----------
Final Week:
(August 25 - September 1)
- Write a detailed report on the entire project.
- Fix bugs if any.
- Reflect on the project, noting challenges faced and lessons learned.
Blogging:
---------
I have also set up a blogging page at [11]. While reading blogs from previous GSoC contributors, I found them useful in understanding the challenges they faced and how they approached their projects. Their experiences gave me a better idea of what to expect and how to navigate the development process. Inspired by this, I decided to start my own blog to document my journey throughout GSoC. This will not only help me track my own progress but also serve as a resource for future contributors who might work on similar projects. I plan to share updates on my work, challenges encountered and insights gained from discussions with mentors and the community.
Additionally, I hope my blog encourages more people to contribute to open source by providing a transparent look into the development process. Writing about my experience will also help me reflect on my work and improve my ability to communicate technical ideas effectively.
I liked the format and structure of Chandra's blog, so I decided to use the same template for my own blogging page.
Availability:
-------------
As a college student, I intend to utilise my summer breaks from May to July to work on the project. After completing my University exams in April, I can start working in May. I can dedicate 40 hours a week from May to July, while in August after the classes commence, I can dedicate about 25 hours a week.
There are no exams or planned vacations throughout the coding period. Besides this project, I have no commitments/vacations planned for the summer. I shall keep my status posted to all the community members and maintain transparency in the project.
Post-GSOC:
----------
Beyond contributing code, I strongly believe in giving back to the community and helping others grow. Open source thrives on mentorship, knowledge sharing, and long-term involvement, and I would love to continue contributing even after GSoC ends.
I have always valued mentorship, both as a mentee and as someone who enjoys guiding others. If given the opportunity, I would be more than happy to mentor/co-mentor future GSoC contributors. By staying involved in the community, whether through contributing, reviewing patches, or mentoring, I hope to help sustain and expand the project’s reach. I look at GSoC as not just as a one-time contribution but as a step toward a longer-term relationship with open source.
I will continue to be involved with Git even after GSoC by contributing patches, reviewing code, and participating in discussions. My work on refactoring Git’s state aligns with long-term improvements to the codebase, and I plan to keep refining it beyond the program. I see GSoC as just the beginning of my journey with Git.
Appreciation:
-------------
I appreciate the Git community for its excellent documentation, which made it much easier for me to understand Git in depth. The well-structured resources helped me navigate the codebase and gain a deeper understanding of how Git works internally.
Beyond the documentation, I am also grateful for how welcoming and supportive the community has been. Whether through discussions on the mailing list or feedback on my patches, the information and guidance I received made my experience even better.
Additionally, I read the blogs and proposals of Chandra, Jialuo, and Ghanashyam, which provided valuable insights into their journeys and helped me shape my own approach to contributing.
Thanks for reviewing this proposal.
References:
-----------
[1] https://github.com/sdslabs/beast/pull/374
[2] https://github.com/sdslabs/beast/tree/add-teams-with-hint
[3] https://github.com/sdslabs/playCTF/pull/177
[4] https://public-inbox.org/git/[email protected]/
[6] https://public-inbox.org/git/20250206-b4-pks-path-drop-the-repository-v1-0-4e77f0313206@pks.im/
[7] https://public-inbox.org/git/[email protected]/#t
[8] https://public-inbox.org/git/[email protected]/
Quoted 57 lines · Ayush Chandekar
Hello,
This is my GSoC 2025 proposal for the project "Refactoring in order to reduce Git’s global state". You can view docs version here:
https://docs.google.com/document/d/1tJrtWxo1UGKChB3hu5eZ-ljm0FtU_fsv0TnIRwu3EKY/edit?usp=sharing---------
Refactoring in order to reduce git’s state
My Information:
---------------Name: Ayush Chandekar
Email: [email protected]
Mobile No: (+91) 9372496874
Education: UG Sophomore, IIT Roorkee
Github: https://github.com/ayu-ch
Blog: https://ayu-ch.github.ioAbout me:
---------I'm Ayush Chandekar, a UG Sophomore studying at Indian Institute of Technology, Roorkee. I like participating in various software development and tech-development endeavors, usually hackathons, CTFs, and projects at SDSLabs. SDSLabs is a student-run technical group that includes passionate developers and designers interested in various fields and involved in multiple software development projects that aim to foster a software development culture on campus. Being a part of this group has exposed me to different software development methodologies, tools and frameworks and helped me become comfortable contributing to an open-source project with multiple contributors. Some open-source contributions I made here are: [1], [2] & [3]
I see this project as a meaningful opportunity to deepen my involvement in the Git community and to build a foundation for continued contributions to open source development in the future.
Overview:
---------Git currently uses a global object called
the_repository, which refers to a single instance ofstruct repository. Many internal functions rely on this global object rather than accepting astruct repositoryas an explicit parameter. This design inherently assumes a single active repository, making it difficult to support multi-repository use cases and obstructing the long-term goal of libification of Git.A key architectural limitation is that while
struct repositoryencapsulates some repository-specific information, many important environment variables and configuration settings that logically belong to a repository are still stored as global variables, primarily inenvironment.c, not within therepositorystruct. As a result, even if multiple repositories were to exist concurrently, they would still share this global state, leading to incorrect behavior, race conditions, or subtle bugs.
Quoted 3 lines
This project aims to refactor Git’s environment handling by relocating these global variables into appropriate local contexts primarily into
struct repositoryandstruct repo_settings. This change will not
I think we could just improve this statement better. Some global variables may only apply to one subsystem or two subsystems. In such situations, we may just put the global variable into their own context but not the "struct repository" or "struct repo_settings".
Quoted 70 lines
only make the environment state repository-specific, but also improve the modularity and maintainability of the codebase. The work involves identifying environment-related global variables, designing a suitable structure to house them within the repository context, and updating all affected code paths accordingly.
The difficulty of this project is medium, and it is estimated to take 175 to 350 hours.
Pre-GSOC:
---------I started exploring Git’s codebase and documentation around the end of January, familiarizing myself with its structure and development practices. I submitted a microproject, which helped me navigate the code and contribution workflow.
After selecting the project on refactoring Git’s state, I studied the surrounding code and reviewed past patches ([4], [5], [6], [7], [8] & [9]) to understand the reasoning behind previous changes. To better prepare for the GSoC timeline, I also submitted a patch related to the project, gaining hands-on experience with both the implementation details and the submission process.
Patches:
--------+ (Microproject) t6423: fix suppression of Git’s exit code in tests
Thread:
https://public-inbox.org/git/[email protected]/
Status: Merged into master
Commit Hash:7c1d34fe5d1229362f2c3ecf2d493167a1f555a2
Description: Instead of executing a Git command as the upstream component of
a pipe, which can result in the exit status being lost, redirect its output to a file and then process that file in two steps to ensure the exit status is properly preserved.+ midx: implement progress reporting for QSORT operation
Thread:
https://public-inbox.org/git/[email protected]/
Status: Dropped
Description: Add progress reporting during the QSORT operation in
multi-pack-index verification. While going through the code, I found this TODO, which I thought was interesting however my approach assumed that theqsort()operation processes elements in a structured order, which isn't guaranteed.+ Stop depending on
the_repositoryfor core.attributesfile
Thread:
https://public-inbox.org/git/[email protected]/
Status: WIP, needs more discussion.
Description: This patch refactors access to thecore.attributesfiles
configuration by moving it into therepo_settingsstruct. It eliminates the global variablegit_attributes_fileand updates relevant code paths to pass thestruct repositoryas a parameter.Proposed Plan:
--------------I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined
config.cand cross-referenced it withenvironment.cto see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into repository-specific settings. This involves:
Review
Quoted 5 lines
(quoted diff) +0
-3- Identifying all occurrences of these global variables. - Removing dependencies on `the_repository`. - Updating function signatures to pass `struct repository` explicitly.
When reading this, I feel a little wired because I think in [1], you have already realized that we should move some global variables to some specific subsystems.
Quoted 8 lines
- Replacing global variable references with repository-scoped configurations.
Instead of adding all variables directly into
repo_settings, we can group related variables into specialized structs (e.g.,performance_config,behaviour_config,whitespace_config) and embed these withinrepo_settings. This approach ensures a more modular and maintainable design while keepingrepo_settingsmanageable.
Quoted 7 lines
I have also created a diagram explaining this structure in [10].
With this approach, I can structure the patch series by grouping the refactoring of related variables within specific structs. This will help maintain a clean and organized codebase while also making the development and review process more systematic and efficient.
Yes, it's a good idea to use sub-structure to make the code be cleaner. However, from my own experience when being a GSoC student, we should not consider about this due to that we will over-engineer this.
You need a lot of time and effort to convince the community why the design is good and why we should put this variable into this sub-structure.
Instead, you'd better focus on which variables you want to remove firstly. And how do you try to remove them with some simple steps. This would make you more concentrate on the jobs you need to do and reduce the risk.
Quoted 7 lines
One key challenge is determining which variables should be part of
repo_settingsand which should remain separate. While working on the patch to refactor access tocore.attributesfile, I received feedback from Junio that not all global variables should be blindly moved into therepo_settingsstruct. This reinforced the need to carefully assess which variables belong inrepo_settingsand which should be handled differently.
Yes, this is correct. I somehow think whether we should put this paragraph into Pre-GSoC part? I think that you have found this when adding a patch to remove one global variable. And thus by communicating with the community, you have further understood that the requirement and the detail of this project.
And in your plan, you should just say that we need to do this. Would this be better?
Quoted 32 lines
This plan is flexible and may be refined through multiple iterations as I receive feedback from the community and reviewers.
Timeline:
---------Pre-GSOC:
(Until 8 May)(quoted diff) +0
-2- Explore the codebase more, focusing on environment-related code paths. - Document how each global variable is used and how it can be moved torepository settings.
(quoted diff) +0
-2- Study Git’s Coding Guidelines and the Pro Git Book to align with best practices. ----------Community Bonding:
(May 8 - June 1)(quoted diff) +0
-1- Engage with mentors to discuss different environment variables, theirdependencies, and the best approach for refactoring.
(quoted diff) +0
-2- Finalize an implementation plan based on discussions. - Since I will be on summer vacation, I can start coding early and make progresson the project.
----------
Coding Period:
(June 2 - August 25)(quoted diff) +0
-1- Refactor global variables, replacing them with repository-scopedconfigurations.
(quoted diff) +0
-1- Modify function signatures to pass `struct repository` explicitly insteadof relying on
the_repository.(quoted diff) +0
-1- Categorize variables into specialized structs to improve modularity and
Quoted 1 line
maintainability.
As I have said, this is a high-risk task. Categorization needs many iterations. And we may do this after GSoC.
Quoted 80 lines
(quoted diff) +0
-1- Continuously submit patches for review and incorporate feedback from mentorsand the community.
(quoted diff) +0
-1- I plan to write weekly blogs which will document what I did in the wholeweek.
----------
Final Week:
(August 25 - September 1)(quoted diff) +0
-3- Write a detailed report on the entire project. - Fix bugs if any. - Reflect on the project, noting challenges faced and lessons learned.Blogging:
---------I have also set up a blogging page at [11]. While reading blogs from previous GSoC contributors, I found them useful in understanding the challenges they faced and how they approached their projects. Their experiences gave me a better idea of what to expect and how to navigate the development process. Inspired by this, I decided to start my own blog to document my journey throughout GSoC. This will not only help me track my own progress but also serve as a resource for future contributors who might work on similar projects. I plan to share updates on my work, challenges encountered and insights gained from discussions with mentors and the community.
Additionally, I hope my blog encourages more people to contribute to open source by providing a transparent look into the development process. Writing about my experience will also help me reflect on my work and improve my ability to communicate technical ideas effectively.
I liked the format and structure of Chandra's blog, so I decided to use the same template for my own blogging page.
Availability:
-------------As a college student, I intend to utilise my summer breaks from May to July to work on the project. After completing my University exams in April, I can start working in May. I can dedicate 40 hours a week from May to July, while in August after the classes commence, I can dedicate about 25 hours a week.
There are no exams or planned vacations throughout the coding period. Besides this project, I have no commitments/vacations planned for the summer. I shall keep my status posted to all the community members and maintain transparency in the project.
Post-GSOC:
----------Beyond contributing code, I strongly believe in giving back to the community and helping others grow. Open source thrives on mentorship, knowledge sharing, and long-term involvement, and I would love to continue contributing even after GSoC ends.
I have always valued mentorship, both as a mentee and as someone who enjoys guiding others. If given the opportunity, I would be more than happy to mentor/co-mentor future GSoC contributors. By staying involved in the community, whether through contributing, reviewing patches, or mentoring, I hope to help sustain and expand the project’s reach. I look at GSoC as not just as a one-time contribution but as a step toward a longer-term relationship with open source.
I will continue to be involved with Git even after GSoC by contributing patches, reviewing code, and participating in discussions. My work on refactoring Git’s state aligns with long-term improvements to the codebase, and I plan to keep refining it beyond the program. I see GSoC as just the beginning of my journey with Git.
Appreciation:
-------------I appreciate the Git community for its excellent documentation, which made it much easier for me to understand Git in depth. The well-structured resources helped me navigate the codebase and gain a deeper understanding of how Git works internally.
Quoted 8 lines
Beyond the documentation, I am also grateful for how welcoming and supportive the community has been. Whether through discussions on the mailing list or feedback on my patches, the information and guidance I received made my experience even better.
Additionally, I read the blogs and proposals of Chandra, Jialuo, and Ghanashyam, which provided valuable insights into their journeys and helped me shape my own approach to contributing.
I'm happy that my blogs help you.
Quoted 3 lines
Thanks for reviewing this proposal.
Thanks for your proposal!
Quoted 17 lines
References:
-----------[1] https://github.com/sdslabs/beast/pull/374
[2] https://github.com/sdslabs/beast/tree/add-teams-with-hint
[3] https://github.com/sdslabs/playCTF/pull/177
[4] https://public-inbox.org/git/[email protected]/
[6] https://public-inbox.org/git/20250206-b4-pks-path-drop-the-repository-v1-0-4e77f0313206@pks.im/
Quoted 7 lines
[8] https://public-inbox.org/git/[email protected]/
Jialuo
Quoted 8 lines
Quoted 3 lines
This project aims to refactor Git’s environment handling by relocating these global variables into appropriate local contexts primarily into
struct repositoryandstruct repo_settings. This change will notI think we could just improve this statement better. Some global variables may only apply to one subsystem or two subsystems. In such situations, we may just put the global variable into their own context but not the "struct repository" or "struct
repo_settings".
Right, I was generalizing in my statement, but I agree that some global variables
may belong in subsystem-specific contexts rather than struct repository or struct repo_settings. I'll make sure to account for that distinction in my proposal
and implementation.
Quoted 14 lines
Quoted 14 lines
Proposed Plan:
--------------I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined
config.cand cross-referenced it withenvironment.cto see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into repository-specific settings. This involves:(quoted diff) +0
-2- Identifying all occurrences of these global variables. - Removing dependencies on `the_repository`.
Quoted 9 lines
Quoted 2 lines
- Updating function signatures to pass
struct repositoryexplicitly.When reading this, I feel a little wired because I think in [1], you have already realized that we should move some global variables to some specific subsystems.
I see your point. I was generalizing again, but I’ll make sure to clarify this distinction
in my proposal. Thanks for pointing it out!
Quoted 20 lines
Quoted 8 lines
- Replacing global variable references with repository-scoped configurations.
Instead of adding all variables directly into
repo_settings, we can group related variables into specialized structs (e.g.,performance_config,behaviour_config,whitespace_config) and embed these withinrepo_settings. This approach ensures a more modular and maintainable design while keepingrepo_settingsmanageable.Quoted 7 lines
I have also created a diagram explaining this structure in [10].
With this approach, I can structure the patch series by grouping the refactoring of related variables within specific structs. This will help maintain a clean and organized codebase while also making the development and review process more systematic and efficient.
Yes, it's a good idea to use sub-structure to make the code be cleaner. However, from my own experience when being a GSoC student, we should not consider about this due to that we will over-engineer this.
Quoted 9 lines
You need a lot of time and effort to convince the community why the design is good and why we should put this variable into this sub-structure.
Instead, you'd better focus on which variables you want to remove firstly. And how do you try to remove them with some simple steps. This would make you more concentrate on the jobs you need to do and reduce the risk.
That makes sense. My intent was to provide a structured approach, but I could see how it
it may introduce unnecessary complexity at this stage. I'll focus on identifying and managing
the global variables before considering additional structuring. I think this is something which
can be done at the end of the project. That is, once all the variables are handled, they can
then be set into specific structures, if needed.
Quoted 8 lines
Quoted 7 lines
One key challenge is determining which variables should be part of
repo_settingsand which should remain separate. While working on the patch to refactor access tocore.attributesfile, I received feedback from Junio that not all global variables should be blindly moved into therepo_settingsstruct. This reinforced the need to carefully assess which variables belong inrepo_settingsand which should be handled differently.
Quoted 5 lines
Yes, this is correct. I somehow think whether we should put this paragraph into Pre-GSoC part? I think that you have found this when adding a patch to remove one global variable. And thus by communicating with the community, you have further understood that the requirement and the detail of this project.
Yep, since I encountered this while working on the patch, it fits well in the Pre-GSoC section.
Moving it there would better show how I learned more about the project's scope through
community feedback.
Quoted 4 lines
And in your plan, you should just say that we need to do this. Would this be better?
So, I should remove all the categorization stuff and just say that I would focus on
each variable, discuss in the community whether it should belong in the struct repo_settings/repo or not while sending patches?
I felt that keeping it general might seem vague, but that's the nature of the project. Every variable
is unique and would need a different approach and outlining the approach of each variable
in the proposal is not very feasible, as these decisions need to happen collaboratively through
discussions in the community.
Should I still mention that once the project is complete, we could consider structuring related
stuff if the community sees value in it.
Quoted 34 lines
Quoted 27 lines
This plan is flexible and may be refined through multiple iterations as I receive feedback from the community and reviewers.
Timeline:
---------Pre-GSOC:
(Until 8 May)(quoted diff) +0
-4- Explore the codebase more, focusing on environment-related code paths. - Document how each global variable is used and how it can be moved to repository settings. - Study Git’s Coding Guidelines and the Pro Git Book to align with best practices. ----------Community Bonding:
(May 8 - June 1)(quoted diff) +0
-4- Engage with mentors to discuss different environment variables, their dependencies, and the best approach for refactoring. - Finalize an implementation plan based on discussions. - Since I will be on summer vacation, I can start coding early and make progress on the project. ----------Coding Period:
(June 2 - August 25)Review
Quoted 6 lines
(quoted diff) +0
-3- Refactor global variables, replacing them with repository-scoped configurations. - Modify function signatures to pass `struct repository` explicitly instead of relying on `the_repository`. - Categorize variables into specialized structs to improve modularity and maintainability.
Quoted 2 lines
As I have said, this is a high-risk task. Categorization needs many iterations. And we may do this after GSoC.
Yep, will update that.
Thanks for your review, again:)
Ayush
On Sat, Mar 29, 2025 at 03:24:05PM +0530, Ayush Chandekar wrote:
[snip]
Quoted 14 lines
Quoted 8 lines
Quoted 7 lines
One key challenge is determining which variables should be part of
repo_settingsand which should remain separate. While working on the patch to refactor access tocore.attributesfile, I received feedback from Junio that not all global variables should be blindly moved into therepo_settingsstruct. This reinforced the need to carefully assess which variables belong inrepo_settingsand which should be handled differently.Quoted 5 lines
Yes, this is correct. I somehow think whether we should put this paragraph into Pre-GSoC part? I think that you have found this when adding a patch to remove one global variable. And thus by communicating with the community, you have further understood that the requirement and the detail of this project.
Quoted 6 lines
Yep, since I encountered this while working on the patch, it fits well in the Pre-GSoC section.
Moving it there would better show how I learned more about the project's scope through
community feedback.
Yes, this is my intention. This represents your ability where you interact with the community and get feedback. And this is what we want to see.
Quoted 8 lines
Quoted 4 lines
And in your plan, you should just say that we need to do this. Would this be better?
So, I should remove all the categorization stuff and just say that I would focus on
each variable, discuss in the community whether it should belong in the struct repo_settings/repo or not while sending patches?
I think you should put the categorization stuff into after-GSoC part. Well, I don't think you could focus on _each_ variable. This is impossible for you to talk about the way for _each_ variable. I somehow think that you could just write the proposal about how to handle one or two global variables.
You already touch one setting "core.attributesfile" right? You may just elaborate more in the proposal.
Quoted 8 lines
I felt that keeping it general might seem vague, but that's the nature of the project. Every variable
is unique and would need a different approach and outlining the approach of each variable
in the proposal is not very feasible, as these decisions need to happen collaboratively through
discussions in the community.
Yes, so you could firstly give how you want to handle the global variables from top. And give some concrete examples to demonstrate your idea.
Quoted 4 lines
Should I still mention that once the project is complete, we could consider structuring related
stuff if the community sees value in it.
You could, mention this in after GSoC part.
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
This plan is flexible and may be refined through multiple iterations as I receive feedback from the community and reviewers.
Timeline:
---------Pre-GSOC:
(Until 8 May)(quoted diff) +0
-4- Explore the codebase more, focusing on environment-related code paths. - Document how each global variable is used and how it can be moved to repository settings. - Study Git’s Coding Guidelines and the Pro Git Book to align with best practices. ----------Community Bonding:
(May 8 - June 1)(quoted diff) +0
-4- Engage with mentors to discuss different environment variables, their dependencies, and the best approach for refactoring. - Finalize an implementation plan based on discussions. - Since I will be on summer vacation, I can start coding early and make progress on the project. ----------Coding Period:
(June 2 - August 25)(quoted diff) +0
-3- Refactor global variables, replacing them with repository-scoped configurations. - Modify function signatures to pass `struct repository` explicitly instead of relying on `the_repository`. - Categorize variables into specialized structs to improve modularity and maintainability.
Quoted 8 lines
Quoted 2 lines
As I have said, this is a high-risk task. Categorization needs many iterations. And we may do this after GSoC.
Yep, will update that.
Thanks for your review, again:)
Ayush
Thanks,
Jialuo
Quoted 11 lines
Quoted 6 lines
Yep, since I encountered this while working on the patch, it fits well in the Pre-GSoC section.
Moving it there would better show how I learned more about the project's scope through
community feedback.Yes, this is my intention. This represents your ability where you interact with the community and get feedback. And this is what we want to see.
Got it!
Quoted 11 lines
Quoted 4 lines
So, I should remove all the categorization stuff and just say that I would focus on
each variable, discuss in the community whether it should belong in the struct repo_settings/repo or not while sending patches?I think you should put the categorization stuff into after-GSoC part. Well, I don't think you could focus on _each_ variable. This is impossible for you to talk about the way for _each_ variable. I somehow think that you could just write the proposal about how to handle one or two global variables.
Right, I can do that.
Quoted 3 lines
You already touch one setting "core.attributesfile" right? You may just elaborate more in the proposal.
Yep!
Quoted 9 lines
Quoted 8 lines
I felt that keeping it general might seem vague, but that's the nature of the project. Every variable
is unique and would need a different approach and outlining the approach of each variable
in the proposal is not very feasible, as these decisions need to happen collaboratively through
discussions in the community.
Quoted 4 lines
Yes, so you could firstly give how you want to handle the global variables from top. And give some concrete examples to demonstrate your idea.
Alright, will do.
I'll send a new iteration of the proposal soon.
Thank you so much for your inputs:)
Ayush
Quoted 113 lines · shejialuo
On Sat, Mar 29, 2025 at 03:24:05PM +0530, Ayush Chandekar wrote:
[snip]
Quoted 14 lines
Quoted 8 lines
Quoted 7 lines
One key challenge is determining which variables should be part of
repo_settingsand which should remain separate. While working on the patch to refactor access tocore.attributesfile, I received feedback from Junio that not all global variables should be blindly moved into therepo_settingsstruct. This reinforced the need to carefully assess which variables belong inrepo_settingsand which should be handled differently.Quoted 5 lines
Yes, this is correct. I somehow think whether we should put this paragraph into Pre-GSoC part? I think that you have found this when adding a patch to remove one global variable. And thus by communicating with the community, you have further understood that the requirement and the detail of this project.
Quoted 6 lines
Yep, since I encountered this while working on the patch, it fits well in the Pre-GSoC section.
Moving it there would better show how I learned more about the project's scope through
community feedback.Yes, this is my intention. This represents your ability where you interact with the community and get feedback. And this is what we want to see.
Quoted 8 lines
Quoted 4 lines
And in your plan, you should just say that we need to do this. Would this be better?
So, I should remove all the categorization stuff and just say that I would focus on
each variable, discuss in the community whether it should belong in the struct repo_settings/repo or not while sending patches?I think you should put the categorization stuff into after-GSoC part. Well, I don't think you could focus on _each_ variable. This is impossible for you to talk about the way for _each_ variable. I somehow think that you could just write the proposal about how to handle one or two global variables.
You already touch one setting "core.attributesfile" right? You may just elaborate more in the proposal.
Quoted 8 lines
I felt that keeping it general might seem vague, but that's the nature of the project. Every variable
is unique and would need a different approach and outlining the approach of each variable
in the proposal is not very feasible, as these decisions need to happen collaboratively through
discussions in the community.Yes, so you could firstly give how you want to handle the global variables from top. And give some concrete examples to demonstrate your idea.
Quoted 4 lines
Should I still mention that once the project is complete, we could consider structuring related
stuff if the community sees value in it.You could, mention this in after GSoC part.
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
This plan is flexible and may be refined through multiple iterations as I receive feedback from the community and reviewers.
Timeline:
---------Pre-GSOC:
(Until 8 May)(quoted diff) +0
-4- Explore the codebase more, focusing on environment-related code paths. - Document how each global variable is used and how it can be moved to repository settings. - Study Git’s Coding Guidelines and the Pro Git Book to align with best practices. ----------Community Bonding:
(May 8 - June 1)(quoted diff) +0
-4- Engage with mentors to discuss different environment variables, their dependencies, and the best approach for refactoring. - Finalize an implementation plan based on discussions. - Since I will be on summer vacation, I can start coding early and make progress on the project. ----------Coding Period:
(June 2 - August 25)(quoted diff) +0
-3- Refactor global variables, replacing them with repository-scoped configurations. - Modify function signatures to pass `struct repository` explicitly instead of relying on `the_repository`. - Categorize variables into specialized structs to improve modularity and maintainability.Quoted 8 lines
Quoted 2 lines
As I have said, this is a high-risk task. Categorization needs many iterations. And we may do this after GSoC.
Yep, will update that.
Thanks for your review, again:)
Ayush
Thanks,
Jialuo
Please excuse the top posting in my previous mail.
PATCH v2 1/1 : Refactoring in order to reduce Git’s global state
In reply to Ayush ChandekarHello,
This is my GSoC 2025 proposal for the project "Refactoring in order to reduce Git’s global state". You can view docs version here:
https://docs.google.com/document/d/1tJrtWxo1UGKChB3hu5eZ-ljm0FtU_fsv0TnIRwu3EKY/edit?usp=sharing
---------
Refactoring in order to reduce git’s state
My Information:
---------------
Name: Ayush Chandekar
Email: [email protected]
Mobile No: (+91) 9372496874
Education: UG Sophomore, IIT Roorkee
Github: https://github.com/ayu-ch
Blog: https://ayu-ch.github.io
About me:
---------
I'm Ayush Chandekar, a UG Sophomore studying at Indian Institute of Technology, Roorkee. I like participating in various software development and tech-development endeavors, usually hackathons, CTFs, and projects at SDSLabs. SDSLabs is a student-run technical group that includes passionate developers and designers interested in various fields and involved in multiple software development projects that aim to foster a software development culture on campus. Being a part of this group has exposed me to different software development methodologies, tools and frameworks and helped me become comfortable contributing to an open-source project with multiple contributors. Some open-source contributions I made here are: [1], [2] & [3]
I see this project as a meaningful opportunity to deepen my involvement in the Git community and to build a foundation for continued contributions to open source development in the future.
Overview:
---------
Git currently uses a global object called the_repository, which refers to a single instance of struct repository. Many internal functions rely on this global object rather than accepting a struct repository as an explicit parameter. This design inherently assumes a single active repository, making it difficult to support multi-repository use cases and obstructing the long-term goal of libification of Git.
A key architectural limitation is that while struct repository encapsulates some repository-specific information, many important environment variables and configuration settings that logically belong to a repository are still stored as global variables, primarily in environment.c, not within the repository struct. As a result, even if multiple repositories were to exist concurrently, they would still share this global state, leading to incorrect behavior, race conditions, or subtle bugs.
This project aims to refactor Git’s environment handling by relocating global variables into more appropriate local contexts, primarily within struct repository and struct repo_settings. However, some global variables may only apply to specific subsystems. In such cases, rather than placing them in struct repository or struct repo_settings, they should be moved into a context that better reflects their scope.
This change will not only make the environment state repository-specific but also improve the modularity and maintainability of the codebase. The work involves identifying environment-related global variables, determining the most suitable structure to house them, and updating all affected code paths accordingly.
The difficulty of this project is medium, and it is estimated to take 175 to 350 hours.
Pre-GSOC:
---------
I started exploring Git’s codebase and documentation around the end of January, familiarizing myself with its structure and development practices. I submitted a microproject, which helped me navigate the code and contribution workflow.
After selecting the project on refactoring Git’s state, I studied the surrounding code and reviewed past patches ([4], [5], [6], [7], [8] & [9]) to understand the reasoning behind previous changes.
To better prepare for the GSoC timeline, I submitted a patch related to the project, to gain hands-on experience with both the implementation details and the submission process. The patch focused on refactoring access to core.attributesfile.
Through discussions and feedback from the community, I gained a clearer understanding of a key aspect of the project:
determining whether certain variables should belong to repo_settings/ repository or be part of a separate subsystem.
Junio pointed out in a feedback that not all global variables should be blindly moved into repo_settings.
Specifically, for git_attributes_file, adding it to the repository struct doesn’t make sense. He explained that it’s similar to how index_state is handled, while index_state knows which repository it belongs to, the repository struct only holds a pointer to a single index_state instance and isn’t aware of other instances.
Following this approach, instead of placing git_attributes_file in the repository struct, we can house it within an attribute set and pass a pointer to that set wherever needed.
This practice patch gave me a clearer understanding of the project.
Patches:
--------
For git:
+ (Microproject) t6423: fix suppression of Git’s exit code in tests
Thread:
https://public-inbox.org/git/[email protected]/
Status: Merged into master
Commit Hash: 7c1d34fe5d1229362f2c3ecf2d493167a1f555a2
Description: Instead of executing a Git command as the upstream component of
a pipe, which can result in the exit status being lost, redirect its output to a file and then process that file in two steps to ensure the exit status is properly preserved.
+ midx: implement progress reporting for QSORT operation
Thread:
https://public-inbox.org/git/[email protected]/
Status: Dropped
Description: Add progress reporting during the QSORT operation in
multi-pack-index verification. While going through the code, I found this TODO, which I thought was interesting however my approach assumed that the qsort() operation processes elements in a structured order, which isn't guaranteed.
+ Stop depending on the_repository for core.attributesfile
Thread:
https://public-inbox.org/git/[email protected]/
Status: WIP, needs more discussion.
Description: This patch refactors access to the core.attributesfiles
configuration by moving it into the repo_settings struct. It eliminates the global variable git_attributes_file and updates relevant code paths to pass the struct repository as a parameter.
For git.github.io:
+ GSoC-participants: add GSoC 2024 participants to the list #762
Status: Merged into master
Description: Adding GSoC 2024 participants will help new
contributors understand their journey, making it easier for them to navigate the program and the project.
Proposed Plan:
--------------
I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined config.c and cross-referenced it with environment.c to see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into their local contexts.
The general approach for handling a global variable begins with understanding its purpose. This involves tracing its usage across the codebase and identifying the subsystem it should belong to. If the variable is closely tied to repository-related functionality, it may belong in struct repository or struct repo_settings. Otherwise, it should be placed in a more suitable context based on its scope.
Additionally, it's important to review previous attempts or related patches to understand past design decisions and ensure consistency with ongoing efforts. Finally, the global instance is eliminated by relocating the variable into the appropriate context and passing it through the relevant code paths.
Example: Handling is_bare_repository_cfg
The variable is_bare_repository_cfg determines whether a repository is bare, meaning it lacks a working directory. Since this property is fundamental to how a repository functions, it should be placed in struct repository.
I have also gone through the code paths and analyzed how this variable is initialized. We can initialize it similarly to how hash_algo is set through the repository format. The repository format already contains an is_bare field, which we can use to set this variable inside struct repository.
However, I still have some questions regarding why the is_bare_repository() function checks for repo->worktree and why the worktree struct itself has an is_bare variable. If a repository is considered bare when !repo->worktree is true, the role of worktree->is_bare needs further clarification. I believe that by engaging with the community, my understanding will become clearer. I also went through [4] to see how John Cai's approach was.
This is how we can also approach for other global variables. Through multiple iterations, this approach will be refined based on feedback, edge cases, and community input.
Timeline:
---------
Pre-GSOC:
(Until 8 May)
- Explore the codebase more, focusing on environment-related code paths.
- Document how each global variable is used and how it can be moved to
repository settings.
- Study Git’s Coding Guidelines and the Pro Git Book to align with best practices.
----------
Community Bonding:
(May 8 - June 1)
- Engage with mentors to discuss different environment variables, their
dependencies, and the best approach for refactoring.
- Finalize an implementation plan based on discussions.
- Since I will be on summer vacation, I can start coding early and make progress
on the project.
----------
Coding Period:
(June 2 - August 25)
- Identify the appropriate subsystem for each global variable and relocate it
into struct repository, struct repo_settings, or other suitable contexts.
- Modify function signatures to pass the new contexts explicitly, replacing
reliance on global variables.
- Continuously submit patches for review and incorporate feedback from mentors
and the community.
- I plan to write weekly blogs which will document what I did in the whole
week.
----------
Final Week:
(August 25 - September 1)
- Write a detailed report on the entire project.
- Fix bugs if any.
- Reflect on the project, noting challenges faced and lessons learned.
Blogging:
---------
I have also set up a blogging page at [10]. While reading blogs from previous GSoC contributors, I found them useful in understanding the challenges they faced and how they approached their projects. Their experiences gave me a better idea of what to expect and how to navigate the development process. Inspired by this, I decided to start my own blog to document my journey throughout GSoC. This will not only help me track my own progress but also serve as a resource for future contributors who might work on similar projects. I plan to share updates on my work, challenges encountered and insights gained from discussions with mentors and the community.
Additionally, I hope my blog encourages more people to contribute to open source by providing a transparent look into the development process. Writing about my experience will also help me reflect on my work and improve my ability to communicate technical ideas effectively.
I liked the format and structure of Chandra's blog, so I decided to use the same template for my own blogging page.
Availability:
-------------
As a college student, I intend to utilise my summer breaks from May to July to work on the project. After completing my University exams in April, I can start working in May. I can dedicate 40 hours a week from May to July, while in August after the classes commence, I can dedicate about 25 hours a week.
There are no exams or planned vacations throughout the coding period. Besides this project, I have no commitments/vacations planned for the summer. I shall keep my status posted to all the community members and maintain transparency in the project.
Post-GSOC:
----------
Beyond contributing code, I strongly believe in giving back to the community and helping others grow. Open source thrives on mentorship, knowledge sharing, and long-term involvement, and I would love to continue contributing even after GSoC ends.
I have always valued mentorship, both as a mentee and as someone who enjoys guiding others. If given the opportunity, I would be more than happy to mentor/co-mentor future GSoC contributors. By staying involved in the community, whether through contributing, reviewing patches, or mentoring, I hope to help sustain and expand the project’s reach. I look at GSoC as not just as a one-time contribution but as a step toward a longer-term relationship with open source.
I will continue to be involved with Git even after GSoC by contributing patches, reviewing code, and participating in discussions. My work on refactoring Git’s state aligns with long-term improvements to the codebase, and I plan to keep refining it beyond the program. I see GSoC as just the beginning of my journey with Git.
Appreciation:
-------------
I appreciate the Git community for its excellent documentation, which made it much easier for me to understand Git in depth. The well-structured resources helped me navigate the codebase and gain a deeper understanding of how Git works internally.
Beyond the documentation, I am also grateful for how welcoming and supportive the community has been. Whether through discussions on the mailing list or feedback on my patches, the information and guidance I received made my experience even better.
Additionally, I read the blogs and proposals of Chandra, Jialuo, and Ghanashyam, which provided valuable insights into their journeys and helped me shape my own approach to contributing.
Thanks for reviewing this proposal.
References:
-----------
[1] https://github.com/sdslabs/beast/pull/374
[2] https://github.com/sdslabs/beast/tree/add-teams-with-hint
[3] https://github.com/sdslabs/playCTF/pull/177
[4] https://public-inbox.org/git/[email protected]/
[6] https://public-inbox.org/git/20250206-b4-pks-path-drop-the-repository-v1-0-4e77f0313206@pks.im/
[7] https://public-inbox.org/git/[email protected]/#t
[8] https://public-inbox.org/git/[email protected]/
Ayush Chandekar <[email protected]> writes:
[snip]
Quoted 38 lines
Proposed Plan:
--------------I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined
config.cand cross-referenced it withenvironment.cto see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into their local contexts.The general approach for handling a global variable begins with understanding its purpose. This involves tracing its usage across the codebase and identifying the subsystem it should belong to. If the variable is closely tied to repository-related functionality, it may belong in struct repository or struct
repo_settings. Otherwise, it should be placed in a more suitable context based on its scope.Additionally, it's important to review previous attempts or related patches to understand past design decisions and ensure consistency with ongoing efforts. Finally, the global instance is eliminated by relocating the variable into the appropriate context and passing it through the relevant code paths.
Example: Handling
is_bare_repository_cfg
The variableis_bare_repository_cfgdetermines whether a repository is bare, meaning it lacks a working directory. Since this property is fundamental to how a repository functions, it should be placed in struct repository.I have also gone through the code paths and analyzed how this variable is initialized. We can initialize it similarly to how
hash_algois set through the repository format. The repository format already contains anis_barefield, which we can use to set this variable inside struct repository.However, I still have some questions regarding why the
is_bare_repository()function checks forrepo->worktreeand why theworktree structitself has anis_barevariable. If a repository is considered bare when !repo->worktree is true, the role ofworktree->is_bareneeds further clarification. I believe that by engaging with the community, my understanding will become clearer. I also went through [4] to see how John Cai's approach was.
Quoted 4 lines
This is how we can also approach for other global variables. Through multiple iterations, this approach will be refined based on feedback, edge cases, and community input.
So the approach you suggest is to comb through the global variables and config and find new locations for them to be stored. While this is definitely a bunch chunk of the problem, shouldn't we also talk about how we can reduce usage of some of these variables?
In particular, I'm wondering how you'd want to tackle 'the_repository' usage. There is some previous work done here, where Patrick added the '#define USE_THE_REPOSITORY_VARIABLE' definition which tracks usage of global variable and usage of them in different files.
A possible approach which has been followed is to simply go from the bottom layers of the code upwards, cleaning up usage of global variables and ensuring we can remove '#define USE_THE_REPOSITORY_VARIABLE' from files. This is also the approach taken in some of the patches that you've linked.
[snip]
Quoted 11 lines
So the approach you suggest is to comb through the global variables and config and find new locations for them to be stored. While this is definitely a bunch chunk of the problem, shouldn't we also talk about how we can reduce usage of some of these variables?
In particular, I'm wondering how you'd want to tackle '
the_repository' usage. There is some previous work done here, where Patrick added the '#defineUSE_THE_REPOSITORY_VARIABLE' definition which tracks usage of global variable and usage of them in different files.
Quoted 6 lines
A possible approach which has been followed is to simply go from the bottom layers of the code upwards, cleaning up usage of global variables and ensuring we can remove '#define
USE_THE_REPOSITORY_VARIABLE' from files. This is also the approach taken in some of the patches that you've linked.
Your approach makes a lot of sense to me, that is, picking a specific subsystem or file and aiming to remove the #define USE_THE_REPOSITORY_VARIABLE definition and thus 'the_repository' eventually. This was the method used by Patrick to tackle
the object subsystem in [1] and the path subsystem in [2] and you to tackle the packfile in [3].
This approach also helps in removing some of the global variables used within that particular
subsystem, which is a nice bonus.
However, this approach might not be feasible for the global variables that arent tightly tied to a single subsystem. So what I can do is, for removing the_repository, I can follow the approach you mentioned, and for relocating the more general global variables, I can use the approach which I talked about in the
proposal.
What do you think?
[1]: https://public-inbox.org/git/20250303-b4-pks-objects-without-the-repository-v1-0-c5dd43f2476e@pks.im/
[2]: https://public-inbox.org/git/20250206-b4-pks-path-drop-the-repository-v1-0-4e77f0313206@pks.im/
[3]: https://public-inbox.org/git/[email protected]/
Quoted 29 lines · Ayush Chandekar
Quoted 12 lines
So the approach you suggest is to comb through the global variables and config and find new locations for them to be stored. While this is definitely a bunch chunk of the problem, shouldn't we also talk about how we can reduce usage of some of these variables?
In particular, I'm wondering how you'd want to tackle '
the_repository' usage. There is some previous work done here, where Patrick added the '#defineUSE_THE_REPOSITORY_VARIABLE' definition which tracks usage of global variable and usage of them in different files.Quoted 6 lines
A possible approach which has been followed is to simply go from the bottom layers of the code upwards, cleaning up usage of global variables and ensuring we can remove '#define
USE_THE_REPOSITORY_VARIABLE' from files. This is also the approach taken in some of the patches that you've linked.Your approach makes a lot of sense to me, that is, picking a specific subsystem or file and aiming to remove the
#define USE_THE_REPOSITORY_VARIABLEdefinition and thus 'the_repository' eventually. This was the method used by Patrick to tackle
the object subsystem in [1] and the path subsystem in [2] and you to tackle the packfile in [3].
This approach also helps in removing some of the global variables used within that particular
subsystem, which is a nice bonus.
Quoted 2 lines
However, this approach might not be feasible for the global variables that arent tightly tied to a single subsystem.
Well, initially 'the_repository' wasn't tightly tied to a single subsystem and even now I am not sure we could say it's tightly tied to a single subsystem. Or maybe I don't understand what you mean.
Do you mean that it's tightly tied because it needs #define USE_THE_REPOSITORY_VARIABLE?
But for other global variables it could be possible to define and use similar macros. This way it might be possible to remove those variables step by step only in some files.
Quoted 7 lines
So what I can do is, for removing
the_repository, I can follow the approach you mentioned, and for relocating the more general global variables, I can use the approach which I talked about in the
proposal.What do you think?
If removing the_repository is part of your proposal, then yeah, describing the approach you will use to remove is a good idea.
Quoted 8 lines
Well, initially '
the_repository' wasn't tightly tied to a single subsystem and even now I am not sure we could say it's tightly tied to a single subsystem. Or maybe I don't understand what you mean.Do you mean that it's tightly tied because it needs
#define USE_THE_REPOSITORY_VARIABLE?
Sorry if I was not clear earlier. I wasn't referring to 'the_repository' being tied, it was about other
global variables being tied to a subsystem.
What I meant is that the approach of picking a subsystem and removing the #define USE_THE_REPOSITORY_VARIABLE is really effective for removing 'the_repository.'
It also helps in localizing the global variables from environment.h that are specific to that subsystem,
either into the subsystem itself or into struct repository / repo_settings.
But let's say if a global variable is common to 2-3 different subsystems, then this approach would not be feasible for that variable. For that, I would require to individually
tackle that variable. This is an approach which I mentioned in my proposal.
So using these two approaches according to different needs, I can move forward.
Quoted 4 lines
But for other global variables it could be possible to define and use similar macros. This way it might be possible to remove those variables step by step only in some files.
Yes, I still need to think through how that would align with the approach I mentioned.
Defining a single macro like #define USE_GLOBAL_VARIABLES is something I can look into.
Quoted 10 lines
Quoted 7 lines
So what I can do is, for removing
the_repository, I can follow the approach you mentioned, and for relocating the more general global variables, I can use the approach which I talked about in the
proposal.What do you think?
If removing
the_repositoryis part of your proposal, then yeah, describing the approach you will use to remove is a good idea.
Yes, it is a part of the project but I haven't added this specific approach in the proposal yet and was hence asking if I can. Thanks:)
Hey Patrick,
It would be great if you could take a look at my proposal, especially since you've worked on this area before. Any feedback would be really appreciated!
Thanks!
Ayush
PATCH v3 1/1 : Refactoring in order to reduce Git’s global state
In reply to Ayush ChandekarHello,
This is the third version of my GSoC 2025 proposal for the project "Refactoring in order to reduce Git’s global state".
The key change from v2 to this v3 is that I’ve added how I plan to tackle the 'the_repository' global object.
You can view docs version here:
https://docs.google.com/document/d/1tJrtWxo1UGKChB3hu5eZ-ljm0FtU_fsv0TnIRwu3EKY/edit?usp=sharing
---------
Refactoring in order to reduce git’s state
My Information:
---------------
Name: Ayush Chandekar
Email: [email protected]
Mobile No: (+91) 9372496874
Education: UG Sophomore, IIT Roorkee
Github: https://github.com/ayu-ch
Blog: https://ayu-ch.github.io
About me:
---------
I'm Ayush Chandekar, a UG Sophomore studying at Indian Institute of Technology, Roorkee. I like participating in various software development and tech-development endeavors, usually hackathons, CTFs, and projects at SDSLabs. SDSLabs is a student-run technical group that includes passionate developers and designers interested in various fields and involved in multiple software development projects that aim to foster a software development culture on campus. Being a part of this group has exposed me to different software development methodologies, tools and frameworks and helped me become comfortable contributing to an open-source project with multiple contributors. Some open-source contributions I made here are: [1], [2] & [3]
I see this project as a meaningful opportunity to deepen my involvement in the Git community and to build a foundation for continued contributions to open source development in the future.
Overview:
---------
Git currently uses a global object called the_repository, which refers to a single instance of struct repository. Many internal functions rely on this global object rather than accepting a struct repository as an explicit parameter. This design inherently assumes a single active repository, making it difficult to support multi-repository use cases and obstructing the long-term goal of libification of Git.
A key architectural limitation is that while struct repository encapsulates some repository-specific information, many important environment variables and configuration settings that logically belong to a repository are still stored as global variables, primarily in environment.c, not within the repository struct. As a result, even if multiple repositories were to exist concurrently, they would still share this global state, leading to incorrect behavior, race conditions, or subtle bugs.
This project aims to refactor Git’s environment handling by relocating global variables into more appropriate local contexts, primarily within struct repository and struct repo_settings. However, some global variables may only apply to specific subsystems. In such cases, rather than placing them in struct repository or struct repo_settings, they should be moved into a context that better reflects their scope.
This change will not only make the environment state repository-specific but also improve the modularity and maintainability of the codebase. The work involves identifying environment-related global variables, determining the most suitable structure to house them, and updating all affected code paths accordingly.
The difficulty of this project is medium, and it is estimated to take 175 to 350 hours.
Pre-GSOC:
---------
I started exploring Git’s codebase and documentation around the end of January, familiarizing myself with its structure and development practices. I submitted a microproject, which helped me navigate the code and contribution workflow.
After selecting the project on refactoring Git’s state, I studied the surrounding code and reviewed past patches ([4], [5], [6], [7], [8] & [9]) to understand the reasoning behind previous changes.
To better prepare for the GSoC timeline, I submitted a patch related to the project, to gain hands-on experience with both the implementation details and the submission process. The patch focused on refactoring access to core.attributesfile.
Through discussions and feedback from the community, I gained a clearer understanding of a key aspect of the project:
determining whether certain variables should belong to repo_settings/ repository or be part of a separate subsystem.
Junio pointed out in a feedback that not all global variables should be blindly moved into repo_settings.
Specifically, for git_attributes_file, adding it to the repository struct doesn’t make sense. He explained that it’s similar to how index_state is handled, while index_state knows which repository it belongs to, the repository struct only holds a pointer to a single index_state instance and isn’t aware of other instances.
Following this approach, instead of placing git_attributes_file in the repository struct, we can house it within an attribute set and pass a pointer to that set wherever needed.
This practice patch gave me a clearer understanding of the project.
Patches:
--------
For git:
+ (Microproject) t6423: fix suppression of Git’s exit code in tests
Thread:
https://public-inbox.org/git/[email protected]/
Status: Merged into master
Commit Hash: 7c1d34fe5d1229362f2c3ecf2d493167a1f555a2
Description: Instead of executing a Git command as the upstream component of
a pipe, which can result in the exit status being lost, redirect its output to a file and then process that file in two steps to ensure the exit status is properly preserved.
+ midx: implement progress reporting for QSORT operation
Thread:
https://public-inbox.org/git/[email protected]/
Status: Dropped
Description: Add progress reporting during the QSORT operation in
multi-pack-index verification. While going through the code, I found this TODO, which I thought was interesting however my approach assumed that the qsort() operation processes elements in a structured order, which isn't guaranteed.
+ Stop depending on the_repository for core.attributesfile
Thread:
https://public-inbox.org/git/[email protected]/
Status: WIP, needs more discussion.
Description: This patch refactors access to the core.attributesfiles
configuration by moving it into the repo_settings struct. It eliminates the global variable git_attributes_file and updates relevant code paths to pass the struct repository as a parameter.
For git.github.io:
+ GSoC-participants: add GSoC 2024 participants to the list #762
Status: Merged into master
Description: Adding GSoC 2024 participants will help new
contributors understand their journey, making it easier for them to navigate the program and the project.
+ Rename references from *.txt to *.adoc in documentation paths. #769
Status: Merged into master
Description: Since the documentation in git is changed from *.txt to *.adoc
format. Update references to reflect that change.
+ Rename references from *.txt to *.adoc in Rev News editions. #770
Status: Merged into master
Description: Since the documentation in git is changed from *.txt to *.adoc
format. Update references in previous editions to reflect that change.
Proposed Plan:
--------------
I have been reviewing global variables across the codebase to understand their dependencies and impact. To do this, I examined config.c and cross-referenced it with environment.c to see how these variables are currently managed. The goal of this project is to eliminate global variables by moving their configurations into their local contexts.
The general approach for handling a global variable begins with understanding its purpose. This involves tracing its usage across the codebase and identifying the subsystem it should belong to. If the variable is closely tied to repository-related functionality, it may belong in struct repository or struct repo_settings. Otherwise, it should be placed in a more suitable context based on its scope.
Additionally, it's important to review previous attempts or related patches to understand past design decisions and ensure consistency with ongoing efforts. Finally, the global instance is eliminated by relocating the variable into the appropriate context and passing it through the relevant code paths.
Example: Handling is_bare_repository_cfg
The variable is_bare_repository_cfg determines whether a repository is bare, meaning it lacks a working directory. Since this property is fundamental to how a repository functions, it should be placed in struct repository.
I have also gone through the code paths and analyzed how this variable is initialized. We can initialize it similarly to how hash_algo is set through the repository format. The repository format already contains an is_bare field, which we can use to set this variable inside struct repository.
However, I still have some questions regarding why the is_bare_repository() function checks for repo->worktree and why the worktree struct itself has an is_bare variable. If a repository is considered bare when !repo->worktree is true, the role of worktree->is_bare needs further clarification. I believe that by engaging with the community, my understanding will become clearer. I also went through [4] to see how John Cai's approach was.
This is how we can also approach for other global variables. Through multiple iterations, this approach will be refined based on feedback, edge cases, and community input.
Other than that, we have a global object 'the_repository'. As an attempt to remove this globally, Patrick introduced a macro#define USE_THE_REPOSITORY_VARIABLE in this patch: [10]. An approach I can follow is picking a subsystem or file, and aiming to remove the macro and hence eliminating the usage of 'the_repository' in that subsystem/file by passing the struct repository explicitly through the call chain. This approach also helps in removing some of the global variables in that particular subsystem.
This is also followed in the patches by Patrick in
[5] and [6] to tackle the object and path subsystem respectively and Karthik in [8] to tackle the packfile subsystem.
Timeline:
---------
Pre-GSOC:
(Until 8 May)
- Explore the codebase more, focusing on environment-related code paths.
- Document how each global variable is used and how it can be moved to
repository settings.
- Study Git’s Coding Guidelines and the Pro Git Book to align with best practices.
----------
Community Bonding:
(May 8 - June 1)
- Engage with mentors to discuss different environment variables, their
dependencies, and the best approach for refactoring.
- Finalize an implementation plan based on discussions.
- Since I will be on summer vacation, I can start coding early and make progress
on the project.
----------
Coding Period:
(June 2 - August 25)
- Identify the appropriate subsystem for each global variable and relocate it
into struct repository, struct repo_settings, or other suitable contexts.
- Modify function signatures to pass the new contexts explicitly, replacing
reliance on global variables.
- Pick subsystems and remove the macro
#define USE_THE_REPOSITORY_VARIABLE and thereby eliminating usage of the global variable ‘the_repository’.
- Continuously submit patches for review and incorporate feedback from mentors
and the community.
- I plan to write weekly blogs which will document what I did in the whole
week.
----------
Final Week:
(August 25 - September 1)
- Write a detailed report on the entire project.
- Fix bugs if any.
- Reflect on the project, noting challenges faced and lessons learned.
Blogging:
---------
I have also set up a blogging page at [11]. While reading blogs from previous GSoC contributors, I found them useful in understanding the challenges they faced and how they approached their projects. Their experiences gave me a better idea of what to expect and how to navigate the development process. Inspired by this, I decided to start my own blog to document my journey throughout GSoC. This will not only help me track my own progress but also serve as a resource for future contributors who might work on similar projects. I plan to share updates on my work, challenges encountered and insights gained from discussions with mentors and the community.
Additionally, I hope my blog encourages more people to contribute to open source by providing a transparent look into the development process. Writing about my experience will also help me reflect on my work and improve my ability to communicate technical ideas effectively.
I liked the format and structure of Chandra's blog, so I decided to use the same template for my own blogging page.
Availability:
-------------
As a college student, I intend to utilise my summer breaks from May to July to work on the project. After completing my University exams in April, I can start working in May. I can dedicate 40 hours a week from May to July, while in August after the classes commence, I can dedicate about 25 hours a week.
There are no exams or planned vacations throughout the coding period. Besides this project, I have no commitments/vacations planned for the summer. I shall keep my status posted to all the community members and maintain transparency in the project.
Post-GSOC:
----------
Beyond contributing code, I strongly believe in giving back to the community and helping others grow. Open source thrives on mentorship, knowledge sharing, and long-term involvement, and I would love to continue contributing even after GSoC ends.
I have always valued mentorship, both as a mentee and as someone who enjoys guiding others. If given the opportunity, I would be more than happy to mentor/co-mentor future GSoC contributors. By staying involved in the community, whether through contributing, reviewing patches, or mentoring, I hope to help sustain and expand the project’s reach. I look at GSoC as not just as a one-time contribution but as a step toward a longer-term relationship with open source.
I will continue to be involved with Git even after GSoC by contributing patches, reviewing code, and participating in discussions. My work on refactoring Git’s state aligns with long-term improvements to the codebase, and I plan to keep refining it beyond the program. I see GSoC as just the beginning of my journey with Git.
Appreciation:
-------------
I appreciate the Git community for its excellent documentation, which made it much easier for me to understand Git in depth. The well-structured resources helped me navigate the codebase and gain a deeper understanding of how Git works internally.
Beyond the documentation, I am also grateful for how welcoming and supportive the community has been. Whether through discussions on the mailing list or feedback on my patches, the information and guidance I received made my experience even better.
Additionally, I read the blogs and proposals of Chandra, Jialuo, and Ghanashyam, which provided valuable insights into their journeys and helped me shape my own approach to contributing.
Thanks for reviewing this proposal.
References:
-----------
[1] https://github.com/sdslabs/beast/pull/374
[2] https://github.com/sdslabs/beast/tree/add-teams-with-hint
[3] https://github.com/sdslabs/playCTF/pull/177
[4] https://public-inbox.org/git/[email protected]/
[6] https://public-inbox.org/git/20250206-b4-pks-path-drop-the-repository-v1-0-4e77f0313206@pks.im/
[7] https://public-inbox.org/git/[email protected]/#t
[8] https://public-inbox.org/git/[email protected]/
[9] https://public-inbox.org/git/[email protected]/