Merge branch 'main' into OpenAI_Whisper

Author: pareenaverma

.github/workflows/deploy.yml

@@ -21,6 +21,10 @@ on:
         required: true
       HUGO_AUDIO_API:
         required: true
+      HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID:
+        required: true
+      HUGO_FORM_ID_FOR_PROGRAM_SIGNUP:
+        required: true
 
 env:
   HUGO_VERSION: 0.130.0
@@ -69,6 +73,8 @@ jobs:
           HUGO_LLM_API: ${{ secrets.HUGO_LLM_API }}
           HUGO_RAG_API: ${{ secrets.HUGO_RAG_API }}
           HUGO_AUDIO_API: ${{ secrets.HUGO_AUDIO_API }}
+          HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID: ${{ secrets.HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID }}
+          HUGO_FORM_ID_FOR_PROGRAM_SIGNUP: ${{ secrets.HUGO_FORM_ID_FOR_PROGRAM_SIGNUP }}
 
       # Deploys website to AWS S3 and invalidate CloudFront Cache
       - name: Deploy to S3

.github/workflows/main.yml

@@ -24,3 +24,5 @@ jobs:
       HUGO_LLM_API: ${{ secrets.HUGO_LLM_API }}
       HUGO_RAG_API: ${{ secrets.HUGO_RAG_API }}
       HUGO_AUDIO_API: ${{ secrets.HUGO_AUDIO_API }}
+      HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID: ${{ secrets.HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID }}
+      HUGO_FORM_ID_FOR_PROGRAM_SIGNUP: ${{ secrets.HUGO_FORM_ID_FOR_PROGRAM_SIGNUP }}

.github/workflows/production.yml

@@ -24,3 +24,5 @@ jobs:
       HUGO_LLM_API: ${{ secrets.HUGO_LLM_API }}
       HUGO_RAG_API: ${{ secrets.HUGO_RAG_API }}
       HUGO_AUDIO_API: ${{ secrets.HUGO_AUDIO_API }}
+      HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID: ${{ secrets.HUGO_DEV_PROG_SIGNIUP_FORM_MUNCHKIN_ID }}
+      HUGO_FORM_ID_FOR_PROGRAM_SIGNUP: ${{ secrets.HUGO_FORM_ID_FOR_PROGRAM_SIGNUP }}

.gitignore

@@ -6,6 +6,8 @@ node_modules/
 package-lock.json
 .hugo_build.lock
 .vscode
+.env
+startup.sh
 
 # macOS files
 *.DS_Store

.wordlist.txt

@@ -3688,4 +3688,84 @@ ver
 vit
 wav
 za
-zh
+zh
+ACM
+APs
+ASG
+AutoModelForSpeechSeq
+AutoProcessor
+Avin
+Bioinformatics
+CDK
+Dropbear
+DxeCore
+EFI
+FFTW
+HMMER
+ILP
+IoC
+Jython
+Khrustalev
+LCP
+Maranget
+Minimap
+NFS
+NVPL
+OMP
+OSR
+OneAPI
+OpenRNG
+OpenSSH
+Phttps
+RNG
+Runbook
+SSM
+Shrinkwrap
+Shrinkwrap's
+TSO
+TSan
+TSan's
+ThreadSanitizer
+Toolkits
+ULP
+ULPs
+VSL
+Yury
+Zarlez
+ada
+armtest
+atomicity
+autoscaling
+cmath
+cuBLAS
+cuDNN
+distro's
+dtype
+dxecore
+foir
+fourier
+getter
+libm
+miniconda
+msg
+nInferencing
+oneAPI
+oneapi
+openai
+pseudorandom
+quasirandom
+reorderings
+rootfs
+runbook
+safetensors
+superset
+sysroot
+testroot
+threadsanitizercppmanual
+toolchain's
+transpiles
+vectorstore
+vlen
+vv
+webhook
+xE

assets/css/feedback.css

@@ -1,7 +1,6 @@
 
 #feedback-container {
     min-height: 200px;
-
 }
 
 /****************************************************/

content/install-guides/_images/wperf-winget-installation.gif

@@ -39,6 +39,46 @@ WindowsPerf consists of a kernel-mode driver and a user-space command-line tool.
 You cannot use WindowsPerf on virtual machines, such as cloud instances.
 {{% /notice %}}
 
+## Using winget (Recommended)
+
+### Install
+
+You can now install WindowsPerf directly from [winget](https://learn.microsoft.com/en-us/windows/package-manager/). Open an `Administrator` terminal on PowerShell and type
+
+```console
+winget install WindowsPerf
+```
+
+The output should look like:
+
+```output
+Found WindowsPerf [Arm.WindowsPerf] Version 4.3.1.0
+This application is licensed to you by its owner.
+Microsoft is not responsible for, nor does it grant any licenses to, third-party packages.
+Downloading https://developer.arm.com/-/cdn-downloads/permalink/WindowsPerf/Installer/windowsperf-4.3.1.msi
+  3.07 MB
+Successfully verified installer hash
+Starting package install...
+Successfully installed
+```
+
+![Winget installation video](/install-guides/_images/wperf-winget-installation.gif)
+
+It will install the lastest available WindowsPerf along with the [WPA plugins](/learning-paths/laptops-and-desktops/windowsperf_wpa_plugin/). To check that the installation was done correctly open a new terminal tab or window and follow the instructions under the [verify installation section](/install-guides/wperf/#verify-install)
+
+### Uninstall 
+If you need to uninstall WindowsPerf, open an `Administrator` terminal on PowerShell and run:
+```console
+winget uninstall WindowsPerf
+```
+
+The output from a successfull uninstallation will look like:
+```output
+Found WindowsPerf [Arm.WindowsPerf]
+Starting package uninstall...
+Successfully uninstalled
+```
+
 ## Visual Studio and the Windows Driver Kit (WDK)
 
 WindowsPerf relies on `dll` files installed with Visual Studio, from the Community Edition or higher and, optionally, installers from the Windows Driver Kit extension.
@@ -86,7 +126,7 @@ Make sure you are in the `windowsperf-bin-<version>` directory:
 cd windowsperf-bin-4.0.0
 ```
 
-### Install with wperf-devgen {#devgen_install}
+### Install with wperf-devgen 
 
 Navigate to the `wperf-driver` folder and run the installer:
 
@@ -103,7 +143,7 @@ Install requested.
 Device installed successfully
 ```
 
-## Verify install
+## Verify install 
 
 You can check everything is working by running the `wperf` executable.
 

content/install-guides/wperf.md

@@ -18,9 +18,7 @@ The framework allows you to parse Learning Path articles and generate instructio
 2. [Edit Learning Path pages](#edit-learning-path-pages)
 3. [Edit metadata](#edit-metadata)
 4. [Run the framework](#run-the-framework)
-5. [Result summary](#result-summary)
-6. [Visualize results](#visualize-results)
-
+5. [Advanced usage for embedded development](#advanced-usage-for-embedded-development)
 
 ## Install dependencies
 
@@ -279,7 +277,7 @@ In the example above, the summary indicates that for this Learning Path all test
 ## Advanced usage for embedded development
 ### Using the Corstone-300 FVP
 
-By default, the framework runs instructions on the Docker images specified by the [metadata](#edit-metadata). For embedded development, it is possible to build software in a container instance and then check its behaviour on the Corstone-300 FVP.
+By default, the framework runs instructions on the Docker images specified by the [metadata](#edit-metadata). For embedded development, it is possible to build software in a container instance and then check its behavior on the Corstone-300 FVP.
 
 For this, all container instances used by the test framework mount a volume in `/shared`. This is where software for the target FVP can be stored. To check the execution, the FVP commands just need to be identified as a `fvp` section for the framework.
 

content/learning-paths/cross-platform/_example-learning-path/appendix-3-test.md

@@ -23,12 +23,13 @@ In the Matrix processing library, you implement two types of checks:
 
 The idea here is to make the program fail in a noticeable way. Of course, in a real world application, the error should be caught and dealt with by the application, if it can. Error handling, and especially recovering from errors, can be a complex topic.
 
-At the top of file `include/Matrix/Matrix.h`, include `<cassert>` to get the C-style assertions declarations for checks in `Debug` mode only:
+At the top of file `include/Matrix/Matrix.h`, include `<cassert>` to get the C-style assertions declarations for checks in `Debug` mode only, as well as `<cstddef>` which provides standard C declaration like `size_t`:
 
 ```CPP
 #pragma once
 
 #include <cassert>
+#include <cstddef>
 
 namespace MatComp {
 ```
@@ -44,7 +45,7 @@ const Version &getVersion();
 /// and the EXIT_FAILURE error code. It will also print the file name (\p
 /// fileName) and line number (\p lineNumber) that caused that application to
 /// exit.
-[[noreturn]] void die(const char *fileName, std::size_t lineNumber,
+[[noreturn]] void die(const char *fileName, size_t lineNumber,
                       const char *reason);
 
 ```
@@ -109,10 +110,11 @@ The Matrix data structure has the following private data members:
 Modern C++ offers constructs in the language to deal safely with memory; you will use `std::unique_ptr` which guaranties that the Matrix class will be safe from a whole range of memory management errors.
 
 Add the following includes at the top of `include/Matrix/Matrix.h`, right under
-the '<cassert>' include:
+the `<cstddef>` include:
 
 ```CPP
 #include <cassert>
+#include <cstddef>
 #include <cstring>
 #include <initializer_list>
 #include <iostream>
@@ -229,12 +231,6 @@ TEST(Matrix, defaultConstruct) {
 TEST(Matrix, booleanConversion) {
     EXPECT_FALSE(Matrix<int8_t>());
     EXPECT_FALSE(Matrix<double>());
-
-    EXPECT_TRUE(Matrix<int8_t>(1, 1));
-    EXPECT_TRUE(Matrix<double>(1, 1));
-
-    EXPECT_TRUE(Matrix<int8_t>(1, 1, 1));
-    EXPECT_TRUE(Matrix<double>(1, 1, 2.0));
 }
 ```
 
@@ -320,9 +316,9 @@ The tests should still pass, check for yourself.
 The next step is to be able to construct valid matrices, so add this constructor to the public section of class `Matrix` in `include/Matrix/Matrix.h`:
 
 ```CPP
-    /// Construct a \p numRows x \p numColumns uninitialized Matrix
-    Matrix(size_t numRows, size_t numColumns)
-        : numRows(numRows), numColumns(numColumns), data() {
+    /// Construct a \p numRows x \p numCols uninitialized Matrix
+    Matrix(size_t numRows, size_t numCols)
+        : numRows(numRows), numColumns(numCmns), data() {
         allocate(getNumElements());
     }
 ```
@@ -348,6 +344,17 @@ TEST(Matrix, uninitializedConstruct) {
 ```
 
 This constructs a valid `Matrix` if it contains elements), and the `uninitializedConstruct` test checks that two valid matrices of different types and dimensions can be constructed.
+You should also update the `booleanConversion` test in this file to check for boolean conversion for valid matrices so it now looks like:
+
+```CPP
+TEST(Matrix, booleanConversion) {
+    EXPECT_FALSE(Matrix<int8_t>());
+    EXPECT_FALSE(Matrix<double>());
+
+    EXPECT_TRUE(Matrix<int8_t>(1, 1));
+    EXPECT_TRUE(Matrix<double>(1, 1));
+}
+```
 
 Compile and test again, all should pass:
 
@@ -374,6 +381,35 @@ ninja check
 [  PASSED  ] 4 tests.
 ```
 
+Another constructor that is missing is one that will create and initialize matrices to a known value. Let's add it to `Matrix` in `include/Matrix/Matrix.h`:
+
+```CPP
+    /// Construct a \p numRows x \p numCols Matrix with all elements
+    /// initialized to value \p val.
+    Matrix(size_t numRows, size_t numCols, Ty val) : Matrix(numRows, numCols) {
+        allocate(getNumElements());
+        for (size_t i = 0; i < getNumElements(); i++)
+            data[i] = val;
+    }
+```
+
+Add boolean conversion tests for this new constructor by modifying `booleanConversion` in `tests/Matrix.cpp` so it looks like:
+
+```CPP
+TEST(Matrix, booleanConversion) {
+    EXPECT_FALSE(Matrix<int8_t>());
+    EXPECT_FALSE(Matrix<double>());
+
+    EXPECT_TRUE(Matrix<int8_t>(1, 1));
+    EXPECT_TRUE(Matrix<double>(1, 1));
+
+    EXPECT_TRUE(Matrix<int8_t>(1, 1, 1));
+    EXPECT_TRUE(Matrix<double>(1, 1, 2.0));
+}
+```
+
+You should be getting the pattern now: each new feature or method comes with tests.
+
 The `Matrix` class is missing two important methods:
 - A *getter*, to read the matrix element at (row, col).
 - A *setter*, to modify the matrix element at (row, col).
@@ -397,20 +433,6 @@ Add them now in the public section of `Matrix` in `include/Matrix/Matrix.h`:
     }
 ```
 
-Another constructor that is missing is one that will create and initialize matrices to a known value. Let's add it to `Matrix` in `include/Matrix/Matrix.h`:
-
-```CPP
-    /// Construct a \p numRows x \p numColumns Matrix with all elements
-    /// initialized to value \p val.
-    Matrix(size_t numRows, size_t numCols, Ty val) : Matrix(numRows, numCols) {
-        allocate(getNumElements());
-        for (size_t i = 0; i < getNumElements(); i++)
-            data[i] = val;
-    }
-```
-
-You should be getting the pattern now.
-
 Add tests for those 3 methods in `tests/Matrix.cpp`:
 
 ```CPP
@@ -503,7 +525,7 @@ The C++ `std::initializer_list`  enables users to provide a list of literal
 values (in row major order) to use to initialize the matrix with:
 
 ```CPP
-    /// Construct a \p numRows x \p numColumns Matrix with elements
+    /// Construct a \p numRows x \p numCols Matrix with elements
     /// initialized from the values from \p il in row-major order.
     Matrix(size_t numRows, size_t numCols, std::initializer_list<Ty> il)
         : Matrix(numRows, numCols) {
@@ -862,7 +884,7 @@ ninja check
 [----------] 16 tests from Matrix (0 ms total)
 
 [----------] Global test environment tear-down
-[==========] 16 tests from 3 test suites ran. (0 ms total)
+[==========] 16 tests from 1 test suite ran. (0 ms total)
 [  PASSED  ] 16 tests.
 ```
 
@@ -941,6 +963,7 @@ Add these to the public section of `Matrix` in `include/Matrix/Matrix.h`:
                 return false;
         return true;
     }
+
     /// Returns true iff matrices do not compare equal.
     bool operator!=(const Matrix &rhs) const { return !(*this == rhs); }
 ```
@@ -1069,4 +1092,4 @@ The compiler also catch a large number of type or misuse errors. With this core
 
 You can refer to this chapter source code in
 `code-examples/learning-paths/cross-platform/matrix/chapter-3` in the archive that
-you have downloaded earlier.
+you have downloaded earlier.