[20190401]那个更快的疑问.txt

女爷i 2022-01-10 02:53 145阅读 0赞

\[20190401\]那个更快的疑问.txt  
  
\--//前一阵子,做了11g于10g下,单表单条记录唯一索引扫描的测试,摘要如下:  
\--//参考链接:  
http://blog.itpub.net/267265/viewspace-2636321/  
http://blog.itpub.net/267265/viewspace-2636342/  
  
1.环境:  
\--//当时的测试,在11g下测试结果如下:  
SCOTT@book> select method,count(\*),round(avg(TIME\_ELA),0),sum(TIME\_ELA) from job\_times group by method order by 3 ;  
METHOD                 COUNT(\*) ROUND(AVG(TIME\_ELA),0) SUM(TIME\_ELA)  
\-------------------- ---------- ---------------------- -------------  
result\_cache                 50                   8611        430536  
id=1\_unique\_index            50                   9494        474714  
null                         50                  10664        533197  
id=1\_index                   50                  28160       1407987  
notnull                      50                  29279       1463928  
  
\--//在10g下测试结果如下:  
SCOTT@test> select method,count(\*),round(avg(TIME\_ELA),0),sum(TIME\_ELA) from job\_times group by method order by 3 ;  
METHOD                 COUNT(\*) ROUND(AVG(TIME\_ELA),0) SUM(TIME\_ELA)  
\-------------------- ---------- ---------------------- -------------  
id=1\_unique\_index            50                   4864        243192  
notnull                      50                  34134       1706713  
id=1\_index                   50                  34703       1735173  
null                         50                  37234       1861717  
  
\--//我的测试环境服务器硬件相同,os版本一样,对比可以发现id=1\_unique\_index的情况下,10g比11g快了1倍(指id=1\_unique\_index的情况).  
\--//而其他方式下11g都明显快于10g,而10g下除了id=1\_unique\_index下其他执行方式都可以看到大量cbc latch等待事件.  
\--//而11g仅仅在id=1\_index,notnull下看到大量cbc latch等待时间,null方式下(全表扫描)的情况下反而看不到cbc  
\--//latch等待事件.  
\--//我一直再想,我是不是测试方法存在什么问题,或者11g做了什么改进?重复测试唯一索引的情况看看:  
  
1.环境:  
SCOTT@book> @ ver1  
PORT\_STRING                    VERSION        BANNER  
\------------------------------ -------------- --------------------------------------------------------------------------------  
x86\_64/Linux 2.4.xx            11.2.0.4.0     Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production  
  
create table t as select rownum id from dual ;  
create unique index pk\_t on t(id);  
create table job\_times (sid number, time\_ela number,method varchar2(20));  
\--//分析表略.  
  
$ cat m1.txt  
set verify off  
host sleep $(echo &&3/50 | bc -l )  
insert into job\_times values ( sys\_context ('userenv', 'sid') ,dbms\_utility.get\_time ,'&&2') ;  
commit ;  
declare  
v\_id number;  
v\_d date;  
begin  
    for i in 1 .. &&1 loop  
        select /\*+ &&3 \*/ count (\*) into v\_id from t where id=1;  
        --//select /\*+ &&3 \*/ count (\*) into v\_id from t ;  
        --//select /\*+ &&3 \*/ 1 into v\_id from dual ;  
        --//select /\*+ &&3 \*/ sysdate into v\_d from dual ;  
    end loop;  
end ;  
/  
update job\_times set time\_ela = dbms\_utility.get\_time - time\_ela where sid=sys\_context ('userenv', 'sid') and method='&&2';  
commit;  
quit  
  
$ sqlplus -s -l scott/book @m1.txt 1e6 id=1\_unique\_index 0 >/dev/null  
SCOTT@book> Select method,count(\*),round(avg(TIME\_ELA),0),sum(TIME\_ELA) from job\_times group by method order by 3 ;  
METHOD                 COUNT(\*) ROUND(AVG(TIME\_ELA),0) SUM(TIME\_ELA)  
\-------------------- ---------- ---------------------- -------------  
id=1\_unique\_index             1                   2615          2615  
  
\--//在10g环境下重复上面的步骤略.环境:  
SCOTT@test> @ &r/ver1  
PORT\_STRING                    VERSION        BANNER  
\------------------------------ -------------- ----------------------------------------------------------------  
x86\_64/Linux 2.4.xx            10.2.0.4.0     Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - 64bi  
  
$ sqlplus -s -l scott/btbtms @m1.txt 1e6 id=1\_unique\_index 0 >/dev/null  
  
SCOTT@test> select method,count(\*),round(avg(TIME\_ELA),0),sum(TIME\_ELA) from job\_times group by method order by 3 ;  
METHOD                 COUNT(\*) ROUND(AVG(TIME\_ELA),0) SUM(TIME\_ELA)  
\-------------------- ---------- ---------------------- -------------  
id=1\_unique\_index             1                   1535          1535  
  
\--//可以看出即使我单个用户执行相似的sql语句情况下,唯一索引查询10g下明显快于11g.  
  
2.使用strace跟踪看看:  
\--//执行1e6次有点慢,改成1e5看看.  
  
\--//11g的测试:  
$ strace -f -c sqlplus -s -l scott/book @m1.txt 1e5 id=1\_unique\_index 0 >/dev/null  
...  
% time     seconds  usecs/call     calls    errors syscall  
\------ ----------- ----------- --------- --------- ----------------  
 72.78    0.043919           0    700708           getrusage  
 19.80    0.011947           0    200179           times  
  6.67    0.004024         671         6         3 wait4  
  0.24    0.000147          29         5           clone  
  0.18    0.000106           0       375         2 read  
  0.16    0.000096           0       264       106 open  
...  
\------ ----------- ----------- --------- --------- ----------------  
100.00    0.060341                902967       206 total  
  
\--//10g的测试:  
$ strace -f -c sqlplus -s -l scott/btbtms @m1.txt 1e5 id=1\_unique\_index 0 >/dev/null  
% time     seconds  usecs/call     calls    errors syscall  
\------ ----------- ----------- --------- --------- ----------------  
 72.00    0.056425           0    700486           getrusage  
 24.98    0.019573        2796         7         2 wait4  
  0.91    0.000714           3       236           read  
  0.74    0.000582          97         6           clone  
  0.73    0.000572         286         2           shmdt  
  0.23    0.000177           1       302       189 open  
  0.16    0.000122           1       145       108 stat  
  0.05    0.000042           1        65           write  
..  
  0.03    0.000025           0       116           times  
\------ ----------- ----------- --------- --------- ----------------  
100.00    0.097352                702291       347 total  
  
\--//差异在于10g很少做times的系统调用上.10g下仅仅116次.而11g高达200179.  
  
\--//如果再次执行跟踪如下,11g:  
$ strace -f  -p 57003  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{19, 483038\}, ru\_stime=\{3, 285500\}, ...\}) = 0  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
times(\{tms\_utime=1948, tms\_stime=328, tms\_cutime=0, tms\_cstime=0\}) = 10865304314  
\--//调用7次getrusage,调用2次times.  
\--//对比前面的调用比例也可以看出getrusage调用700708,times调用times200179.非常接近7:2  
  
\--//而10g下仅仅看到:  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{13, 203992\}, ru\_stime=\{1, 700741\}, ...\}) = 0  
  
\--//正是这样的差异导致10g下明显快于11g.  
\--//顺便看看times输出表示什么?  
$ man 2 times  
NAME  
       times - get process times  
  
SYNOPSIS  
       \#include <sys/times.h>  
  
       clock\_t times(struct tms \*buf);  
  
DESCRIPTION  
       times() stores the current process times in the struct tms that buf points to.  The struct tms is as defined in <sys/times.h>:  
  
       struct tms \{  
              clock\_t tms\_utime;  /\* user time \*/  
              clock\_t tms\_stime;  /\* system time \*/  
              clock\_t tms\_cutime; /\* user time of children \*/  
              clock\_t tms\_cstime; /\* system time of children \*/  
       \};  
  
       The  tms\_utime field contains the CPU time spent executing instructions of the calling process.  The tms\_stime  
       field contains the CPU time spent in the system while executing tasks on behalf of the calling process.  The  
       tms\_cutime field contains the sum of the tms\_utime and tms\_cutime values for all waited-for terminated children.  
       The tms\_cstime field contains the sum of the tms\_stime and tms\_cstime values for all waited-for terminated  
       children.  
  
       Times for terminated children (and their descendants) is added in at the moment wait(2) or waitpid(2) returns  
       their process ID. In particular, times of grandchildren that the children did not wait for are never seen.  
  
       All times reported are in clock ticks.  
  
RETURN VALUE  
       times() returns the number of clock ticks that have elapsed since an arbitrary point in the past.  For Linux 2.4  
       and earlier this point is the moment the system was booted.  Since Linux 2.6, this point is (2^32/HZ) -  300  
       (i.e.,  about  429 million) seconds before system boot time.  The return value may overflow the possible range of  
       type clock\_t.  On error, (clock\_t) -1 is returned, and errno is set appropriately.  
  
$ cat   /proc/uptime ;uptime  
104375436.65 104342102.07  
10:12:33 up 1208 days,  1:10,  2 users,  load average: 0.01, 0.01, 0.07  
  
\--//我的计算:  
2^32 = 4294967296  
4294967296-300 = 4294966996 ,文档提到 429 million seconds,不对明显相差10被.难道Hz的单位1/10秒吗?不懂.  
4294967296/60-300 = 429496429.6  
10437543665+429496429.6 = 10867040094.6  
\--//这样与上面的结果比较接近了,再次验证看看.  
  
$ strace -f -p 57447 ; cat /proc/uptime  
...  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
times(\{tms\_utime=2276, tms\_stime=382, tms\_cutime=0, tms\_cstime=0\}) = 10865578855  
times(\{tms\_utime=2276, tms\_stime=382, tms\_cutime=0, tms\_cstime=0\}) = 10865578855  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
getrusage(RUSAGE\_SELF, \{ru\_utime=\{22, 765539\}, ru\_stime=\{3, 829417\}, ...\}) = 0  
^CProcess 57447 detached  
104377639.45 2484149083.69  
  
4294967296/2593.795/1^6 -300  = 1655562.27747374021462760164  
  
104377639.45+1655562.27747374021462760164  
10437763945+(4294967296/10-300) = 10867260374.6  
  
\--//存在很大的误差放弃!!

转载于:https://www.cnblogs.com/lfree/p/10637195.html

发表评论取消回复

表情：

评论列表（有 0 条评论，145人围观）

还没有评论，来说两句吧...

相关阅读

相关 ClickHouse 挺快，esProc SPL 更快

源分析数据库ClickHouse以快著称，真的如此吗？我们通过对比测试来验证一下。 ClickHouse vs Oracle 先用ClickHouse（简...

心已赠人/ 2024年04月17日 10:56/ 0 赞/ 39 阅读

相关更快更好用的Redis6.0

文心一言对Redis6.0新特性的总结 ![706e982192964102a7b44972c8b08fec.png][] 目录 Redis6.0新特性 1：从单线程处

梦里梦外;/ 2023年09月25日 20:49/ 0 赞/ 10 阅读

相关 React与AngularJS到底那个更快...

React自诞生以来，一直以其渲染速度快著称，特别与AngularJS和EmberJS等相比更是如此。但也有人不同意这个观点，以色列软件开发公司500Tech的CEO [Bor

た入场券/ 2022年09月23日 04:56/ 0 赞/ 120 阅读

相关旷视YOLOX：更快更强！

本文转载自机器之心编辑：杜伟、陈萍 > 在本文中，来自旷视的研究者提出高性能检测器 YOLOX，并对 YOLO 系列进行了经验性改进，将 Anchor-free、数据增强等

缺乏、安全感/ 2022年08月31日 09:40/ 0 赞/ 216 阅读

相关 Mockplus-更快更简单的原型设计

> 本文主要介绍Mockplus的基础功能，主要是基于学习过程的总结记录，可能比较简要，详细内容请参考Mockplus的[官方教程][Link 1]，也即本文的主要参考资料。

偏执的太偏执、/ 2022年05月29日 02:12/ 0 赞/ 324 阅读

相关 mysql中关联查询和子查询那个更快

Navicat 11.0.10版本结果证明表关联比子查询速度更快 1.子查询：0.287s SELECT sw,sh,cx,cy, (SELE

心已赠人/ 2022年04月12日 10:42/ 0 赞/ 1422 阅读

相关 [20190401]隐含参数_mutex_spin_count.txt

\[20190401\]隐含参数\_mutex\_spin\_count.txt \--//上午做了一些测试关于semtimedop函数调用,发现自己上个星期在一些问

电玩女神/ 2022年01月10日 02:53/ 0 赞/ 180 阅读

相关 [20190401]关于semtimedop函数调用.txt

\[20190401\]关于semtimedop函数调用.txt \--//上个星期测试,链接http://blog.itpub.net/267265/viewspa

喜欢ヅ旅行/ 2022年01月10日 02:53/ 0 赞/ 176 阅读

相关 [20190401]那个更快的疑问.txt

\[20190401\]那个更快的疑问.txt \--//前一阵子,做了11g于10g下,单表单条记录唯一索引扫描的测试,摘要如下: \--//参考链接: h

女爷i/ 2022年01月10日 02:53/ 0 赞/ 146 阅读

相关 [20190423]那个更快的疑问3.txt

\[20190423\]那个更快的疑问3.txt \--//前一阵子,做了11g在单表单条记录唯一索引扫描的测试,摘要如下: \--//参考链接: http:

痛定思痛。/ 2022年01月05日 22:04/ 0 赞/ 150 阅读