Mainframe Tech: Setting the Stage

Matt’s story starts between college and grad school, when he was working for a company providing a database system for material requirements planning in manufacturing.

At the time, powerful computer systems were far too expensive for most smaller businesses to own. Companies like Matt’s provided an alternative: buy computing time on large systems, run their software there, and sell that service to customers. In many ways, it was cloud computing several decades before anyone called it cloud computing.

Breaking Down the Jargon

For those less familiar with the technical vocabulary, fear not! Our journey includes a glossary tour:

• VM/CMS: A hypervisor environment and an operating system enabling multiple virtual machines.
• Amdahl and Timeshares: Think old-school cloud computing where you leased computing power from larger systems.

In today’s terms, imagine renting space from Amazon Web Services, much like you would rent a virtual machine within a hypervisor back then.

Microcode Mayhem: When the Mainframe Started Slowing Down

The trouble started after a microcode update. At first, everything seemed fine, but over the course of the day the system would gradually slow down until it became almost unusable. Restarting it fixed the problem — temporarily. Then the same thing would happen again.

“The most interesting adventure was a microcode update after which the system slowed down over the day.” — Matt

The investigation took Matt deep into the internals of the system. Eventually, he narrowed the problem down to timer interrupts and the queues VM used to keep track of them.

Understanding Timer Interrupts

In simplified terms, VM kept a queue of events that were supposed to happen at specific times. As the clock advanced, those events should have been processed when their time arrived.

Finding the problem meant digging through the linked lists behind those queues and examining memory directly. Matt eventually found that timer events were not being handled correctly, causing the queue to become corrupted and the system to slow down progressively until it was restarted.

From Mainframe Microcode to Modern Systems

There are some obvious parallels with modern systems. Microcode still sits largely out of sight, and when something goes wrong at that level, the symptoms can appear far removed from the actual cause. The difference today is that we generally have better tools to investigate it.

Microcode Problems Didn’t End with Mainframes

Intel processors aren’t immune either. The Pentium floating-point division bug in the 1990s is another reminder that problems can exist deep below the software we normally interact with. The technology has moved on considerably, but those lower layers haven’t stopped mattering.

Key Takeaways:

• Microcode and hardware still must align perfectly to avoid processing pitfalls.
• Tools and methodologies have evolved, offering enhanced ways to update and fix microcode vulnerabilities.

“Technology for microcomputers and mainframes hasn’t fundamentally changed; it has advanced but retains its core complexities.” — Matt

What Mainframes Can Still Teach Us

Matt’s story starts with time-sharing systems and ends in a world dominated by cloud computing. The technology has changed enormously, but the basic idea of sharing expensive computing resources has turned out to be remarkably persistent.

From Time-Sharing to Cloud Computing

The move from time-sharing to personal computers put computing power directly on people’s desks. With cloud computing, we’ve moved much of it back into shared systems again. The technology is very different, but the basic model has come full circle.

Amdahl itself eventually became part of Fujitsu, but the systems and ideas from that era still have plenty of parallels with the infrastructure we use today.

What We Learned

Companies disappear and brands get absorbed, but the lessons tend to stick around. So the next time a cloud service starts behaving strangely, remember that people were debugging equally obscure problems decades ago — they just had fewer dashboards to blame.