Oracle I / O延迟监控


跑表我发现在企业管理器的性能页面中发现的一件事是各种类型的I / O的延迟值。性能页面或顶部活动可以显示高I / O等待,但如果I / O的延迟非常高,则不会指示。因此,我汇集了一个shell脚本,显示主I / O等待的延迟

  • DB文件顺序读取
  • DB文件分散读取
  • 日志文件并行写入
  • 直接路径读取
  • 直接路径读取温度

当然,添加一些像直接路径写入这样的其他人会很好,直接路径写入临时和日志文件同步,但屏幕宽度只有这么多的空间。

oramon.sh.

 

脚本称为Oramon.sh,可在Github上获得

//github.com/khailey/oramon/blob/master/oramon.sh

例子:

$  oramon.sh
Usage: oramon.sh [username] [password] [host] [sid] <port=1521> <runtime=3600>

$ ./oramon.sh system sys 172.16.100.81 vsol
RUN_TIME=-1
COLLECT_LIST=
FAST_SAMPLE=iolatency
TARGET=172.16.100.81:vsol
DEBUG=0
Connected, starting collect at Wed Apr 18 18:41:13 UTC 2012
starting stats collecting

   single block       logfile write       multi block      direct read   direct read temp
   ms      IOP/s        ms    IOP/s       ms    IOP/s       ms    IOP/s       ms    IOP/s
   20.76    27.55    32.55      .71     3.50      .00      .00      .01      .00      .00
     .00      .20               .00               .00               .00               .00
   34.93   369.64   116.79     3.55               .00               .00               .00
   31.43   640.33    92.40     8.33               .00               .00               .00
   39.39   692.33   111.69     8.00               .00               .00               .00

第一行输出是自数据库启动以来的平均值。
后续行是自默认为5秒的最后一行以来的平均值。
一个人应该能够立即看到数据库上有多少活动以及数据库I / O基本类型的延迟。


单个块读取 是来自数据库的典型I / O,例如,当读取具有索引的表中读取一行时会发生。
多块读取 常见的是,例如,当例如在表中所有行求出值时会发生这种情况。
直接阅读 不太常见但非常正常,几乎完全用于并行查询,尽管可以用于其他活动,尤其是较新版本的Oracle,例如11.2。直接读取是多块读取,通过传递Oracle缓冲区缓存。大小从Datablock变化,例如8k到1MB。
直接阅读温度 当排序溢出的内存限制并被写入磁盘时会发生。直接读取临时是多块读取,通过传递Oracle缓冲区缓存。大小从Datablock变化,例如8k到1MB。

写道
logfile写道 数据库用户一般等待的唯一写字。实际上用户才会在提交时等待,然后是从日志作者等待信号,所以它们的特定重做数据是可以发生的磁盘。通常,用户等待时间比LogWrite时间慢一点,但通常它关闭,即在几毫秒内。用户等待时间越远离日志写入时间,VDB主机上的CPU,分页或其他并发问题越有可能减慢用户信令并唤醒时间。

利润升高

Oramon.sql:Oracle Latency查询

如果出于某种原因shell脚本无法连接到数据库,则可以通过手动运行SQL * Plus中的SQL查询来手动收集相同的数据。
在github上可用以下两个sql查询,oramon_setup.sql和oramon.sql

//github.com/khailey/oramon

如果您想在短于60秒的时间内看到延迟,那么您必须在时间A中收集累积计数器的值,然后在时间B再次收集差异。以下两个查询,Oramon.sql和oramon_setup.sql可在FTP站点上使用

运行oramon_setup.sql *一次*
  column seq_ms for 9999.99
   column seq_ct for 9999.99
   column lfpw_ms for 9999.99
   column lfpw_ct for 9999.99
   column seq_ms for 9999.99
   column scat_ct for 9999.99
   column dpr_ms for 9999.99
   column dpr_ct for 9999.99
   column dprt_ms for 9999.99
   column dprt_ct for 9999.99
   column prevdprt_ct new_value prevdprt_ct_var
   column prevdprt_tm new_value prevdprt_tm_var
   column prevdpwt_ct new_value prevdpwt_ct_var
   column prevdpwt_tm new_value prevdpwt_tm_var
   column prevdpr_ct new_value prevdpr_ct_var
   column prevdpr_tm new_value prevdpr_tm_var
   column prevdpw_ct new_value prevdpw_ct_var
   column prevdpw_tm new_value prevdpw_tm_var
   column prevseq_ct new_value prevseq_ct_var
   column prevseq_tm new_value prevseq_tm_var
   column prevscat_ct new_value prevscat_ct_var
   column prevscat_tm new_value prevscat_tm_var
   column prevlfpw_ct new_value prevlfpw_ct_var
   column prevlfpw_tm new_value prevlfpw_tm_var
   column prevsec new_value prevsec_var
   select 0 prevsec from dual;
   select 0 prevseq_tm from dual;
   select 0 prevseq_ct from dual;
   select 0 prevscat_ct from dual;
   select 0 prevscat_tm from dual;
   select 0 prevlfpw_ct from dual;
   select 0 prevlfpw_tm from dual;
   select 0 prevdprt_ct from dual;
   select 0 prevdprt_tm from dual;
   select 0 prevdpwt_ct from dual;
   select 0 prevdpwt_tm from dual;
   select 0 prevdpr_ct from dual;
   select 0 prevdpr_tm from dual;
   select 0 prevdpw_ct from dual;
   select 0 prevdpw_tm from dual;
   column prevdprt_ct noprint
   column prevdprt_tm noprint
   column prevdpwt_ct noprint
   column prevdpwt_tm noprint
   column prevdpr_ct noprint
   column prevdpr_tm noprint
   column prevdpw_ct noprint
   column prevdpw_tm noprint
   column prevseq_ct noprint
   column prevseq_tm noprint
   column prevscat_ct noprint
   column prevscat_tm noprint
   column prevlfpw_ct noprint
   column prevlfpw_tm noprint
   column prevsec noprint

在查询之后运行以查看当前延迟

  • 单块读取
  • 日志文件并行写入
  • 多块读取

oramon.sql.

select
        round(seqtm/nullif(seqct,0),2) seq_ms,
        round(seqct/nullif(delta,0),2) seq_ct,
        round(lfpwtm/nullif(lfpwct,0),2) lfpw_ms,
        round(lfpwct/nullif(delta,0),2) lfpw_ct,
        round(scattm/nullif(scatct,0),2) scat_ms,
        round(scatct/nullif(delta,0),0) scat_ct,
        round(dprtm/nullif(dprct,0),2) dpr_ms,
        round(dprct/nullif(delta,0),2) dpr_ct,
        round(dprttm/nullif(dprtct,0),2) dprt_ms,
        round(dprtct/nullif(delta,0),2) dprt_ct,
        prevseq_ct, prevscat_ct, prevseq_tm, prevscat_tm, prevsec,prevlfpw_tm,prevlfpw_ct
        , prevdpr_ct, prevdpr_tm , prevdprt_ct, prevdprt_tm , prevdpw_ct, prevdpw_tm
        , prevdpwt_ct, prevdpwt_tm
from
(select
       sum(decode(event,'DB文件顺序读取', round(time_waited_micro/1000) -  &prevseq_tm_var,0)) seqtm,
       sum(decode(event,'DB文件分散读取',  round(time_waited_micro/1000) - &prevscat_tm_var,0)) scattm,
       sum(decode(event,'日志文件并行写入',  round(time_waited_micro/1000) - &prevlfpw_tm_var,0)) lfpwtm,
       sum(decode(event,'DB文件顺序读取', round(time_waited_micro/1000) ,0)) prevseq_tm,
       sum(decode(event,'DB文件分散读取',  round(time_waited_micro/1000) ,0)) prevscat_tm,
       sum(decode(event,'日志文件并行写入',  round(time_waited_micro/1000) ,0)) prevlfpw_tm,
       sum(decode(event,'DB文件顺序读取', total_waits - &prevseq_ct_var,0)) seqct,
       sum(decode(event,'DB文件分散读取',  total_waits - &prevscat_ct_var,0)) scatct,
       sum(decode(event,'日志文件并行写入',  total_waits - &prevlfpw_ct_var,0)) lfpwct,
       sum(decode(event,'DB文件顺序读取', total_waits ,0)) prevseq_ct,
       sum(decode(event,'DB文件分散读取',  total_waits ,0)) prevscat_ct,
       sum(decode(event,'日志文件并行写入',  total_waits ,0)) prevlfpw_ct,
       sum(decode(event,'direct path read',  round(time_waited_micro/1000) - &prevdpr_tm_var,0)) dprtm,
       sum(decode(event,'direct path read',  round(time_waited_micro/1000) ,0)) prevdpr_tm,
       sum(decode(event,'direct path read',  total_waits - &prevdpr_ct_var,0)) dprct,
       sum(decode(event,'direct path read',  total_waits ,0)) prevdpr_ct,
       sum(decode(event,'direct path write',  round(time_waited_micro/1000) - &prevdpw_tm_var,0)) dpwtm,
       sum(decode(event,'direct path write',  round(time_waited_micro/1000) ,0)) prevdpw_tm,
       sum(decode(event,'direct path write',  total_waits - &prevdpw_ct_var,0)) dpwct,
       sum(decode(event,'direct path write',  total_waits ,0)) prevdpw_ct,
       sum(decode(event,'direct path write temp',  round(time_waited_micro/1000) - &prevdpwt_tm_var,0)) dpwttm,
       sum(decode(event,'direct path write temp',  round(time_waited_micro/1000) ,0)) prevdpwt_tm,
       sum(decode(event,'direct path write temp',  total_waits - &prevdpwt_ct_var,0)) dpwtct,
       sum(decode(event,'direct path write temp',  total_waits ,0)) prevdpwt_ct,
       sum(decode(event,'direct path read temp',  round(time_waited_micro/1000) - &prevdprt_tm_var,0)) dprttm,
       sum(decode(event,'direct path read temp',  round(time_waited_micro/1000) ,0)) prevdprt_tm,
       sum(decode(event,'direct path read temp',  total_waits - &prevdprt_ct_var,0)) dprtct,
       sum(decode(event,'direct path read temp',  total_waits ,0)) prevdprt_ct,
       to_char(sysdate,'SSSSS')-&prevsec_var delta,
       to_char(sysdate,'SSSSS') prevsec
from
     v$system_event
where
     event in ('DB文件顺序读取',
               'DB文件分散读取',
               'direct path read temp',
               'direct path write temp',
               'direct path read',
               'direct path write',
               '日志文件并行写入')
) ;

输出看起来像

  SEQ_MS   SEQ_CT  LFPW_MS  LFPW_CT   SEQ_MS  SCAT_CT   DPR_MS   DPR_CT  DPRT_MS  DPRT_CT
-------- -------- -------- -------- -------- -------- -------- -------- -------- --------
  115.71   422.67    76.17    12.00               .00               .00               .00

查询的第一次执行是I / O由于数据库启动,因此很可能忽略。
自上次执行以来的后续执行是I / O

列是

  1. SEQ_MS:单块延迟
  2. SEQ_CT:每秒单块读数
  3. LFPW_MS:日志文件并行写入延迟
  4. lfpw_ct:每秒日志文件并行写入计数
  5. SCAT_MS:多块延迟
  6. Scat_ct:每秒多块读数
  7. DPR_MS:直接路径读取延迟
  8. DPR_CT:直接路径读数
  9. DPRT_MS:直接路径读取温度延迟
  10. dprt_ct:直接路径读取温度计数
而不是通过手工脚本“oramon.sh”来运行查询 //github.com/khailey/oramon/blob/master/oramon.sh (请参阅页面顶部)将在循环中以5秒钟收集此信息,并在UNIX提示符下输出标准

简单但只有一次

注意:以下是一个更简单的查询,但数据仅在一分钟内更新一次
select
       n.name event,
       m.wait_count  cnt,
       10*m.time_waited ms,
       nvl(round(10*m.time_waited/nullif(m.wait_count,0),3) ,0) avg_ms
  from v$eventmetric m,
       v$event_name n
  where m.event_id=n.event_id
        and (
              wait_class_id= 1740759767 --  User I/O 
                   or
              wait_class_id= 4108307767 --  System I/O  
             )
        and m.wait_count > 0 ;

.

5 thoughts on “甲骨文 I / O延迟监控

  • Pingback: 凯尔 Hailey..»等待度量vs等待事件

  • Pingback: 甲骨文 IO延迟监控| Vishal Desai的Oracle博客

  • 2013年9月12日在下午3:21
    永久链接

    感谢您分享详细信息…

    一个问题。上周我的报告需要超过5个小时而不是3小时…当我检查所有内心&外部细节在工具的帮助下&追踪..etc ..但找不到任何有趣的东西甚至执行计划..收集统计也完好无损。

    当我们上次检查存储级别时&发现一个存储路径已经死了&所有流量只移动一个导致这个问题的路径…修复再次报告恢复正常3小时..

    我们可以找到pro主动这种意外问题吗?

    请要求脱掉一些光线&如何处理此类问题..

    谢谢

    yousuf.

    注意:我有好处&这个问题的坏AWR报告。

  • 2013年9月12日在下午4:19
    永久链接

    @yousuf:灰烬会让你休息一下时间花在花时间,为什么要在5小时而不是3小时的时间花费更多的时间。一旦确定差异,您可以在发生偶数发生时设置警报

  • 2013年9月17日在晚上9:01
    永久链接

    感谢您的回复…..

    当然,我将验证与Ash(活动会话历史)的建议的结果验证。

评论被关闭。