FreeBSD Foundation Intern Sourojeet Adhikari on Bringing ROCm to FreeBSD

For University of Waterloo student Sourojeet Adhikari, an early interest in understanding how computers work eventually grew into a summer spent helping bring AMD’s ROCm GPU computing platform to FreeBSD.

Sourojeet is studying Mathematical Physics and entering the third year of his degree. This summer, he joined the FreeBSD Foundation as an intern, working on a project that combines several of his interests: systems programming, GPU computing, and open source.

We spoke with Sourojeet about his path into open source, the challenges of bringing ROCm to FreeBSD, what he learned from debugging difficult problems, and why students shouldn’t be intimidated by contributing to a large open source project.

An Early Introduction to Open Source

Sourojeet’s interest in open source began when he built his first computer. Without a Windows installation disc or drive available, he turned to what he could find: an Ubuntu 12.04 installation CD sitting on a shelf in his basement.

“I installed Ubuntu and spent days figuring out how to use it,” he said. “From then on, I more or less ran Linux on almost every computer or server I’ve ever owned.”

FreeBSD was also part of his early exposure to open source. One of his parents ran a FreeBSD firewall and another FreeBSD server for a time. The firewall is still running today.

What kept Sourojeet interested was the freedom to explore.

“Open source software generally let me play around with and look deep into the internals of software, modify it, and try to break it,” he said. “That’s why I loved it so much.”

His interest in systems programming came from another question: How can I make my programs faster?

Understanding performance meant understanding what a system was doing under the hood. That curiosity led him deeper into systems programming and, eventually, GPU programming.

Bringing ROCm to FreeBSD

Sourojeet found the FreeBSD Foundation internship through WaterlooWorks, the University of Waterloo’s co-op job board.

His internship project focused on bringing AMD’s ROCm platform to FreeBSD.

Modern computers rely on different components designed for different kinds of work. CPUs are general-purpose processors built to handle a broad range of tasks, while GPUs are highly effective at performing certain kinds of mathematical operations in parallel.

That makes GPUs useful for much more than graphics. Workloads including machine learning, fluid simulations, and data processing can benefit significantly from GPU acceleration.

Platforms such as NVIDIA’s CUDA and AMD’s ROCm give developers the tools needed to take advantage of that computing power. However, these ecosystems have primarily focused on Windows and Linux, with limited native support on FreeBSD.

Sourojeet’s goal was to help change that.

His work involved patching AMD’s LLVM fork, making changes to ROCm’s GPU runtimes, and working to integrate the driver into drm-kmod. Some of the LLVM changes have already been upstreamed, while other pieces of the work are still being merged and developed.

“Slowly but surely, we’ll soon be able to natively run ROCm code on FreeBSD,” he said.

Finding the Bugs That Don’t Want to Be Found

For Sourojeet, one of the most rewarding parts of the internship was also one of the most difficult: debugging.

One issue took several hours to track down and came from a subtle difference between mutable and constant data.

The problem involved LinuxKPI, a compatibility layer in the FreeBSD kernel that helps translate or provide Linux kernel interfaces needed by certain drivers. A Linux function called class_register had changed in newer Linux versions to accept a const structure. The AMD kernel code Sourojeet was porting expected that newer behavior, while the corresponding FreeBSD LinuxKPI implementation still expected a mutable structure.

The mismatch caused a kernel panic.

“It took me maybe three or four hours to figure that one out,” Sourojeet said.

Rather than being discouraged by those problems, he found them to be some of the most enjoyable parts of the work.

“The most fun part was generally debugging the hard-to-find bugs and issues in the code.”

Working Through the Tedious Parts

Not every challenge involved a single difficult bug. Much of the porting work required dealing with Linux-specific macros and functions that did not yet exist on FreeBSD.

Sourojeet first had to determine whether a missing function or code path was actually necessary. Some functionality, such as code related to suspend or sleep behavior, was not required for the initial work and could be temporarily disabled. In other cases, a missing function was too important to remove and needed a temporary stub so development could continue.

The individual changes were not always technically complex. The challenge was often the amount of careful, repetitive work required to move the project forward.

“The actual changes you needed to make to get the driver running weren’t hard or insane,” he said. “Rather, they were just mentally grueling and very tedious.”

That experience also reinforced something Sourojeet wants other potential contributors to understand: meaningful open source work does not always require being an expert.

“If you’re reading this and have some ability to read and write C code, you could probably help out with almost everything.”

Connecting With the Community at BSDCan

During the summer, Sourojeet also attended BSDCan, giving him an opportunity to connect with members of the BSD community in person.

One talk that stood out was Minsoo Choo’s presentation on heterogeneous scheduling on FreeBSD. Sourojeet was particularly interested in the discussion around scheduling costs and performance across different CPU cores.

But some of his favorite parts of BSDCan happened outside the formal sessions.

“The hallway track was a lot more interesting from what I remember,” he said.

Those conversations covered topics ranging from software testing and GPU initialization to heterogeneous memory management on FreeBSD. The latter is especially relevant to where Sourojeet’s own work may go next.

Open Source Is More Approachable Than It Looks

After spending the summer working directly within the FreeBSD ecosystem, Sourojeet came away with an even stronger belief that contributing to open source is more accessible than many new developers assume.

“This internship reinforced my belief that open source is not particularly scary or hard to contribute to,” he said. “It just needs some time and energy.”

His advice to students and first-time contributors is simple: don’t wait until you think you know everything.

“Don’t wait until you think you’re perfect, or the best at coding,” he said. “A lot of the work is tedious debugging, writing docs, or even implementing basic functions.”

Large codebases can look intimidating from the outside, but Sourojeet encourages new contributors to focus on the problem in front of them rather than the size of the entire project.

“It’s just code—maybe a lot of code—but I have faith that anyone who puts in some time and energy can come out with some meaningful changes.”

What’s Next?

Sourojeet expects his work with ROCm and FreeBSD to continue beyond the internship.

The project is already approaching an important milestone: running a simple vector addition workload. The driver can link, load, and run, although there are still issues to resolve in userspace.

From there, Sourojeet expects to spend more time exploring FreeBSD’s memory management systems, particularly the work required to support Heterogeneous Memory Management (HMM).

As for his longer-term career plans, he is keeping his options open.

His ideal path may involve computational fluid dynamics—or, as he jokes, making enough money to eventually retire and hire interns to tackle difficult problems like HMM on FreeBSD. But his experience this summer has also opened another possibility: working on GPU toolchains.

Whatever direction he takes, the internship has given him practical experience solving problems deep within a complex open source system, and a reason to keep contributing.

Sourojeet also credits the people who supported him throughout the project, including Ed Maste, Olivier Certner, Mark Johnson, Jean-Sébastien Pédron, Bjoern Zeeb, Adrian Chadd, Minsoo Choo, and Devin Teske.

His summer is also a reminder for students considering their first open source contribution: you don’t need to understand an entire operating system before you can make an impact. Start with a problem, spend the time to understand it, and contribute what you can.

The FreeBSD Foundation would also like to thank Sourojeet for his contributions throughout the semester. We appreciate the curiosity, persistence, and technical effort he brought to the internship, as well as his willingness to tackle challenging problems and continue pushing ROCm support on FreeBSD forward.