Campbell: Changes in operating systems

You have just…

You have just bought a new computer. It has a quad-core processor in it. That means it’s fast. Right?

Depending on whom you ask, the answer could be a grudging yes to an emphatic “it could be faster!”

Dave Probert, an engineer with Microsoft, suggests in a recent NetworkWorld.com article that a complete rethink of the way operating systems are written could greatly improve the performance of systems with multi-core processors.

He asserts that modern operating systems are archaic and should be brought up to speed with new hardware technology.

At face value, a processor with multiple cores is a natural progression from the old style of just making processors beefier.

With the Pentium IV series, every few months Intel would add a few notches to its processor speeds. Eventually, the speed became too much; processors became too power hungry and began to become unreliable.

In order to squeeze more performance out of its product, Intel decided to take an existing processor, cut down its speed — to maybe about a gigahertz — copy it several times, and place all those copies together on one chip. The dual core processor was born.

Multiple-core systems have a bit of a problem, however. With that many cooks in the kitchen, making sure each processor core is constantly fed with tasks can become problematic.

Multiple-core systems can be thought of as an office full of typists. The typists require input to do their jobs. Whenever the typists are without input, they sit around doing nothing, losing money for their “company.”

Potentially, every typist might require certain information, but the information is not necessarily shared easily.

Each piece of information is written on a piece of paper. Two typists cannot easily use the same piece of paper twice, and having a bunch of typists standing around a desk staring at paper hurts productivity.

Typist A might therefore need some information held by Typist B, and vice versa. Until that information becomes available, Typist A cannot continue, and must be content to sit idle.

Modern operating systems attempt to create managers for the processor cores. As part of the typist analogy, the manager would determine which piece of information goes to which typist and how information is shared between the typists.

If the manager were optimally good at his job, each typist would spend a minimal amount of his time waiting for information to become available.

In the article, Probert describes how, unfortunately, modern operating systems generally fail to produce worthwhile managers. The operating systems were designed originallyto give the illusion of parallel processing — running multiple programs or performing multiple tasks at once — for single-processor, single-core machines.

Your computer, while you’re running a Web browser, an e-mail client and iTunes, appears to be responding to each application at once.

It is, in reality, switching furiously between the applications, doing a little bit of work for your Web browser, then doing a little bit of work for your e-mail client and so on.

The programs do not know this is happening. In fact, the operating system works very hard to make the programs think they are running by themselves.

This approach makes the operating systems painfully unprepared to deal with multi-core machines.

Instead, Probert says, the operating system should reduce in size and merely act as a conductor, assigning programs to processor cores. Instead of making each program think it is running by itself, the operating system should give it a core of its very own and let it actually run alone.

This is not necessarily a new idea. It is, however, an interesting admission from an operating system producer who has remained true to the original schemes of operating system design.

Probert owes much of his inspiration to the world of virtualization. VMware Fusion, Parallels Desktop and other products that allow you to run multiple operating systems “concurrently” all come close to Probert’s suggestions. They provide a mechanism that assigns processor cores to the various operating systems they are running. This mechanism is known grandly as a “hypervisor.”

It is rather doubtful that Microsoft Windows will suddenly, in the near future, begin using hypervisor in its common terminology. Computers with multi-core processors will eventually become more efficient as the ideas of Probert and others become mainstream and available. Until then, if you want to do some digging, you could probably pull up a research operating system that tests these concepts.