diff --git a/.wordlist.txt b/.wordlist.txt index 8242e258c..d11fe18d8 100644 --- a/.wordlist.txt +++ b/.wordlist.txt @@ -1615,3 +1615,16 @@ drcachesim dynamorio mispredicted lookaside +devel +glibc +procps +PACBTI +gatord +awscli +dns +Borycki +Dawid +rg +pds +WebApp +AllowAnyCustom \ No newline at end of file diff --git a/content/install-guides/_images/download-win-armpl.png b/content/install-guides/_images/download-win-armpl.png deleted file mode 100644 index d23718fe8..000000000 Binary files a/content/install-guides/_images/download-win-armpl.png and /dev/null differ diff --git a/content/install-guides/_images/download-win-armpl_23.10.png b/content/install-guides/_images/download-win-armpl_23.10.png new file mode 100644 index 000000000..2b7df887a Binary files /dev/null and b/content/install-guides/_images/download-win-armpl_23.10.png differ diff --git a/content/install-guides/_images/windows-sys-env.png b/content/install-guides/_images/windows-sys-env.png deleted file mode 100644 index a30ae8f71..000000000 Binary files a/content/install-guides/_images/windows-sys-env.png and /dev/null differ diff --git a/content/install-guides/_images/windows-sys-env_23.10.png b/content/install-guides/_images/windows-sys-env_23.10.png new file mode 100644 index 000000000..4153d46fb Binary files /dev/null and b/content/install-guides/_images/windows-sys-env_23.10.png differ diff --git a/content/install-guides/armpl.md b/content/install-guides/armpl.md index 1889656a4..acad35ef7 100644 --- a/content/install-guides/armpl.md +++ b/content/install-guides/armpl.md @@ -15,8 +15,7 @@ additional_search_terms: minutes_to_complete: 10 ### Link to official documentation -official_docs: https://developer.arm.com/downloads/-/arm-performance-libraries#documentation - +official_docs: https://developer.arm.com/documentation/101004/latest author_primary: Pareena Verma ### PAGE SETUP @@ -29,30 +28,37 @@ layout: installtoolsall # DO NOT MODIFY. Always true for tool install ar The [Arm Performance Libraries](https://developer.arm.com/downloads/-/arm-performance-libraries#documentation) provide developers with optimized math libraries for high performance computing applications on Arm Neoverse based hardware. -These libraries include highly optimized functions for BLAS, LAPACK, FFT, sparse linear algebra, libamath and libastring. -These libraries are free to use and do not require a license. They can be installed either standalone or with your installation of [Arm Compiler for Linux](/install-guides/acfl). This install guide covers the standalone installation. +These libraries include highly optimized functions for BLAS, LAPACK, FFT, sparse linear algebra, libamath and libastring. +These libraries are free to use and do not require a license. They can be installed either standalone or with your installation of [Arm Compiler for Linux](/install-guides/acfl). This install guide covers the standalone installation. Arm Performance Libraries are available for use on [Windows 11 on Arm](#windows), [macOS](#macos) (Apple Silicon), and [Linux](#linux) (AArch64) hosts. +Below are the official documentation references: + +- Reference Guide:  [Arm Performance Libraries Reference Guide](https://developer.arm.com/documentation/101004/latest) +- Windows:     [Get started with Arm Performance Libraries (Windows version)](https://developer.arm.com/documentation/109361/2310/?lang=en) +- MacOS:        [Get started with Arm Performance Libraries (macOS version)](https://developer.arm.com/documentation/109362/2310/?lang=en) +- Linux:         [Get started with Arm Performance Libraries (stand-alone Linux version)](https://developer.arm.com/documentation/102620/2310/?lang=en) + ## Windows {#windows} On your Windows 11 Arm machine, go to the [Arm Performance Libraries download page](https://developer.arm.com/downloads/-/arm-performance-libraries). Click on the Download Windows section. You will be prompted to review and accept the End User License Agreement before you can download the zip file. Click on the `I accept the terms of this License Agreement` checkbox and proceed to `Download` as shown below. -![win_download #center](/install-guides/_images/download-win-armpl.png) - -Open your Windows File Explorer and locate the downloaded `arm-performance-libraries_23.08.zip` file. +![win_download #center](/install-guides/_images/download-win-armpl_23.10.png) + +Open your Windows File Explorer and locate the downloaded `arm-performance-libraries_23.10.zip` file. Extract the contents of this zip file using the "Extract all" button at the top of the Windows File Explorer. ### Update your system environment variables Using Windows Search, open `Edit the System Variables` in the `Control Panel`. -On the `Advanced Tab` of the `System Properties` window, click on the `Environment Variables` button. +On the `Advanced Tab` of the `System Properties` window, click on the `Environment Variables` button. ![sys_prop #center](/install-guides/_images/windows-sys-prop.png) Add a New variable called `ARMPL_DIR` which should point to the location where you unpacked the Arm Performance Libraries. -![add_var #center](/install-guides/_images/windows-sys-env.png) +![add_var #center](/install-guides/_images/windows-sys-env_23.10.png) Edit the `Path` variable to add `%ARMPL_DIR%\bin` to the list of existing directories in your path. @@ -60,47 +66,53 @@ Edit the `Path` variable to add `%ARMPL_DIR%\bin` to the list of existing direct You can now start linking your application to the Arm Performance libraries on your Windows on Arm device. Follow the examples in the included `RELEASE_NOTES` file of your extracted installation directory to get started. +For more information refer to [Get started with Arm Performance Libraries (Windows version) +Version 23.10](https://developer.arm.com/documentation/109361/2310/?lang=en) + ## macOS {#macos} Go to the Download MacOS section of the [Arm Performance Libraries download page](https://developer.arm.com/downloads/-/arm-performance-libraries) and download the `dmg` file. Double-click on the icon of the downloaded package to mount the disk image. Alternatively, open a terminal and run the command below: ```console -hdiutil attach armpl_23.06_flang-new_clang_16.dmg +hdiutil attach arm-performance-libraries_23.10_macOS.dmg ``` Now run the installation script as a superuser: ```console -/Volumes/armpl_23.06_flang-new_clang_16_installer/armpl_23.06_flang-new_clang_16_install.sh -y +/Volumes/arm-performance-libraries_23.10_macOS/arm-performance-libraries_23.10_macOS_install.sh -y ``` Using this command you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory. If you want to change the installation directory location use the `--install_dir` option with the script and provide the desired directory location. To get started, compile and test the examples included in the `/opt/arm//examples/`, or `//examples/` directory, if you have installed to a different location than the default. +For more information refer to [Get started with Arm Performance Libraries (macOS version) +Version 23.10](https://developer.arm.com/documentation/109362/2310/?lang=en) + ## Linux {#linux} Arm Performance Libraries are supported on most Linux Distributions like Ubuntu, RHEL, SLES and Amazon Linux on an `AArch64` host and compatible with various versions of GCC. [Download](https://developer.arm.com/downloads/-/arm-performance-libraries) the appropriate package for your Linux distribution and version of GCC from the Download Linux section. -The instructions shown below are for an Ubuntu 22.04 AArch64 Linux Host with GCC version 11.3 installed. +The instructions shown below are for an Ubuntu 22.04 AArch64 Linux Host with GCC version 12.2 installed. On a terminal, run the command shown below to download the appropriate package: ```command -wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/23-04-1/ubuntu-22/arm-performance-libraries_23.04.1_Ubuntu-22.04_gcc-11.3.tar +wget https://developer.arm.com/-/media/Files/downloads/hpc/arm-performance-libraries/23-10/ubuntu-22/arm-performance-libraries_23.10_Ubuntu-22.04_gcc-12.2.tar ``` Use `tar` to extract the file and then change directory: ```command -tar -xf arm-performance-libraries_23.04.1_Ubuntu-22.04_gcc-11.3.tar -cd arm-performance-libraries_23.04.1_Ubuntu-22.04/ +tar -xf arm-performance-libraries_23.10_Ubuntu-22.04_gcc-12.2.tar +cd arm-performance-libraries_23.10_Ubuntu-22.04/ ``` Run the installation script as a super user: ```command -sudo ./arm-performance-libraries_23.04.1_Ubuntu-22.04.sh -a +sudo ./arm-performance-libraries_23.10_Ubuntu-22.04.sh -a ``` Using the `-a` switch you automatically accept the End User License Agreement and the packages are installed to the `/opt/arm` directory. If you want to change the installation directory location use the `--install-to` option with the script and provide the desired directory location. @@ -112,6 +124,12 @@ Install environment modules on your machine: sudo apt install environment-modules ``` +Set your bash environment to use modules: + +```command +source /usr/share/modules/init/bash +``` + Set the `MODULEPATH` environment variable to point to the location of the installed modulefiles for Arm Performance Libraries: ```command @@ -127,13 +145,16 @@ module avail The output should be similar to: ```output -armpl/23.04.1_gcc-11.3 +armpl/23.10.0_gcc-12.2 ``` Load the appropriate module: ```command -module load armpl/23.04.1_gcc-11.3 +module load armpl/23.10.0_gcc-12.2 ``` -You can now compile and test the examples included in the `/opt/arm//examples/`, or `//examples/` directory, if you have installed to a different location than the default. +You can now compile and test the examples included in the `/opt/arm//examples/`, or `//examples/` directory, if you have installed to a different location than the default. + +For more information refer to [Get started with Arm Performance Libraries (stand-alone Linux version) +Version 23.10](https://developer.arm.com/documentation/102620/2310/?lang=en) diff --git a/content/install-guides/wperf.md b/content/install-guides/wperf.md index 1ce727c89..1d264acef 100644 --- a/content/install-guides/wperf.md +++ b/content/install-guides/wperf.md @@ -55,12 +55,17 @@ The latest release package `windowsperf-bin-.zip` can be downloaded fro https://gitlab.com/Linaro/WindowsPerf/windowsperf/-/releases ``` To download directly from command prompt, use: + ```console -curl https://gitlab.com/api/v4/projects/40381146/packages/generic/windowsperf/2.5.1/windowsperf-bin-2.5.1.zip --output windowsperf-bin-2.5.1.zip +mkdir windowsperf-bin-3.2.0 +cd windowsperf-bin-3.2.0 +curl https://gitlab.com/api/v4/projects/40381146/packages/generic/windowsperf/3.2.0/windowsperf-bin-3.2.0.zip --output windowsperf-bin-3.2.0.zip ``` -Unzip the package to your preferred location. + +Unzip the package: + ```console -tar -xmf windowsperf-bin-2.5.1.zip +tar -xmf windowsperf-bin-3.2.0.zip ``` ## Install wperf driver @@ -75,22 +80,25 @@ Open a `Windows Command Prompt` terminal with `Run as administrator` enabled. Navigate to the `windowsperf-bin-` directory. ```command -cd windowsperf-bin-2.5.1 +cd windowsperf-bin-3.2.0 ``` ### Install with devcon {#devcon} Navigate into the `wperf-driver` folder, and use `devcon` to install the driver: + ```command cd wperf-driver devcon install wperf-driver.inf Root\WPERFDRIVER ``` You will see output similar to: + ```output Device node created. Install is complete when drivers are installed... Updating drivers for Root\WPERFDRIVER from \wperf-driver.inf. Drivers installed successfully. ``` + ### Install with wperf-devgen {#devgen} Copy the `wperf-devgen.exe` executable to the `wperf-driver` folder. @@ -122,14 +130,14 @@ Once the above driver is installed, you can use `wperf` without `Administrator` For example: ```command cd .. -wperf -version +wperf --version ``` You should see output similar to: ```output -Component Version -========= ======= -wperf 2.5.1 -wperf-driver 2.5.1 +Component Version GitVer +========= ======= ====== +wperf 3.2.0 a947eed8 +wperf-driver 3.2.0 a947eed8 ``` ## Further reading diff --git a/content/learning-paths/cross-platform/_example-learning-path/setup.md b/content/learning-paths/cross-platform/_example-learning-path/setup.md index bf78a53df..f700ef1a1 100644 --- a/content/learning-paths/cross-platform/_example-learning-path/setup.md +++ b/content/learning-paths/cross-platform/_example-learning-path/setup.md @@ -85,9 +85,12 @@ Check Hugo is installed correctly and check the version by running this command: ```bash hugo version ``` -Run hugo to launch a development version of website on your machine. + +Navigate into the `arm-learning-paths` folder and run hugo to launch a +development version of website on your machine. ```bash +cd arm-learning-paths hugo server ``` @@ -158,9 +161,11 @@ There are a number of good options for text editors if you don't have a full Lin To use Visual Studio Code in the browser on your remote Linux server check the install information for [OpenVSCode Server](/install-guides/openvscode-server/) and [VS Code Tunnels](/install-guides/vscode-tunnels/) -Run hugo to launch a development version of website on your machine. +Navigate into the `arm-learning-paths` folder and run hugo to launch a +development version of website on your machine. ```bash +cd arm-learning-paths hugo server ``` diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md index 50b2ad671..c178d5546 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/_index.md @@ -1,18 +1,17 @@ --- -title: Learn how to access hardware counters using the Performance Monitoring Unit (PMU) +title: How to use the Arm Performance Monitoring Unit and System Counter minutes_to_complete: 90 -who_is_this_for: This is an advanced topic for software developers who want to instrument hardware event counters in software applications. +who_is_this_for: This is an advanced topic for software developers who want to instrument hardware event counters or the system counter in software applications. learning_objectives: - - Understand different options for accessing event counters from user space + - Understand different options for accessing counters from user space + - Use the system counter to measure time in code - Use PAPI to instrument event counters in code - - Call the Linux perf_event_open system call to instrument event counters in code - - Write Arm assembly instructions to instrument event counters in code - + - Use the Linux perf_event_open system call to instrument event counters in code prerequisites: - - An Arm computer running Linux. A bare metal or cloud metal instance is best because they expose more counters. A virtual machine (VM) can be used, but fewer counters may be available. + - An Arm 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 fewer counters may be available. author_primary: Julio Suarez diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/access_options.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/access_options.md index 631dc9791..c8b1d905a 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/access_options.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/access_options.md @@ -1,20 +1,20 @@ --- -title: "Hardware counter access options" +title: "Counter access options" weight: 2 layout: "learningpathall" --- -In this Learning Path, the terms hardware counter and event counter are used interchangeably. +In this Learning Path, we use the terms hardware counter and event counter interchangeably. ## Hardware and software events -Software events are generated by the Linux kernel or user software. Examples of software events are context switches and page faults. Hardware events are generated by the CPU or other system hardware. Examples of hardware events are instructions executed and CPU clock cycles. The focus of this Learning Path is hardware events. +Software events are generated by the Linux kernel or user software. Examples of software events that can be measured are context switches and system calls. Hardware events are generated by the CPU or other system hardware. Examples of hardware events are instructions executed and CPU clock cycles. This Learning Path focuses on hardware events. ## Hardware events on Arm -Arm hardware events are managed by the Performance Monitoring Unit (PMU). This unit contains the system registers that configure event counting, it is also where counter results are stored. The number of hardware events that can be counted at the same time is limited. Arm CPUs typically support 4-8 counters. The number of supported hardware events can be found in the Technical Reference Manual (TRM) of each CPU. There is also a dedicated counter for CPU clock cycles which does not occupy the 4-8 event slots. Lastly, the PMU supports software increment counters which can be used to count things such as accesses to a specific data structure. +Arm hardware events are managed by the Performance Monitoring Unit (PMU). This unit contains the system registers that configure event counting, it is also where counter results are stored. The number of hardware events that can be counted at the same time is limited. Arm CPUs typically support 4-8 counters. The number of supported hardware events can be found in the Technical Reference Manual (TRM) of each CPU. There is also a dedicated counter for CPU clock cycles which does not occupy any of the 4-8 event slots. Last, the PMU supports software increment counters which can be used to count things such as accesses to a specific data structure. -If you need to count more hardware events than the available counters you can multiplex different counters over a measurement period. For example, if the CPU supports 6 counters, and you want to count 12 different events, you can swap in and out a set of 6 events over the measurement period. However, this means that the counter results will need to be extrapolated over the total measurement period due to the swapping. When multiplexing is implemented, the final scaled counter results should be taken as an estimate of the total events counted. This may be acceptable for many cases, but if your debug and analysis work is done methodically, you usually can narrow down the number of counters needed to a number that doesn't require you to multiplex. Avoiding multiplexing is preferable as it keeps the counter results more accurate. +If you need to count more hardware events than the available counters, you can multiplex different counters over a measurement period. For example, if the CPU supports 6 counters, and you want to count 12 different events, you can swap in and out a set of 6 events over the measurement period. However, this means that the counter results will need to be extrapolated over the total measurement period due to the swapping. When multiplexing is implemented, the final scaled counter results should be taken as an estimate of the total events counted. This may be acceptable for many cases, but if your debug and analysis work is done methodically, you usually can narrow down the number of counters needed to a number that doesn't require you to multiplex. Avoiding multiplexing is preferable as it keeps the counter results more accurate. ### Find the list of hardware events @@ -22,21 +22,29 @@ All available hardware events and their unique event numbers are found in the Te ### Exception levels (or execution privilege) and hardware counters -It's helpful to have a basic understanding of Arm exception levels because it impacts counter setup. The [Arm Architecture A-profile reference manual](https://developer.arm.com/documentation/ddi0487/ja/?lang=en) defines 4 exception levels. These are called EL0 (required), EL1 (required), EL2 (optional), and EL3 (optional). For Neoverse cores, all 4 levels are implemented because Neoverse based platforms usually need to support virtualization. The easiest way to think of these levels is through the lens of execution privilege. User space code executes in EL0, kernel code executes in EL1, hypervisor code executes in EL2, and firmware executes in EL3. Arm CPUs will enforce this execution privilege at the hardware level. For example, by default, EL0 (user) code, cannot access the PMU configuration registers. For EL0 access to work, EL1 (kernel) code needs to enable PMU access for EL0 (user) code. Once this happens, user programs will be allowed to configure and read counters. Most methods for PMU access take care of this for you, however, it's good to have this understanding because some methods don't take care of this and you might have to enable access yourself. +It's helpful to have a basic understanding of Arm exception levels because it impacts counter setup. The [Arm Architecture A-profile reference manual](https://developer.arm.com/documentation/ddi0487/ja/?lang=en) defines 4 exception levels. These are called EL0 (required), EL1 (required), EL2 (optional), and EL3 (optional). For Neoverse cores, all 4 levels are implemented because Neoverse based platforms usually need to support virtualization. The easiest way to think of these levels is through the lens of execution privilege. User space code executes in EL0, kernel code executes in EL1, hypervisor code executes in EL2, and firmware executes in EL3. Arm CPUs will enforce this execution privilege at the hardware level. For example, by default, EL0 (user) code, cannot access the PMU configuration registers. For EL0 access to work, EL1 (kernel) code needs to enable PMU access for EL0 (user) code. Once this happens, user programs will be allowed to configure and read counters. Most methods for PMU access take care of this for you, however, it's good to have this understanding in case you decide implement custom/assembly code for counter access. -## Linux Perf +## Before you instrument counters -Perf is capable of measuring software and hardware events. It is used for measuring events at the process or system level. If your interest is to instrument counting directly in your code, then you will need to use one of the methods discussed in this Learning Path. Depending on what you are working on, Perf can save you the need to instrument counters directly in your code. Refer to the [Perf on Arm Linux ](/install-guides/perf/) install guide to learn how to install Perf. +Before you instrument counters, you should consider using tools which do not require you to write code in order to access counters. These tools are discussed below. -## Options for accessing event counters from user space +### Linux Perf -If you decide you need add counter instrumentation to your source code, there are different ways to use the Arm PMU to read hardware counters from user space. The method you use should be determined by a combination of preference and whatever limitations you may have in your environment. +Linux Perf is part of the Linux source code (under tools/perf). It is capable of measuring software and hardware events. It is used for measuring events at the process or system level. Depending on what you are working on, Perf can save you the need to instrument counters directly in your code. Refer to the [Perf on Arm Linux ](/install-guides/perf/) install guide to learn how to install Perf. There is also a walk through on perf and its features [published by Brendan Gregg](https://www.brendangregg.com/perf.html). -### Counting time +### Arm Telemetry Solution (Topdown Tool) + +Arm publishes [Telemetry Solution](https://gitlab.arm.com/telemetry-solution/telemetry-solution) - a tool that does not require code to be written. In fact, it uses Linux perf. This tool is accompanied with a general performance analysis methodology. It allows you to separate performance bottlenecks between the front-end and the back-end of the CPU. Using this methodology, you can measure things like branch effectiveness, cache effectiveness, instruction mix, etc. This tool will continue to grow in capabilities over time. It's strongly recommended to try this tool before instrumenting your code. + +## Options for instrumenting event counters from user space + +If you decide to add counter instrumentation to your source code, various methods allow this from user space. The method you use should be determined by a combination of preference and whatever limitations you may have in your environment. + +### Counting time If all you need to do is count time, you can use a system timer instead of the PMU. This requires the least amount of code and is the quickest way to get started. -This Learning Path contains an example of using a system counter in the assembly code section. +This Learning Path contains an example of using a system counter. ### Performance Application Programming Interface (PAPI) @@ -50,16 +58,14 @@ The Linux perf_events infrastructure is another way hardware and software events This Learning Path contains a `perf_event_open` based instrumentation example. -### Arm assembly - -Hardware counters can be enabled and configured using assembly code. Counting events this way requires knowledge of the specific PMU registers that are required to enable and configure the counters of interest. This method can be useful in an environment where there is no operating system, or if there is a system limitation or bug preventing the use of tools like PAPI or the Linux perf_events infrastructure. This method requires that you implement multiplexing if you need to count more events than the available CPU counters. - -This Learning Path contains an assembly based instrumentation example. - ### eBPF The Linux kernel contains a tool called [eBPF (extended Berkeley Packet Filter)](https://docs.kernel.org/bpf/) that can be used for event counting. This tool is complex and the above methods should be considered before trying eBPF. In fact, eBPF should only be used for counting if you are already using eBPF as part of a broader performance investigation. For this reason, this Learning Path does not contain an example of how to use eBPF for event counting. -## Non-C/C++ environments +### Non-C/C++ environments + +The easiest way to instrument non-C/C++ programs is to write a C library and call it from your non-C/C++ program. For example, in Java, it is possible to use the Java Native Interface (JNI) to call C/C++ functions. There may also be tools in other environments that enable access to performance counters. Perhaps in a future revision of this learning path, non-C/C++ examples will be discussed. + +### Arm assembly -The easiest way to instrument non-C/C++ programs is to write a C library and call it from your non-C/C++ program. For example, in Java, it is possible to use the Java Native Interface (JNI) to call C/C++ functions. There may also be tools in other environments that enable access to performance counters. \ No newline at end of file +You can enable and configure hardware counters using assembly code. Counting events this way requires knowledge of the specific PMU registers that are required to enable and configure the counters of interest. This method requires that you implement multiplexing if you need to count more events than the available CPU counters. This method for counter access is not covered in this learning path because the other methods outlined in this learning path are easier. diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md index 6e0ea535d..681d4e621 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/assembly.md @@ -1,6 +1,6 @@ --- title: "Use a system counter" -weight: 5 +weight: 3 layout: "learningpathall" --- @@ -8,7 +8,7 @@ There are two Arm instructions that allow access to system registers. These are ## Using assembly for system counter access -If you only need to count time/cycles, then the [system counter](https://developer.arm.com/documentation/102379/0102/System-Counter?lang=en)] can be used. This can be done from user space. Below is an example of measuring system counter ticks across a function. +If you only need to count time/cycles, then the [system counter](https://developer.arm.com/documentation/102379/0102/System-Counter?lang=en)] can be used. You can do this from user space. An example of measuring system counter ticks across a function is shown below: Use a text editor to create a file named `syscnt.c` with the code below: @@ -62,7 +62,7 @@ Run the application: ``` console ./syscnt ``` - + The output will be similar to: ```output diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/papi.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/papi.md index 238a355f8..dae8d2acc 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/papi.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/papi.md @@ -1,18 +1,18 @@ --- title: "Use PAPI for counting" -weight: 3 +weight: 4 layout: "learningpathall" --- ## Install PAPI -Use the [Performance Application Programming Interface (PAPI) install guide](/install-guides/papi/) to install PAPI on your computer. +Use the [Performance Application Programming Interface (PAPI) install guide](/install-guides/papi/) to install PAPI on your computer. -More information is available in the [documentation](https://github.com/icl-utk-edu/papi/wiki/Downloading-and-Installing-PAPI). +You can find more information in the [documentation](https://github.com/icl-utk-edu/papi/wiki/Downloading-and-Installing-PAPI). -Set the environment variable `PAPI_DIR` to the location where PAPI is installed. +Set the environment variable `PAPI_DIR` to the location where PAPI is installed. -For example, if you installed PAPI in `/usr/local` and are using bash then execute: +For example, if you installed PAPI in `/usr/local` and are using bash then execute: ```console export PAPI_DIR=/usr/local @@ -30,7 +30,7 @@ If you don't run the above command you will need to run the `papi_example` progr ## Use PAPI to instrument counters -You can use PAPI to measure total instructions executed (INST_RETIRED: 0x08) and the load instructions executed speculatively (LD_SPEC: 0x70). +You can use PAPI to measure total instructions executed (INST_RETIRED: 0x08) and the load instructions executed speculatively (LD_SPEC: 0x70). Use a text editor to create a file named `papi_example.c` and paste the code below into the file: @@ -52,7 +52,7 @@ int main() { int retval, EventSet=PAPI_NULL; long_long values[TOT_EVENTS]; // Holds event counter results - // Initialize the PAPI library + // Initialize the PAPI library retval = PAPI_library_init(PAPI_VER_CURRENT); if (retval != PAPI_VER_CURRENT) { fprintf(stderr, "PAPI library init error!\n"); @@ -82,7 +82,7 @@ int main() { if (PAPI_stop(EventSet, values) != PAPI_OK) fprintf(stderr, "Error creating event set"); - // Read the events in the Event Set + // Read the events in the Event Set if (PAPI_read(EventSet, values) != PAPI_OK) fprintf(stderr, "Error creating event set"); @@ -95,7 +95,7 @@ int main() { At the top of the file there is a function called `code_to_measure`. This is called from `main` and is the function to analyze. -At the top of `main`, there is a PAPI library initialization (`PAPI_library_init`). Under that initialization an EventSet is created (`PAPI_create_eventset`). The Event Set is a PAPI construct that allows for the grouping of a set of hardware events that will be counted together. Once this Event Set is created, two events are added to the Event Set with a pair of calls to `PAPI_add_event`. The first call adds the PAPI preset event `PAPI_TOT_INS`. This preset event is mapped to the Arm INST_RETIRED event (`0x08`). +At the top of `main`, there is a PAPI library initialization (`PAPI_library_init`). Under that initialization an EventSet is created (`PAPI_create_eventset`). The Event Set is a PAPI construct that allows for the grouping of a set of hardware events that will be counted together. Once this Event Set is created, two events are added to the Event Set with a pair of calls to `PAPI_add_event`. The first call adds the PAPI preset event `PAPI_TOT_INS`. This preset event is mapped to the Arm INST_RETIRED event (`0x08`). Preset events are included in PAPI as a convenience. It is also possible to add events using event codes. This is the case in the second call to `PAPI_add_event`. Here the event code `0x40000007` is used. This is the PAPI event code for the Arm LD_SPEC event. However, the Arm event ID is actually `0x70`, not `0x40000007`. This is because the event code that needs to be passed into `PAPI_add_event` is a PAPI specific event code. The easiest way to get the PAPI event code is to use `papi_avail` utility as shown below. @@ -150,11 +150,11 @@ Unit Masks: -------------------------------------------------------------------------------- ``` -As shown above, the PAPI event code for LD_SPEC is `0x40000007`. This code is mapped to the Arm LD_SPEC event (`0x70`). +As shown above, the PAPI event code for LD_SPEC is `0x40000007`. This code is mapped to the Arm LD_SPEC event (`0x70`). -After the events are added, `PAPI_start` is used to start the counters and `PAPI_stop` is used to stop them. +After the events are added, `PAPI_start` is used to start the counters and `PAPI_stop` is used to stop them. -Any code that is executed in between these actions is the code that will be measured. In this example, it's the function `code_to_measure`. +Any code that is executed in between these actions is the code that will be measured. In this example, it's the function `code_to_measure`. After counting is stopped, `PAPI_read` is called to read the counts for the events in the Event Set. @@ -170,15 +170,15 @@ Run the application: ./papi_example ``` -The two counters are printed: +The program prints the two counters: ```output Instructions retired: 11000000451 Loads executed speculatively: 3000014538 ``` -Your counter values may be different from what is shown above. +Your counter values may be different from what is shown above. -The events are also dependent on the specific instructions emitted by the compiler. Instructions may change based on compiler options and the version of the compiler. +The events are also dependent on the specific instructions emitted by the compiler. Instructions may change based on compiler options and the version of the compiler. PAPI supports [multiplexing](https://github.com/icl-utk-edu/papi/wiki/PAPI-Multiplexing). It is possible to count more events than the CPU supports using PAPI. diff --git a/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md b/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md index 09e3ec227..d907c71e3 100644 --- a/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md +++ b/content/learning-paths/servers-and-cloud-computing/arm_pmu/perf_event_open.md @@ -1,10 +1,10 @@ --- title: "Use perf_event_open for counting" -weight: 4 +weight: 5 layout: "learningpathall" --- -The `perf_event_open` Linux system call can be used to read hardware counters. In this section, two examples are provided. The first example shows how to read a single counter, the second example shows how to read a group of counters without multiplexing. `perf_event_open` does not support multiplexing. +The `perf_event_open` Linux system call can be used to read hardware counters. In this section, two examples are provided. The first example shows how to read a single counter, the second example shows how to read a group of counters without multiplexing. `perf_event_open` does not support multiplexing. ## Configure a single counter @@ -78,15 +78,15 @@ int main() { } ``` -The example counts the number of instructions executed in the `code_to_measure` function. +The example counts the number of instructions executed in the `code_to_measure` function. -Just as with PAPI, the counter is started right before the call to `code_to_measure` and the counter is stopped and read just after the call to `code_to_measure`. +Just as with PAPI, the counter is started right before the call to `code_to_measure` and the counter is stopped and read just after the call to `code_to_measure`. -The event being counted is `PERF_COUNT_HW_INSTRUCTIONS` which maps to the Arm PMU INST_RETIRED (ID: 0x08) event. +The event being counted is `PERF_COUNT_HW_INSTRUCTIONS` which maps to the Arm PMU INST_RETIRED (ID: 0x08) event. -The `perf_event_open` documentation lists the preset events that can be used. +The `perf_event_open` documentation lists the preset events that can be used. -It is also possible to use a raw event code if a preset doesn't exist. The data structure `perf_event_attr` is how the event to count is configured. This data structure has numerous fields. In the example above, the data structure is setup so that instructions executed in the kernel (or Arm exception level EL1) and instructions executed in the hypervisor (or Arm exception level EL2) are not counted. This means the example is only counting user space instructions executed (or Arm exception level EL0). +It is also possible to use a raw event code if a preset doesn't exist. The data structure `perf_event_attr` is how the event to count is configured. This data structure has numerous fields. In the example above, the data structure is setup so that instructions executed in the kernel (or Arm exception level EL1) and instructions executed in the hypervisor (or Arm exception level EL2) are not counted. This means the example is only counting user space instructions executed (or Arm exception level EL0). You can review the [manual page](https://www.man7.org/linux/man-pages/man2/perf_event_open.2.html) to understand the configuration options for event counting. @@ -99,7 +99,7 @@ gcc perf_event_example1.c -o perf_event_example1 Run the application as `root` (or using sudo): ``` console -sudo ./perf_event_example1 +sudo ./perf_event_example1 ``` The output will be similar to: @@ -108,7 +108,7 @@ The output will be similar to: Instructions retired: 11000000029 ``` -Your counter value may be different from what is shown above. There are many variables that change the count including the CPU design and the compiler. +Your counter value may be different from what is shown above. There are many variables that change the count including the CPU design and the compiler. ## Configure multiple counters (no multiplexing) @@ -174,7 +174,7 @@ struct read_format { int main() { int fd[TOTAL_EVENTS]; // fd[0] will be the group leader file descriptor int id[TOTAL_EVENTS]; // event ids for file descriptors - uint64_t pe_val[TOTAL_EVENTS]; // Counter value array corresponding to fd/id array. + uint64_t pe_val[TOTAL_EVENTS]; // Counter value array corresponding to fd/id array. struct perf_event_attr pe[TOTAL_EVENTS]; // Configuration structure for perf events (see man perf_event_open) struct read_format counter_results; @@ -232,23 +232,23 @@ int main() { } ``` -Near the top of the code there is a data structure called `read_format`. It is setup to contain `TOTAL_EVENTS` (6 in this case) of an inner structure called `values`. This structure is populated when the group of 6 counters is read. +Near the top of the code there is a data structure called `read_format`. It is setup to contain `TOTAL_EVENTS` (6 in this case) of an inner structure called `values`. This structure is populated when the group of 6 counters is read. {{% notice Note1 %}} The `read_format` structure can take different forms depending on how the `perf_event_attr` structure is configured. Refer to the [man page](https://www.man7.org/linux/man-pages/man2/perf_event_open.2.html) for more information. {{% /notice %}} -In addition to `read_format`, there is also the `perf_event_attr` structure which allows configuration of each of the 6 events. This is why the `perf_event_attr` structure array called `pe` is a size of `TOTAL_EVENTS` (or 6 in this case). This means there is 1 `perf_event_attr` structure per event to count. +In addition to `read_format`, there is also the `perf_event_attr` structure which allows configuration of each of the 6 events. This is why the `perf_event_attr` structure array called `pe` is a size of `TOTAL_EVENTS` (or 6 in this case). This means there is 1 `perf_event_attr` structure per event to count. {{% notice Note2 %}} -It is possible to reuse one `perf_event_attr` structure for setting up all events but this is not done here. +It is possible to reuse one `perf_event_attr` structure for setting up all events but this is not done here. {{% /notice %}} -The events to count are configured using the `configure_event` function. In this example, there are 6 events to count, 4 are the preset events of `PERF_COUNT_HW_CPU_CYCLES`, `PERF_COUNT_HW_INSTRUCTIONS`, `PERF_COUNT_HW_STALLED_CYCLES_FRONTEND` and `PERF_COUNT_HW_STALLED_CYCLES_BACKEND`. +The events to count are configured using the `configure_event` function. In this example, there are 6 events to count, 4 are the preset events of `PERF_COUNT_HW_CPU_CYCLES`, `PERF_COUNT_HW_INSTRUCTIONS`, `PERF_COUNT_HW_STALLED_CYCLES_FRONTEND` and `PERF_COUNT_HW_STALLED_CYCLES_BACKEND`. -The last two are raw events `0x70` and `0x71` which correspond to loads executed speculatively (LD_SPEC) and stores executed speculatively (ST_SPEC). +The last two are raw events `0x70` and `0x71` which correspond to loads executed speculatively (LD_SPEC) and stores executed speculatively (ST_SPEC). -Remember that these event codes (`0x70` and `0x71`) can be found in the TRM for the CPU. +Remember that these event codes (`0x70` and `0x71`) can be found in the TRM for the CPU. These last two events are examples of how an event that might not have a preset can be counted. Of these 6 events, one needs to be selected as the group leader. When this is done, whenever an action on the group leader is taken (such as start counting), that action is taken on all of the counters in the group. @@ -265,7 +265,7 @@ Run the application as `root` (or using sudo): ``` console sudo ./perf_event_example2 ``` - + The output will be similar to: ```output @@ -280,6 +280,6 @@ Stores executed speculatively: 2000009529 Your counter values may be different from the output above. -If you want to measure more counters than is supported by the CPU, you will need to implement multiplexing yourself. +If you want to measure more counters than is supported by the CPU, you will need to implement multiplexing yourself. If you choose to do this, be sure to set the `PERF_FORMAT_TOTAL_TIME_ENABLED` and `PERF_FORMAT_TOTAL_TIME_RUNNING` fields in the `perf_event_attr.read_format` structure. This is done by ORing these flags into the same line you see `PERF_FORMAT_GROUP` and `PERF_FORMAT_ID` above. If this is done, the `read_format` structure will need to be changed to include the time enabled and time running fields. If this multiplexing is implemented, the resulting counts should be taken as an estimate. diff --git a/content/learning-paths/servers-and-cloud-computing/csp/alibaba.md b/content/learning-paths/servers-and-cloud-computing/csp/alibaba.md index 0253374e3..5854994e7 100644 --- a/content/learning-paths/servers-and-cloud-computing/csp/alibaba.md +++ b/content/learning-paths/servers-and-cloud-computing/csp/alibaba.md @@ -34,25 +34,25 @@ The easiest way to launch your instance is via the [ECS Console](https://ecs.con Navigate to `Elastic Compute Service` by search or the menu. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/588897d0-6c77-ee64-c7aa-235cbf460426.png "Navigate to the ECS Dashboard") +![alibaba #center](images/588897d0-6c77-ee64-c7aa-235cbf460426.png "Navigate to the ECS Dashboard") Use the `Create ECS Instance` button to get started. Select `Custom Launch` configuration. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png "Create Instance") +![alibaba #center](images/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png "Create Instance") -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png "Custom Launch") +![alibaba #center](images/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png "Custom Launch") ### Select a Billing Method `Subscription`, `Pay-as-you-go`, or `Preemptible Instance` options are available. If you are experimenting initially, select `Preemptible Instance` for the lowest cost. You will be prompted for pricing options later. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png "Select a Billing Method") +![alibaba #center](images/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png "Select a Billing Method") ### Select Instance Type Using the `Type-based Selection` tab, set `Architecture` as `ARM`, and `Category` as `General Purpose`, to see the available instance types. If you already know the desired instance type, you can enter this in the filter. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/6ccdd195-7020-b944-4eed-846edf808b2a.png "Select Instance Type") +![alibaba #center](images/6ccdd195-7020-b944-4eed-846edf808b2a.png "Select Instance Type") ### Select OS image @@ -60,33 +60,33 @@ There are many images available on the [Alibaba Cloud Marketplace](https://marke For now, select `Ubuntu` version (e.g. `20.04 64-bit for ARM`) from the pull-down menu. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/c0329674-b751-5aa5-09b8-f2786a338d8e.png "Select OS Image") +![alibaba #center](images/c0329674-b751-5aa5-09b8-f2786a338d8e.png "Select OS Image") ### Other settings Other settings, such as storage size are selectable. For now, use the default selection. Click `Next` to move to `Networking`. Proceed with the default selection for `Networking`. Click `Next` to move to `System Configurations`. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/08b7ccdd-003f-b23d-de99-471aa11eb285.png "Configure Storage Options") +![alibaba #center](images/08b7ccdd-003f-b23d-de99-471aa11eb285.png "Configure Storage Options") -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png "Configure Network Options") +![alibaba #center](images/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png "Configure Network Options") ### Set a Key Pair and other security settings To be able to access the instance (see later), you must use a [key pair](https://www.alibabacloud.com/help/en/elastic-compute-service/latest/key-pairs). If this is your first time logging in, use the `Create Key Pair` dialog to create your key. The `public-key` will be downloaded to your local machine. When created, select from the pull-down. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png "Select or create a key pair") +![alibaba #center](images/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png "Select or create a key pair") Select `Logon Credentials` and set `Logon Username` to `ecs-user` and an appropriate `password` if desired. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png "Set Username and Password for logon") +![alibaba #center](images/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png "Set Username and Password for logon") Other settings such as `Instance Name` and `Description` are free-form for appropriate personal input. Other settings can be left as default. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/fd90820b-5ac5-6fae-831c-1505028e4393.png "Advanced Settings(Optional)") +![alibaba #center](images/fd90820b-5ac5-6fae-831c-1505028e4393.png "Advanced Settings(Optional)") In the `Preview` stage, click `Create Instance`. After a few moments, the instance will be available for use. -![alibaba #center](../../../ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/e8e336c4-87e7-a8ae-d798-f5d755211270.png "The last step of instance creation") +![alibaba #center](images/e8e336c4-87e7-a8ae-d798-f5d755211270.png "The last step of instance creation") ## Connect to your instance diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/08b7ccdd-003f-b23d-de99-471aa11eb285.png b/content/learning-paths/servers-and-cloud-computing/csp/images/08b7ccdd-003f-b23d-de99-471aa11eb285.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/08b7ccdd-003f-b23d-de99-471aa11eb285.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/08b7ccdd-003f-b23d-de99-471aa11eb285.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png b/content/learning-paths/servers-and-cloud-computing/csp/images/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/2bd139ad-a28b-8e82-8dae-c0d7e54a4ebc.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/588897d0-6c77-ee64-c7aa-235cbf460426.png b/content/learning-paths/servers-and-cloud-computing/csp/images/588897d0-6c77-ee64-c7aa-235cbf460426.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/588897d0-6c77-ee64-c7aa-235cbf460426.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/588897d0-6c77-ee64-c7aa-235cbf460426.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/6ccdd195-7020-b944-4eed-846edf808b2a.png b/content/learning-paths/servers-and-cloud-computing/csp/images/6ccdd195-7020-b944-4eed-846edf808b2a.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/6ccdd195-7020-b944-4eed-846edf808b2a.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/6ccdd195-7020-b944-4eed-846edf808b2a.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png b/content/learning-paths/servers-and-cloud-computing/csp/images/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/8be6f704-0b04-1a19-e156-9f4b5e2f6d10.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png b/content/learning-paths/servers-and-cloud-computing/csp/images/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/99554b4b-5f15-2dce-4de4-c59e26a3a90e.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png b/content/learning-paths/servers-and-cloud-computing/csp/images/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/bf231337-39ba-5d61-6bbb-4c9d2c3f8d6c.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png b/content/learning-paths/servers-and-cloud-computing/csp/images/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/bf7f23d0-2afb-6a84-60aa-78dc1c27be39.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/c0329674-b751-5aa5-09b8-f2786a338d8e.png b/content/learning-paths/servers-and-cloud-computing/csp/images/c0329674-b751-5aa5-09b8-f2786a338d8e.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/c0329674-b751-5aa5-09b8-f2786a338d8e.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/c0329674-b751-5aa5-09b8-f2786a338d8e.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/e8e336c4-87e7-a8ae-d798-f5d755211270.png b/content/learning-paths/servers-and-cloud-computing/csp/images/e8e336c4-87e7-a8ae-d798-f5d755211270.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/e8e336c4-87e7-a8ae-d798-f5d755211270.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/e8e336c4-87e7-a8ae-d798-f5d755211270.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png b/content/learning-paths/servers-and-cloud-computing/csp/images/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/ee8331cb-caec-a3a1-5ded-f7eb56f3e558.png diff --git a/content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/fd90820b-5ac5-6fae-831c-1505028e4393.png b/content/learning-paths/servers-and-cloud-computing/csp/images/fd90820b-5ac5-6fae-831c-1505028e4393.png similarity index 100% rename from content/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/fd90820b-5ac5-6fae-831c-1505028e4393.png rename to content/learning-paths/servers-and-cloud-computing/csp/images/fd90820b-5ac5-6fae-831c-1505028e4393.png diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_index.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_index.md new file mode 100644 index 000000000..4c7da95d9 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_index.md @@ -0,0 +1,39 @@ +--- +title: 'Deploy .NET applications to Arm Virtual Machines in Microsoft Azure' + +minutes_to_complete: 30 + +who_is_this_for: This learning path is for software developers interested in learning how to deploy .NET applications to Microsoft Azure using Arm64-powered Virtual Machines. + +learning_objectives: + - Create a Virtual Machine (VM) in Microsoft Azure. + - Connect to the VM to install app dependencies, including SDK. + - Create and run the .NET application. + - Configure the network security group of the VM to expose the application over the Internet. + +prerequisites: + - 'A subscription to Azure. Use this link to sign up for a free account: https://azure.microsoft.com/en-us/free/' + +author_primary: Dawid Borycki + +### Tags +skilllevels: Introductory +subjects: Containers and Virtualization + +armips: + - Neoverse + +tools_software_languages: + - .NET SDK + - C# + - Azure +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/from-iot-to-the-cloud-part1/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_next-steps.md new file mode 100644 index 000000000..1f894a99b --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_next-steps.md @@ -0,0 +1,40 @@ +--- +# ================================================================================ +# Edit +# ================================================================================ + +next_step_guidance: > + You can continue learning about migrating applications to Arm. +# 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/migration/" +# Link to the next learning path being recommended(For example this could be /learning-paths/servers-and-cloud-computing/mongodb). + + +# 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: Terraform on Azure + link: https://www.udemy.com/course/terraform-on-azure-basic-tutorial + type: Tutorial + - resource: + title: Azure Virtual Machines with Ampere Altra Arm–based processors—generally available + link: https://azure.microsoft.com/en-us/blog/azure-virtual-machines-with-ampere-altra-arm-based-processors-generally-available/ + type: Blog + - resource: + title: About Azure bastion + link: https://learn.microsoft.com/en-us/azure/bastion/bastion-overview + 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/from-iot-to-the-cloud-part1/_review.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_review.md new file mode 100644 index 000000000..59ad69058 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/_review.md @@ -0,0 +1,35 @@ +--- +review: + - questions: + question: > + What do you use to specify which ports are open in the Virtual Machine? + answers: + - Network Security Group + - Azure Firewall + - Microsoft Firewall + correct_answer: 1 + explanation: > + Network Security Group is the Azure resource you can use to filter network traffic. + + - questions: + question: > + Which command is used to build and start the .NET app from the command line? + answers: + - .net run + - .net start + - dotnet run + - dotnet start + + correct_answer: 3 + explanation: > + .NET CLI is the command-line tool you use to build and run applications. The tool is accessed by dotnet command. To run the application you use the run subcommand. + + + +# ================================================================================ +# 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/from-iot-to-the-cloud-part1/example-picture.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/example-picture.png new file mode 100644 index 000000000..c69844bed Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/example-picture.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/01.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/01.png new file mode 100644 index 000000000..003ac2103 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/01.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/02.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/02.png new file mode 100644 index 000000000..64d16d187 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/02.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/03.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/03.png new file mode 100644 index 000000000..95034a437 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/03.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/04.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/04.png new file mode 100644 index 000000000..bfa146dec Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/04.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/05.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/05.png new file mode 100644 index 000000000..02397535a Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/05.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/06.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/06.png new file mode 100644 index 000000000..cf18075d8 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/06.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/07.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/07.png new file mode 100644 index 000000000..71ce5d540 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/07.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/08.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/08.png new file mode 100644 index 000000000..2d4ec1a29 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/08.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/09.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/09.png new file mode 100644 index 000000000..0f3b3b50b Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/09.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/10.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/10.png new file mode 100644 index 000000000..96f82c4e6 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/10.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/11.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/11.png new file mode 100644 index 000000000..e2d9a1776 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/11.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/12.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/12.png new file mode 100644 index 000000000..2e45c92ed Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/12.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/13.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/13.png new file mode 100644 index 000000000..c14244798 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/13.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/14.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/14.png new file mode 100644 index 000000000..cd0590ee3 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/14.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/15.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/15.png new file mode 100644 index 000000000..702b9019b Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/15.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/16.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/16.png new file mode 100644 index 000000000..24b42a026 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/16.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/17.png b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/17.png new file mode 100644 index 000000000..90472d2d1 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/figures/17.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-1.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-1.md new file mode 100644 index 000000000..589a6c923 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-1.md @@ -0,0 +1,16 @@ +--- +title: Motivation +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Why arm64 in the cloud? +The general architecture of the Internet of Things includes various edge devices which stream data to the central processing unit which, in turn, is deployed to the cloud. + +As an IoT or Arm developer, you are already familiar with app development for your edge devices. Also, you know that arm64-powered devices offer power-efficient computations that enable us to achieve accelerated computing at reduced power consumption. + +Cloud providers including Microsoft Azure are now adopting this technology. Specifically, Azure provides arm64-powered virtual machines which you can use to deploy your apps to utilize arm64 power and reduce the carbon trace. + +This tutorial demonstrates how to create the arm64-powered virtual machine in Microsoft Azure and use it for running a .NET application. The idea is to show you how to leverage Microsoft Azure, .NET, and aarch64 to build and host a central unit for your IoT solutions. diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-2.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-2.md new file mode 100644 index 000000000..30634f97f --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-2.md @@ -0,0 +1,71 @@ +--- +title: Creating the Virtual Machine +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Virtual Machine + +### Virtual Machine Azure Resource +Let's start by creating the Virtual Machine. Go to https://portal.azure.com and sign in. You will see this screen which enables you to create Azure resources: +![Azure portal#left](figures/01.png "Figure 1. A fragment of the Azure Portal") + +In the search box, type **VM**, and pick the first item on the list (Virtual machines): +![Selecting Virtual Machine resource#left](figures/02.png "Figure 2. Selecting the virtual machine Azure resource") + +In the Virtual machines, click **+ Create** (in the top left corner), and then select **Azure virtual machine**: +![Creating Virtual Machine#left](figures/03.png "Figure 3. Creating the virtual machine") + +This takes you to the **Create a Virtual Machine** wizard as shown below: +![Creating Virtual Machine#left](figures/04.png "Figure 4. Virtual machine wizard") + +### Virtual machine configuration +Configure your VM with the following settings: + +1. Subscription: select your subscription. +2. Resource group: click Create new link, then type **rg-arm64**, and click OK. +3. Virtual machine name: **vm-arm64**. +4. Region: select depending on your physical location. +5. Availability options: select **No infrastructure redundancy required**. +6. Security type: **Standard**. +7. VM architecture: **arm64**. +8. Image: **Ubuntu Server 20.04 LTS – ARM64 Gen 2**. +9. Size: + * Click **See all sizes**. + * In the **Select a VM size** type **D2pds** in the search box + * Select **D2pds_v5**. + +{{% notice Note %}} This size might not be available due to quota limits. If this happens, click **Request quota link** (which is located next to the **VM size** name). This will activate a New Quota Request. Type **2** under New limit and click Submit. Wait a few minutes for the quota limits to be updated.{{% /notice %}} + +At this point, your configuration should look like this example: +![Creating Virtual Machine#left](figures/05.png "Figure 5. Virtual machine wizard (configured)") + +Let's now configure other aspects of the Virtual Machine: +1. Administrator account. **Select Password**, and then populate with: + * Username: **arm** + * Password: type your password (make a note of this password as you'll need it to connect to VM) + * Confirm password: re-type your password +2. Inbound port rules. Keep them default: **SSH(22)**. + +![Creating Virtual Machine#left](figures/06.png "Figure 6. Administrator account and inbound rules of the virtual machine") + +Click the **Review + create** button. The Azure Portal will validate your configuration and, if all is correct, you will see a green box saying: **Validation passed**: + +![Creating Virtual Machine#left](figures/07.png "Figure 7. A summary of the create virtual machine wizard") + +Click the Create button. The portal will now start the process of creating your VM. You will notice that apart from the VM itself, the portal creates additional resources for you: +* Public IP address (you'll need to use it to connect to the VM and then to see your application running) +* Network Security Group +* Virtual network +* Network interface +* Virtual disk + +Wait a few moments for the deployment to be completed: +![Creating Virtual Machine#left](figures/08.png "Figure 8. A confirmation screen") + +Finally, click the **Go to resource** button. You'll be redirected to the overview of your newly created virtual machine in Microsoft Azure: +![Creating Virtual Machine#left](figures/09.png "Figure 9. An overview of the virtual machine") + +Note your Public IP address (top right part of the overview). In this tutorial, this is **52.149.156.228**. diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-3.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-3.md new file mode 100644 index 000000000..8338d04ee --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-3.md @@ -0,0 +1,35 @@ +--- +title: Connecting to the Virtual Machine +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Objective +You will now connect to the VM using the SSH protocol and the public IP address of the virtual machine. +{{% notice Note %}} In this tutorial we will use the public IP **52.149.156.228**. Please make sure to use the public IP of your virtual machine instead. {{% /notice %}} + +You can use a local terminal or the Azure Cloud Shell to connect to the VM. The latter is available directly from the Azure Portal and to avoid installing additional tools, we will use the Cloud Shell. + +### Azure Cloud Shell +To open the Cloud Shell, click on the Cloud Shell icon located in the top right corner of Azure Portal: +![Azure Cloud Shell#left](figures/10.png "Figure 10. A top right corner of the Azure Portal") + +This will activate a new popup window which appears at the bottom of the Azure Portal: +![Azure Cloud Shell#left](figures/11.png "Figure 11. Mounting a storage") + +Click **Create storage**, and wait until the storage account is created. A Cloud Shell terminal should be ready. If it asks you for the interpreter, select **Bash**. The Cloud Shell terminal will look as follows: +![Azure Cloud Shell#left](figures/12.png "Figure 12. Cloud shell") + +### Connecting to the Virtual Machine using Azure Cloud Shell +You can now use the Cloud Shell to connect to the VM via SSH. To do so, type the Public IP address (remember to use the Public IP address of your virtual machine): + +```console +ssh arm@52.149.156.228 +``` + +This will initiate the connection with the VM. The ssh will display the following message: Are you sure you want to continue connecting (yes/no/[fingerprint])? Type **yes**. Then provide your password to authenticate: +![Azure Cloud Shell#left](figures/13.png "Figure 13. Authentication") + +You now have terminal access to the VM. You can use it in the next step to install application dependencies (.NET SDK). diff --git a/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-4.md b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-4.md new file mode 100644 index 000000000..bc621e7c3 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/from-iot-to-the-cloud-part1/how-to-4.md @@ -0,0 +1,95 @@ +--- +title: Installing application dependencies and running the application +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Objective +In this step, you will install in the virtual machine the following tools: +- .NET 7 SDK – to build and run the application +- git – to clone application sources + +Next, you will use git to clone application sources and finally, you will build and launch the application. + +### Dependencies +To install .NET SDK: +1. In the terminal of the virtual machine type: +```console +wget https://dot.net/v1/dotnet-install.sh +``` +This will download the installation script. + +2. Make the script executable: +```console +chmod +x dotnet-install.sh +``` +3. Run the script (it will install .NET SDK 7 under the folder .dotnet): +```console +./dotnet-install.sh --channel 7.0 +``` +4. Add the .dotnet folder to the PATH by typing: +```console +export PATH="/home/arm/.dotnet/:$PATH" +``` +5. To check that the installation was successful, type: +```console +dotnet --list-sdsk +``` + +{{% notice Note %}} In this tutorial, we installed .NET 7 because the application we will deploy was built using .NET 7. If you need to install another .NET version, modify the channel parameter of the installation script.{{% /notice %}} + +To install git, use the terminal of the virtual machine and type: +```console +sudo apt-get install -y git-all +``` + +Wait for the installation to be completed. It will take a while. + +### Clone and run the application +You will now clone the application by typing: +```console +git clone https://github.com/dawidborycki/People.WebApp.git +``` +The application sources will be cloned to the People.WebApp folder. Change the working directory to: +```conolse +cd People.WebApp/ +``` +Then, run the application so that it will listen for requests on port 8080: +```console +dotnet run --urls "http://0.0.0.0:8080" +``` +After completing this step, you will see the following output: + +![Application#left](figures/14.png "Figure 14. Cloning and running the application") + +The application is ready and listening for the requests on port 8080. However, the network traffic is blocked on all ports except 22. You will need to configure the Network Security Group to enable the traffic. + +### Configure Network Security Group +To allow traffic on port 8080 for the Virtual Machine **vm-arm64**, proceed as follows: +1. In the search box of the Azure Portal, type **vm-arm64** and select this resource +2. In the **vm-arm64** screen, click the **Networking** tab on the left (it's under **Settings**). You will see the following screen: +![Application#left](figures/15.png "Figure 15. Networking tab of the virtual machine") + +In the **Networking** tab of the Virtual Machine, click the **Add inbound port rule** button (it's on the right). This will open a new popup window **Add inbound security rule**: +![Application#left](figures/16.png "Figure 16. Adding inbound port rule") + +Ensure the rule is configured as follows: +1. Source: **Any** +2. Source port ranges: ***** +3. Destination: **Any** +4. Service: **Custom** +5. Destination port ranges: **8080** +6. Protocol: **Any** +7. Action: **Allow** +8. Priority: **310** +9. Name: **AllowAnyCustom8080Inbound** + +Then, click **Add** and wait for the security rule to be applied. + +Once this is done, open your web browser and type the public IP address of your VM followed by 8080 port: **52.149.156.228:8080**. You'll see that the application is up and running: +![Application#left](figures/17.png "Figure 17. An application deployed to Azure virtual machine") + +## Summary +This tutorial has shown you how to create an arm64-powered Virtual Machine in Microsoft Azure, how to connect to that VM using SSH, and how to install the tools required to build and run the .NET web application. Finally, you have learned how to configure a network security group to enable inbound traffic on port 8080. 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 index 342a369d3..3b5819454 100644 --- 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 @@ -25,7 +25,7 @@ sudo apt install python3.10-venv ## Install Pulumi -You can install Pulumi with this [install guide](https://learn.arm.com/install-guides/pulumi/) +You can install Pulumi with this [install guide](/install-guides/pulumi/) Check the version of Pulumi: @@ -121,7 +121,7 @@ template: default: us-east-1 ``` -Edit the `__main__.py` file to change the availabilty zone of your network subnet +Edit the `__main__.py` file to change the availability zone of your network subnet ```python subnet = aws.ec2.Subnet("p1-subnet", @@ -134,7 +134,7 @@ subnet = aws.ec2.Subnet("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. +Note: The security groups created by this script are lot less restrictive, to simplify the deployment process and to remove additional complexities. Please modify the ingress/egress rules as per your organizations' policy. ```python group = aws.ec2.SecurityGroup('p1-security-grouup', diff --git a/data/stats_current_test_info.yml b/data/stats_current_test_info.yml index ca7a4a0c3..eca9363ea 100644 --- a/data/stats_current_test_info.yml +++ b/data/stats_current_test_info.yml @@ -1,5 +1,5 @@ summary: - content_total: 178 + content_total: 179 content_with_all_tests_passing: 32 content_with_tests_enabled: 32 sw_categories: diff --git a/data/stats_weekly_data.yml b/data/stats_weekly_data.yml index 59eae46d4..386a30a05 100644 --- a/data/stats_weekly_data.yml +++ b/data/stats_weekly_data.yml @@ -810,3 +810,44 @@ avg_close_time_hrs: 0 num_issues: 8 percent_closed_vs_total: 0.0 +- a_date: '2023-10-23' + content: + cross-platform: 7 + embedded-systems: 14 + install-guides: 73 + laptops-and-desktops: 9 + microcontrollers: 22 + servers-and-cloud-computing: 47 + smartphones-and-mobile: 7 + total: 179 + contributions: + external: 3 + internal: 174 + github_engagement: + num_forks: 30 + num_prs: 6 + individual_authors: + brenda-strech: 1 + christopher-seidl: 4 + daniel-gubay: 1 + dawid-borycki: 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: 7 + percent_closed_vs_total: 0.0 diff --git a/themes/arm-design-system-hugo-theme/layouts/_default/baseof.html b/themes/arm-design-system-hugo-theme/layouts/_default/baseof.html index 172bfee65..6dd4ed998 100644 --- a/themes/arm-design-system-hugo-theme/layouts/_default/baseof.html +++ b/themes/arm-design-system-hugo-theme/layouts/_default/baseof.html @@ -7,6 +7,7 @@ {{partial "head/social.html" .}} {{partial "head/analytics.html" .}} {{partial "head/conditional-redirect.html" .}} + {{partial "head/hotjar-surveys.html" .}} {{partial "header/nav-masthead.html" .}} diff --git a/themes/arm-design-system-hugo-theme/layouts/partials/head/hotjar-surveys.html b/themes/arm-design-system-hugo-theme/layouts/partials/head/hotjar-surveys.html new file mode 100644 index 000000000..b946c0d60 --- /dev/null +++ b/themes/arm-design-system-hugo-theme/layouts/partials/head/hotjar-surveys.html @@ -0,0 +1,11 @@ + + \ No newline at end of file