[20231130]快速刪除大量檔案測試(perl版本)3.txt

[20231130]快速刪除大量檔案測試(perl版本)3.txt

--//上上個星期做維護時，發現一臺機器累積了大量aud檔案，使用find -mtime +30 做保留1個月的刪除操作時那個慢簡直無法形容。
--//我做了一些測試,結果測試遇到一些問題或者疑惑,浪費大量時間,根據以前測試我知道perl對於這樣的刪除很快，我以前做個類似測
--//試。以下測試是在我多次測試後發現的規律或者總結。

1.建立測試環境：
$ mount | column | grep u01
/dev/cciss/c0d0p6 on /u01 type ext3 (rw)
--// /u01的檔案系統是ext3.

--//按照順序建立檔案。
$ cd /u01/testrm
$ time for i in $(seq -f "%06g" 300000); do >| $i.aud; done
--//注：這樣建立檔案大小0位元組，並不影響後面的測試結論。你可以修改echo test $i >| $i.aud.
--//順便說一下使用touch $i.aud 建立檔案很慢,我不知道為什麼.
$ time perl -e 'unlink for ( <*.aud> )'
real    0m4.077s
user    0m0.445s
sys     0m2.961s

--//按照相反的順序建立檔案。
$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
$ time perl -e 'unlink for ( <*.aud> )'
real    0m4.625s
user    0m0.459s
sys     0m3.476s
--//你可以發現不論從順序建立檔案刪除還是相反的順序刪除檔案,perl刪除全部檔案的時間基本差不多。

2.亂序測試：
--//按照亂序建立檔案,我不知道bash shell如何實現，我先透過oracle的sql語句建立亂序數字輸出。
set pagesize 0
spool aa.txt
select lpad(level,6,'0') from dual connect by level <=3e5 order by dbms_random.value;
spool off
--//注意設定set pagesize 0，不然中間出現多次頁頭。注意保持aa.txt的備份，測試要重複多次。

--//適當編輯整理aa.txt檔案，刪除開頭結尾的內容。
$ head -3 aa.txt ;tail -3 aa.txt
140937
240905
270377
146231
222876
100875

$ time for i in $(cat aa.txt ); do >| $i.aud; done
real    0m6.139s
user    0m1.917s
sys     0m3.602s
--//按照亂序建立檔案

$ ls -f| head
.
..
026879.aud
078531.aud
084876.aud
034744.aud
280025.aud
063529.aud
137869.aud
163787.aud
--//ls -f 按照不排序輸出ls的結果，注意這裡的輸出順序,開始忘記記錄這部分內容後面補充。

$ time perl -e 'unlink for ( <*.aud> )'
real    1m56.617s
user    0m0.582s
sys     0m7.562s

--//大約使用了2分鐘，建立同樣數量的檔案，刪除全部檔案時時間存在巨大的差異。你可以從前面的測試得到一個結論，如果按照檔案建立順序或
--//者按照檔案建立相反順序刪除，perl執行時間最短。
--//而亂序情況下perl刪除全部檔案需要的時間就很長。

$ time for i in $(cat aa.txt ); do >| $i.aud; done
real    0m6.426s
user    0m1.952s
sys     0m3.773s
--//按照亂序建立檔案

--//如果按照建立檔案順序刪除情況如何呢?
$ time sed "s/$/.aud/" aa.txt | xargs rm -f
real    0m5.848s
user    0m0.541s
sys     0m5.105s

$ time for i in $(cat aa.txt ); do >| $i.aud; done
real    0m6.142s
user    0m1.828s
sys     0m3.667s

$ sed "s/$/.aud/" aa.txt | head | xargs -IQ ls -il Q
307658760 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 140937.aud
307658761 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 240905.aud
307658762 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 270377.aud
307658763 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 193840.aud
307658764 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 246942.aud
307658765 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 293988.aud
307658766 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 108455.aud
307658767 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 191485.aud
307658768 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 139070.aud
307658769 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:43 252420.aud
--//注意看前面的inode號，從小到大遞增。

$ time sed "s/$/.aud/" aa.txt | xargs rm -f
real    0m5.756s
user    0m0.567s
sys     0m5.002s
--//做了2次測試基本都是在6秒之內完成全部刪除操作。

--//如果按照建立檔案相反順序刪除情況如何呢?
$ time for i in $(cat aa.txt ); do >| $i.aud; done
..
$ sed "s/$/.aud/" aa.txt | tail | tac |xargs -IQ ls -il Q
240129000 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 100875.aud
240128999 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 222876.aud
240128998 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 146231.aud
240128997 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 088828.aud
240128996 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 288965.aud
240128995 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 279611.aud
240128994 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 021304.aud
240128993 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 137863.aud
240128992 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 000497.aud
240128991 -rw-r--r-- 1 oracle oinstall 0 Dec  1 08:53 138707.aud
--//注意看前面的inode號，從大到小遞減。

$ time sed "s/$/.aud/" aa.txt | tac | xargs rm -f
real    0m6.924s
user    0m0.447s
sys     0m5.915s
--//到這裡應該很容易猜測只要按著inode的大小順序(反向也可以)，刪除操作很快完成，至於為什麼我不知道。

3.繼續探究：
--//按照順序建立檔案。
$ time for i in $(seq -f "%06g" 300000); do >| $i.aud; done
real    0m6.432s
user    0m2.108s
sys     0m3.730s

$ ls -f| head
.
..
026879.aud
078531.aud
084876.aud
034744.aud
280025.aud
063529.aud
137869.aud
163787.aud
--//注意這裡的輸出順序與前面亂序建立的情況ls -f的輸出完全一樣，也就是可以看出建立檔案時按照某種結構插入目錄檔案的，我估
--//計最大的可能是為了快速定位檔案在目錄的位置，具體的演演算法我不知道。

$  find /u01/testrm -name "*.aud" -type f -mtime 0 | head
/u01/testrm/026879.aud
/u01/testrm/078531.aud
/u01/testrm/084876.aud
/u01/testrm/034744.aud
/u01/testrm/280025.aud
/u01/testrm/063529.aud
/u01/testrm/137869.aud
/u01/testrm/163787.aud
/u01/testrm/111415.aud
/u01/testrm/177021.aud
--//find的輸出順序與ls -f的顯示順序一致。

4.使用strace跟蹤看看:
$ strace -T -tt -o /tmp/yy1.txt  perl -e 'unlink for ( <*.aud> )'

--//檢視跟蹤檔案內容:
...
09:32:12.880118 open(".", O_RDONLY|O_NONBLOCK|O_DIRECTORY) = 3 <0.000022>
09:32:12.880192 fcntl(3, F_SETFD, FD_CLOEXEC) = 0 <0.000016>
09:32:12.880275 getdents(3, /* 1024 entries */, 32768) = 32752 <0.000959>
--//開始讀取目錄
09:32:12.884932 lstat("026879.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000024>
09:32:12.885034 lstat("078531.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
09:32:12.885127 lstat("084876.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000018>
09:32:12.885215 lstat("034744.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
09:32:12.885308 lstat("280025.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
09:32:12.885393 lstat("063529.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
...
--//你可以發現perl delete的特點是getdents之後跟著lstat,注意看lstat裡面的檔案與前面的一樣.
--//也就是建立檔案插入目錄時,linux似乎做了某種hash或者像oracle索引結構的設計,我估計為了查詢檔名時加快尋找.
09:32:12.976026 getdents(3, /* 1024 entries */, 32768) = 32768 <0.000916>
09:32:12.980519 lstat("121204.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000024>
09:32:12.980617 lstat("006462.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000019>
09:32:12.980704 lstat("235760.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000018>
09:32:12.980791 lstat("187943.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000019>
09:32:12.980880 lstat("235116.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000019>
09:32:12.980967 lstat("077735.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000020>
09:32:12.981056 lstat("126397.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000020>
...
--//接著getdents之後跟著lstat,如此反覆.
09:32:42.003591 brk(0x421d000)          = 0x421d000 <0.000009>
09:32:42.004063 unlink("000001.aud")    = 0 <0.000100>
09:32:42.004195 unlink("000002.aud")    = 0 <0.000021>
09:32:42.004240 unlink("000003.aud")    = 0 <0.000073>
09:32:42.004354 unlink("000004.aud")    = 0 <0.000047>
09:32:42.004440 unlink("000005.aud")    = 0 <0.000051>
09:32:42.004523 unlink("000006.aud")    = 0 <0.000019>
09:32:42.004565 unlink("000007.aud")    = 0 <0.000049>
09:32:42.004656 unlink("000008.aud")    = 0 <0.000018>
09:32:42.004697 unlink("000009.aud")    = 0 <0.000036>
09:32:42.004793 unlink("000010.aud")    = 0 <0.000018>
--//最後集中做unlink操作,注意看unlink的檔案按照檔名順序排序刪除的,你可以測試反序建立檔案也是按照這個順序unlink。
--//這樣刪除檔案最快，這也是perl為什麼測試刪除檔案快的原因。只要按照檔名順序建立或者反序建立，perl刪除檔案都是最快的。
--//補充實際上按照inode的順序刪除最快(反向類似)。

--//按照相反的順序建立檔案。
$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m6.564s
user    0m2.311s
sys     0m3.634s

$ ls -f | head
.
..
026879.aud
078531.aud
084876.aud
034744.aud
280025.aud
063529.aud
137869.aud
163787.aud

$ find /u01/testrm -name "*.aud" -type f -mtime 0 | head
/u01/testrm/026879.aud
/u01/testrm/078531.aud
/u01/testrm/084876.aud
/u01/testrm/034744.aud
/u01/testrm/280025.aud
/u01/testrm/063529.aud
/u01/testrm/137869.aud
/u01/testrm/163787.aud
/u01/testrm/111415.aud
/u01/testrm/177021.aud
--//與前面測試亂序建立的輸出順序一致。

--//採用find方式刪除。
$ strace -T -tt -o  /tmp/yy2.txt find /u01/testrm -name "*.aud" -type f -mtime 0 -delete

--//檢視跟蹤檔案內容:
...
09:44:09.125396 lstat("testrm", {st_mode=S_IFDIR|0755, st_size=15110144, ...}) = 0 <0.000016>
09:44:09.125482 open("testrm", O_RDONLY|O_NONBLOCK|O_DIRECTORY) = 4 <0.000017>
09:44:09.125547 fcntl(4, F_SETFD, FD_CLOEXEC) = 0 <0.000014>
09:44:09.125614 getdents(4, /* 1024 entries */, 32768) = 32752 <0.000937>
09:44:09.130441 getdents(4, /* 1024 entries */, 32768) = 32768 <0.000912>
09:44:09.135179 getdents(4, /* 1024 entries */, 32768) = 32768 <0.000890>
09:44:09.139739 brk(0xfa2000)           = 0xfa2000 <0.000021>
09:44:09.140032 getdents(4, /* 1024 entries */, 32768) = 32768 <0.000907>
09:44:09.144713 getdents(4, /* 1024 entries */, 32768) = 32768 <0.000907>
09:44:09.149302 mmap(NULL, 135168, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fdbe36c5000 <0.000025>

--//開始讀取目錄，find -delete 的特點是集中讀取目錄。
..
09:44:10.468072 open("testrm", O_RDONLY|O_NOFOLLOW) = 4 <0.000028>
09:44:10.468156 fchdir(4)               = 0 <0.000019>
09:44:10.468220 close(4)                = 0 <0.000016>
09:44:10.468282 stat(".", {st_mode=S_IFDIR|0755, st_size=15110144, ...}) = 0 <0.000023>
09:44:10.468404 lstat("026879.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000021>
09:44:10.468501 unlink("026879.aud")    = 0 <0.000078>
09:44:10.468631 lstat("078531.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
09:44:10.468715 unlink("078531.aud")    = 0 <0.000043>
09:44:10.468807 lstat("084876.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000018>
09:44:10.468892 unlink("084876.aud")    = 0 <0.000036>
09:44:10.468979 lstat("034744.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000019>
09:44:10.469063 unlink("034744.aud")    = 0 <0.000038>
09:44:10.469152 lstat("280025.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000017>
09:44:10.469235 unlink("280025.aud")    = 0 <0.000041>
09:44:10.469327 lstat("063529.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000019>
...

--//你可以發現find -delete的特點是lstat,然後unlink,交替執行,並且刪除時按照ls -f輸出順序刪除的。這也是測試時為什麼find 刪
--//除很慢的原因。

5.如何加快find的刪除操作，如果我find輸出後按照建立順序排序，就可以加快刪除操作。

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m7.151s
user    0m2.273s
sys     0m4.279s

$ time find /u01/testrm -name "*.aud" -type f -mtime 0 -delete
real    0m25.613s
user    0m0.235s
sys     0m5.051s

$ time for i in $(seq -f "%06g" 300000 ); do >| $i.aud; done
real    0m7.855s
user    0m2.393s
sys     0m4.845s

$ time find /u01/testrm -name "*.aud" -type f -mtime 0 -delete
real    0m37.125s
user    0m0.234s
sys     0m4.978s
--//正反順序find刪除差距還是很大的。但是比前面亂序建立時的perl刪除要快(當時測試1m56.617s),不能簡單的得出perl刪除要快的結
--//論.

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m3.978s
user    0m1.985s
sys     0m1.688s

$  time find /u01/testrm -name "*.aud" -type f -mtime 0 | sort | xargs rm -f
real    0m9.582s
user    0m2.634s
sys     0m6.518s

$ time for i in $(seq -f "%06g" 300000 ); do >| $i.aud; done
real    0m7.166s
user    0m2.191s
sys     0m4.324s

$ time find /u01/testrm -name "*.aud" -type f -mtime 0 | sort | xargs rm -f
real    0m9.381s
user    0m2.599s
sys     0m6.443s
--//我僅僅排序後做刪除就可以提到3-4倍的執行效率。

$ time for i in $(seq -f "%06g" 300000 ); do >| $i.aud; done
real    0m7.157s
user    0m2.267s
sys     0m4.277s

$ time find /u01/testrm -name "*.aud" -type f -mtime 0 | sort -r | xargs rm -f
real    0m10.542s
user    0m2.696s
sys     0m7.458s
--//正反順序find刪除時間基本接近,包括sort -r 反向排序.

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m6.505s
user    0m2.177s
sys     0m3.732s

$ ls -1| head
000001.aud
000002.aud
000003.aud
000004.aud
000005.aud
000006.aud
000007.aud
000008.aud
000009.aud
000010.aud
--//ls -1輸出是按照檔名排序。注意:不能加入*.aud，否者報錯。
$ ls -1 *.aud
-bash: /bin/ls: Argument list too long

$ time  ls -1 | xargs rm -f
real    0m7.600s
user    0m1.078s
sys     0m6.059s

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m6.357s
user    0m2.075s
sys     0m3.655s

$ ls -1r | head
300000.aud
299999.aud
299998.aud
299997.aud
299996.aud
299995.aud
299994.aud
299993.aud
299992.aud
299991.aud
--//ls -1r輸出是按照檔名反序輸出。

$ time ls -1r |xargs rm -f
real    0m7.071s
user    0m1.087s
sys     0m5.507s
--//兩者刪除檔案的時間基本差不多。實際上find+sort操作需要2秒多一點，ls -1或者ls -1r少了這步，快一點點在這裡。
$ time find /u01/testrm -name "*.aud" -type f -mtime 0 | sort > /dev/null
real    0m2.820s
user    0m2.318s
sys     0m0.515s

6.好了前面的測試已經很好的說明問題，只要按照檔案建立的順序正反序刪除就可以很快完成刪除操作,補充按照inode順序也更準確一些。
--//回到oracle審計檔案刪除上來：
$ ls -f | head
.
..
orcl_ora_49229_20231117104957354906290008.aud
orcl_ora_49262_20231117104958479874669278.aud
orcl_ora_49599_20231117105130899183697083.aud
orcl_ora_52344_20231117105835514553538354.aud
orcl_ora_52379_20231117105836626306454092.aud
orcl_m002_6305_20231117110051062094812410.aud
orcl_ora_55493_20231117110714334874822725.aud
orcl_ora_55528_20231117110715482289829155.aud

--//oracle現在審計檔案格式 例項名_ora_程式號_時間戳.aud.(秒後面有12位數字,有這麼高的精度嗎).
--//只要find輸出時按照檔名的時間戳排序，在一定程度就可以加快刪除操作。

$ find /u01/app/oracle/admin/orcl/adump -name "*.aud" -type f -mtime +42 | sort -t_ -k4 | head | xargs -IQ ls -i1 Q
154733506 /u01/app/oracle/admin/orcl/adump/orcl_m002_103732_20231017110035359232720142.aud
154733529 /u01/app/oracle/admin/orcl/adump/orcl_m004_110675_20231017120043480619698786.aud
154735804 /u01/app/oracle/admin/orcl/adump/orcl_ora_224151_20231017153647587216377199.aud
154735805 /u01/app/oracle/admin/orcl/adump/orcl_ora_224186_20231017153648713247889013.aud
154735806 /u01/app/oracle/admin/orcl/adump/orcl_ora_227253_20231017154511435652647386.aud
154735807 /u01/app/oracle/admin/orcl/adump/orcl_ora_227287_20231017154512551234098090.aud
154735810 /u01/app/oracle/admin/orcl/adump/orcl_ora_230283_20231017155335462649619544.aud
154735811 /u01/app/oracle/admin/orcl/adump/orcl_ora_230316_20231017155336584898000692.aud
154735812 /u01/app/oracle/admin/orcl/adump/orcl_ora_233425_20231017160201781015769289.aud
154735813 /u01/app/oracle/admin/orcl/adump/orcl_ora_233459_20231017160202911201216180.aud

$ find /u01/app/oracle/admin/orcl/adump -name "*.aud" -type f -mtime +42 | sort -t_ -k4 | tail | xargs -IQ ls -i1 Q
103842512 /u01/app/oracle/admin/orcl/adump/orcl_ora_77343_20231019084123230771453574.aud
103842515 /u01/app/oracle/admin/orcl/adump/orcl_ora_80356_20231019084948508678940025.aud
103860237 /u01/app/oracle/admin/orcl/adump/orcl_ora_80423_20231019084949696624114445.aud
103860242 /u01/app/oracle/admin/orcl/adump/orcl_ora_81719_20231019085609240478764069.aud
103860249 /u01/app/oracle/admin/orcl/adump/orcl_ora_83411_20231019085812371480121491.aud
103860250 /u01/app/oracle/admin/orcl/adump/orcl_ora_83476_20231019085813512882039706.aud
103860258 /u01/app/oracle/admin/orcl/adump/orcl_ora_84880_20231019090438453718991051.aud
103860259 /u01/app/oracle/admin/orcl/adump/orcl_ora_84918_20231019090442867110453317.aud
103860260 /u01/app/oracle/admin/orcl/adump/orcl_ora_86557_20231019090636659035246312.aud
103860273 /u01/app/oracle/admin/orcl/adump/orcl_ora_86593_20231019090637789105421979.aud
--//注意看inode的順序，注意看tail的輸出inode比head的輸出要小，但是從區域性講還是按照順序的。

$ find /u01/app/oracle/admin/orcl/adump -name "*.aud" -type f -mtime +42 | sort -t_ -k4 |  xargs -IQ ls -i1 Q | less
...
154761643 /u01/app/oracle/admin/orcl/adump/orcl_ora_198568_20231018022435344923865006.aud
154761644 /u01/app/oracle/admin/orcl/adump/orcl_ora_198602_20231018022436473357263289.aud
--//這裡出現不按照inode順序排列輸出的情況，inode滿了嗎。
70734765 /u01/app/oracle/admin/orcl/adump/orcl_ora_199728_20231018023001996661466789.aud
79132241 /u01/app/oracle/admin/orcl/adump/orcl_ora_199730_20231018023002033991270613.aud
...

--//具體刪除操作不做了，現在看不出來區別。

7.一些補充說明：
--//我也嘗試使用perl方式刪除，因為我不能全部刪除，必須保留一定的時間。我測試並不是很好，放棄。
--//連結 ，提到
--//方式是錯誤的。
/bin/perl -e 'unlink ( <`find ${DIRECTORY} -name "*.${FILETYPE}" -type f -mtime +${DELETE_OLDER_THAN}`> ) or die "Nothing deleted\n" ' >> ${REMOVAL_LOGFILE} 2>&1  
--//它無法實現部分刪除,而是全部刪除!!

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m6.980s
user    0m2.307s
sys     0m4.117s

$ time perl -e 'my $a=`find /u01/testrm -name "*.aud" -type f -mtime 0|sort`;unlink for ( < $a > );'
--//注意在<與$a存在空格，不然操作錯誤！！

$ strace -f -T -tt -p 24601
Process 24601 attached - interrupt to quit
10:30:49.512438 brk(0x3916000)          = 0x3916000 <0.000082>
10:30:51.472135 brk(0x3937000)          = 0x3937000 <0.000043>
10:30:53.312033 brk(0x3958000)          = 0x3958000 <0.000048>
10:30:55.124076 brk(0x3979000)          = 0x3979000 <0.000040>
10:30:56.923482 brk(0x399a000)          = 0x399a000 <0.000063>
10:30:58.678359 brk(0x39bb000)          = 0x39bb000 <0.000073>
10:31:00.303104 brk(0x39dc000)          = 0x39dc000 <0.000039>
10:31:01.920933 brk(0x39fd000)          = 0x39fd000 <0.000059>
10:31:03.492740 brk(0x3a1e000)          = 0x3a1e000 <0.000080>
--//慢主要集中在這裡。

$ time for i in $(seq -f "%06g" 300000 -1 1 ); do >| $i.aud; done
real    0m6.737s
user    0m2.190s
sys     0m3.932s

$ strace -T -tt -o /tmp/yy3.txt perl -e 'my @a=`find /u01/testrm -name "*.aud" -type f -mtime 0| sort`;  unlink for ( < @a > );'
--//看出跟蹤檔案：
10:33:37.801543 ioctl(3, SNDCTL_TMR_TIMEBASE or TCGETS, 0x7fffd30f53e0) = -1 EINVAL (Invalid argument) <0.000017>
10:33:37.801622 lseek(3, 0, SEEK_CUR)   = -1 ESPIPE (Illegal seek) <0.000017>
10:33:37.801795 read(3, "/u01/testrm/000001.aud\n/u01/test"..., 4096) = 4096 <2.881576>
10:33:40.683590 read(3, "01/testrm/000179.aud\n/u01/testrm"..., 4096) = 4096 <0.000018>
10:33:40.683772 read(3, "/testrm/000357.aud\n/u01/testrm/0"..., 4096) = 4096 <0.000029>
10:33:40.683898 brk(0x1d09000)          = 0x1d09000 <0.000025>
10:33:40.684020 read(3, "estrm/000535.aud\n/u01/testrm/000"..., 4096) = 4096 <0.000031>
10:33:40.684174 read(3, "trm/000713.aud\n/u01/testrm/00071"..., 4096) = 4096 <0.000029>
10:33:40.684377 read(3, "m/000891.aud\n/u01/testrm/000892."..., 4096) = 4096 <0.000028>
10:33:40.684554 read(3, "001069.aud\n/u01/testrm/001070.au"..., 4096) = 4096 <0.000031>
10:33:40.684714 read(3, "1247.aud\n/u01/testrm/001248.aud\n"..., 4096) = 4096 <0.000032>
10:33:40.684780 brk(0x1d2a000)          = 0x1d2a000 <0.000007>
10:33:40.684827 brk(0x1d29000)          = 0x1d29000 <0.000041>
...
10:33:41.313614 close(3)                = 0 <0.000019>
10:33:41.313722 mmap(NULL, 7200768, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f696b1c2000 <0.000013>
10:33:41.317007 mmap(NULL, 7200768, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7f696aae4000 <0.000023>
10:33:41.321387 munmap(0x7f696aae4000, 7200768) = 0 <0.000238>
10:33:41.321670 brk(0x5238000)          = 0x5238000 <0.000020>
10:33:59.424916 brk(0x525e000)          = 0x525e000 <0.000030>
10:34:50.227654 brk(0x52de000)          = 0x52de000 <0.000031>
10:37:27.603509 brk(0x54de000)          = 0x54de000 <0.000047>
--//慢主要集中在這裡。
10:39:07.427004 brk(0x54ff000)          = 0x54ff000 <0.000036>
10:39:07.427416 brk(0x5520000)          = 0x5520000 <0.000009>
10:39:07.427662 brk(0x5541000)          = 0x5541000 <0.000008>
10:39:07.428084 brk(0x5562000)          = 0x5562000 <0.000028>
10:39:07.428407 brk(0x5583000)          = 0x5583000 <0.000008>
10:39:07.428655 brk(0x55a4000)          = 0x55a4000 <0.000008>
....
10:39:07.530670 brk(0x727b000)          = 0x727b000 <0.000008>
10:39:07.555615 lstat("/u01/testrm/000001.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000052>
10:39:07.564012 lstat("/u01/testrm/000002.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000034>
10:39:07.564763 lstat("/u01/testrm/000003.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000026>
10:39:07.565247 lstat("/u01/testrm/000004.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000010>
10:39:07.565770 lstat("/u01/testrm/000005.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000029>
10:39:07.566261 lstat("/u01/testrm/000006.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000042>
10:39:07.566798 lstat("/u01/testrm/000007.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000027>
10:39:07.567336 lstat("/u01/testrm/000008.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000026>
10:39:07.567874 lstat("/u01/testrm/000009.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000027>
10:39:07.568420 lstat("/u01/testrm/000010.aud", {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000011>
...
10:39:36.885909 brk(0x74cc000)          = 0x74cc000 <0.000022>
10:39:37.013522 unlink("/u01/testrm/000001.aud") = 0 <0.000114>
10:39:37.013781 unlink("/u01/testrm/000002.aud") = 0 <0.000045>
10:39:37.013880 unlink("/u01/testrm/000003.aud") = 0 <0.000046>
10:39:37.013976 unlink("/u01/testrm/000004.aud") = 0 <0.000045>
10:39:37.014070 unlink("/u01/testrm/000005.aud") = 0 <0.000048>
10:39:37.014168 unlink("/u01/testrm/000006.aud") = 0 <0.000042>
10:39:37.014260 unlink("/u01/testrm/000007.aud") = 0 <0.000079>
10:39:37.014388 unlink("/u01/testrm/000008.aud") = 0 <0.000045>
10:39:37.014483 unlink("/u01/testrm/000009.aud") = 0 <0.000046>
10:39:37.014578 unlink("/u01/testrm/000010.aud") = 0 <0.000042>
...
10:40:11.124497 unlink("/u01/testrm/299996.aud") = 0 <0.000045>
10:40:11.124603 unlink("/u01/testrm/299997.aud") = 0 <0.000047>
10:40:11.124711 unlink("/u01/testrm/299998.aud") = 0 <0.000047>
10:40:11.124820 unlink("/u01/testrm/299999.aud") = 0 <0.000046>
10:40:11.124927 unlink("/u01/testrm/300000.aud") = 0 <0.000046>
10:40:11.258188 munmap(0x7f696bf7e000, 7200768) = 0 <0.000701>
10:40:11.259021 munmap(0x7f696c65c000, 7200768) = 0 <0.000654>
10:40:11.259749 munmap(0x7f696cd3a000, 2400256) = 0 <0.000360>
10:40:11.260285 exit_group(0)           = ?

8.總結:
--//如果你測試簡單得到使用perl最快,那就犯了經驗主義的錯誤,沒有認真測試與分析,沒有找到問題的本質.
--//最快的方式是按照檔案建立的順序刪除或者反序刪除操作效率最好,不在於使用perl還是其他命令.
--//更準確講按照inode的順序(不管正序還是反序),做刪除操作效率最高。