Ram Disk Application for Windows Environment (imdisk, sqlio)

Version 4

    It is common practice to use a RAM disk and not an actual hard disk to measure storage performance.

    imdisk is a free RAM disk application that can be downloaded from several locations on the web.



    To run performance testing on this RAM disk, follow this procedure:


    1. On one of the servers, create a 20GB virtual RAM disk (NTFS). Run:


    PS C:\>  imdisk -a -t vm -s 20G -p "/fs:ntfs /q /y" -m S:

    Creating device...

    Created device 1: S: -> VM image

    Formatting disk...

    The type of the file system is RAW.

    The new file system is NTFS.

    QuickFormatting 20.0 GB

    Creating file system structures.

    Format complete.

          20.0 GB total disk space.

          20.0 GB are available.

    Notifying applications...


    PS C:\Users\Administrator> s:

    PS S:\>


    The disk will appear under "This PC".


    2. Share that disk using Windows GUI (right-click on the Disk->Share)


    3. One the other server, download the SQLIO tool (Download SQLIO Disk Subsystem Benchmark Tool from Official Microsoft Download Center)


    Run SQLIO tests. Here is an example:


    C:\Users\Administrator\Desktop>sqlio2_15 -BYRT -e200 -b16 -fsequential -T0 -t32 -o4 -s5 -LS \\\S\1.txt

    sqlio v2.15. 64bit_SG

    32 threads writing for 5 secs to file \\\S\1.txt

            using a 0/100 read/write ratio

            using 16KB sequential IOs

            enabling multiple I/Os per thread with 4 outstanding

            buffering set to use both file and disk caches

            buffering will occur on the remote server, not locally

            software buffer cache will defer writeback, honoring temporary attribute

    Ensuring that  file \\\S\1.txt, as requested,

    is at least 209715200 bytes in size.

    using current size: 200 MB for file: \\\S\1.txt

    initialization done


    throughput metrics:

    IOs/sec: 158987.63

    MBs/sec:  2484.18

    latency metrics:

    Min_Latency(ms): 0

    Avg_Latency(ms): 0

    Max_Latency(ms): 3


    ms: 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24+

    %: 76 23  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0


    To get the command help, just type the command.

    You may wish to play with some of the parameters to see the effect on the bandwidth.


    C:\Users\Administrator\Desktop>sqlio2_15  -h


    sqlio v2.15. 64bit_SG

    Usage: sqlio2_15 [options] [<filename>...]

            [options] may include any of the following:

            -k<R|W>                 kind of IO (R=reads, W=writes)

            -T<percentage>          R/W mix as % of reads (Writes are 100-this)

            -t<threads>             number of threads

            -s<secs>                number of seconds to run

            -c<IOPS>                maximum number of IOPS to send per thread

            -d<drv_A><drv_B>..      use same filename on each drive letter given

            -R<drv_A/0>,<drv_B/1>.. raw drive letters/number for I/O

            -f<stripe factor>       stripe size in blocks, random, or sequential

            -p[I]<cpu affinity>     cpu number for affinity (0 based)(I=ideal)

            -a[R[I]]<cpu mask>      cpu mask for (R=roundrobin (I=ideal)) affinity

            -o<#outstanding>        depth to use for completion routines

            -b<io size(KB)>         IO block size in KB

            -i<#IOs/run>            number of IOs per IO run

            -q<filename>            filename to use as source of data to write

            -e<file size>           minimum file size, megabytes (enlarge to fit)

            -z                      Results in csv form (suppress all non-errors)

            -zh                     Results in csv form with column headers

            -r                      hide drive size IOCTL errors (adv. users only)

            -W<secs>                Number of seconds to warmup (IOs not measured)

            -m<[C|S]><#sub-blks>    do multi blk IO (C=copy, S=scatter/gather)

            -L<[S|P][i|]>           latencies from (S=system, P=processor) timer

            -B<[N|Y|H|S][RT]>       set buffering (N=none, Y=all, H=hdwr, S=sfwr, R=remote, T=temporary)

            -S<#blocks>             start I/Os #blocks into file

            -v1.1.1                 I/Os runs use same blocks, as in version 1.1.1

            -F<paramfile>           read parameters from <paramfile>


            -Td -t1 -s30 -f64 -b2 -i64 -BN testfile.dat


            -t (threads):                   256

            no. of files, includes -d & -R: 256

            filename length:                256