Disk Schedulers for Linux
                    -------------------------

  cat /sys/block/sda/queue/scheduler:
    noop deadline [cfq]
                  ^^^^^
                  current (and default)

    noop - The NOOP scheduler inserts all incoming I/O requests into a
           simple FIFO queue and implements request merging. 
           This scheduler is useful when it has been determined that
           the host should not attempt to re-order requests based on
           the sector numbers contained therein.
           For example:
              -  If I/O scheduling will be handled at a lower layer of 
                 the I/O stack. For example: at the block device, by 
                 an intelligent RAID controller, Network Attached 
                 Storage, or by an externally attached controller such 
                 as a storage subsystem accessed through a switched 
                 Storage Area Network
              - If accurate details of sector position are hidden from 
                the host system.  For example: a RAID controller that 
                performs no scheduling on its own. 
              - If movement of the read/write head has been determined 
                to not impact application performance in a way that 
                justifies the additional CPU time being spent 
                re-ordering requests.

    cfq  - CFQ places synchronous requests submitted by processes into
           a number of per-process queues and then allocates
           timeslices for each of the queues to access the disk. The 
           length of the time slice and the number of requests a queue 
           is allowed to submit depends on the I/O priority of the
           given process

    deadline - The main goal of the Deadline scheduler is to guarantee
           a start service time for a request. It does that by imposing a
           deadline on all I/O operations to prevent starvation of
           requests. It maintains two deadline queues and read and write
           queues sorted by sector number. Deadline queues are sorted
           by deadline (the expiration time), while the sorted queues 
           are sorted by the sector number.

           Before serving the next request, the Deadline scheduler
           decides which queue to use. Read queues are given a higher
           priority, because processes usually block on read
           operations. Next, the Deadline scheduler checks if the
           first request in the deadline queue has expired. Otherwise,
           the scheduler serves a batch of requests from the sorted
           queue. In both cases, the scheduler also serves a batch of
           requests following the chosen request in the sorted queue.
           By default, read requests have an expiration time of 500
           ms, write requests expire in 5 seconds.