Chapter 214: Learning and Inference
Han Yu-ju’s briefing materials were far more extensive than I had anticipated.
So I loosened my tie and settled in properly.
“So, where are we at with this?”
Han Yu-ju pressed a key to advance the slide.
“Luna OS is currently at the Beta 1.8 version. The core kernel is complete, and the file system and runtime manager are mostly implemented. It’s designed with a universal structure that can be ported to various devices like smartphones, electric cars, and PCs. The bus layer for AI module communication is also parallel-supported.”
“So, multi-device expansion works without issues?”
Even before the regression, this was a challenging part to resolve, so I asked, just in case.
As expected, Han Yu-ju looked at me with a surprised expression.
“…Actually, that’s the part we’re struggling with the most right now.”
Han Yu-ju advanced to the next slide.
A document titled Resource Abstraction and Layer Conflicts appeared.
“Each device requires completely different resources, and even when we try to abstract and integrate resources, inter-layer conflicts keep occurring. No matter what we do, we can’t seem to resolve it.”
In the future, Luna won’t just operate on a single device.
It needs to run simultaneously on different devices like smartphones, electric cars, and desktops.
However, the resources each device requires—
CPU usage patterns, memory activity criteria, and I/O timing—are all completely different.
This meant that attempts to integrate resources within the OS were failing.
Han Yu-ju added a specific example.
“For instance, the MCU for electric cars requires precise scheduling like a hard real-time OS, whereas smartphones prioritize user interface responsiveness. So, it’s unclear which resource should be allocated first.”
As I carefully examined the materials, a familiar metric caught my eye.
“This is… the resource allocation ratio compared to thread demand. With these numbers, I think there would be CPU monopolization on the smartphone side?”
Han Yu-ju nodded.
“In actual field tests, when both a smartphone and a car were running on Luna, the smartphone’s user interface response speed slowed significantly.”
“Why didn’t you use multi-domain kernel partitioning?”
Han Yu-ju paused, looking momentarily confused.
“…We excluded it because we were worried about memory overhead. We thought partitioning the kernel would make the cost of switching between domains too high.”
“That’s a design issue, not a structural limitation.”
I pressed on the memory block map on the right side of the screen.
“Don’t fully separate the domains for each device. Switch to a semi-independent kernel cluster structure. Keep the common kernel as is, but only separate the single operating environment for each device. That way, you can reduce I/O conflicts and minimize memory overhead.”
“…So, instead of a full multi-domain setup, you’re suggesting we only isolate the interrupt hub and connect it with a segment tree?”
“Yes. And while the resource pool will be physically shared, adjust the scheduler’s priority using a rescaling method. If Luna was designed from the start as ‘one ecosystem,’ it should operate on ‘one resource graph.’”
Han Yu-ju seemed at a loss for words for a while.
Then, with a mix of surprise and self-reproach, she looked at me.
“…Why didn’t I think of that?”
Seeing Han Yu-ju’s awkward smile, I shook my head.
“No one’s perfect from the start. And what you’re building isn’t just an operating system—it’s a full-fledged AI platform.”
Normally, even with countless failures and efforts, completing such a system couldn’t be guaranteed.
And the advice I gave merely reduced some of those trials and errors.
“First… I’ll run a simulation.”
Han Yu-ju sighed softly and started typing on her laptop, following my advice.
It was a time-consuming task, but I waited silently for it to finish.
After a long while,
Han Yu-ju, having finished the setup, ran the simulation.
“After redesigning it with the semi-independent kernel cluster structure you suggested… the conflicts in the network layer have disappeared, and the wait times between I/O threads have noticeably decreased.”
The monitor displayed a virtual simulation of Luna running simultaneously on different devices—
smartphones, electric cars, tablets, and PCs.
The smartphone screen, which used to flicker frequently, was now responding smoothly.
Though she didn’t show it outwardly, Han Yu-ju’s eyes revealed her astonishment.
‘Clearly, the CEO has never built an AI platform before… So how did he know this solution?’
Given how many unexpected things he had done, and what I had seen so far,
Han Yu-ju’s doubt didn’t last long.
“It seems the multi-device expansion issue is resolved, so let’s move on to the next item.”
At my words, Han Yu-ju nodded and brought up the next slide.
It was a list of Luna’s current development status by function and the remaining tasks ahead.
“Currently, Luna’s overall progress is at 72.4%.”
She started explaining the completed items first.
“The kernel architecture received its final stability mark last month. The file system was finalized with our own extension of LFS, called LFS0X, and the module interface was switched from the existing IPC structure to a μBus-based asynchronous channel. Additionally, the power management profile and resource reallocation algorithm have been stability-verified for both smart devices and vehicle environments.”
Development was progressing faster than expected.
Of course, that didn’t mean the remaining tasks would be easy.
“…There are still three major unfinished parts.”
Han Yu-ju pointed to the top of the screen.
- OS-level integration of the AI acceleration module
- UX-Adapt Layer for device-specific user experience optimization
- Integration of the security kernel with a multi-factor authentication system
“The first goal is to minimize communication latency between the Black Robin chipset’s computational structure and the OS.”
It seemed Han Yu-ju was designing the system so that AI computation results would be buffered and processed directly within the kernel space, bypassing the GPU or TPU.
“In initial tests, GPU computation results took 27 to 32ms to move from user space back to the kernel. To address this, we’re designing an AI Fast Path routing within the kernel and plan to introduce Pre-Buffer Scheduling for high computation loads.”
“So, you’re making AI computations callable as internal functions within the OS structure?”
Perhaps because I understood her intent accurately,
Han Yu-ju nodded, looking satisfied.
“And the second item, the UX-Adapt Layer, is the resource adaptation layer for different user environments.”
Even with the same OS, interfaces vary completely by device, such as smartwatches or vehicle HUDs.
The screen Han Yu-ju showed displayed various UI form factors.
“So, while maintaining the same core structure, you’re preparing different UI components and event handling structures for each device?”
“Yes. But planning is only at 70%, and implementation is under 30%.”
The third and final item was a security-related issue.
“The security kernel is currently only used for auxiliary authentication. The Luna authentication system, based on quantum key synchronization, hasn’t been fully integrated with the OS kernel yet.”
“What about using a ‘Secure Root’ to chain everything from boot to initialization?”
Han Yu-ju gave a somewhat ambiguous response to my question.
“It’s possible, but… it would slow down the boot speed, and the memory protection area would become too large.”
“Just virtualize the encryption module in a key store and use a hybrid setup with TPM 2.0 for root authentication. That should solve it.”
Han Yu-ju’s eyes widened at my casual solution.
“If we do that… devices with Luna installed should be able to directly implement a Chain of Trust at the OS level.”
“Great. So, what about learning?”
After confirming Luna OS’s development status, I brought up the real reason for my visit.
As if she had been waiting, Han Yu-ju brought up the next slide.
She pointed to the title at the top of the screen and began explaining.
“Currently, the core of the AI learning module on the Luna platform is the ‘Luna-Train engine.’ This module is designed to maximize the dedicated computational structure of the Black Robin chipset, enabling efficient model learning and inference at the OS level.”
This included the data pipeline for model learning, automatic optimization processes, hardware acceleration stages, and more.
“Looks like you’ve put in a lot of effort.”
It wasn’t an empty compliment—I could feel the traces of hard work everywhere.
“The team has worked really hard, but they’ve been well-compensated, so there aren’t many complaints.”
“So… what’s the biggest remaining issue for learning?”
Han Yu-ju answered immediately, as if she had expected the question.
“The software learning module and data pipeline are almost done. But to start large-scale AI model training in an actual hardware environment, we first need the hardware utilizing the Black Robin chipset to be ready.”
As expected, I showed Han Yu-ju the hardware build roadmap I received from Chilbong.
Mass production of the Black Robin chipset, optimization of hardware acceleration libraries and drivers,
stabilization of the interface between HBM2e memory modules and Black Robin,
high-speed interface based on PCIe Gen5,
and the construction of a large-scale parallel learning cluster within the data center.
“In about six months, we should have the basic infrastructure ready.”
“So, I just need to finish preparing Luna for learning by then?”
“Yes.”
There was still a lot to prepare, including the hardware and OS needed for the Luna platform,
but we were getting closer to our goal.
Now, all that remained was to create a ‘standard’ for the latecomers to follow and to secure the data needed to train Luna.
For example, data related to electric cars and autonomous driving.