diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/1_setup.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/1_setup.md new file mode 100644 index 0000000000..737df21707 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/1_setup.md @@ -0,0 +1,159 @@ +--- +title: Tomcat benchmark set up +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + + +## Overview + +There are numerouse client-server and network-based workloads, and Tomcat is a typical example of such applications, which provide services via HTTP/HTTPS network requests. + +In this section, you'll set up a benchmark environment using Apache Tomcat and `wrk2` to simulate HTTP load and evaluate performance on an Arm-based bare-metal (**__`Nvidia-Grace`__**). + +## Set up the Tomcat benchmark server on **Nvidia Grace** +[Apache Tomcat](https://tomcat.apache.org/) is an open-source Java Servlet container that runs Java web applications, handles HTTP requests, and serves dynamic content. It supports technologies such as Servlet, JSP, and WebSocket. + +## Install the Java Development Kit (JDK) + +Install OpenJDK 21 on your Arm-based Ubuntu 24 bare-metal: + +```bash +sudo apt update +sudo apt install -y openjdk-21-jdk +``` + +## Install Tomcat + +Download and extract Tomcat: + +```bash +wget -c https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.9/bin/apache-tomcat-11.0.9.tar.gz +tar xzf apache-tomcat-11.0.9.tar.gz +``` +Alternatively, you can build Tomcat [from source](https://github.com/apache/tomcat). + +## Enable access to Tomcat examples + +To access the built-in examples from your local network or external IP, use a text editor to modify the `context.xml` file by updating the `RemoteAddrValve` configuration to allow all IP addresses. + +The file is at: +```bash +apache-tomcat-11.0.9/webapps/examples/META-INF/context.xml +``` + +```xml + + + + + +``` + +## Start the Tomcat server +{{% notice Note %}} +To achieve maximum performance of Tomcat, the maximum number of file descriptors that a single process can open simultaneously should be sufficiently large. +{{% /notice %}} + +Start the server: + +```bash +ulimit -n 65535 && ./apache-tomcat-11.0.9/bin/startup.sh +``` + +You should see output like: + +```output +Using CATALINA_BASE: /home/ubuntu/apache-tomcat-11.0.9 +Using CATALINA_HOME: /home/ubuntu/apache-tomcat-11.0.9 +Using CATALINA_TMPDIR: /home/ubuntu/apache-tomcat-11.0.9/temp +Using JRE_HOME: /usr +Using CLASSPATH: /home/ubuntu/apache-tomcat-11.0.9/bin/bootstrap.jar:/home/ubuntu/apache-tomcat-11.0.9/bin/tomcat-juli.jar +Using CATALINA_OPTS: +Tomcat started. +``` + +## Confirm server access + +In your browser, open: `http://${tomcat_ip}:8080/examples`. + +You should see the Tomcat welcome page and examples, as shown below: + +![Screenshot of the Tomcat homepage showing version and welcome panel alt-text#center](./_images/lp-tomcat-homepage.png "Apache Tomcat homepage") + +![Screenshot of the Tomcat examples page showing servlet and JSP demo links alt-text#center](./_images/lp-tomcat-examples.png "Apache Tomcat examples") + +{{% notice Note %}}Make sure port 8080 is open in the security group of the IP address for your Arm-based Linux machine.{{% /notice%}} + +## Set up the benchmarking client using wrk2 +[Wrk2](https://github.com/giltene/wrk2) is a high-performance HTTP benchmarking tool specialized in generating constant throughput loads and measuring latency percentiles for web services. `wrk2` is an enhanced version of `wrk` that provides accurate latency statistics under controlled request rates, ideal for performance testing of HTTP servers. + +{{% notice Note %}} +Currently `wrk2` is only supported on x86 machines. Run the benchmark client steps below on an `x86_64` server running Ubuntu 24. +{{% /notice %}} + +## Install dependencies + +Install the required packages: + +```bash +sudo apt-get update +sudo apt-get install -y build-essential libssl-dev git zlib1g-dev +``` + +## Clone and build wrk2 + +Clone the repository and compile the tool: + +```bash +sudo git clone https://github.com/giltene/wrk2.git +cd wrk2 +sudo make +``` + +Move the binary to a directory in your system’s PATH: + +```bash +sudo cp wrk /usr/local/bin +``` + +## Run the benchmark +{{% notice Note %}} +To achieve maximum performance of wrk2, the maximum number of file descriptors that a single process can open simultaneously should be sufficiently large. +{{% /notice %}} + +Use the following command to benchmark the HelloWorld servlet running on Tomcat: + +```bash +ulimit -n 65535 && wrk -c32 -t16 -R50000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` +You should see output similar to: + +```console +Running 1m test @ http://172.26.203.139:8080/examples/servlets/servlet/HelloWorldExample + 16 threads and 32 connections + Thread calibration: mean lat.: 0.986ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.984ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.999ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.994ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.983ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.989ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.991ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.993ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.985ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.990ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.987ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.990ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.984ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.991ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.978ms, rate sampling interval: 10ms + Thread calibration: mean lat.: 0.976ms, rate sampling interval: 10ms + Thread Stats Avg Stdev Max +/- Stdev + Latency 1.00ms 454.90us 5.09ms 63.98% + Req/Sec 3.31k 241.68 4.89k 63.83% + 2999817 requests in 1.00m, 1.56GB read +Requests/sec: 49997.08 +Transfer/sec: 26.57MB +``` diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/2_baseline.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/2_baseline.md new file mode 100644 index 0000000000..970ee2e10a --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/2_baseline.md @@ -0,0 +1,186 @@ +--- +title: Optimal baseline before tuning +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +{{% notice Note %}} +To achieve maximum performance, ulimit -n 65535 must be executed on both server and client! +{{% /notice %}} + +## Optimal baseline before tuning +- Baseline on Grace bare-metal (default configuration) +- Baseline on Grace bare-metal (access logging disabled) +- Baseline on Grace bare-metal (optimal thread count) + +### Baseline on Grace bare-metal (default configuration) +{{% notice Note %}} +To align with the typical deployment scenario of Tomcat, reserve 8 cores online and set all other cores offline +{{% /notice %}} + +1. You can offline the CPU cores using the below command. +```bash +for no in {8..143}; do sudo bash -c "echo 0 > /sys/devices/system/cpu/cpu${no}/online"; done +``` +2. Use the following commands to verify that cores 0-7 are online and the remaining cores are offline. +```bash +lscpu +``` +You can check the following information: +```bash +Architecture: aarch64 + CPU op-mode(s): 64-bit + Byte Order: Little Endian +CPU(s): 144 + On-line CPU(s) list: 0-7 + Off-line CPU(s) list: 8-143 +Vendor ID: ARM + Model name: Neoverse-V2 +... +``` + +3. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +4. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +tomcat_ip=10.169.226.181 +``` +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result of default configuration is: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 13.29s 3.25s 19.07s 57.79% + Req/Sec 347.59 430.94 0.97k 66.67% + 3035300 requests in 1.00m, 1.58GB read + Socket errors: connect 1280, read 0, write 0, timeout 21760 +Requests/sec: 50517.09 +Transfer/sec: 26.84MB +``` + +### Baseline on Grace bare-metal (access logging disabled) +To disable the access logging, use a text editor to modify the `server.xml` file by commenting out or removing the **`org.apache.catalina.valves.AccessLogValve`** configuration. + +The file is at: +```bash +vi ~/apache-tomcat-11.0.9/conf/server.xml +``` + +The configuratin is at the end of the file, and common out or remove it. +```xml + +``` + +1. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +2. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result of access logging disabled is: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 12.66s 3.05s 17.87s 57.47% + Req/Sec 433.69 524.91 1.18k 66.67% + 3572200 requests in 1.00m, 1.85GB read + Socket errors: connect 1280, read 0, write 0, timeout 21760 +Requests/sec: 59451.85 +Transfer/sec: 31.59MB +``` + +### Baseline on Grace bare-metal (optimal thread count) +To minimize resource contention between threads and overhead from thread context switching, the number of CPU-intensive threads in Tomcat should be aligned with the number of CPU cores. + +1. When using `wrk` to perform pressure testing on `Tomcat`: +```bash +top -H -p$(pgrep java) +``` + +You can see the below information +```bash +top - 12:12:45 up 1 day, 7:04, 5 users, load average: 7.22, 3.46, 1.75 +Threads: 79 total, 8 running, 71 sleeping, 0 stopped, 0 zombie +%Cpu(s): 3.4 us, 1.9 sy, 0.0 ni, 94.1 id, 0.0 wa, 0.0 hi, 0.5 si, 0.0 st +MiB Mem : 964975.5 total, 602205.6 free, 12189.5 used, 356708.3 buff/cache +MiB Swap: 0.0 total, 0.0 free, 0.0 used. 952786.0 avail Mem + + PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND + 53254 yinyu01 20 0 38.0g 1.4g 28288 R 96.7 0.1 2:30.70 http-nio-8080-e + 53255 yinyu01 20 0 38.0g 1.4g 28288 R 96.7 0.1 2:30.62 http-nio-8080-e + 53256 yinyu01 20 0 38.0g 1.4g 28288 R 96.7 0.1 2:30.64 http-nio-8080-e + 53258 yinyu01 20 0 38.0g 1.4g 28288 R 96.7 0.1 2:30.62 http-nio-8080-e + 53260 yinyu01 20 0 38.0g 1.4g 28288 R 96.7 0.1 2:30.69 http-nio-8080-e + 53257 yinyu01 20 0 38.0g 1.4g 28288 R 96.3 0.1 2:30.59 http-nio-8080-e + 53259 yinyu01 20 0 38.0g 1.4g 28288 R 96.3 0.1 2:30.63 http-nio-8080-e + 53309 yinyu01 20 0 38.0g 1.4g 28288 R 95.3 0.1 2:29.69 http-nio-8080-P + 53231 yinyu01 20 0 38.0g 1.4g 28288 S 0.3 0.1 0:00.10 VM Thread + 53262 yinyu01 20 0 38.0g 1.4g 28288 S 0.3 0.1 0:00.12 GC Thread#2 +``` + +It can be observed that **`http-nio-8080-e`** and **`http-nio-8080-P`** threads are CPU-intensive. +Since the __`http-nio-8080-P`__ thread is fixed at 1 in current version of Tomcat, and the current number of CPU cores is 8, the http-nio-8080-e thread count should be configured to 7. + +To configure the `http-nio-8080-e` thread count, use a text editor to modify the `context.xml` file by updating the ` + +``` + +```xml + + +``` + +2. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +3. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result of optimal thread count is: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 24.34s 9.91s 41.81s 57.77% + Req/Sec 1.22k 4.29 1.23k 71.09% + 9255672 requests in 1.00m, 4.80GB read +Requests/sec: 154479.07 +Transfer/sec: 82.06MB +``` diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/3_nic-queue.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/3_nic-queue.md new file mode 100644 index 0000000000..a2ead0e5fc --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/3_nic-queue.md @@ -0,0 +1,105 @@ +--- +title: Tuning via NIC queue count +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Tuning via NIC queue count +- Setting NIC queue count +- The result after tuning NIC queue count + +Typically, the number of transmit/receive queues for network cards in bare-metal environments is relatively large, reaching 63 on Grace. Each transmit/receive queue corresponds to one interrupt number. Before CPU cores are taken offline, there are sufficient cores to handle these interrupt numbers. However, when only 8 cores are retained, it results in a single core having to handle multiple interrupt numbers, thereby triggering more context switches. + +### Setting NIC queue count + +1. Use the following command to find the NIC name corresponding to he IP address. +```bash +ip addr +``` +It can be observed that the NIC name `enp1s0f0np0` corresponsed to the IP address `10.169.226.181`. +```bash +1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000 + link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 + inet 127.0.0.1/8 scope host lo + valid_lft forever preferred_lft forever + inet6 ::1/128 scope host noprefixroute + valid_lft forever preferred_lft forever +2: enp1s0f0np0: mtu 1500 qdisc mq state UP group default qlen 1000 + link/ether b8:e9:24:67:d5:3a brd ff:ff:ff:ff:ff:ff + inet 10.169.226.181/24 brd 10.169.226.255 scope global enp1s0f0np0 + valid_lft forever preferred_lft forever + inet6 fe80::bae9:24ff:fe67:d53a/64 scope link + valid_lft forever preferred_lft forever +``` + +2. Set the network interface name variable +```bash +net=enp1s0f0np0 +``` + +3. Use the following command to check the current transmit/receive queues of the ${net} network interface +```bash +sudo ethtool -l ${net} +``` +It can be observed that the number of transmit/receive queues for the ${net} network interface is currently 63. +```bash +Channel parameters for enp1s0f0np0: +Pre-set maximums: +RX: n/a +TX: n/a +Other: n/a +Combined: 63 +Current hardware settings: +RX: n/a +TX: n/a +Other: n/a +Combined: 63 +``` + +4. Use the following command to reset the number of transmit/receive queues for the ${net} to match the number of CPUs, which is 8. +```bash +sudo ethtool -L ${net} combined 8 +``` +5. Verify whether the settings have been successfully applied. +```bash +sudo ethtool -l ${net} +``` +It can be observed that the number of combined Rx/Tx queues has been updated to 8. +```bash +Channel parameters for enp1s0f0np0: +Pre-set maximums: +RX: n/a +TX: n/a +Other: n/a +Combined: 63 +Current hardware settings: +RX: n/a +TX: n/a +Other: n/a +Combined: 8 +``` + +### The result after tuning NIC queue count + +1. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +2. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result after NIC queue count tuned: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 21.64s 8.71s 37.22s 57.82% + Req/Sec 1.53k 5.70 1.55k 77.15% + 11562557 requests in 1.00m, 6.00GB read +Requests/sec: 192932.92 +Transfer/sec: 102.49MB +``` diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/4_local-numa1.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/4_local-numa1.md new file mode 100644 index 0000000000..f657d11456 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/4_local-numa1.md @@ -0,0 +1,97 @@ +--- +title: Tuning via local NUMA +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Tuning via local NUMA +- Setting local NUMA +- The result after tuning local NUMA + +Typically, cross-NUMA data transfers within the CPU incur higher latency than intra-NUMA transfers. Therefore, Tomcat should be deployed on the NUMA node where the network interface resides. + +### Setting local NUMA + +1. Use the following command to check that the latency for cross-NUMA transfers is greater than the latency for intra-NUMA transfers. +```bash +numactl -H +``` + +It can be observed that the cross-NUMA latency to intra-NUMA latency ratio is 10:40. +```bash +available: 2 nodes (0-1) +node 0 cpus: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 +node 0 size: 483129 MB +node 0 free: 462395 MB +node 1 cpus: 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 +node 1 size: 481845 MB +node 1 free: 472013 MB +node distances: +node 0 1 + 0: 10 40 + 1: 40 10 +``` + +2. Use the following command to check the NUMA node where the ${net} network interface resides. +```bash +cat /sys/class/net/${net}/device/numa_node +``` +It can be observed that the NUMA node where the ${net} network interface resides is 1. +```bash +1 +``` + +3. Therefore, allocate the reserved 8 cores to NUMA node 1. +```bash +for no in {72..79}; do sudo bash -c "echo 1 > /sys/devices/system/cpu/cpu${no}/online"; done +for no in {0..71} {80..143}; do sudo bash -c "echo 0 > /sys/devices/system/cpu/cpu${no}/online"; done +``` + +4. Verify whether the settings have been successfully applied. +```bash +lscpu +``` + +It can be observed that the only online CPUs are 72-79 on NUMA node 1. +```bash +Architecture: aarch64 + CPU op-mode(s): 64-bit + Byte Order: Little Endian +CPU(s): 144 + On-line CPU(s) list: 72-79 + Off-line CPU(s) list: 0-71,80-143 +Vendor ID: ARM + Model name: Neoverse-V2 +... +NUMA: + NUMA node(s): 2 + NUMA node0 CPU(s): + NUMA node1 CPU(s): 72-79 +... +``` + +### The result after tuning local NUMA + +1. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +2. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result after NUMA node tuned: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 18.72s 7.76s 33.78s 57.93% + Req/Sec 1.87k 59.38 2.08k 58.75% + 14111369 requests in 1.00m, 7.32GB read + Socket errors: connect 0, read 0, write 0, timeout 64 +Requests/sec: 235505.32 +Transfer/sec: 125.10MB +``` diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/5_iommu.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/5_iommu.md new file mode 100644 index 0000000000..7de6c80961 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/5_iommu.md @@ -0,0 +1,76 @@ +--- +title: Tuning via iommu +weight: 6 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Tuning via iommu +- Setting iommu +- The result after tuning iommu + +In cloud environments, SmartNICs are typically used to offload the IOMMU workload. On bare-metal systems, to align performance with the cloud, you should disable iommu.strict and enable iommu.passthrough. + +### Setting iommu + +1. Use the following command to verify the default IOMMU status on the bare-metal +```bash +sudo dmesg | grep iommu +``` +It can be observed that under the default configuration, iommu.strict is enabled, and iommu.passthrough is disabled. +```bash +[ 11.558455] iommu: Default domain type: Translated +[ 11.563355] iommu: DMA domain TLB invalidation policy: strict mode +``` + +2. To set IOMMU status, use a text editor to modify the `grub` file by adding or updating the `GRUB_CMDLINE_LINUX` configuration. + +```bash +sudo vi /etc/default/grub +``` +then add or update +```bash +GRUB_CMDLINE_LINUX="iommu.strict=0 iommu.passthrough=1" +``` + +3. Update GRUB and reboot to apply the settings. +```bash +sudo update-grub +sudo reboot +``` + +4. Verify whether the settings have been successfully applied. +```bash +sudo dmesg | grep iommu +``` + +It can be observed that the IOMMU is already in passthrough mode. +```bash +[ 0.000000] Kernel command line: BOOT_IMAGE=/boot/vmlinuz-6.8.0-71-generic root=UUID=a9adbbfa-892b-473d-906f-8bc0250bf544 ro iommu.strict=0 iommu.passthrough=1 +[ 11.565539] iommu: Default domain type: Passthrough (set via kernel command line) +``` + +### The result after tuning local NUMA + +1. Use the following command on the Grace bare-metal where `Tomcat` is on +```bash +~/apache-tomcat-11.0.9/bin/shutdown.sh 2>/dev/null +ulimit -n 65535 && ~/apache-tomcat-11.0.9/bin/startup.sh +``` + +2. And use the following command on the `x86_64` bare-metal where `wrk2` is on +```bash +ulimit -n 65535 && wrk -c1280 -t128 -R500000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample +``` + +The result after iommu tuned: +```bash + Thread Stats Avg Stdev Max +/- Stdev + Latency 10.52s 4.83s 22.43s 61.31% + Req/Sec 2.75k 67.27 2.97k 70.85% + 20917980 requests in 1.00m, 10.85GB read + Socket errors: connect 0, read 0, write 0, timeout 16 +Requests/sec: 349085.30 +Transfer/sec: 185.43MB +``` diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/6_summary.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/6_summary.md new file mode 100644 index 0000000000..5fecaf9bf1 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/6_summary.md @@ -0,0 +1,19 @@ +--- +title: Summary +weight: 7 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Summary +It can be observed that each step of the tuning method can bring significant performance improvements to Tomcat. **Similarly, these methods are equally applicable to other network-based workloads.** + +| Method | Requests/sec | Latency-Avg | +|:----------------|:-------------|:------------| +| default | 154479.07 | 24.34s | +| NIC-Rx/Tx-Queue | 192932.92 | 21.64s | +| NUMA-local | 235505.32 | 18.72s | +| IOMMU | 349085.30 | 10.52s | + + diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-examples.png b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-examples.png new file mode 100644 index 0000000000..2590c08f65 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-examples.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-homepage.png b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-homepage.png new file mode 100644 index 0000000000..56b23a733a Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_images/lp-tomcat-homepage.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_index.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_index.md new file mode 100644 index 0000000000..843fbcc314 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_index.md @@ -0,0 +1,54 @@ +--- +title: Tune network workloads on Arm bare-metal + +draft: true +cascade: + draft: true + +minutes_to_complete: 60 + +who_is_this_for: This is an advanced topic for engineers who want to tune the performance of network workloads on Arm Neoverse-based bare-metal. + +learning_objectives: + - Set up a benchmarking environment using Tomcat and wrk2 + - Baseline of optimal performance configuration before tuning + - Tune network workloads performance with NIC queue + - Tune network workloads performance with local NUMA + - Tune network workloads performance with iommu.strict and iommu.passthrough + +prerequisites: + - Access to an Arm-based bare-metal running Ubuntu-24 (you can use a Grace) (for Tomcat) + - Access to a x86-based bare-metal running Ubuntu-24 (you can use an any x86_64 bare-metal) (for wrk2) + - Basic familiarity with Java applications + - Basic familiarity with computer system, network communication, etc. + +author: Ying Yu, Ker Liu, Rui Chang + +### Tags +skilllevels: Advanced +subjects: Performance tuning +armips: + - Neoverse +tools_software_languages: + - Tomcat + - wrk2 + - OpenJDK-21 +operatingsystems: + - Linux + + + +further_reading: + - resource: + title: OpenJDK Wiki + link: https://wiki.openjdk.org/ + type: documentation + + + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +---