diff --git a/.wordlist.txt b/.wordlist.txt index a1ac65ff8..8242e258c 100644 --- a/.wordlist.txt +++ b/.wordlist.txt @@ -1598,4 +1598,20 @@ pmuserenr MPU Uma Ramalingam - +topdown +eksctl +sLO +Wl +lpapi +rpath +alibaba +pmu +PJDOC +SDP +Lookaside +TLB +DynamoRIO +drcachesim +dynamorio +mispredicted +lookaside diff --git a/content/install-guides/acfl.md b/content/install-guides/acfl.md index 9d8265339..e5b14811e 100644 --- a/content/install-guides/acfl.md +++ b/content/install-guides/acfl.md @@ -11,7 +11,7 @@ layout: installtoolsall minutes_to_complete: 15 multi_install: false multitool_install_part: false -official_docs: https://developer.arm.com/documentation/102621 +official_docs: https://developer.arm.com/documentation/101458/latest test_images: - ubuntu:latest - fedora:latest @@ -52,14 +52,20 @@ If you see a different result, you are not using an Arm computer running 64-bit ## Install pre-requisites -If any of the following are not already installed by your Linux distribution, you must install them before installing Arm Compiler for Linux: +If any of the following tools are not already installed by your Linux +distribution, you must install them before installing Arm Compiler for Linux. +These packages can be installed with the appropriate package manager for your OS: -* Python (version 2.7 or later) -* C Libraries: - - SUSE and RHEL - - `glibc-devel` - - Ubuntu - - `libc6-dev` + - SLES: awk environment-modules glibc-devel gzip python3 tar + - RHEL: environment-modules glibc-devel procps python3 + - Amazon Linux: environment-modules glibc-devel gzip procps python3 tar + - Ubuntu: environment-modules libc6-dev python3 + +Note: The minimum supported version for Python is version 3.6. + +You must have at least 2 GB of free hard disk space to both download and unpack +the Arm Compiler for Linux package. You must also have an additional 6 GB of +free space to install the package. For example: ```command @@ -85,16 +91,16 @@ Fetch the `ACfL` installers: #### Ubuntu Linux: ```bash { target="ubuntu:latest" } -wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-compiler-for-linux/23-04-1/arm-compiler-for-linux_23.04.1_Ubuntu-22.04_aarch64.tar +wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-compiler-for-linux/23-04-1/arm-compiler-for-linux_23.10_Ubuntu-22.04_aarch64.tar ``` #### Red Hat Linux: ```bash { target="fedora:latest" } -wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-compiler-for-linux/23-04-1/arm-compiler-for-linux_23.04.1_RHEL-8_aarch64.tar +wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-compiler-for-linux/23-04-1/arm-compiler-for-linux_23.10_RHEL-8_aarch64.tar ``` ### Install -To install the `Arm Compiler for Linux` package on your 64-bit Linux Arm machine extract the package and run the installation script. +To install the `Arm Compiler for Linux` package on your 64-bit Linux Arm machine extract the package and run the installation script. Each command sequence includes accepting the license agreement to automate the installation and installing the `modules` software. @@ -102,25 +108,25 @@ Each command sequence includes accepting the license agreement to automate the i ```bash { target="ubuntu:latest", env="DEBIAN_FRONTEND=noninteractive" } sudo -E apt-get -y install environment-modules python3 libc6-dev -tar -xvf arm-compiler-for-linux_23.04.1_Ubuntu-22.04_aarch64.tar -cd ./arm-compiler-for-linux_23.04.1_Ubuntu-22.04 -sudo ./arm-compiler-for-linux_23.04.1_Ubuntu-22.04.sh --accept +tar -xvf arm-compiler-for-linux_23.10_Ubuntu-22.04_aarch64.tar +cd ./arm-compiler-for-linux_23.10_Ubuntu-22.04 +sudo ./arm-compiler-for-linux_23.10_Ubuntu-22.04.sh --accept ``` #### Red Hat Linux: ```bash { target="fedora:latest" } sudo yum -y install environment-modules python3 glibc-devel -tar -xvf arm-compiler-for-linux_23.04.1_RHEL-8_aarch64.tar -cd arm-compiler-for-linux_23.04.1_RHEL-8 -sudo ./arm-compiler-for-linux_23.04.1_RHEL-8.sh --accept +tar -xvf arm-compiler-for-linux_23.10_RHEL-8_aarch64.tar +cd arm-compiler-for-linux_23.10_RHEL-8 +sudo ./arm-compiler-for-linux_23.10_RHEL-8.sh --accept ``` ### Set up environment `Arm Compiler for Linux` uses environment modules to dynamically modify your user environment. Refer to the [Environment Modules documentation](https://lmod.readthedocs.io/en/latest/#id) for more information. -Set up the environment, for example, in your `.bashrc` and add module files. +Set up the environment, for example, in your `.bashrc` and add module files. #### Ubuntu Linux: @@ -147,13 +153,13 @@ module avail To configure Arm Compiler for Linux: ```bash { env_source="~/.bashrc" } -module load acfl/23.04.1 +module load acfl/23.10 ``` To configure GCC: ```bash { env_source="~/.bashrc" } -module load gnu/12.2.0 +module load gnu/12.3.0 ``` `ACfL` is now [ready to use](#armclang). @@ -197,7 +203,7 @@ spack compiler find ## Get started with Arm C/C++ compiler {#armclang} -To get started with the Arm C/C++ Compiler and compile a simple application follow the steps below. +To get started with the Arm C/C++ Compiler and compile a simple application follow the steps below. Check that the correct compiler version is being used: ```bash { env_source="~/.bashrc", pre_cmd="module load acfl/22.1" } @@ -235,7 +241,7 @@ Hello, C World! ## Get started with Arm Fortran compiler {#fortran} -To get started with the Arm Fortran Compiler and compile a simple application follow the steps below. +To get started with the Arm Fortran Compiler and compile a simple application follow the steps below. Check that the correct compiler version is being used: ```bash { env_source="~/.bashrc", pre_cmd="module load acfl/22.1" } @@ -268,4 +274,4 @@ Hello, Fortran World! ## Get started with Arm Performance Libraries {#armpl} -To get started with the [Arm Performance Libraries](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Libraries) and learn how to select the optimal library for your system, follow the [Get started with Arm Performance Libraries](https://developer.arm.com/documentation/102574) guide. +To get started with the [Arm Performance Libraries](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Libraries) and learn how to select the optimal library for your system, follow the [Get started with Arm Performance Libraries](https://developer.arm.com/documentation/101004/latest) guide. diff --git a/content/install-guides/perf.md b/content/install-guides/perf.md index 5d08f94d3..3e516e0e8 100644 --- a/content/install-guides/perf.md +++ b/content/install-guides/perf.md @@ -142,7 +142,19 @@ sudo cp tools/perf/perf /usr/local/bin ## Test Perf {#test} -Regardless of how you installed Perf, try the `perf list` command: +Regardless of how you installed Perf, run the `version` command: + +```console +perf version +``` + +The output will be similar to: + +```output +perf version 5.15.116 +``` + +You can also try the `list` command to confirm `perf` is working as expected: ```console perf list @@ -260,6 +272,18 @@ To permanently set the paranoid level, add the following line to the file `/etc/ kernel.perf_event_paranoid=2 ``` +### Additional Perf commands + +There are five common commands used in performance analysis. + +* **stat** provides performance counter statistics for the overall execution of a program + +* **record** samples the program and records the samples into a data file (perf.data by default) + +* **report** generates a report of where the samples occurred + +* **annotate** displays the annotated code showing the source and assembly code for the samples + ### Arm PMU driver Arm systems use a kernel driver to expose PMU hardware counters. The driver needs to be enabled in the Linux kernel in order to collect the hardware events. diff --git a/content/install-guides/topdown-tool.md b/content/install-guides/topdown-tool.md index 2a03a90a4..094e0d4f7 100644 --- a/content/install-guides/topdown-tool.md +++ b/content/install-guides/topdown-tool.md @@ -31,8 +31,6 @@ The Arm Telemetry Solution provides tools and data for performance analysis. The Arm Topdown Methodology specifies a set of metrics and steps to measure them using the Telemetry Solution. -Refer to the [Arm Neoverse V1 Performance Analysis Methodology whitepaper](https://armkeil.blob.core.windows.net/developer/Files/pdf/white-paper/neoverse-v1-core-performance-analysis.pdf) for an introduction to the Arm Topdown methodology. - The Telemetry Solution requires Linux Perf to collect metrics. The Telemetry Solution also includes data for defining PMU events, a test suite to stress CPU resources, and a tool to parse Statistical Profiling Extension (SPE) data for analysis. @@ -156,10 +154,11 @@ output options: 4. Test `topdown-tool` {{% notice Note %}} -You may need to enable user space access to the counters. +You may need to enable access to the counters. More information about the options is in the [Linux Perf install guide](/install-guides/perf/). ```console sudo sh -c "echo -1 > /proc/sys/kernel/perf_event_paranoid" +sudo sh -c "echo 0 > /proc/sys/kernel/kptr_restrict" ``` {{% /notice %}} diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/_index.md b/content/learning-paths/servers-and-cloud-computing/mongodb/_index.md index 8ad9ce019..2cfa3adbe 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/_index.md @@ -21,7 +21,7 @@ test_link: https://github.com/armflorentlebeau/arm-learning-paths/actions/runs/4 test_maintenance: true test_status: - passed -title: Learn about MongoDB on Arm servers +title: Test the performance of MongoDB on Arm servers tools_software_languages: - MongoDB - AWS diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/mongodb/_next-steps.md index fdbe4889a..c7e25a21d 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb/_next-steps.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/_next-steps.md @@ -4,7 +4,7 @@ # ================================================================================ next_step_guidance: > - You can continue learning about porting cloud applications to the Arm architecture for increased performance and cost savings. The Learning Path on HyperScan is a great next step. + You can continue learning about porting cloud applications to the Arm architecture for increased performance and cost savings. The Learning Path on Hyperscan is a great next step. # 1-3 sentence recommendation outlining how the reader can generally keep learning about these topics, and a specific explanation of why the next step is being recommended. recommended_path: "/learning-paths/servers-and-cloud-computing/vectorscan/" diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/_review.md b/content/learning-paths/servers-and-cloud-computing/mongodb/_review.md index f1eeda81f..403f7a241 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb/_review.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/_review.md @@ -6,7 +6,7 @@ # Always 3 questions. Should try to test the reader's knowledge, and reinforce the key points you want them to remember. # question: A one sentence question # answers: The correct answers (from 2-4 answer options only). Should be surrounded by quotes. - # correct_answer: An integer indicating what answer is correct (index starts from 0) + # correct_answer: An integer indicating what answer is correct (index starts from 1) # explanation: A short (1-3 sentence) explanation of why the correct answer is correct. Can add additional context if desired @@ -23,7 +23,7 @@ review: - questions: question: > - Can you test MongoDB performance by running multiple threads executing different operation types? + Can MongoDB performance be tested by running multiple threads executing different operation types? answers: - "Yes" - "No" @@ -41,7 +41,7 @@ review: - "Java" correct_answer: 4 explanation: > - You will need Java 1.8 or newer installed, which can be done with one bash command. + You will need to have Java 1.8 or newer installed, which can be done with a single bash command. diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/automate_setup_pulumi.md b/content/learning-paths/servers-and-cloud-computing/mongodb/automate_setup_pulumi.md new file mode 100644 index 000000000..342a369d3 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/automate_setup_pulumi.md @@ -0,0 +1,224 @@ +--- +# User change +title: "Automate MongoDB Performance Benchmarking Infrastructure Setup with Pulumi" + +weight: 5 # (intro is 1), 2 is first, 3 is second, etc. + +# Do not modify these elements +layout: "learningpathall" +--- + +You can automate the MongoDB performance benchmarking setup, along with the YCSB framework and the required infrastructure in AWS using Pulumi. + +[Pulumi](https://www.pulumi.com/) is a multi-language 'Infrastructure as Code' tool. Pulumi is [open source](https://github.com/pulumi/pulumi) and makes it easy to deploy cloud infrastructure. + +## Before you begin + +Install the python dependencies on your Ubuntu 22.04 machine: + +```bash +sudo apt update +sudo apt install python-is-python3 -y +sudo apt install python3-pip -y +sudo apt install python3.10-venv +``` + +## Install Pulumi + +You can install Pulumi with this [install guide](https://learn.arm.com/install-guides/pulumi/) + +Check the version of Pulumi: + +```bash +pulumi version +``` + +## Clone the Repository +The following github repo contains all the scripts required for this automation. Clone the repo on your local linux system: + +```bash +git clone https://github.com/pbk8s/pulumi-ec2.git +``` + +## Build gatord +You would also need the gatord binary for performance analysis. [gator](https://github.com/ARM-software/gator) is a target agent (daemon), part of Arm Streamline, a set of performance analysis tools. Use the following commands to build it from source. + +```bash +git clone https://github.com/ARM-software/gator.git +cd gator +sudo apt-get install ninja-build cmake gcc g++ g++-aarch64-linux-gnu zip pkg-config +./build-linux.sh +``` +Once the build is successful, you should see an output like below + +```output +Build complete. Please find gatord binaries at: + /home/ubuntu/gator/build-native-gcc-rel/gatord +``` + +Copy the gatord binary to the Pulumi working directory + +```bash +cp build-native-gcc-rel/gatord ~/pulumi-ec2/ +``` + +## Install awscli and set environment variables +Use the [awscli](https://learn.arm.com/install-guides/aws-cli/) learning path to install the awscli. + +Set the following environment variables on your local computer to connect to your AWS account +```console +export AWS_ACCESS_KEY_ID= +export AWS_SECRET_ACCESS_KEY= +export AWS_SESSION_TOKEN= +``` +Execute the following command to validate the credentials +```console +aws sts get-caller-identity +``` + +You should see an output as follows +```output +{ + "UserId": "XYXYXYXYXYXY:xyz@email.com", + "Account": "123456789", + "Arn": "arn:aws:sts::123456789:assumed-role/myrole/xyz@email.com" +} +``` + +## Setup configurations + +Navigate to 'pulumi-ec2' folder and set it as your working directory + +```bash +cd ~/pulumi-ec2 +``` + +Execute the following python script to install all dependencies + +```bash +./python-setup.sh +``` + +Open the 'Pulumi.yaml' file in your preferred editor: + +```bash +vi Pulumi.yaml +``` + +Edit the default AWS region to your preferred region: + +```yaml +name: p1-py +runtime: + name: python + options: + virtualenv: venv +description: Basic EC2 setup +template: + config: + aws:region: + description: The AWS region to deploy into + default: us-east-1 +``` + +Edit the `__main__.py` file to change the availabilty zone of your network subnet + +```python +subnet = aws.ec2.Subnet("p1-subnet", + vpc_id=vpc.id, + cidr_block="172.16.0.0/24", + availability_zone="us-east-1a", + map_public_ip_on_launch=True, + tags={ + "Name": "p1-subnet", + }) +``` + +Note: The security groups created by this script are lot less restrictive, to simplify the deployment process and to remove addtional complexities. Please modify the ingress/egress rules as per your organizations' policy. + +```python +group = aws.ec2.SecurityGroup('p1-security-grouup', + vpc_id=vpc.id, + description='Enable HTTP and SSH access', + ingress=[ + aws.ec2.SecurityGroupIngressArgs( + protocol='tcp', + from_port=80, + to_port=80, + cidr_blocks=['0.0.0.0/0'],), + aws.ec2.SecurityGroupIngressArgs( + protocol='tcp', + from_port=22, + to_port=22, + cidr_blocks=['0.0.0.0/0'],), + ], + egress=[aws.ec2.SecurityGroupEgressArgs( + from_port=0, + to_port=0, + protocol="-1", + cidr_blocks=["0.0.0.0/0"], + ipv6_cidr_blocks=["::/0"], + )] + ) +``` + +## Pulumi commands + +Log in to your local machine, a shortcut to use ~/.pulumi to store project data. + +```bash +pulumi login --local +``` + +Execute the following command to set the AWS region where you'd like to deploy the resources: + +```bash +pulumi config set aws:region us-east-1 +``` +Enter the name of the new stack you'd like to create. + +Now, deploy the Pulumi stack with the following command + +```bash +pulumi up +``` +Select the name of the stack from previous step and hit enter. You should see the following output. + +```output +Previewing update (newstack2): + Type Name Plan + + pulumi:pulumi:Stack p1-py-newstack2 create + + ├─ tls:index:PrivateKey p1-key create + + │ └─ aws:ec2:KeyPair p1-key create + + ├─ aws:ec2:Vpc p1-vpc create + + ├─ aws:ec2:Subnet p1-subnet create + + ├─ aws:ec2:InternetGateway p1-igw create + + ├─ aws:ec2:SecurityGroup p1-security-grouup create + + ├─ aws:ec2:RouteTable p1-route-table create + + ├─ aws:ec2:Instance p1-server create + + ├─ aws:ec2:RouteTableAssociation p1-rta create + + ├─ command:remote:CopyFile gatord-copy create + + ├─ command:remote:CopyFile p1-copy-script create + + └─ command:remote:Command p1-run-script create + + +Outputs: + private_key_pem: output + public_dns : output + public_ip : output + +Resources: + + 13 to create +``` +You will be prompted to update the stack. Select 'yes' to create the stack. Once successfully completed, you can ssh to the instance using the 'public_ip' or 'public_dns' property. + +Execute the following script to get the private key to SSH to the new instance +```bash +./get-key.sh +``` +For passphrase, you can just hit 'Enter' key. You should see the following message on the console +```console +You can SSH now: ssh -i p1-key.pem ubuntu@ +``` +This will generate a .pem file 'p1-key.pem' in your current working directory. Use this key to SSH to the instance created by Pulumi. +Verify that you can see all of the following components installed: mongodb, ycsb test suite, java etc. diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/benchmark_mongodb.md b/content/learning-paths/servers-and-cloud-computing/mongodb/benchmark_mongodb.md index 4321b262a..608f01171 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb/benchmark_mongodb.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/benchmark_mongodb.md @@ -15,7 +15,7 @@ To further measure the performance of MongoDB, you will run the [Yahoo Cloud Ser To run YCSB, additional software packages are required, [Apache Maven](https://maven.apache.org/), and [Python](https://www.python.org) 2.7. -Apache Maven: +Installing Apache Maven: ```bash cd ~ @@ -28,8 +28,8 @@ Apache Maven: export PATH="$M2_HOME/bin:$PATH" ``` -Python 2.7 - +Installing Python 2.7: +``` {{< tabpane code=true >}} {{< tab header="Ubuntu" >}} sudo apt-get update @@ -40,8 +40,8 @@ sudo yum check-update sudo yum install python2 {{< /tab >}} {{< /tabpane >}} - {{% notice Python Note%}} +``` For Ubuntu 22.04 the `python` package may not be found. You can install Python 2.7 using: ```console sudo apt install python2 -y @@ -56,7 +56,7 @@ sudo alternatives --set python /usr/bin/python2 ## Setup YCSB -Download the latest released YCSB zip file and uncompress +Download the latest released YCSB zip file and uncompress it. ```bash { pre_cmd="sudo apt install -y python" } mkdir ycsb && cd ycsb diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb/perf_mongodb.md b/content/learning-paths/servers-and-cloud-computing/mongodb/perf_mongodb.md index 95bf2d3c7..5c5f824c8 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb/perf_mongodb.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb/perf_mongodb.md @@ -13,7 +13,7 @@ This is an open source Java application that tests the MongoDB performance, such ## Install OpenJDK packages Install the appropriate run-time environment to be able to use the performance test tool. - +``` {{< tabpane code=true >}} {{< tab header="Ubuntu" >}} sudo apt-get install -y openjdk-18-jre @@ -22,7 +22,7 @@ sudo apt-get install -y openjdk-18-jre sudo yum install java-17-openjdk {{< /tab >}} {{< /tabpane >}} - +``` For more information see the [OpenJDK](https://openjdk.org/install/) website. ## Setup the MongoDB performance test tool @@ -33,7 +33,7 @@ On your instance running MongoDB (you may need to start a new terminal), clone t git clone https://github.com/idealo/mongodb-performance-test.git ``` -Now `cd` into project folder and execute the `jar` file +Now `cd` into the project folder and execute the `jar` file: ```bash { ret_code="1" } cd mongodb-performance-test @@ -71,7 +71,7 @@ For instructions on running any other tests or more details on the metrics repor ## View the results -During each test, statistics over the last second are printed every second in the console. Shown below is the output from the end of running Insert test +During each test, statistics over the last second are printed every second in the console. The following is the output from the end of running Insert test: ``` output -- Timers ---------------------------------------------------------------------- diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md new file mode 100644 index 000000000..bac87a331 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_index.md @@ -0,0 +1,36 @@ +--- +title: Learn the Arm Neoverse N1 performance analysis methodology + +minutes_to_complete: 60 + +who_is_this_for: This is an introductory topic for software developers who want to learn about performance analysis methodology for Linux applications running on Arm Neoverse. + +learning_objectives: + - Understand sampling and counting for performance analysis + - Learn commonly used hardware metrics + - Analyze a sample application using the Arm Telemetry Solution and Linux Perf + - Make an application code change and see improved performance + +prerequisites: + - An Arm Neoverse N1 computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. You can use a virtual machine (VM), but it may offer fewer counters and some commands might not succeed. + +author_primary: Jason Andrews + +### Tags +skilllevels: Introductory +subjects: Performance and Architecture +armips: + - Neoverse +tools_software_languages: + - perf + - Telemetry + +operatingsystems: + - Linux + +### 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/top-down-n1/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_next-steps.md new file mode 100644 index 000000000..4a3ceae14 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_next-steps.md @@ -0,0 +1,43 @@ +--- +# ================================================================================ +# Edit +# ================================================================================ + +next_step_guidance: > + To use performance counters in your source code, proceed to: +# 1-3 sentence recommendation outlining how the reader can generally keep learning about these topics, and a specific explanation of why the next step is being recommended. + +recommended_path: "/learning-paths/servers-and-cloud-computing/arm_pmu/" +# Link to the next learning path being recommended. + + +# further_reading links to references related to this path. Can be: + # Manuals for a tool / software mentioned (type: documentation) + # Blog about related topics (type: blog) + # General online references (type: website) + +further_reading: + - resource: + title: "Arm Neoverse N1: Core Performance Analysis Methodology" + link: https://armkeil.blob.core.windows.net/developer/Files/pdf/white-paper/neoverse-n1-core-performance-v2.pdf + type: documentation + - resource: + title: "Arm Neoverse N1 PMU Guide" + link: https://developer.arm.com/documentation/PJDOC-466751330-547673/r4p1/ + type: documentation + - resource: + title: "Introduction to Computer Architecture" + link: https://www.arm.com/resources/education/education-kits/computer-architecture + type: book + - resource: + title: "Computer Architecture: A Quantitative Approach" + link: https://www.amazon.com/Computer-Architecture-Quantitative-John-Hennessy/dp/012383872X + type: documentation + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ +weight: 21 # set to always be larger than the content in this path, and one more than 'review' +title: "Next Steps" # Always the same +layout: "learningpathall" # All files under learning paths have this same wrapper +--- diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/_review.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_review.md new file mode 100644 index 000000000..f37465584 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/_review.md @@ -0,0 +1,55 @@ +--- +# ================================================================================ +# Edit +# ================================================================================ + +# Always 3 questions. Should try to test the reader's knowledge, and reinforce the key points you want them to remember. + # question: A one sentence question + # answers: The correct answers (from 2-4 answer options only). Should be surrounded by quotes. + # correct_answer: An integer indicating what answer is correct (index starts from 0) + # explanation: A short (1-3 sentence) explanation of why the correct answer is correct. Can add additional context if desired + + +review: + - questions: + question: > + Lower IPC indicates a program will complete in less time. + answers: + - "True" + - "False" + correct_answer: 2 + explanation: > + Lower IPC indicates a stalled pipeline. The Neoverse N1 is capable of up to 4 instructions per cycle and higher IPC means it is retiring more instructions in each cycle. + + - questions: + question: > + High backend stall rate is a signal to look at data cache metrics and the memory system. + answers: + - "True" + - "False" + correct_answer: 1 + explanation: > + If you see a high backend stall rate you should investigate L1 data cache and unified L2 and last level caches, instruction mix, and data TLB. + + - questions: + question: > + Which tool is provided by the Arm Telemetry Solution? + answers: + - "perf" + - "topdown-tool" + - "topdown-perf" + - "strace" + correct_answer: 2 + explanation: > + Telemetry Solution provides topdown-tool. + + + + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ +title: "Review" # Always the same title +weight: 20 # Set to always be larger than the content in this path +layout: "learningpathall" # All files under learning paths have this same wrapper +--- diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md new file mode 100644 index 000000000..56acfb51c --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/analysis-1.md @@ -0,0 +1,304 @@ +--- +title: "Gather performance metrics" +weight: 4 +layout: "learningpathall" +--- + +{{% notice Note %}} +The hardware used in the white paper is the [Neoverse N1 Software Development Platform (N1SDP)](https://developer.arm.com/Tools%20and%20Software/Neoverse%20N1%20SDP). This hardware is different from Neoverse N1 servers and cloud instances so your results will be different. + +You can also run this Learning Path on single board computers with the Cortex-A76 processors and the results will be closer to those in the white paper. Example boards include the [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/), [Khadas Edge2](https://www.khadas.com/edge2), and [Orange Pi 5](http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-5.html). + +The example output provided is from the Khadas Edge2, but yours will be different with different hardware. +{{% /notice %}} + +The white paper explains the definitions of the metrics and the performance analysis results for the stride benchmark in more detail. The section below provides the collection commands and interpretation of the metrics in the same order as the white paper. + +## Workload characterization using counting + +### Cycle accounting + +##### Instructions per Cycle (IPC) + +The first metric is instructions per cycle and uses the instruction count, clock cycle count, and calculates IPC. + +To collect the IPC using `perf` run: + +```console +perf stat -e instructions,cycles ./stride +``` + +The first lines of output display the instructions, cycles and IPC: + +```output + Performance counter stats for './stride': + + 10,002,762,164 instructions:u # 0.22 insn per cycle + 45,157,063,927 cycles:u + + 20.172522129 seconds time elapsed + + 20.148369000 seconds user + 0.023335000 seconds sys +``` + +To collect IPC using `topdown-tool` run: + +```console +topdown-tool --cpu neoverse-n1 -m General ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[General] +Instructions Per Cycle 0.224 per cycle +``` + +##### Front end and back end stall rate + +The next metrics are front end and back end stall rate. + +To collect the stall information using `perf` run: + +```console + perf stat -e cycles,stalled-cycles-backend,stalled-cycles-frontend ./stride +``` + +The output will be similar to: + +```output + Performance counter stats for './stride': + + 44,847,565,198 cycles:u + 37,845,044,034 stalled-cycles-backend:u # 84.39% backend cycles idle + 706,422 stalled-cycles-frontend:u # 0.00% frontend cycles idle +``` + +To collect the stall information using `topdown-tool` run: + +```console +topdown-tool --cpu neoverse-n1 -m Cycle_Accounting ./stride +``` + +The output will be similar to: + +```output +Stage 1 (Topdown metrics) +========================= +[Cycle Accounting] +Frontend Stalled Cycles 0.00% cycles +Backend Stalled Cycles. 84.38% cycles +``` + +The metrics indicate the application is back end bound. + +According to the methodology the next step is to investigate L1 data cache and unified L2 and last level caches, instruction mix, and data TLB. + +### Data cache effectiveness + +Collect the data cache related metrics using `topdown-tool`. + +Collect Level 1 data cache metrics: + +```console +topdown-tool --cpu neoverse-n1 -m L1D_Cache_Effectiveness ./stride +``` + +The output will be similar to: + +```ouptput +Stage 2 (uarch metrics) +======================= +[L1 Data Cache Effectiveness] +L1D Cache MPKI............... 83.548 misses per 1,000 instructions +L1D Cache Miss Ratio......... 0.418 per cache access +``` + +Collect Level 2 cache metrics: + +```console +topdown-tool --cpu neoverse-n1 -m L2_Cache_Effectiveness ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[L2 Unified Cache Effectiveness] +L2 Cache MPKI................... 42.865 misses per 1,000 instructions +L2 Cache Miss Ratio............. 0.102 per cache access +``` + +Collect last level cache metrics: + +```console +topdown-tool --cpu neoverse-n1 -m LL_Cache_Effectiveness ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[Last Level Cache Effectiveness] +LL Cache Read MPKI.............. 172.029 misses per 1,000 instructions +LL Cache Read Miss Ratio........ 0.864 per cache access +LL Cache Read Hit Ratio......... 0.136 per cache access +``` + +The data cache metrics show misses in all levels of the data cache hierarchy with high last level cache reads misses. + +This suggests the workload is memory bound. + +The L2 cache is a unified cache (instructions and data), but the L1 instruction and data caches are separate. You should check the L1 instruction cache misses to understand how they contribute to the L2 and last level cache metrics, but L1 instruction cache misses are not expected because the front end stall rate is very low. + +### Instruction mix + +Collect the instruction mix metrics using `topdown-tool`. + +```console +topdown-tool --cpu neoverse-n1 -m Operation_Mix ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[Speculative Operation Mix] +Load Operations Percentage.......... 20.00% operations +Store Operations Percentage......... 0.01% operations +Integer Operations Percentage....... 59.99% operations +Advanced SIMD Operations Percentage. 0.00% operations +Floating Point Operations Percentage 0.00% operations +Branch Operations Percentage........ 20.00% operations +Crypto Operations Percentage........ 0.00% operations +``` + +The instruction mix shows 60% integer operations, 20% load operations, and 20% branches. + +This suggests that the application is memory bound and would benefit from improved caching. + +The workload is not front end bound, but it is still useful to check the branch effectiveness as the instruction mix shows 20% branches. + +### Branch prediction + +Collect the branch predictor effectiveness metrics using `topdown-tool`. + +```console +topdown-tool --cpu neoverse-n1 -m Branch_Effectiveness ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[Branch Effectiveness] +Branch MPKI............... 0.002 misses per 1,000 instructions +Branch Misprediction Ratio 0.000 per branch +``` + +As expected, mispredicted branches are very low. + +### Translation lookaside buffer (TLB) + +Collect the TLB metrics using `topdown-tool`. + +##### Instruction TLB + +```console +topdown-tool --cpu neoverse-n1 -m ITLB_Effectiveness ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[Instruction TLB Effectiveness] +ITLB MPKI...................... 0.000 misses per 1,000 instructions +L1 Instruction TLB MPKI........ 0.000 misses per 1,000 instructions +L2 Unified TLB MPKI............ 19.489 misses per 1,000 instructions +ITLB Walk Ratio................ 0.000 per TLB access +L1 Instruction TLB Miss Ratio.. 0.000 per TLB access +L2 Unified TLB Miss Ratio...... 0.890 per TLB access +``` + +##### Data TLB + +```console +topdown-tool --cpu neoverse-n1 -m DTLB_Effectiveness ./stride +``` + +The output will be similar to: + +```output +Stage 2 (uarch metrics) +======================= +[Data TLB Effectiveness] +DTLB MPKI................ 19.493 misses per 1,000 instructions +L1 Data TLB MPKI......... 21.886 misses per 1,000 instructions +L2 Unified TLB MPKI...... 19.500 misses per 1,000 instructions +DTLB Walk Ratio.......... 0.097 per TLB access +L1 Data TLB Miss Ratio... 0.109 per TLB access +L2 Unified TLB Miss Ratio 0.891 per TLB access +``` + +Instruction TLB misses are very low as expected. Data TLB misses are higher. This suggests data-side page misses resulting in page table walks for some memory accesses. + +## Hot spot analysis using sampling + +To identify execution bottlenecks, use `perf record` to run with sampling. + +There are two ways to control the sampling rate: +- counting events: record a sample every n number of events for a given event list +- frequency: record a specified number of samples per second + +To record at a rate of 1000 samples per second run: + +```console +perf record -F 1000 ./stride +``` + +The output from `perf record` is limited. The size of the `perf.data` file and the number of samples is printed: + +```output +[ perf record: Captured and wrote 0.772 MB perf.data (20210 samples) ] +``` + +To record a sample every 100 last level cache misses run: + +```console +perf record -e ll_cache_rd -c 100 ./stride +``` + +Because the application runs in a tight loop the sampling frequency doesn't have any impact. + +To view the recorded data use `perf report`: + +```console +perf report +``` + +When the report opens, use the down arrow key to highlight the `main` function: + +![stride #center](report-1.png) + +Press return to annotate the main function. + +![annotate #center](report-2.png) + +You will see the source code of the `main` function with the percent of samples for each line of source code. + +![main #center](report-3.png) + +All the samples are on `subs` instruction which is right after the load instruction which reads the array and causes the high cache miss rate. + +The next section demonstrates an optimization to increase performance. + + diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md new file mode 100644 index 000000000..b96344712 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/application-1.md @@ -0,0 +1,122 @@ +--- +title: "Build an example application" +weight: 3 +layout: "learningpathall" +--- + +## Example application: DynamoRIO stride benchmark + +The white paper presents a micro-benchmark from the DynamoRIO project. The stride benchmark is a pointer chasing algorithm that accesses values in a 16 MB array, with the array position being determined by the pointer being chased. The pointer position is a function of a constant value set in the array before the pointer chasing function begins. + +The original source code is at https://github.com/DynamoRIO/dynamorio/blob/master/clients/drcachesim/tests/stride_benchmark.cpp + +The code below is slightly modified to increase the number of iterations so that it runs longer for performance analysis. + +1. Use a text editor to copy the code below into a text file named `stride.cpp`: + +```C++ +/* ********************************************************** + * Copyright (c) 2018-2023 Google LLC All rights reserved. + * **********************************************************/ + +/* + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * * Neither the name of Google, Inc. nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE LLC OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + */ + + +#include +#include +#include + +#define MEM_BARRIER() __asm__ __volatile__("" ::: "memory") + +int +main(int argc, const char *argv[]) +{ + // Cache line size in bytes. + const int kLineSize = 64; + // Number of cache lines skipped by the stream every iteration. + const int kStride = 7; + // Number of 1-byte elements in the array. + const size_t kArraySize = 16 * 1024 * 1024; + // Number of iterations in the main loop. + const int kIterations = 2000000000; + // The main vector/array used for emulating pointer chasing. + unsigned char *buffer = new unsigned char[kArraySize]; + memset(buffer, kStride, kArraySize); + + // Add a memory barrier so the call doesn't get optimized away or + // reordered with respect to callers. + MEM_BARRIER(); + + int position = 0; + + // Here the code will pointer chase through the array skipping forward + // kStride cache lines at a time. Since kStride is an odd number, the main + // loop will touch different cache lines as it wraps around. + for (int loop = 0; loop < kIterations; ++loop) { + #if defined(ENABLE_PREFETCH) && defined (DIST) + const int prefetch_distance = DIST * kStride * kLineSize; + __builtin_prefetch(&buffer[position + prefetch_distance], 0, 0); + #endif + + position += (buffer[position] * kLineSize); + position &= (kArraySize - 1); + } + + // Add a memory barrier so the call doesn't get optimized away or + // reordered with respect to callers. + MEM_BARRIER(); + + std::cerr << "Value = " << position << std::endl; + + return 0; +} +``` + + +2. Compile the application: + +```console +g++ -g -O3 stride.cpp -o stride +``` + +Using `-g` provides source code information later for `perf report`. + +3. Run the application: + +```console +./stride +``` + +The program runs for about 10-20 seconds, depending on your hardware, and the expected output is: + +```output +Value = 12779520 +``` + +The next section demonstrates how to collect metrics for performance analysis. \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/intro.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/intro.md new file mode 100644 index 000000000..a775f7603 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/intro.md @@ -0,0 +1,77 @@ +--- +title: "Introduction to performance analysis" +weight: 2 +layout: "learningpathall" +--- + +This Learning Path provides instructions to use the Arm Telemetry solution and Linux Perf for performance analysis on an example application presented in the [Arm Neoverse N1 Core: Performance Analysis Methodology](https://armkeil.blob.core.windows.net/developer/Files/pdf/white-paper/neoverse-n1-core-performance-v2.pdf) white paper (referred to as "white paper" for the remainder of the Learning Path). + +## Before you begin + +Follow the [Telemetry Solution install guide](/install-guides/topdown-tool/) to install the required tools on an Arm Neoverse server. The Telemetry Solution install guide includes instructions to install Python and Linux Perf. + +You will also need the GNU C++ compiler, `g++`. Refer to the [GNU Compiler install guide](/install-guides/gcc/native/) to install it. + + +## Introduction to performance analysis + +Application performance analysis involves measuring hardware and software events, understanding their meaning, and making software changes to improve performance. Performance analysis is a challenging task that may or may not yield meaningful results, but learning how to measure software performance and knowing how to identify performance issues is an important skill. + +The Linux Perf event system provides a way to collect events for performance analysis. Linux Perf is a common tool for collecting performance information, but other tools exist. + +There are two types of events, software events and hardware events. Examples of software events are context switches and page faults. Examples of hardware events are instructions executed and cache accesses. + +In addition to the two types of events, there are two ways to collect the events, counting and sampling. + +**Counting** collects the number of times an event occurs over a period of time, such as an entire program or a section of a program. Counting indicates how many times the event occurred, but does not help identify which instructions in an application are causing the events. Counting is a useful first step to characterize application performance. + +**Sampling** is used to find places for performance improvement in code. It identifies which sections of code are executing most frequently. This information is gathered by taking a "sample" and recording where the program is executing (program counter). The samples can be collected based on time passing (such as every 10 milliseconds) or triggered by hardware events occurring. By sampling the software execution it is possible to locate the areas in the code that are running most often and connect the code to the hardware events. + +## Hardware events + +Performance analysis requires an understanding of the hardware events, and how to connect them to causes of suboptimal performance. + +Arm Neoverse processors include more than 100 hardware counters, but not all are important to get started with performance analysis. + +Important event categories include: +- Cycle and instruction counting +- Branch prediction effectiveness +- Translation Lookaside Buffer (TLB) effectiveness +- Cache effectiveness +- Memory traffic +- Instruction mix + +The white paper covers these events in more detail. Each Neoverse CPU also has a complete PMU guide that documents all events. + +## Performance metrics + +To make performance analysis easier, combinations of events are used to compute frequently used metrics. For example, the L1 instruction cache miss rate is computed by dividing the L1 instruction cache refill count by the number of L1 instruction cache accesses. + +The white paper outlines the important performance metrics for the Neoverse N1 and provides the calculations. The metrics are built into the Telemetry Solution so you don't need to make the calculation or write scripts to compute the metrics. + +If the events and metrics are not familiar to you, you may want to learn more about common CPU architecture features so you are better able to connect software execution to hardware events. Additional resources are provided in the Next Steps section of this Learning Path. + +## Performance analysis methodology + +The white paper uses the hardware events and performance metrics to build a methodology you can follow to improve application performance. + +The first step is to collect instructions per clock cycle (IPC), front end stall rate, and back end stall rate. The results will determine where to go next. + +A high front end stall rate indicates cycles are being wasted due to pipeline stalls in the instruction fetch, L1 instruction cache, L1 instruction TLB, and the branch predictor. Such an application is characterized as front end bound. + +A high back end stall rate indicates cycles are wasted due to pipeline stalls. Such an application is characterized as back end bound. + +For front end bound applications look at the following metrics: + +* Instruction TLB metrics +* L1 Instruction cache metrics as well as L2 cache and last level cache metrics +* Branch predictor metrics + +For back end bound applications look at the following metrics: + +* Data TLB metrics +* Memory System related metrics +* Data cache metrics as well as L2 cache and last level cache metrics +* Instruction mix + +The following sections demonstrate the performance analysis methodology on an example application. \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/optimize-1.md b/content/learning-paths/servers-and-cloud-computing/top-down-n1/optimize-1.md new file mode 100644 index 000000000..12da3cabe --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/top-down-n1/optimize-1.md @@ -0,0 +1,69 @@ +--- +title: "Optimize the application" +weight: 5 +layout: "learningpathall" +--- + +## Performance Optimization + +You can use software prefetching to improve performance. + + +The code to enable prefetching is: + +```C++ + #if defined(ENABLE_PREFETCH) && defined (DIST) + const int prefetch_distance = DIST * kStride * kLineSize; + __builtin_prefetch(&buffer[position + prefetch_distance], 0, 0); + #endif +``` + +To enable data prefetching, recompile the application with 2 defines. You can experiment with values of `DIST` to see how performance is impacted. + +The white paper shows a graph of various values of DIST and explains how the performance saturates at a `DIST` value of 40 on the N1SDP hardware. The example below uses 100 for `DIST`. + +To compile with prefetching: + +```console +g++ -g -O3 -DENABLE_PREFETCH -DDIST=100 stride.cpp -o stride +``` + +Run the `perf` command again to count instructions and cycles. + +```console +perf stat -e instructions,cycles ./stride +``` + +The output is similar to: + +```output +Performance counter stats for './stride': + + 14,002,762,166 instructions:u # 0.63 insn per cycle + 22,106,858,662 cycles:u + + 9.895357134 seconds time elapsed + + 9.874959000 seconds user + 0.020003000 seconds sys +``` + +The time to run the original application was more than 20 seconds and with prefetching the time drops to under 10 seconds. + +The table below shows the improvements in instructions, cycles, and IPC. + +| Metrics | Baseline | Optimized | +| ----------- | ----------- |----------- | +| Instructions | 10,002,762,164 | 14,002,762,166 | +| Cycles | 45,157,063,927 | 22,106,858,662 | +| IPC | 0.22 | 0.63 | +| Runtime | 20.1 sec | 9.9 sec | + +As outlined in the white paper, the IPC nearly triples and the runtime halves. + +You can review how the other metrics change with prefetching enabled. + +{{% notice Note %}} +Neoverse N1 servers and cloud instances will not demonstrate as much performance improvement because they have higher memory bandwidth, but you will be able to see performance improvement as a result of enabling prefetching. +{{% /notice %}} + diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-1.png b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-1.png new file mode 100644 index 000000000..f663ea072 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-1.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-2.png b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-2.png new file mode 100644 index 000000000..8729bf041 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-2.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-3.png b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-3.png new file mode 100644 index 000000000..8c5ead050 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/top-down-n1/report-3.png differ diff --git a/data/stats_current_test_info.yml b/data/stats_current_test_info.yml index 292598816..ca7a4a0c3 100644 --- a/data/stats_current_test_info.yml +++ b/data/stats_current_test_info.yml @@ -1,5 +1,5 @@ summary: - content_total: 177 + content_total: 178 content_with_all_tests_passing: 32 content_with_tests_enabled: 32 sw_categories: @@ -114,7 +114,7 @@ sw_categories: tests_and_status: - ubuntu:latest: passed mongodb: - readable_title: Learn about MongoDB on Arm servers + readable_title: Test the performance of MongoDB on Arm servers tests_and_status: - mongo:latest: passed mysql_tune: diff --git a/data/stats_weekly_data.yml b/data/stats_weekly_data.yml index 572c385d4..59eae46d4 100644 --- a/data/stats_weekly_data.yml +++ b/data/stats_weekly_data.yml @@ -770,3 +770,43 @@ avg_close_time_hrs: 0 num_issues: 8 percent_closed_vs_total: 0.0 +- a_date: '2023-10-16' + content: + cross-platform: 7 + embedded-systems: 14 + install-guides: 73 + laptops-and-desktops: 9 + microcontrollers: 22 + servers-and-cloud-computing: 46 + smartphones-and-mobile: 7 + total: 178 + contributions: + external: 3 + internal: 174 + github_engagement: + num_forks: 30 + num_prs: 8 + individual_authors: + brenda-strech: 1 + christopher-seidl: 4 + daniel-gubay: 1 + elham-harirpoush: 2 + florent-lebeau: 5 + "fr\xE9d\xE9ric--lefred--descamps": 2 + gabriel-peterson: 3 + jason-andrews: 77 + julie-gaskin: 1 + julio-suarez: 5 + kasper-mecklenburg: 1 + kristof-beyls: 1 + liliya-wu: 1 + mathias-brossard: 1 + michael-hall: 3 + pareena-verma: 29 + pranay-bakre: 1 + ronan-synnott: 39 + uma-ramalingam: 1 + issues: + avg_close_time_hrs: 0 + num_issues: 8 + percent_closed_vs_total: 0.0