Software Quarterly

Moving To A 32-Bit
Operating System: Myth vs. Reality

By Randall C. Kennedy


You can hardly pick up a computer industry magazine these days without coming across at least one story about 32-bit operating systems. Heralded by some as the most important technology advancement since the original IBM PC, 32-bit operating systems are being portrayed as the key to computing the salvation -- a means of breaking down the barriers to high-performance, multithreaded computing Nirvana.

All of which sounds good on paper but, if you're a veteran of the information systems (IS) arena, you're probably growing tired of all the media hype. What you want is some real information, the practical reasons how a 32-bit operating system can help make your computing world so much more pleasant. In a nutshell, you want facts. So here they are.

It's a Big World

Among the many significant benefits of moving to a 32-bit operating system platform is better memory management. To put it bluntly, today's popular 16-bit operating systems -- MS-DOS, PC-DOS, DR-DOS, and DOS/Windows -- just don't cut it when it comes to managing memory. Why? Because each taps only a small fraction of the memory management capabilities of its central processing unit (CPU), the Intel x86 microprocessor family.

Since the 80386 was released back in 1985, Intel CPUs have had the capacity to address literally gigabytes (GB) of system memory. Yet, for compatibility purposes, today's 16-bit operating systems continue to ignore these tremendous capabilities, and instead run all Intel CPUs as if they were a 16-bit 80286 -- an older, far less-capable chip limited to addressing 16 megabytes (MB) of random access memory (RAM).

Introduce a 32-bit operating system (OS) to your environment, however, and the picture changes drastically. With a 32-bit OS you're able to fully exploit the memory management hardware of the 80386 -- and higher -- Intel CPUs. This, in turn, opens up a whole new world of possibilities that were inconceivable (literally) with a 16-bit architecture.

For example, imagine an application that has access to 4 GB -- that's right, 4 billion bytes -- of addressable memory. Outrageous? Hardly. In fact, this is precisely the amount of memory available to each process (or application) running on a 32-bit Intel x86 CPU. In addition, all of those memory locations can be addressed in a linear fashion, which means no more awful segment arithmetic and no more squeezing your code into 64 kilobyte (KB) blocks.

In a 32-bit world, the memory model is flat, which means a program can directly address every byte of its process address space. What this translates into for the user is a selection of powerful applications that have almost unlimited capacity. With a solid, 32- bit OS at your side, you'll be able to create huge spreadsheets, edit enormous graphic images, and sort through mammoth databases -- all while barely causing the CPU to break a sweat.

It's a More Productive World

In our day-to-day lives, we normally do more than one thing at a time. For example, while speaking on the telephone with a client you may be simultaneously writing notes about the call. Eyes, ears, and hands are all coordinated, letting you accomplish more than one task at the same time. In other words, you're multitasking.

This same "more than one task at once" concept can be applied to your PC, too. At the heart of any modern personal computer is a CPU that can juggle multiple concurrent tasks. When you combine such a CPU with a multitasking operating system, such as OS/2 or Windows NT, the resulting marriage creates a very powerful ally in your quest to be more productive.

Why? Because a multitasking computer system lets you do more with your computer. It accomplishes this by dividing the CPU's processing time among multiple, concurrent application programs, or tasks. In a multitasking environment, you can assign tedious batch functions -- like a long print job or modem file transfer -- to run as background tasks, freeing up your PC's interface and letting you continue to work in other applications while the tasks running in the background complete their work.

Currently there are two popular multitasking techniques, or models. The Cooperative Multitasking Model is a primitive method for sharing CPU time. In this model the individual application programs are in control of the CPU, and each must relinquish control of the CPU from time to time to give the next application a chance to execute. The Cooperative Model is inefficient in that it places the system at the mercy of the applications -- if a single program refuses to relinquish control, other tasks will be blocked from executing. This sort of multitasking gridlock can be disastrous for timing-critical programs like communications software. The system can become very unresponsive -- or even unusable -- while performing such simple tasks as printing and FAXing. Windows 3.1 and, to some extent, Microsoft's forthcoming Chicago operating system, are based on a Cooperative Multitasking Model.

The Preemptive Multitasking Model places the responsibility of dividing CPU time with the operating system itself, and is the technique of choice for advanced, 32-bit operating systems like OS/2 and Windows NT. Through an elaborate system of priority levels and minimum time slice values, a preemptive OS decides which task gets how much CPU time, and is thus more flexible when dealing with complex multitasking demands. For example, when a preemptive OS detects that a communications program is about to handle incoming data, it can boost the program's priority and thus give it more of the available CPU processing time. What this means to users is that their system remains responsive and usable while performing tasks like printing, FAXing, or downloading.

A preemptive OS also provides a way for applications themselves to become more responsive. Through a technique known as multithreading, programs in a preemptive environment can break themselves into multiple threads of execution, each of which is then assigned its own slice of the CPU processing pie. Thus a word processing program can spin off a print job to a background thread while it continues to accept new user input using a foreground thread. This makes the application seem more responsive to the user, and in fact lets you get more work done since you can continue to enter data into the same application.


"The benefits of moving forward from

the existing 16-bit world are enormous:

multitasking, better memory management,

increased robustness, improved performance,

and new application types -- all are hallmarks

of a 32-bit environment."


It's a Virtual World

If you've been following closely you may have run into a minor problem with our picture of computing Nirvana. Who on earth has 4 GB of RAM? Fortunately, the folks at Intel were thinking ahead when they designed the 32-bit x86 architecture. Realizing that RAM technology was not keeping pace with CPU technology, they hedged their bets by designing into the x86 a virtual memory management scheme.

In the 32-bit Intel world, each 4 KB page of memory is dynamic. The CPU controls which page contains which code or data for which process, and it can move these pages around in physical RAM at will, simply by altering a series of address tables (the CPU page tables). And, if the CPU has control of the memory pages, it also stands to reason that it could store them outside of the system's physical RAM until they're called upon.

This is exactly how the x86 handles a situation known as memory over-commit. When an application that thinks it has 4 GB of address space asks for additional memory on an already overburdened 8 MB PC, the operating system, in conjunction with the x86 CPU's virtual memory manager, begins to swap some of the least recently used memory pages to a file on a mass storage device -- typically a hard disk.

This mechanism is referred to as Demand Paged Virtual Memory, and the freed memory pages are then available for assignment to any process that needs them. The net result is a virtual memory pool that is limited only by your available disk space -- a big step up from the 16 MB limitation of the 16-bit world.

So now you no longer have to worry about squeezing your applications into the artificial confines of system RAM. With virtual memory, you can tap into a seemingly inexhaustible supply of memory, allowing you to create larger spreadsheets, bigger databases, and edit huge multimedia files that would normally choke on a typical PC with 4 or 8 MB.

Robustness: Blessing or Buzzword?

Another major benefit with a 32-bit operating system is the promise of better stability and crash protection; simply put, they're supposed to be more "robust." In many ways this particular benefit is one of the hardest to define in concrete terms. Just what makes it robust? And doesn't an established 16-bit environment -- where virtually all of the bugs have been worked out -- qualify as robust?

Maybe yes, maybe no. You can test a production environment until you're blue in the face and still not find all the potential glitches. And since Murphy's Law of Application Failures states that the probability of a data-corrupting crash occurring is directly proportional to the sensitivity of the task at hand, the recoverability of the underlying operating system becomes a critical factor.

And recoverability from application failures is one of the key areas where 16-bit environments, like DOS and DOS/Windows, have come up short. Under DOS -- where an application has complete control of the machine -- the only recourse if a failure occurs is to reboot. Under Windows an application failure can interfere with the operating system itself, bringing the entire system to a crashing halt. (Even OS/2 1.x, which does an acceptable job of protecting the OS from applications, can still be destabilized if certain areas of global memory are corrupted.) In reality, the only way to create a truly robust runtime environment is to isolate individual subsystems and applications into their own private address spaces.

Fortunately, this is exactly what a 32-bit OS offers. Using the Virtual Machine concept promoted by the Intel x86 CPU architecture, it's easy to isolate faults and make the system more robust. Under a 32-bit environment, such as OS/2 Version 2 or Windows NT, each application runs in its own address space and is oblivious to the existence of other, concurrent processes. If the application fails, the resulting damage is limited to those memory locations that are part of its process address space. Memory and resources assigned to other processes remain unaffected and the system recovers gracefully from even the worst failures (the lone exception being a failure of the OS kernel itself).

What does this mean for users? More confidence in their operating system due to the increased stability that a 32-bit, multiple VM model provides. And for the MIS staff? Reduced downtime due to better OS recoverability. It's a win-win situation.

Performance: 32 Heads Are Better Than...

When most users discuss improving performance, they typically refer to purchasing faster hardware. But what most of them don't realize is that these days the bottleneck is rarely related to the hardware. In reality, what's holding back their system's performance is the operating system. When it comes to burning up the computing pavement, 32-bits are almost always better than 16.

I say almost because there will always be a disgruntled assembly- language programmer or two who will argue the merits of tight, 16- bit code for certain functions (like a device driver). However, on the whole a 32-bit environment will outperform a 16-bit environment with typical, application-oriented tasks.

Why? In a word, bandwidth. A 32-bit operating system can move data and application programming interface (API) call parameters 32-bits at a time, and this translates into better overall performance. In many ways it's like widening a freeway to compensate for increased traffic. Add a few lanes and the capacity of that roadway increases dramatically. The same is true of operating systems -- widen the plumbing and more data can flow at once (capacity) or the same amount of data can flow faster.

To revisit an earlier point -- that of applications being able to use a flat memory model -- 32-bits means better performance within a particular process. For example, consider an image-editing program that has to manipulate multimegabyte graphic files.

In a 16-bit environment the program has to break that multimegabyte image up into 64 KB segments, which makes manipulating the corresponding data structures in memory that much more difficult. Now imagine that same application in a flat model. The image's entire data structure can be referenced as a whole, in linear fashion, which instantly translates into better performance due to the elimination of segment overhead (the amount of time it takes to switch the CPU's memory tables to reference a different segment).

Exploiting All That Great Hardware

Now that you know where the real performance bottleneck is, it becomes clear how moving to a 32-bit OS platform will finally begin to put your 32-bit x86 computer through its paces. Today's PCs are designed for 32-bit performance: 32-bit (or even 64-bit) memory busses; 32-bit input/output (I/O) busses (EISA, MCA, PCI, and VL- Bus); and 32-bit memory components -- all these cry out for an operating system that will tap their capabilities.

With a 32-bit OS your mass storage devices will run faster, thanks to a wider I/O channel between the bus adapter and the operating system's I/O subsystems (32-bit device drivers). The same can be said of video and multimedia I/O -- playback of a full-motion, multiframe/second television clip, or a high-fidelity audio recording is smoother when the underlying operating system has the necessary internal bandwidth to handle the flow of data.

Then there's the issue of hardware you don't already own, but are considering down the road. One hot category is symmetrical multiprocessing (SMP). SMP systems can distribute the processing load evenly across multiple CPUs, giving a potentially huge performance boost to certain applications. CAD/CAM workstations or database servers are both good examples. Imagine 300 transaction per second (TPS) or better throughput on a PC-based server platform. It's enough to make even the most jaded minicomputer jocks drool with envy.

The catch is that you need a 32-bit operating system -- like OS/2 for SMP or Windows NT -- to exploit these applications. And the same can be said of non-Intel technologies, like the PowerPC systems from IBM. Existing 16-bit operating systems are tied closely to the Intel x86 architecture and can't be easily ported to new CPU platforms. But both OS/2 (for PowerPC) and Windows NT are portable, as is UNIX, another of the 32-bit stalwarts. So investing in these platforms now can mean access to exciting, non-Intel technologies down the road.

Dreaming in 32-bits

So far we've focused mostly on how a 32-bit OS can help you be more efficient in your current day-to-day tasks. But the real promise of 32-bit operating system technology is as yet undefined. In many ways the biggest benefit of the move to a 32-bit OS is that it opens the doors to a new world of possibilities. And not just improved versions of existing applications, but new and exciting categories that we've only begun to dream of.

As programmers begin to exploit the new breathing room available in a 32-bit OS, watch out! Give a creative mind 4 GB of address space and a virtual memory model and you're bound to see something exciting. The sheer capacity of a 32-bit process lets a programmer create the kind of mammoth constructs that were simply unfeasible in a 16-bit, segmented world. Go ahead, think big -- the OS can handle it!

Of course, when you combine all this breathing room with a preemptive multitasking architecture, one category that is bound to take off is multimedia. The integration of voice and video with traditional data types is fast becoming a necessity in corporate computing environments. But until now, the operating system technology wasn't up to the task.

With 32-bits of internal bandwidth, however, and with a preemptive multitasking model that's capable of handling realtime data, multimedia has finally found a home.

In fact, the very way you interact with your PC may be changed forever by the introduction of 32-bit OS technology. For starters, object technology -- where every element, from interface icons to file system entries, is a dynamic, self-contained entity -- has really only taken root with the introduction of the world's premiere 32-bit OS, Operating System/2. The OS/2 WorkPlace Shell is a masterpiece of object-oriented interface design, but it requires the underlying horsepower of a true 32-bit OS in order to perform acceptably.

But as good as object oriented technology is, it's only the tip of the iceberg when it comes to the potential for change that a 32-bit operating system represents. Voice recognition is universally viewed as the most natural interface of all, and it's slowly becoming a reality thanks to the added bandwidth and multitasking prowess of 32-bit OS technology.

32 Really Is the Magic Number

If you've read this far you've undoubtedly been sold on the ideas of 32-bit OS technology. The benefits of moving forward from the existing 16-bit world are enormous: multitasking, better memory management, increased robustness, improved performance, and new application types -- all are hallmarks of a 32-bit environment. For both users and MIS staffs alike, 32-bits is the magic number.

A parting word of advice: As you examine the various 32-bit options available to you, keep in mind the fact that the operating system choices you make today will shape your computing environment for the remainder of this century (see the related article "Major Players in the 32-bit OS Arena" for an analysis of what's available). So choose wisely, and pay close attention to the companies behind the products, their track records, and customer loyalty.

Because in the end, the best choice is the one that makes as much sense in three years as it does today.

Check out the following articles which accompany our feature story on 32-Bit operating systems:


Randall C. Kennedy is a freelance writer and computer industry consultant. Randall is author of Migrating to Windows NT and a contributing editor with Windows Sources magazine. A Certified NetWare Engineer, Randall is recognized as an expert on 32-bit operating system technology and consults on a regular basis with information technology firms.



[SQ] [tell SQ] [get SQ] ["software"]

[ IBM home page | Order | Search | Contact IBM | Help | (C) | (TM) ]