Oracle Data File I/O Test
If an Oracle datafile is able to process I/O requests to it quickly, it is a sign of the good health of the Oracle database server. On the other hand, any slowdown in IOPS could indicate a serious processing bottleneck on the server, probably caused by a poor indexing engine or badly structured tables in a datafile. Administrators should hence continuously track the I/O requests to every datafile on the Oracle database server, identify the type of requests received – i.e., whether single block or multi-block I/O requests - and measure the time taken by that datafile to process each type of request. For this purpose, you can run the Oracle Data File I/O test.
This test auto-discovers the datafiles on the Oracle database server and reports the time taken by each datafile to process single block and multiblock I/O requests. In the process, I/O processing bottlenecks can be detected and the datafiles affected can be identified.
Target of the test : An Oracle 12c server
Agent deploying the test : An internal agent
Outputs of the test : One set of results for every datafile on the Oracle server.
|
Measurement | Description | Measurement Unit | Interpretation |
---|---|---|---|
Multiblock read time: |
Indicates the time taken by this datafile to service multiblock I/O requests during the last measurement period. |
Secs/Read |
Multiblock I/O read means reading multiple database blocks with a single operating system READ call. Typically, a database block is 8 KB. A single block read call results in one of these 8 KB blocks read from the datafile. Where a lot of data is to be read, it would be less efficient and more resource-intensive to read single blocks of data of 8KB each when the underlying I/O system is capable of reading say, 1 MB in one read. Oracle therefore issues a multiblock I/O and requests 1MB worth of block (128 8kb blocks) in one system READ call rather than 128 individual requests and therefore speeds up performance of the I/O requests. A very high value of this measure could indicate a bottleneck when processing multiblock read requests to a particular datafile. Compare the value of this measure across files to accurately identify that datafile from which multiple blocks of data were read from most slowly. In the event of high latency when processing read requests, you can do one/more of the following to clear the processing bottleneck:
|
Singleblock read time: |
Indicates the time taken for singleblock reads from this datafile during the last measurement period. |
Secs/read |
Typically, a database block is 8 KB. A single block read call results in one of these 8 KB blocks read from the datafile. Where a lot of data is to be read, it would be less efficient and more resource-intensive to read single blocks of data of 8KB each when the underlying I/O system is capable of reading say, 1 MB in one read. A very high value of this measure could indicate a bottleneck when processing single block write requests to a particular datafile. Compare the value of this measure across files to accurately identify that datafile from which a single block of data was read most slowly. |
Multiblock write time: |
Indicates the time taken for multiblock writes into this datafile during the last measurement period. |
Secs/write |
Multiblock I/O write means writing multiple database blocks to a datafile with a single operating system WRITE call. A very high value of this measure could indicate a bottleneck when processing multiblock write requests to a particular datafile. Compare the value of this measure across files to accurately identify that datafile to which multiple blocks of data were written most slowly. If the write latency is very high, you can do one/more of the following to clear the processing bottleneck:
|
Singleblock write time: |
Indicates the time taken for singleblock writes to this datafile during the last measurement period. |
Secs/write |
In case of a singleblock write, a write call results in a single 8KB block being written into the datafile. If a lot of data is to be written to a datafile, single block writes can significantly increase I/O processing overheads and related resource costs. A very high value of this measure could indicate a bottleneck when processing single block write requests to a particular datafile. Compare the value of this measure across files to accurately identify that datafile to which a single block of data was written most slowly. |
Sync read latency: |
Indicates the average latency for singleblock synchronous reads for single request since last test cycle on each datafile. |
Msecs/request |
If there is a high latency for critical data files, you may want to consider relocating these files to improve their service time. |
IO time since last measure: |
Indicates the time taken by IOPS on this datafile during the last measurement period. |
Secs |
A high value could indicate a processing bottleneck with the datafile. Compare the value of this measure across datafiles to identify that datafile to which the read/write requests take too long to be serviced. |