Chapter 152: Double Buffering and Threshold

13:45. The cursor on the screen rests on the first line of io_scheduler.c. Lin Chen is in no hurry to type. First, he sketches the data flow for double buffering on a draft sheet: Buffer A receives the cleaned results output by the parsing thread, while Buffer B is responsible for batch-flushing A’s data to disk. Once B finishes writing, the pointers swap. A becomes B, B becomes A. The cycle repeats. The core lies in lock granularity. If a global lock is applied every time they swap, the parsing thread will be blocked, and CPU utilization will plummet once again. He decides to use semaphores to control the "empty/full" state of the buffers. The parsing thread writes only when the buffer is "not full," and the I/O thread reads only when it is "not empty." A variant of a lock-free queue.

The sound of the keyboard resumes. pthread_mutex_t buf_lock; sem_t buf_full, buf_empty; Structure definitions, initialization, and destruction functions. The rigor of C lies in the fact that every memory allocation must have a corresponding release. He writes malloc, then immediately adds free under the cleanup label. Considering CPU cache line alignment, he appends char padding[64] to the end of the structure to prevent multi-core performance degradation caused by false sharing. The coolness of the mineral water bottle beneath his left foot has long faded, and the condensation on its surface has soaked through the edge of his slipper. His swollen ankle begins to tighten, as if constricted by a rough hemp rope, loop by loop. He forces himself to stand up every twenty minutes, gripping the edge of the server cabinet to pace slowly. The cartilage in his knees emits a faint grinding sound. He doesn’t care. The progress bar running in his mind is far clearer than the pain in his legs.

16:10. The basic framework is complete. He compiles it into a Python extension module, replacing the original direct-write logic. He launches a full-scale test. The terminal scrolls. The memory curve remains stable. But at the 1.2 million-line mark, the program freezes. CPU usage plummets to 5%. A deadlock. He pulls up gdb and attaches to the process. Thread 1 is halted at sem_wait(&buf_full), Thread 2 at pthread_mutex_lock(&buf_lock). A classic variant of the dining philosophers problem. He stares at the call stack, his fingers tapping the desk unconsciously. The issue lies in the order of semaphore releases. When the buffer is full, the parsing thread waits for buf_empty, but the I/O thread must acquire buf_lock before writing. The holder of that lock happens to be the parsing thread, which is itself waiting on a semaphore. The logical loop has deadlocked itself.

He takes a deep breath, leaving the overarching framework untouched. Inside the I/O thread’s write loop, he adds a pthread_mutex_trylock. If it fails to acquire the lock, it means the parsing thread is currently operating on the buffer boundary; the I/O thread simply skips this write cycle and yields its CPU time slice. A non-blocking retry. The cost is a few extra idle spins, but it completely sidesteps the deadlock. He modifies the code and recompiles. Runs it. The terminal scrolls once more. The freeze point is passed smoothly. Two million lines. Two point five million. Three million. Complete. Latency: 9.2s. 30.6 milliseconds per ten thousand lines. I/O wait time drops by 60%. He leans back in his chair and closes his eyes. The hum of the cooling fans seems to have softened.

19:00. Most of the people in the server room have left. The fluorescent tubes emit a faint electrical hum. Lin Chen clears his desk, tossing the remaining half of a cold steamed bun and an empty water bottle into the trash. His left foot is so swollen it shines, the skin stretched taut and translucent. He tries to squeeze it back into his sneaker, but it gets stuck halfway. He gives up and keeps the slipper on. Stepping out of the server building, the night wind carries the chill of early autumn against his face. The campus streetlights cast a dim yellow glow, and fallen plane tree leaves carpet the ground. He walks slowly, his weight entirely on his right leg. Every time his left foot touches down, it feels like stepping on shattered glass, but he keeps his stride meticulously even. His breathing is steady. Passing the sports field, a few students are jogging on the track, their footsteps synchronized. He doesn’t look. His attention is entirely fixed on tomorrow’s code submission deadline.

He walks to a Shaxian Snacks shop just outside the South Gate. Orders a bowl of dry-mixed noodles with a side of wontons. Scans to pay: 8 yuan. Balance displayed: 27.3 yuan. The 810.4 yuan in his online bank account still sits quietly, untouched. He cannot touch it. Xiao Man’s sodium valproate for next month cannot be interrupted. He bows his head and eats. The noodles are tough, the broth bland. But he eats it all clean. The carbohydrates enter his stomach, converting into tangible strength. He needs that strength to last until Wednesday. Behind the counter, the owner watches a TV drama, the volume turned down low. Lin Chen finishes, neatly stacks his bowl and chopsticks on the corner of the table, and pushes the door open into the night.

Back in the dorm, he powers on his computer, preparing to push the final version of the code to the internal Git repository. His phone screen lights up. A message from Engineer Li pops up: “Notice: The hard drives on the Wednesday acceptance machine have been uniformly replaced with an enterprise-grade SSD array. The original HDD I/O scheduling logic is now void. The demo environment remains locked and unchanged. Submit the SSD-adapted version before 9 AM tomorrow, with a focus on optimizing queue latency under high concurrency. Reply upon receipt.”

Lin Chen stares at the screen. SSD. Random writes are no longer the bottleneck. The double buffering and sequential write logic have become redundant. He needs to roll the code back to the v2.0 parsing architecture, but retain the checkpoint and exception rollback modules, and rewrite the consumer queue to leverage the SSD’s high IOPS characteristics. The time window has been compressed to less than fourteen hours.

He doesn’t reply. He opens the terminal and creates a new branch: feature/ssd_optimization. His left foot twitches faintly beneath the desk. He pulls out his chair and sits down. His fingers rest on the keyboard. The rhythm is slow, but steady. Outside, the night is heavy. The glow of the screen reflects on his face, utterly calm. He types the first line of comments: // Objective: Remove dependency on sequential writes, refactor lock-free ring buffer, adapt for high-concurrency random I/O.