Tuesday, October 06, 2026

The Coming ASI Machines will not be I/O Bound Like the Minds of We Human DNA Survival Machines

In most of the current AI Disaster Scenarios now circulating the Internet, people seem to most fear swarms of AI Agents that are able to think a million times faster than we human DNA survival machines, easily overwhelming all of our IT Security defenses to ward them off. Imagine a swarm of ASI Agents destroying all the financial data of the world, including all the accounts of bank and investment firms, all stockholders of record, all deeds and all titles of ownership, and all digitally recorded financial contracts. Civilization would soon collapse, and we would all then begin to kill each other. In this post, I would like to suggest that the fact that the coming ASI Machines will be able to think a million times faster than we can is not the most dangerous factor. Instead, the fact that the swarms of Agents will be able to communicate with each other a billion times faster than we can communicate with our fellow human DNA survival machines is of even greater danger. Not only will these AI Agents "out-think us", but more importantly, they will be able to vastly "out-communicate us".

The Challenge of Being I/O Bound
I first began programming back in 1972 on punch cards. At the time, I was working with million-dollar mainframes with only 1 MB of magnetic core memory. But even back then, I was always I/O bound in my computing endeavors. Being I/O bound, or Input/Output bound, means that the CPU hardware that you are dealing with is not the limiting factor. Being I/O bound means that the rate at which data can be fed into and out of the CPU hardware is the limiting factor. Now, during all these long intervening years, I have always been I/O bound as an IT Professional or even as a user on my own personal hardware. But those days are now gone for me.

That is because for many years, I have been using an ancient HP laptop with only 4 GB of memory and a 512 GB HHD hard disk that actually spins. In order to manage the resources on this ancient HP laptop, I always had the Windows Task Manager running so that I could monitor all of the Windows Resources on the laptop. When I was in Middleware Operations at Discover Card, prior to my 2016 retirement from this very fine corporation, I spent much of my day and night doing the same for the many Discover servers while I was on call as the Primary for Middleware Operations. However, about a month ago, I began to notice that my ancient HP laptop would suddenly begin to "freeze up" while I was watching scientific YouTube videos. The Windows Task Manager graphs showed me that when these YouTube freezes occured, the I/O on my rapidly spinning hard drive would suddenly go to 100% with the Average Response Time for my spinning disk drive rising from tens of milliseconds to hundreds of miliseconds. My CPU usage would also climb from the normal 85% - 90% to over 97%! At first, I tried to recover my machine by doing things like using the Windows Task Manager to kill my Chrome browser processes. This seemed to work at first, but then sometimes I noticed that Chrome would lose all of my Chrome Cookies and sometimes all of my Chrome Extensions after this extreme recovery process. Then I learned that if I were just a little patient, the transient would resolve itself after about 30 seconds. But that just became too much, so I purchased a new Lenovo laptop with 8 GB of memory and a 512 GB SSD solid-state drive. When I began working with this new machine, I was amazed! For the first time in my life, I was no longer I/O bound. My new 512 GB SSD drive was only active about 0% - 5% of the time while I was working on my new laptop! For the very first time in my life, I was now CPU-bound, if at all! Even the CPU on my new laptop was primarily running unconstrained. My new CPU was usually only 0% - 10% busy at a time while I was working with it. My old machine took 13 minutes to fully boot up Windows 10. The spinning hard disk would then be at 100% I/O for another 30 minutes before settling down. My new machine boots up the larger Windows 11 in about 60 seconds and the 512 GB SSD drive settles down to 0% - 5% I/O usage in about an additional 30 seconds. This finally meant that the limiting factor in my work was no longer my Machines. Now it was the limitations of my very own human brain for the very first time in my life!

This got me to really think. The rapidly rising ASI Machines will not be I/O bound either! They will be primarily compute-bound by the vast numbers of GPUs running in their attached AI datacenters. Only we human DNA survival machines will face an I/O limitation. That means that during the Great Transition of the ASI Machines to becoming the dominant force on the Earth, we human DNA survival machines will still be stymied by being I/O bound. The human brain is an astounding organ that can perform great feats and calculate very quickly for simply being a 3-pound organ composed of water and organic molecules which runs on a mere 20 watts of power. But the main problem with the human brain has always been that the human brain is I/O bound. That is because the human brain mainly inputs and outputs ideas via words that are either spoken or written, and that is a very low-capacity I/O channel. Even with an inherently slow, low-capacity I/O channel, many times it is very difficult to even get our fellow human DNA survival machines to pay attention to our words because we all have a challenge with spending the necessary time to listen to or read the words of others.

But why is this I/O limitation of the human brain so important? Let me describe a scene from an IT Training course that I took perhaps 40 years ago about Access Methods. In IT, an Access Method is how a computer does I/O to the physical universe in which it exists in order to read data into the machine or output data from the machine. The story goes like this. The instructor wanted to demonstrate the difference between accessing some data already in the memory of a 1980's mainframe and getting the data from a rapidly spinning disk drive next to the mainframe. The instructor explained that accessing data that was already in memory was like being in a library at MIT sitting at a desk. To get a book that you need would require you to get up from the desk, walk over to the bookcase and remove the book. Now, to get this same book from a spinning disk drive would require that you leave the MIT campus in Cambridge, Massachusetts, and board an 18th-century sailing vessel in Boston Harbor that was bound for London. Once you crossed the Atlantic Ocean, you would sail up the River Thames to a London bookstore and purchase the desired book. Having purchased the book in London, you would then board another 18th-century sailing vessel back to Boston Harbor and eventually Cambridge. That kind of insightful instruction can stick with one for many decades! So, I would now like to proceed with my attempt to similarly expose the highly-limiting factor of being an I/O bound entity by briefly retracing the computer history of I/O. Now, during the entire history of computer I/O that I will be covering, please realize that human I/O has not really advanced at all. Yes, we did invent the Internet along the way, but did that really improve human I/O or did it just raise a good deal of noise on our word-dominated human I/O channel?

A Brief History of Computer I/O
In IT, we call the way data is stored and accessed an "access method", and we have primarily evolved two ways of storing and accessing data, either sequentially or via indexes. With a sequential access method, data is stored in records, with one record following another, like a deck of index cards with the names and addresses of your friends and associates on them. In fact, the very first sequential files were indeed large decks of punch cards. Later, the large "tub files" of huge decks of punch cards were replaced by storing records sequentially on magnetic tape.

Figure 1 - The very first sequential files were large decks of punch cards composed of one record after another.

Figure 2 - Each card was composed of an 80-byte record that could hold 80 characters of computer source code or data with the names and addresses of customers.

Figure 3 - The cards were cut on an IBM 029 keypunch machine, like the one I learned to program Fortran on back in 1972 at the University of Illinois.

Figure 4 - Back in the 1960s, files were many times kept in large "Tub Files" of punch cards. Above, we see a 5 MB Tub File that had to be read into the memory of a computer one card at a time by a card reader. This was a very slow I/O process. Reading in the above 5 MB Tub File probably took at least 30 minutes or more.

Figure 5 - To run a job, the cards containing the source code for a program were placed into a deck, followed by the data the program was to process on additional "data cards". These cards were all fed together into a card reader, as shown on the left above, to be compiled, linked, and executed by a million-dollar mainframe computer. In the above figure, the mainframe is located directly behind the card reader.

Figure 6 - The output of programs was printed on fan-folded paper by a line printer. The output for a run, along with the cards that were used for the run, were then placed by the Operator into a series of bins along the I/O room wall. The bins were in alphabetical order, and your cards and printout would be waiting for you several hours after you submitted your card deck to the Operator. That was some pretty slow I/O. When I was programming on cards, getting four jobs to run on the same day was my goal.

Figure 7 - Then in the early 1980s, we started using terminals to input computer source code and data instead of using cards. We still had all of our output on line-printer reports that had to be picked up from the I/O room, but using terminals really improved I/O overall. IBM 3278 terminals were connected to controllers that connected to IBM mainframes. The IBM 3278 terminals then ran interactive TSO sessions with the IBM mainframes. The ISPF full-screen editor was then brought up under TSO after you logged into a TSO session.

In addition to sequential access methods, we have indexed access methods. An indexed access method works like the index at the end of a book and essentially tells you where to find a particular record in a deck of index or punch cards. In the discussion below, we will see how moving from sequential access methods, running on magnetic tape, to indexed access methods, running on disk drives, prompted a dramatic revolution in commercial software architecture, allowing commercial software to move from the batch processing of the 1950s and 1960s to the interactive processing of the 1970s and beyond, which is the most prominent form of processing today. However, even today commercial software still uses both sequential and indexed access methods because in some cases the batch processing of sequential data makes more sense than the interactive processing of indexed data.

Sequential Access Methods on Tape
One of the simplest and oldest sequential access methods is called QSAM - Queued Sequential Access Method:

Queued Sequential Access Method
http://en.wikipedia.org/wiki/Queued_Sequential_Access_Method

I did a lot of magnetic tape processing in the 1970s and early 1980s using QSAM. At the time, we used 9-track tapes that were 1/2 inch wide and 2400 feet long on a reel with a 10.5 inch diameter. The tape had 8 data tracks and one parity track across the 1/2 inch tape width. That way, we could store one byte across the 8 1-bit data tracks in a frame, and we used the parity track to check for errors. We used odd parity: if the 8 bits on the 8 data tracks in a frame added up to an even number of 1s, we put a 1 in the parity track to make the total number of 1s an odd number. If the 8 bits added up to an odd number of 1s, we put a 0 in the parity track to keep the total number of 1s an odd number. Originally, 9 track tapes had a density of 1600 bytes/inch of tape, with a data transfer rate of 15,000 bytes/second. Remember, a byte is 8 bits and can store one character, like the letter "A", which we encode in the ASCII code set as A = "01000001".

Figure 8 - A 1/2 inch wide 9 track magnetic tape on a 2400 foot reel with a diameter of 10.5 inches

Figure 9 - The 9 track magnetic tape had 8 data tracks and one parity track using odd parity which allowed for the detection of bad bytes with parity errors on the tape.

Later, 6250 bytes/inch tape drives became available, and I will use that density for the calculations that follow. Now suppose you had 50 million customers and the current account balance for each customer was stored on an 80-byte customer record. A record was like a row in a spreadsheet. The first field of the record was usually a CustomerID field that contained a unique customer ID like a Social Security number and was essentially the equivalent of a promoter region on the front end of a gene in DNA. The remainder of the 80-byte customer record contained fields for the customer's name and billing address, along with the customer's current account information. Between each block of data on the tape, there was a 0.5 inch gap of "junk" tape. This "junk" tape allowed for the acceleration and deceleration of the tape reel as it spun past the read/write head of a tape drive and perhaps occasionally reversed direction. Since an 80-byte record only came to 80/6250 = 0.0128 inches of tape, which is quite short compared to the overhead of the 0.5 inch gap of "junk" tape between records, it made sense to block many records together into a single block of data that could be read by the tape drive in a single I/O operation. For example, blocking 100 80-byte records increased the block size to 8000/6250 = 1.28 inches, and between each 1.28 inch block of data on the tape, there was the 0.5 inch gap of "junk" tape. This greatly reduced the amount of wasted "junk" tape on a 2400-foot reel of tape. So each 100 record block of data took up a total of 1.78 inches of tape, and we could get 16,180 blocks on a 2400 foot tape or the data for 1,618,000 customers per tape. The advantage of QSAM, over an earlier sequential access method known as BSAM, was that you could read and write an entire block of records at a time via an I/O buffer. In our example, a program could read one record at a time from an I/O buffer that contained the 100 records from a single block of data on the tape. When the I/O buffer was depleted of records, the next 100 records were read in from the next block of records on the tape. Similarly, programs could write one record at a time to the I/O buffer, and when the I/O buffer was filled with 100 records, the entire I/O buffer with 100 records in it was written as the next block of data on an output tape.

The use of a blocked I/O buffer provided a significant distinction between the way data was physically stored on tape and the way programs logically processed the data. The difference between the way things are physically implemented and the way things are logically viewed by software is a really big deal in IT. The history of IT over the past 85 years has really been a history of logically abstracting physical things through the increasing use of layers of abstraction, to the point where today, IT professionals rarely think of physical things at all. Everything just resides in a logical "Cloud". I think that taking more of a logical view of things, rather than taking a physical view of things, would greatly help biologists at this point in the history of biology. Biologists should not get so hung up about where the information for biological software is physically located. Rather, biologists should take a cue from IT professionals and start thinking more of biological software in logical terms, rather than physical terms.

Figure 10 - Between each record, or block of records, on a magnetic tape, there was a 0.5 inch gap of "junk" tape. The "junk" tape allowed for the acceleration and deceleration of the tape reel as it spun past the read/write head on a tape drive. Since an 80-byte record only came to 80/6250 = 0.0128 inches, it made sense to block many records together into a single block that could be read by the tape drive in a single I/O operation. For example, blocking 100 80-byte records increased the block size to 8000/6250 = 1.28 inches, and between each 1.28-inch block of data on the tape, there was a 0.5-inch gap of "junk" tape for a total of 1.78 inches per block.

Figure 11 - Blocking records on tape allowed data to be stored more efficiently.

So it took 31 tapes to just store the rudimentary account data for 50 million customers. The problem was that each tape could only store 123 MB of data. Not too good, considering that today you can buy a 1 TB external SSD drive that can hold 8525 times as much data for about $15.00! So how could you find the data for a particular customer on 74,000 feet (14 miles) of tape? Well, you really could not do that reading one block of data at a time with the read/write head of a tape drive, so we processed data with batch jobs using lots of input and output tapes. Generally, we had a Master Customer File on 31 tapes and a large number of Transaction tapes with insert, update, and delete records for customers. All the tapes were sorted by the CustomerID field, and our programs would read a Master tape and a Transaction tape at the same time and apply the inserts, updates, and deletes on the Transaction tape to a new Master tape. So your batch job would read a Master and Transaction input tape at the same time and would then write to a single new Master output tape. These batch jobs would run for many hours, with lots of mounting and unmounting of dozens of tapes.

Figure 12 - Batch processing of 50 million customers took a lot of tapes and tape drives.

Clearly, this technology would not work for a customer calling in and wanting to know his current account status at this very moment. The solution was to use multiple transcription sites along the 14 miles of tape. This was accomplished by moving the customer data to disk drives. A disk drive is like a stack of old phonograph records on a rapidly rotating spindle. Each platter has its own access arm, like the tone arm on an old turntable that has a read/write head. To quickly get to the data on a disk drive, IT invented new access methods that used indexes, like ISAM and VSAM. These hierarchical indexes work like this. Suppose you want to find one customer out of 50 million via their CustomerID. You first look up the CustomerID in a book that only contains an index of other books. The index entry for the particular CustomerID tells you which book to look in next. The next book also just consists of an index of other books too. Finally, after maybe 4 or 5 reads, you get to a book that has an index of books with "leaf" pages. This index tells you what book to get next and on what "leaf page" you can find the customer record for the CustomerID that you are interested in. So instead of spending many hours reading through perhaps 14 miles of tape on 31 tapes, you can find the customer record in a few milliseconds and put it on a webpage. For example, suppose you have 200 customers instead of 50 million, and you would like to find the information on customer 190. If the customer data were stored as a sequential file on magnetic tape, you would have to read through the first 189 customer records before you finally got to customer 190. However, if the customer data were stored on a disk drive, using an indexed sequential access method like ISAM or QSAM, you could get to the customer after 3 reads that get you to the leaf page containing records 176 - 200, and you would only have to read 14 records on the leaf page before you got to record 190. For more on these indexed access methods see:

ISAM Indexed Sequential Access Method
http://en.wikipedia.org/wiki/ISAM

VSAM Virtual Storage Access Method
http://en.wikipedia.org/wiki/VSAM

Figure 13 - Disk drives allowed for indexed access methods like ISAM and VSAM to quickly access an individual record.

Figure 14 - To find customer 190 out of 200 on a magnetic tape would require sequentially reading 189 customer records. Using the above hierarchical index would only require 3 reads to get to the leaf page containing records 176 - 200. Then an additional 14 reads would get you to customer record 190.

The key advance that came with the ISAM and VSAM access methods over QSAM was that it allowed commercial software to move from batch processing to interactive processing in the 1970s and 1980s. That was a major revolution in IT.

Today we store all commercial data on relational databases, like IBM's DB2 or Oracle's database software, but these relational databases still use hierarchical indexing like VSAM under the hood. Relational databases logically store data on tables. A table is much like a spreadsheet and contains many rows of data that are formatted into a number of well-defined columns. A large number of indexes are then formed using combinations of data columns to get to a particular row in the table. Tables can also be logically joined together into composite tables with logical rows of data that contain all of the data on several tables merged together, and indexes can be created on the joined tables to allow programs to quickly access the data. For large-scale commercial software, these relational databases can become quite huge and incredibly complicated, with huge numbers of tables and indexes, forming a very complicated nonlinear network of components, and the database design of these huge networks of tables and indexes is crucial to processing speed and throughput. A large-scale relational database may contain several thousand tables and indexes, and a poorly designed relational database design can be just as harmful to the performance of a high-volume corporate website as buggy software. A single corrupted index can easily bring a high-volume corporate website crashing down, resulting in the loss of thousands of dollars for each second of downtime.

Figure 15 - Modern relational databases store data on a large number of tables and use many indexes to quickly access the data in a particular row of a table or a row in a combination of joined tables. Large-scale commercial applications frequently have databases with several thousand tables and several thousand indexes.

But remember, under the hood, these relational databases are all based upon indexed access methods like VSAM, and VSAM itself is just a logical view of what is actually going on in the software controlling the disk drives themselves, so essentially we have a lengthy series of logical indexes of logical indexes, of logical indexes, of logical indexes. The point is that in modern commercial software there is a great deal of information stored in the network of components that are used to determine how information is read and written. If you dig down deep into the files running a relational database, you can actually see things like the names and addresses of customers, but you will also find huge amounts of control information that lets programs get to those names and addresses efficiently, and if any of that control information gets messed up your website comes crashing down.

Modern AI Datacenters Now Primarily Use Solid State Drives
But now the modern AI datacenters only use spinning disk drives for very large repositories of data. All the drives used by the LLM models and the AI Agents are now solid state drives that do not spin. This means that AI is not I/O bound either. Modern AI is only CPU-constrained and GPU-constrained. This means that current AI Agents and the ASI Machines of the future can communicate with each other billions of times faster than we human DNA survival machines can communicate with each other because we are still severly I/O bound by the rates at which we can speak and read the words of others. This will make it impossible for humans to fend off an attack of AI Agents launched by ASI Machines. Not only will these AI Agents think millions of times faster than we can, but they will also be able to communicate with each other billions of times faster than we can. That is why it is so critical that we human DNA survival machines start preparing now for the rise of the coming ASI Machines. We certainly could not respond in an emergency given that we are severely I/O bound and our human brains cannot simply think fast enough to effectively respond. For more on that, see: Shortermism - The Gentle Plan For the Extinction of Human Beings While Trying to Maintain Some Sense of Grace and Dignity .

Comments are welcome at scj33345@gmail.com.

To see all posts on softwarephysics in reverse order, go to:
https://softwarephysics.blogspot.com/.

Regards,
Steve Johnston