TweetFollow Us on Twitter

Asynchronous IO
Volume Number:12
Issue Number:12
Column Tag:Toolbox Techniques

Building Better Applications
Via Asynchronous I/O

By Richard Clark, General Magic, Inc.

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Have you ever looked at an application and wondered how to make it faster? Sure, you can select better algorithms or rewrite sections in assembly language, but sometimes a fast processor or great algorithm is not enough. Many applications reach a limit where they can process the information faster than they can get it. These applications are said to be I/O bound. Improving such programs is straightforward, once you know something more about how the Macintosh reads and writes information.

Most developers go through several basic stages in getting information in and out of their programs. In the first stage, they use their programming language’s built-in I/O commands - printf and scanf for C, WRITELN and READLN for Pascal. Soon, driven by the derision of their peers, a desire to manipulate something other than text streams, or a feeling they should be using the underlying operating system directly, they will shift over to the Macintosh FSWrite and FSRead routines.

Quite a few Macintosh programmers spend the remainder of their careers using FSRead and FSWrite. Some use FSRead’s “newline mode” to emulate scanf or READLN. Others read their data in as needed, whether they need a single character or an entire structure. The wisest users of FSRead use buffering - they read the data in large blocks and process the information in memory.

All of these techniques have one property in common - they all use “synchronous I/O.” A synchronous I/O operation makes the calling program wait until the operation has been completed. Programmers who want to get the best possible performance out of their applications can eliminate this wait by switching to “asynchronous I/O” which asks the OS to transfer information at the same time the other code is running. There is another reason why advanced Macintosh programmers use asynchronous I/O - it’s the only way to get at some of the more advanced communications features such as TCP/IP and to get real-time information from users.

A Programmer’s Look at I/O

We will take a look at the uses of synchronous and asynchronous I/O through a function that counts occurrences of the letter “A” in a text file. The simplest version of this program uses the C Standard I/O Library functions.

int countChars(FSSpecPtr fsp)
{
  // Count the number of times the letter A appears in the file
 FILE *f = NULL;
 int  counter = 0;
 char currChar;
 char filename[64];
 
  // Homemade PtoCstr operation which makes a copy of the string
 BlockMove((Ptr)&fsp->name[1], filename, fsp->name[0]);
 filename[fsp->name[0]] = ‘\0’;
 
  // Count the characters
 f = fopen(filename, “r”);
 while ((currChar = fgetc(f)) != EOF) {
 if (currChar == ‘A’) counter += 1;
 }
 fclose(f);
 return counter;
}

While this looks like a simple program, quite a bit is going on behind the scenes. fgetc() does not simply read each character from the disk as the program requests it, but uses a buffering scheme instead. When buffering, the application (or library) reads a block of information into memory all at once, then returns each item from that block of memory. Without buffering, each read would have to position the disk’s read/write head to the proper location on the disk, then wait for the correct area of the disk to rotate into place. Thus the program would spend most of its time waiting for the drive hardware itself.

Even with buffering, most Standard I/O library implementations are not as fast as going directly to the machine’s own file system. The extra bookkeeping associated with tracking an arbitrary number of files slows things down. We can write a faster program using the “high level” File Manager calls. When we build our new program, we will buffer the data by reading it into memory in large blocks, then process the information directly in memory. The algorithm for our buffered program is as follows.

• Allocate a fixed-size buffer (for best results, the size should be an even multiple of 1K so the Macintosh OS can read entire blocks off the disk)

• Repeat:

• Read one buffer’s worth of data

• Process data

• Until the entire file has been read (charCount == 0 after FSRead)

• Release the memory used by the buffer

And here is the source code:

int countCharsFS(FSSpecPtr fsp)
{
  // Count the number of times the letter A appears in the file reading the file in blocks
 int counter = 0;
 char *buffer, *currChar;
 short refNum;
 long charCount;
 OSErr err;
 
 err = FSpOpenDF(fsp, fsRdPerm, &refNum); 
 if (err == noErr) {
 buffer = (char*)NewPtr(kBufferSize);
 if (buffer != nil) {
  for (;;) {
  charCount = kBufferSize;
  err = FSRead(refNum, &charCount, (Ptr)buffer);
  if ((err != noErr) && (err != eofErr)) break;
  if (charCount == 0) break;
  currChar= buffer;
   while (charCount- > 0) {
   if (*currChar++ == ‘A’) counter++;
   }
  }
   DisposePtr(buffer);
 }
 FSClose(refNum);
 }
 return counter;
}

In the most extreme case, our program could read the whole file in at once before processing it. This would reduce the number of seek operations to an absolute minimum, at the cost of allocating a huge block of memory. This is not always faster than reading a few blocks at a time.

Let’s compare some real-world timing figures for these three routines. We ran these tests on a variety of Macintosh systems, including 680x0 and PowerPC models. The system disk cache was set to 32K for all tests. This article includes only the results from a PowerMac 7100/66, but the other systems were similar. If you want to see the values for your own machine, the test application’s sources are available from MacTech NOW.

file size countchars countCharsFS

1000K 1003 ms 218 ms

2000K 2754 ms 661 ms

3000K 4031 ms 1076 ms

4000K 5328 ms 1467 ms

5000K 6608 ms 1885 ms

Shown graphically, the advantage of going directly to the file system becomes even more apparent:

Improving the Program with Asynchronous I/O

In all of these routines the “count characters” code has to wait for the data to arrive from the disk before starting processing. We can make the code even faster by reading in the next buffer at the same time we are processing the current buffer’s contents. Reading in some data while performing other work is known as asynchronous I/O.

Asynchronous I/O works on the basis of scheduling I/O operations. Instead of calling FSRead and waiting until the buffer has been filled, we will pass the system a request to fill a buffer and instructions on how to notify us when the request has been completed. The Macintosh OS puts our request into a list (known as a Queue) and fills the requests in the order they were made.

Here’s how to structure our program using asynchronous I/O:

• Allocate two buffers in memory.

• Tell the Macintosh OS we want the first block of data to go into the first buffer. (This schedules the buffer for filling as soon as possible and returns control immediately.)

• Tell the OS we want another block of data to go into the second buffer.

• Repeat:

• Wait until a full buffer is available,

• Process it, and

• Make another request for data using this buffer as the destination until the entire file has been processed.

• Release the memory used by the buffers

Notice that our program may have to wait for a buffer to finish filling, but it also gets to work for part of that time. Since we used to do nothing while waiting for the read to complete, any work we do while waiting now happens “for free.”

Changing Your I/O Model

Taking advantage of asynchronous I/O requires that you break away from the “high level” calls we used in the previous code samples. Fortunately, the operating system provides PBRead and PBWrite as the more flexible “low level” counterparts to FSRead and FSWrite.

The PB calls don’t take their parameters in the stack like the FS calls. Instead, each PB call takes a pointer to a “parameter block” structure containing all of the required information. You can easily translate an FS call into a PB call by allocating a parameter block and filling in the appropriate fields. In fact, the Macintosh OS basically does this every time you use an FS call.

Converting from FSRead to PBRead

err = FSRead(refNum, &charCount, (Ptr)buffer);

// Create a parameter block. We’ll use “clear” to zero fields we don’t need for this example
pb = (ParmBlkPtr)NewPtrClear(sizeof(ParamBlockRec));
pb->ioParam.ioRefNum = refNum;
pb->ioParam.ioVRefNum = vRefNum;
// Note: Somebody has to supply the volume RefNum
pb->ioParam.ioBuffer = (Ptr)buffer;
pb->ioParam.ioReqCount = charCount;
err = PBReadSync(pb);
charCount = pb->ioParam.ioActCount;
DisposePtr((Ptr)pb);

So far it looks like a lot of extra work to use a PBRead call instead of an FSRead call. That is true for basic synchronous I/O, but the PB calls can do more. One of the better aspects of PBRead and PBWrite is the ability to set the positioning mode and offset each time. If you make a simple FSWrite call, you’ll get the information located at the “mark” - a value which indicates the current position in the file. The PB calls allow you begin reading or writing from the file mark, at an offset relative to the file mark, or at an offset relative to the start of the file. In addition, PBWrite can perform a “read-verify” operation after writing data to confirm that it went out correctly.

Our real reason for introducing the PB calls in this article is to use them for asynchronous I/O. We want to place a request with the system to get some data and learn when that request has been fulfilled. The parameter blocks have just the information we need to make this happen: the ioResult and ioCompletion fields.

The ioResult field gives the result code of the operation - either 0 for “no error” or a negative value designating an operating system error. This field is filled in after the data has been transferred, which gives us one way to learn when the OS is finished. The File Manager places a positive value into this field when the request is posted. When the value changes, we know the transfer is finished and we can use the data. Hopefully to a 0, meaning “no error”, but it might also contain a negative error code.

Using what we’ve learned so far, we can improve on all of our FSRead-based routines. The code can run as fast as the “read the whole file into memory” version, but only use two small blocks of memory as buffers. Notice how we use a two entry table to hold a pair of parameter blocks. This allows us to fill one block while processing the other.

int countCharsAsync(FSSpecPtr fsp)
{
  // Count the number of times the letter A appears in the file, reading the file one 
  // character at a time
 int   counter = 0;
 ParmBlkPtr pb[2], currPBPtr;
 int   currPB = 0;
 char  *buffer, *currChar;
 short  refNum;
 long  charCount;
 OSErr  err;
 
  // Allocate parameter blocks
  // Open the file
 err = FSpOpenDF(fsp, fsRdPerm, &refNum); 
 if (err == noErr) {
  // Set up parameter blocks
 pb[0] = (ParmBlkPtr)NewPtrClear(sizeof(ParamBlockRec));
 pb[1] = (ParmBlkPtr)NewPtrClear(sizeof(ParamBlockRec));
 setup(pb[0], refNum, fsp->vRefNum, kBufferSize);
 setup(pb[1], refNum, fsp->vRefNum, kBufferSize);
 
  // Start 2 read operations going
 (void) PBReadAsync(pb[0]); 
 (void) PBReadAsync(pb[1]); 
 currPBPtr = pb[0];
 
 for (;;) {
    // Wait for the I/O operation to complete
  while (currPBPtr->ioParam.ioResult > 0) {};
  
    // The data is ready, so count the characters
  buffer = currPBPtr->ioParam.ioBuffer;
  charCount = currPBPtr->ioParam.ioActCount;
  if (charCount == 0) break;
  currChar= buffer;
  while (charCount- > 0) {
   if (*currChar++ == ‘A’) counter++;
  }
  
    // Put this buffer back into the reading queue
  (void) PBReadAsync(currPBPtr);
  
    // Switch to the other buffer
  currPB = 1 - currPB;
  currPBPtr = pb[currPB];
  currPBPtr->ioParam.ioPosMode = fsAtMark;
 }
    // Release the memory
  destroy(pb[0]);
  destroy(pb[1]);
  FSClose(refNum);
 }
 return counter;
}

void setup (ParmBlkPtr pb, short refNum,
   short vRefNum, long bufSize)
{
 pb->ioParam.ioCompletion = NULL;
 pb->ioParam.ioResult = 1;
 pb->ioParam.ioRefNum = refNum;
 pb->ioParam.ioVRefNum = vRefNum;
 pb->ioParam.ioReqCount = bufSize;
 pb->ioParam.ioBuffer = NewPtr(bufSize);
 pb->ioParam.ioPosMode = fsAtMark;
 pb->ioParam.ioPosOffset = 0;
}
void destroy (ParmBlkPtr pb)
{
  DisposePtr(pb->ioParam.ioBuffer);
  DisposePtr((Ptr)pb);
}

Let’s look at the timing results for the above code. Again, since the PowerPC and 68K numbers follow the same pattern, we will show only the PowerPC numbers here.

file size countCharsFS PBRead async

1000K 218 ms 167 ms

2000K 661 ms 454 ms

3000K 1076 ms 700 ms

4000K 1467 ms 934 ms

5000K 1885 ms 1183 ms

Graphically, the timing looks like this: (Notice that we’ve changed scale from our previous graph so you can get a better look at the difference between synchronous and asynchronous I/O.)

While not a dramatic change, the last result is still an improvement over synchronous I/O. It’s hard to make this code much faster, but you can take advantage of the available processing time to add features and improve the user’s experience.

Improving the User’s Experience

All of these routines share a common drawback - they don’t allow any time for other programs to run. They sit in tight loops reading and processing information or waiting for the next read to complete. This is OK when writing demonstration code for a magazine article, but it isn’t a reasonable practice in “real” programs. Real applications should arrange for their I/O intensive routines to give time to other applications and to allow the user to cancel at any time.

A well-designed application will give away time while it’s simply waiting for an I/O request to finish. Most applications could do this by calling WaitNextEvent, processing the event, then checking the result code of the pending operation before giving away any more time. The only problem is that when an application gives away time with WaitNextEvent, there’s no telling how soon control will be returned. Applications that need immediate notification at the end of an I/O operation must use completion routines.

A completion routine is a function in the program that the Macintosh OS calls when a specific I/O operation ends. (The requesting program supplies the function pointer in the ioCompletion field of the parameter block.) Completion routines run under the same tight restrictions as any other “interrupt time” code including not being able to allocate or move memory nor being able to use the content of any relocatable block. Most completion routines are not guaranteed access to their application’s globals, and the information passed into each completion routine varies wildly. For these reasons, we will defer a thorough discussion of completion routines to another article.

The completion routine for PBRead is especially poor, as it receives no parameters and the Parameter Block has been pulled off of the I/O queue by the time the routine is called. This routine appears to have A5 set up for it so it can reach the application’s globals, but it can’t do much even then - only set a flag indicating the completion of I/O or take an existing block and issuing another I/O call for it.

Besides giving away time, there is one other thing a well-behaved application should do, and that is allow the user to cancel an operation. If the user asks to cancel during a synchronous I/O operation, the application simply completes that operation and doesn’t begin another. However, if the user cancels during asynchronous I/O, the application has to remove all of the pending requests. The KillIO() call takes a file or driver reference number and removes all of its pending I/O requests, so applications can kill the pending requests then wait for the current operation to complete before closing the file or driver.

Conclusion

Developers need to look beyond basic I/O calls if they want to get maximum performance from their programs. Asynchronous I/O, while the most complicated way to read and write information, is one of the best ways to improve your application’s performance. These same techniques that improve the performance of File I/O become critical when dealing in near real-time applications such as TCP/IP networking or serial communications that cannot afford pauses in their data collection.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

X Lossless Decoder 20141129a - Encode, t...
X Lossless Decoder (XLD) is a tool for OS X that is able to decode/convert/play various 'lossless' audio files. The supported audio files can be split into some tracks with cue sheet when decoding... Read more
Mariner Write 3.9.4 - Light-weight and s...
Mariner Write is your Mac OS go-to word processing tool! Professional writer, educator or student, Write has all the functionality you need for that important letter, technical paper or research... Read more
Google Chrome 45.0.2454.85 - Modern and...
Google Chrome is a Web browser by Google, created to be a modern platform for Web pages and applications. It utilizes very fast loading of Web pages and has a V8 engine, which is a custom built... Read more
Apple Pro Video Formats 2.0.2 - Updates...
Apple Pro Video Formats brings updates to Apple's professional-level codes for Final Cut Pro X, Motion 5, and Compressor 4. Version 2.0.2: Includes support for the following professional video codecs... Read more
Apple Final Cut Pro X 10.2.2 - Professio...
Apple Final Cut Pro X is a professional video editing solution.Completely redesigned from the ground up, Final Cut Pro adds extraordinary speed, quality, and flexibility to every part of the post-... Read more
Apple Compressor 4.2.1 - Adds power and...
Compressor adds power and flexibility to Final Cut Pro X export. Customize output settings, work faster with distributed encoding, and tap into a comprehensive set of delivery features. Powerful... Read more
Apple Motion 5.2.2 - Create and customiz...
Apple Motion is designed for video editors, Motion 5 lets you customize Final Cut Pro titles, transitions, and effects. Or create your own dazzling animations in 2D or 3D space, with real-time... Read more
Posterino 3.2.2 - Create posters, collag...
Posterino offers enhanced customization and flexibility including a variety of new, stylish templates featuring grids of identical or odd-sized image boxes. You can customize the size and shape of... Read more
A Better Finder Rename 10.00b1 - File, p...
A Better Finder Rename is the most complete renaming solution available on the market today. That's why, since 1996, tens of thousands of hobbyists, professionals and businesses depend on A Better... Read more
CrossOver 14.1.6 - Run Windows apps on y...
CrossOver can get your Windows productivity applications and PC games up and running on your Mac quickly and easily. CrossOver runs the Windows software that you need on Mac at home, in the office,... Read more

Spirit Hunter is an Upcoming Collectible...
Boomlagoon, the team behind hybrid CCG/runner Monsu, has announced their newest project: a collectible card game/action RPG named Spirit Hunter. [Read more] | Read more »
Zen Brush 2 (Entertainment)
Zen Brush 2 1.0 Device: iOS Universal Category: Entertainment Price: $2.99, Version: 1.0 (iTunes) Description: Zen Brush 2 is a drawing app focused on the strong yet beautiful feel of the East Asian ink brush. | Read more »
NetNewsWire (News)
NetNewsWire 4.0.0 Device: iOS iPhone Category: News Price: $3.99, Version: 4.0.0 (iTunes) Description: Follow the Web NetNewsWire 4, completely written from the ground up for iPhone. NetNewsWire is the best way to keep up with the... | Read more »
Huzzah! Farming Simulator 16 Supports Cl...
As though it weren't difficult enough to resist the siren call of Farming Simulator 16, now it's been updated with cloud saves - so you can jump between devices without missing any of that precious crop-harvesting time. [Read more] | Read more »
Don't Starve: Pocket Edition Finall...
I've made no effort to hide my enjoyment of Don't Starve: Pocket Edition, but I will admit I was a tiny bit disappointed that it was only available for the iPad. Well nuts to that, because Klei Entertainment has made it universal! [Read more] | Read more »
Goat Simulator Wasn't Enough? Then...
If you just didn't get enough goat in Goat Simulator - or if you've been wanting to play a simulated MMO as a microwave - then you're in luck! Goat Simulator MMO Simulator is out now, and it's a game about simulated goats in simulated MMOs. Plus... | Read more »
You Can Play Madfinger Games' Unkil...
Madfinger Games - probably best known for the Dead Trigger series - has officially launched their newest zombie shooter (that isn't called Dead Trigger), named Unkilled. [Read more] | Read more »
KORG iELECTRIBE for iPhone (Music)
KORG iELECTRIBE for iPhone 1.0.1 Device: iOS iPhone Category: Music Price: $9.99, Version: 1.0.1 (iTunes) Description: ** 50% OFF Special Launch Sale - For a Limited Time **The ELECTRIBE reborn in an even smaller form A full-fledged... | Read more »
Toca Life: City Just Got a Bunch of New...
Toca Life: City is Toca Boca's most popular app (number 1 in 47 different countries, apparently), and it's just had an update that adds a bunch of new content. [Read more] | Read more »
My Country 3D is More About Cities than...
My Country 3D is an upcoming city builder from Game Insight that looks pretty decent - although the name seems a tad out of whack for a city builder. Ah well, it is what it is. [Read more] | Read more »

Price Scanner via MacPrices.net

DEVONthink and Co. 40% Off For Students And E...
Students and teachers are either preparing for the new semester or are already back in school. And the better organized they are the easier it is for them to concentrate on what’s really important:... Read more
Labor Day Weekend Sale: MacBook Air for up to...
Best Buy has MacBook Airs on sale for up to $150 off MSRP on their online store this weekend. Choose free shipping or free local store pickup (if available). Sale prices for online orders only, in-... Read more
BassJump Subwoofer for MacBook Refreshed...
Twelve South has released a software update for BassJump, their portable subwoofer for Macbook. BassJump 3.0 has a radically redesigned interface, and the software refresh makes the BassJump... Read more
Near-Office Input Functionality Virtually Any...
Today Logitech introduced the Logitech K380 Multi-Device Bluetooth Keyboard and the Logitech M535 Bluetooth Mouse, giving users the freedom to work on any device, most anywhere. According to... Read more
College Student Deals: Additional $100 off Ma...
Take an additional $100 off all MacBooks and iMacs at Best Buy Online with their College Students Deals Savings, valid through September 4, 2015. Anyone with a valid .EDU email address can take... Read more
2.8GHz Mac mini available for $988, includes...
Adorama has the 2.8GHz Mac mini available for $988, $11 off MSRP, including a free copy of Apple’s 3-Year AppleCare Protection Plan. Shipping is free, and Adorama charges sales tax in NY & NJ... Read more
Will You Buy An iPad Pro? – The ‘Book Mystiqu...
It looks like we may not have to wait much longer to see what finally materializes as a new, larger-panel iPad (Pro/Plus?) Usually reliable Apple product prognosticator KGI Securities analyst Ming-... Read more
eFileCabinet Announces SMB Document Managemen...
Electronic document management (EDM) eFileCabinet, Inc., a hosted solutions provider for small to medium businesses, has announced that its SecureDrawer and eFileCabinet Online services will be... Read more
WaterField Designs Unveils American-Made, All...
San Francisco’s WaterField Designs today unveiled their all-leather Cozmo 2.0 — an elegant attach laptop bag with carefully-designed features to suit any business environment. The Cozmo 2.0 is... Read more
Apple’s 2015 Back to School promotion: Free B...
Purchase a new Mac or iPad at The Apple Store for Education and take up to $300 off MSRP. All teachers, students, and staff of any educational institution qualify for the discount. Shipping is free,... Read more

Jobs Board

*Apple* Desktop Analyst - KDS Staffing (Unit...
…field and consistent professional recruiting achievement. Job Description: Title: Apple Desktop AnalystPosition Type: Full-time PermanentLocation: White Plains, NYHot Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
Content Partner Engineer - *Apple* TV - App...
**Job Summary** The Apple TV team is looking for an experienced engineer with a passion for delivering first in class home entertainment solutions. The candidate will Read more
*Apple* Desktop Analyst - KDS Staffing (Unit...
…field and consistent professional recruiting achievement. Job Description: Title: Apple Desktop AnalystPosition Type: Full-time PermanentLocation: White Plains, NYHot Read more
*Apple* Retail - Multiple Customer Support P...
Job Description: Customer Support Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.