Motivation
When planning a new Oracle Data Guard setup, we do a lot of benchmarking beforehand. We do I/O benchmarks using Orion, or application benchmarks like SwingBench or SLOB. For network bandwith and throughput there is iPerf. But iPerf tells us only half the truth. It just measures the network. But in a Data Guard setup with synchronous redo transport there is more. The receiving site needs to write the information to disk and after successful completion acknowledge back to the sender.
Oracle provides a tool called “OraTCPTest” for that purpose which is pretty similar to iPerf but with additional capability to reflect the behaviour of Data Guard. The tool and basic instructions can be found in My Oracle Support document “Measuring Network Capacity using oratcptest (Doc ID 2064368.1)“.
Basically we start a server process at the receiving site, that optionally can write the received information to disk, and another client process at the sending site. Let’s walk through a basic example. I did this on Windows boxes, it works even there 🙂
1. Start the server process
We just need to specify the port which should be used for listening.
D:\install>java -jar oratcptest.jar -server -port=4711 OraTcpTest server started.
There is nothing more than that.
2. Start the client process
Here we need some more parameters, the target, the port and some timing stuff.
D:\install>java -jar oratcptest.jar myotherserver -port=4711 -duration=10s -interval=2s
[Requesting a test]
Message payload = 1 Mbyte
Payload content type = RANDOM
Delay between messages = NO
Number of connections = 1
Socket send buffer = (system default)
Transport mode = SYNC
Disk write = NO
Statistics interval = 2 seconds
Test duration = 10 seconds
Test frequency = NO
Network Timeout = NO
(1 Mbyte = 1024x1024 bytes)
(15:05:55) The server is ready.
Throughput Latency
(15:05:57) 101.832 Mbytes/s 9.820 ms
(15:05:59) 102.159 Mbytes/s 9.789 ms
(15:06:01) 102.169 Mbytes/s 9.788 ms
(15:06:03) 101.954 Mbytes/s 9.808 ms
(15:06:05) 101.998 Mbytes/s 9.804 ms
(15:06:05) Test finished.
Socket send buffer = 64 kbytes
Avg. throughput = 101.968 Mbytes/s
Avg. latency = 9.807 ms
And that’s it. You can see all the parameters that were used and which values these have. The output then tells us the performance details, the average throughput and latency.
Finding the truth
Assuming we are migrating an existing system, we need to know if the network can handle the amount of redo that needs to be shipped. AWR or Statspack reports tells us these numbers, but they are averages. Peaks might be masked in those reports. Using the information in V$ARCHIVED_LOG is much more accurate.
Let’s look at a timeframe during daytime workload and find the maximum redo rate.
select
thread#,
sequence#,
blocks*block_size/1024/1024 MB,
(next_time-first_time)*86400 sec,
(blocks*block_size/1024/1024)/((next_time-first_time)*86400) "MB/s"
from
v$archived_log
where
( (next_time-first_time)*86400<>0)
and
first_time between
to_date('2016/11/22 08:00:00','YYYY/MM/DD HH24:MI:SS') and
to_date('2016/11/22 16:00:00','YYYY/MM/DD HH24:MI:SS')
and
dest_id=2
order by 5;
THREAD# SEQUENCE# MB SEC MB/s
---------- ---------- ---------- ---------- ----------
1 349010 226.600586 453 .500222044
1 348976 226.943848 415 .546852645
[...]
1 349048 240.336914 56 4.29173061
1 348953 240.79248 53 4.54325435
1 349049 246.279785 47 5.23999543
1 348987 228.593262 37 6.17819626
So at peak workloads one redo file of roughly 230MB is written in 37 seconds which results in 6-7 MB/s. In the first simple example we achieved over 100MB/s, so this is easy, isn’t it? No, it isn’t. We will see in a moment. First we need to find out how large a typical redo write is. We can get these values from AWR reports or just query V$SYSTAT.
select
(select value from v$sysstat where statistic# = (select statistic# from v$statname where name = 'redo size')) /
(select value from v$sysstat where statistic# = (select statistic# from v$statname where name = 'redo writes')) "avg redo write size"
from
dual;
avg redo write size
-------------------
9399.55267
The typical redo write size is 9400 bytes in this case. Now we can start over and do the benchmark again with the propper parameters.
Real Life Benchmark
Again we start the server process, this time we specify a file which is writeable. Since the tool cannot write directly to ASM, I created an ACFS volume to get roughly the performance of my ASM disk that will host the Standby Redologs in the future environment.
D:\install>java -jar oratcptest.jar -server -port=4711 -file=d:\app\oracle\oradata\acfs\oratcptest.tmp OraTcpTest server started.
Now we can start several tests against this server process. Let’s start with asynchronous transmission without writing the information at the receiving site.
D:\install>java -jar oratcptest.jar myotherserver -port=4711 -duration=10s -interval=2s -mode=async -length=9400
[Requesting a test]
Message payload = 9400 bytes
Payload content type = RANDOM
Delay between messages = NO
Number of connections = 1
Socket send buffer = (system default)
Transport mode = ASYNC
Disk write = NO
Statistics interval = 2 seconds
Test duration = 10 seconds
Test frequency = NO
Network Timeout = NO
(1 Mbyte = 1024x1024 bytes)
(08:42:53) The server is ready.
Throughput
(08:42:55) 112.814 Mbytes/s
(08:42:57) 112.731 Mbytes/s
(08:42:59) 112.641 Mbytes/s
(08:43:01) 112.622 Mbytes/s
(08:43:03) 112.665 Mbytes/s
(08:43:03) Test finished.
Socket send buffer = 16 Mbytes
Avg. throughput = 112.642 Mbytes/s
Ok, 10MB/s more than the first test, we are transferring just 9kB per message instead of 1MB wich was the default.
Next test, again asynchronous transfer, but this time the server should write the message content to disk before replying.
D:\install>java -jar oratcptest.jar myotherserver -port=4711 -duration=10s -interval=2s -mode=async -write -length=9400
[Requesting a test]
Message payload = 9400 bytes
Payload content type = RANDOM
Delay between messages = NO
Number of connections = 1
Socket send buffer = (system default)
Transport mode = ASYNC
Disk write = YES
Statistics interval = 2 seconds
Test duration = 10 seconds
Test frequency = NO
Network Timeout = NO
(1 Mbyte = 1024x1024 bytes)
(08:42:34) The server is ready.
Throughput
(08:42:36) 25.230 Mbytes/s
(08:42:38) 26.655 Mbytes/s
(08:42:40) 27.600 Mbytes/s
(08:42:42) 27.578 Mbytes/s
(08:42:44) 27.603 Mbytes/s
(08:42:44) Test finished.
Socket send buffer = 1 Mbyte
Avg. throughput = 26.922 Mbytes/s
The throughput went down massively. Only 27MB/s are left, that is 1/4 of the previous throughput that we achieved without writing the message payload. A massive impact.
So what will happen when we do the transfer in a synchronous manner as Data Guard will do with Maximum Availability? Let’s see.
D:\install>java -jar oratcptest.jar myotherserver -port=4711 -duration=10s -interval=2s -mode=sync -write -length=9400
[Requesting a test]
Message payload = 9400 bytes
Payload content type = RANDOM
Delay between messages = NO
Number of connections = 1
Socket send buffer = (system default)
Transport mode = SYNC
Disk write = YES
Statistics interval = 2 seconds
Test duration = 10 seconds
Test frequency = NO
Network Timeout = NO
(1 Mbyte = 1024x1024 bytes)
(08:44:28) The server is ready.
Throughput Latency
(08:44:30) 15.082 Mbytes/s 0.595 ms
(08:44:32) 15.959 Mbytes/s 0.562 ms
(08:44:34) 16.402 Mbytes/s 0.547 ms
(08:44:36) 16.603 Mbytes/s 0.541 ms
(08:44:38) 16.579 Mbytes/s 0.541 ms
(08:44:38) Test finished.
Socket send buffer = 64 kbytes
Avg. throughput = 16.117 Mbytes/s
Avg. latency = 0.557 ms
Again a degradation, there are only 16MB/s left. And remember, we’ll need 7MB/s during peak load. And beside that, we get the latency which will later impact the commit performance since the sending (primary) server will wait till the redo is written and acknowledged by the receiving (standby) server.
Just for the sake of completeness, the test with synchronous transfer but without writing.
D:\install>java -jar oratcptest.jar myotherserver -port=4711 -duration=10s -interval=2s -mode=sync -length=9400
[Requesting a test]
Message payload = 9400 bytes
Payload content type = RANDOM
Delay between messages = NO
Number of connections = 1
Socket send buffer = (system default)
Transport mode = SYNC
Disk write = NO
Statistics interval = 2 seconds
Test duration = 10 seconds
Test frequency = NO
Network Timeout = NO
(1 Mbyte = 1024x1024 bytes)
(08:44:11) The server is ready.
Throughput Latency
(08:44:13) 23.547 Mbytes/s 0.381 ms
(08:44:15) 31.800 Mbytes/s 0.282 ms
(08:44:17) 33.249 Mbytes/s 0.270 ms
(08:44:19) 32.639 Mbytes/s 0.275 ms
(08:44:21) 31.627 Mbytes/s 0.284 ms
(08:44:21) Test finished.
Socket send buffer = 64 kbytes
Avg. throughput = 30.556 Mbytes/s
Avg. latency = 0.294 ms
It is somewhat faster than asnychronous transfer with writing.
Conclusion
Simple network bandwith tests are not sufficient to predict future Data Guard redo transfer performance. The OraTCPTest provides a nice opportunity to measure the throughput and get realistic values that can be used to plan and size the network. Again, here are the numbers of the different tests.
| ASYNC nowrite | ASYNC write | SYNC nowrite | SYNC write |
| 112 MB/s | 27 MB/s | 32 MB/s | 16 MB/s |
We could now try to tune that more by playing around with send and receive buffer size. But for the time being, the defaults are sufficient for my case. So I skipped that.
Marco's DBA Blog 