| Previous | Table of Contents | Next |
Large addresses are in vogue today in the computer industry. Nearly all hardware and operating-system vendors have begun to incorporate larger addresses into their products. In this case, larger means having more than 32 bits. Most vendors have settled on 64 bits as the new standard for the next generation of systems. This move to larger addresses is being fueled by new applications, such as data warehousing, and by lower memory prices. Customers are starting to see significant performance improvements with large main memories, with the result that memory sizes measured in gigabytes (GB) are becoming commonplace in many businesses. A 32-bit address that can support memory sizes up to only 4 GB is rapidly becoming obsolete.
For many years, the AS/400 processors, and the System/38 processors before them, incorporated a 48-bit address. With the RISC processors, that address size increased to 64 bits. The single-level store with its large address is probably the best known characteristic of the AS/400, and rarely is the single-level store not prominently mentioned in an AS/400 presentation. But what is so surprising about this focus on single-level store is that nobody and nothing above the MI ever sees it.
OS/400 doesn’t see it, application programs don’t see it — even the compilers don’t see it. Only the SLIC sees the AS/400’s single-level store. The MI works with objects, and objects are referenced by name. The closest thing to a memory at the MI is a space, and a space is a far cry from a single-level store.
Application programs and OS/400 programs address objects through the use of 16-byte pointers; actually, it’s more accurate to refer to these addresses as being 128 bits long. (All application programs use 128-bit addresses, which they have done since the System/38 was announced in 1978.) As we will see shortly, however, not all the bits in a pointer are used, so we don’t usually call the AS/400 a 128-bit machine. The pointer contains the 64-bit single-level store address, along with some descriptor bits and several unused bits that are reserved for future expansion of the address.
Maybe from now on we should describe the AS/400 as a 128-bit system — “128 Bits, No Buts,” has a nice ring to it. Digital, for example, calls its Alpha processor a 64-bit processor even though it has only 41-bit addresses. HP also uses fewer than 64 bits for the addresses in its PA RISC 2.0 processor. For now, I suppose we’d better stick with 64 bits — at least until the rest of the industry gets closer to us, then we can jump to 128 bits. Besides, 64 bits already gives a pretty big address space. “But,” you might ask, “just how big is it?”
The answer is 16 exabytes, which is about 18.4 quintillion bytes (or to be more exact, 18,446,744,073,709,551,616 bytes), a number too big for most of us to comprehend. In Chapter 5, I said we often talked about the number of bytes that could be addressed with 48 bits as equal to the distance from the earth to the sun and back measured in millimeters. I also said we needed a new analogy for 64 bits.
Richard Rubin, who helped immensely with the review of this book, offered an analogy for 64 bits. Richard notes that George Gamow, in his book One, Two, Three, Infinity, tells a story about King Shirham of India, who wanted to reward his grand vizier Sissa Ben Dahir for inventing the game of chess. The vizier asked that the king put one grain of wheat on the first square of the chessboard, two on the second, four on the third, eight on the fourth, and so on, doubling the amount on each square until he reached the 64th square. The total number of grains would be 264-1. Gamow estimates that at 5 million grains of wheat per bushel, it would take 4,000 billion bushels to cover the chessboard. World production in 1946 (when Gamow’s book was written) was 2 billion bushels a year. At that rate, it would take the world two thousand years to produce enough wheat.
For those of you who like the millimeter analogy, 18 quintillion is about twice the number of millimeters in a light year. That’s just less than half the distance to Alpha Centauri (the closest star to the solar system) in millimeters. Obviously, if we want to start measuring astronomical distances in millimeters, we will need more than 64 bits. Let’s see, 128 bits in a pointer will give us. … No matter how you look at it, 64-bit addressability gives a mighty big store.
The AS/400’s single-level store was named in honor of the original work the virtual memory pioneers did in the early 1960s. To understand where the term single-level store came from requires a look at its intended design and the evolution of virtual memory.
Virtual memory first appeared on a computer called Atlas, designed in Manchester, England, in 1961. The core memory technology used for the main memory of computers in those days was very expensive. Large programs needed lots of memory space, often more than the computer had available. To make these large programs fit into the limited memory size, the programmer would have to break his or her program up into pieces, each small enough to fit into the existing memory. Those pieces of the program that didn’t fit would be stored on a magnetic disk or drum.
Drums were popular in the early 1960s. A drum is similar to a hard disk, except that it has one read/write head per track. Drums generally provided higher performance than disks because with drums it was not necessary to wait for the head to seek to the desired track. As disk seek times improved, however, drums disappeared.
The problem with having to break large programs into smaller pieces was the increased programmer effort required to manage the memory. When a piece of the program to be executed was not in memory, the programmer had to issue the commands to read that piece from the disk or drum and write it into the memory. These pieces were called overlays, and much of a programmer’s time was spent creating and managing overlays. Virtual memory attacked this problem by letting the programmer think there was such a large memory that the entire program would always fit. The operating system would manage the movement of data and programs in this large virtual memory, relieving the programmer of the effort.
Kilburn, et al., wrote in their 1962 paper that described the memory system of the Atlas computer, “… a system has been devised to make the core drum combination appear to the programmer as a single-level store, the requisite transfers taking place automatically.”1
1T. D. Kilburn, B. G. Edwards, M. J. Lanigan, F. H. Sumner, “One-level Storage System,” IRE Transactions on Electronic Computers, April 1962.
| Previous | Table of Contents | Next |