orion工具

下載地址：http://www.oracle.com/technetwork/cn/topics/index-088165-zhs.html

orion是一個獨立的磁碟效能測試工具，通過模擬資料庫的行為來測試磁碟效能，而不用真正的安裝資料庫軟體或者資料庫。

 

使使用辦法距離：

 

orion -run simple -testname mytest -num_disks 1

 

cat   mytest.lun

/dev/raw/raw1000

 

orion  -help

Mandatory parameters:
run                     Type of workload to run (simple, normal, advanced, dss, oltp)
                        simple - tests random 8K small IOs at various loads,
                                 then random 1M large IOs at various loads.
                        normal - tests combinations of random 8K small
                                 IOs and random 1M large IOs
                        advanced - run the workload specified by the user
                                   using optional parameters
                        dss - run with random 1M large IOs at increasing loads
                                to determine the maximum throughput
                        oltp - run with random 8K small IOs at increasing loads
                                to determine the maximum IOPS
Optional parameters:
testname                Name of the test run
num_disks                       Number of disks (physical spindles). Default is
                        the number of LUNs in .lun
size_small              Size of small IOs (in KB) - default 8
size_large              Size of large IOs (in KB) - default 1024

type                    Type of large IOs (rand, seq) - default rand
                          rand - Random large IOs
                          seq -  Sequential streams of large IOs
num_streamIO            Number of concurrent IOs per stream (only if type is
                        seq) - default 4
simulate                Orion tests on a virtual volume formed by combining the
                        provided volumes in one of these ways (default concat):
                          concat - A serial concatenation of the volumes
                          raid0 - A RAID-0 mapping across the volumes

write                   Percentage of writes (SEE WARNING ABOVE) - default 0

cache_size              Size *IN MEGABYTES* of the array's cache.
                        Unless this option is set to 0, Orion does a number
                        of (unmeasured) random IO before each large sequential
                        data point.  This is done in order to fill up the array
                        cache with random data.  This way, the blocks from one
                        data point do not result in cache hits for the next
                        data point.  Read tests are preceded with junk reads
                        and write tests are preceded with junk writes.  If
                        specified, this 'cache warming' is done until
                        cache_size worth of IO has been read or written.
                        Default behavior. fill up cache for 2 minutes before
                        each data point.

duration                Duration of each data point (in seconds) - default 60

num_small               Number of outstanding small IOs (only if matrix is
                        point, col, or max) - no default
num_large               For random, number of outstanding large IOs.
                        For sequential, number of streams (only if matrix is
                        point, row, or max) - no default

matrix                  An Orion test consists of data points at various small
                        and large IO load levels.  These points can be
                        represented as a two-dimensional matrix: Each column
                        in the matrix represents a fixed small IO load.  Each
                        row represents a fixed large IO load.  The first row
                        is with no large IO load and the first column is with
                        no small IO load.  An Orion test can be a single point,
                        a row, a column or the whole matrix, depending on the
                        matrix option setting below (default basic):
                          basic - test the first row and the first column
                          detailed - test the entire matrix
                          point - test at load level num_small, num_large
                          col - varying large IO load with num_small small IOs
                          row - varying small IO load with num_large large IOs
                          max - test varying loads up to num_small, num_large

verbose                 Prints tracing information to standard output if set.
                        Default -- not set

Examples
For a preliminary set of data
        -run simple
For a basic set of data
        -run normal
To evaluate storage for an OLTP database
        -run oltp
To evaluate storage for a data warehouse
        -run dss
To generate combinations of 32KB and 1MB reads to random locations:
        -run advanced
        -size_small 32 -size_large 1024 -type rand      -matrix detailed
To generate multiple sequential 1MB write streams, simulating 1MB RAID0 stripes
        -run advanced
        -simulate RAID0 -stripe 1024 -write 100 -type seq
        -matrix col -num_small 0