ORACLE ORION介紹

ORION簡介

ORION (Oracle I/O Calibration Tool) 是校準用於 Oracle 資料庫的儲存系統 I/O 效能的獨立工具。校準結果對於瞭解儲存系統的效能有很大幫助，不僅可以找出影響 Oracle 資料庫效能的問題，還能測量新資料庫安裝的大小。由於 ORION 是一個獨立工具，使用者不需要建立和執行 Oracle 資料庫。 

為了儘可能地模擬 Oracle 資料庫，ORION 使用和 Oracle 相同的 I/O 軟體集生成一個合成的 I/O 負載。可以將 ORION 配置為生成很多 I/O 負載，包括一個模擬 OLTP 和資料倉儲負載的 I/O 負載。 

ORION 支援多種平臺。將來還會增加對更多平臺的支援。使用者指南提供詳細的使用文件，包括“入門”部分和疑難解答提示。在 ORION 中呼叫“-help”選項可以直接獲取關於如何使用 ORION 的摘要。 

請注意，Oracle 不對 ORION 提供支援。 

ORION安裝配置

[root@bogon oracle]# gunzip orion_linux_x86-64.gz

 

[root@bogon oracle]# vi rjx.lun

 

/dev/cciss/c0d0p3

/dev/cciss/c0d0p1

 

[root@bogon oracle]# chmod -R 777 orion_linux_x86-64

 

[root@bogon oracle]# ./orion_linux_x86-64 -run simple -testname rjx -num_disks 2

 

ORION: ORacle IO Numbers -- Version 11.1.0.7.0

rjx_20130805_1550

Test will take approximately 9 minutes

Larger caches may take longer

 

[root@bogon oracle]# ls -l | grep  rjx

-rw-r--r-- 1 root   root           128 08-05 15:57 rjx_20130805_1550_iops.csv

-rw-r--r-- 1 root   root           128 08-05 15:57 rjx_20130805_1550_lat.csv

-rw-r--r-- 1 root   root           100 08-05 15:57 rjx_20130805_1550_mbps.csv

-rw-r--r-- 1 root   root           630 08-05 15:57 rjx_20130805_1550_summary.txt

-rw-r--r-- 1 root   root          2931 08-05 15:57 rjx_20130805_1550_trace.txt

-rw-r--r-- 1 root   root            36 08-05 15:49 rjx.lun

 

 

[root@bogon oracle]# more rjx_20130805_1550_summary.txt

ORION VERSION 11.1.0.7.0

 

Commandline:

-run simple -testname rjx -num_disks 1

 

This maps to this test:

Test: rjx

Small IO size: 8 KB

Large IO size: 1024 KB

IO Types: Small Random IOs, Large Random IOs

Simulated Array Type: CONCAT

Write: 0%

Cache Size: Not Entered

Duration for each Data Point: 60 seconds

Small Columns:,      0

Large Columns:,      0,      1,      2

Total Data Points: 8

 

Name: /dev/cciss/c0d0p3 Size: 282970521600

Name: /dev/cciss/c0d0p1 Size: 104431616

2 FILEs found.

 

Maximum Large MBPS=61.39 @ Small=0 and Large=2

Maximum Small IOPS=361 @ Small=5 and Large=0

Minimum Small Latency=7.60 @ Small=1 and Large=0

 

MBPS 為61.39M IOPS為361

 

ORION使用幫助資訊

[root@X3850-02 oracle]# ./orion_linux_x86-64 -help

ORION: ORacle IO Numbers -- Version 11.1.0.7.0

ORION runs IO performance tests that model Oracle RDBMS IO workloads.

It measures the performance of small (2-32K) IOs and large (128K+) IOs

at various load levels.  Each Orion data point is done at a specific

mix of small and large IO loads sustained for a duration.  Anywhere

from a single data point to a two-dimensional array of data points can

be tested by setting the right options.

 

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.

 

The 'run' parameter is the only mandatory parameter. Defaults

are indicated for all other parameters.  For additional information on

the user interface, see the Orion User Guide.

 

is a filename prefix.  By default, it is "orion".  It can be

specified with the 'testname' parameter.

 

.lun should contain a carriage-return-separated list of LUNs

The output files for a test run are prefixed by _ where

date is "yyyymmdd_hhmm".

 

The output files are:

__summary.txt -  Summary of the input parameters along with

                                 min. small latency, max large MBPS

                                 and/or max. small IOPS.

__mbps.csv - Performance results of large IOs in MBPS

__iops.csv - Performance results of small IOs in IOPS

__lat.csv - Latency of small IOs

__tradeoff.csv - Shows large MBPS / small IOPS

                                 combinations that can be achieved at

                                 certain small latencies

_trace.txt - Extended, unprocessed output

 

WARNING: IF YOU ARE PERFORMING WRITE TESTS, BE PREPARED TO LOSE ANY DATA STORED

ON THE LUNS.

 

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

 

 

下載地址:

聯機文件: