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

 

 

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

联机文档: http://download.oracle.com/otn/utilities_drivers/orion/Orion_Users_Guide.pdf?AuthParam=1375694877_e54cdbaf317719d5a02ab18156b94f1e

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/15747463/viewspace-767814/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/15747463/viewspace-767814/