The performance difference between using aio_suspend and active waiting with aio_error can be explained by the differences in waiting mechanisms and processing of asynchronous operations.

When you use aio_suspend, the program pauses and waits for a notification from the kernel about the completion of at least one of the asynchronous operations, which can lead to some delay since the program "wakes up" only after receiving such a notification. This means there can be some time between the completion of the operation and the resumption of the program's work during which the CPU is not occupied with processing other copying operations.

On the other hand, active waiting with aio_error leads to the program constantly checking the status of each asynchronous operation in a loop. Although this might seem less efficient in terms of CPU usage, such an approach can allow for a quicker response to the completion of operations, especially if the operations finish at different speeds. This can lead to an earlier start of new read or write operations, which, in turn, can speed up the overall copying process.

It is also important to consider that the performance of asynchronous I/O can greatly depend on the system characteristics, such as disk performance, system load, block size, and the number of concurrent asynchronous operations. In some cases, active waiting might be more preferable if it allows for a more efficient use of the available I/O bandwidth, despite the higher CPU consumption.

Ultimately, the choice between aio_suspend and active waiting with aio_error should be based on the specific performance and resource requirements of your application, as well as the characteristics of the target system. In some cases, it might be useful to conduct your own performance testing to determine the most efficient approach.

In my case, when using aio_suspend, a 4 GB file is copied in 16 seconds using an 8 KB block size and 8 operations, whereas using aio_error for active waiting, the same operation takes only 9 seconds