diff --git a/AI-and-Analytics/Getting-Started-Samples/README.md b/AI-and-Analytics/Getting-Started-Samples/README.md index 42c9cc2323..778f2fe424 100644 --- a/AI-and-Analytics/Getting-Started-Samples/README.md +++ b/AI-and-Analytics/Getting-Started-Samples/README.md @@ -14,19 +14,19 @@ Third party program Licenses can be found here: [third-party-programs.txt](https # Getting Started Samples -|AI Tools preset bundle | Compoment | Folder | Description +|AI Tools preset | Component | Folder | Description |--------------------------| --------- | ------------------------------------------------ | - -|Deep Learning| Intel® Neural Compressor | [INC-Sample-for-PyTorch](INC-Quantization-Sample-for-PyTorch) | Performs INT8 quantization on a Hugging Face BERT model. -|Deep Learning| Intel® Neural Compressor | [INC-Sample-for-Tensorflow](INC-Sample-for-Tensorflow) | Quantizes a FP32 model into INT8 by Intel® Neural Compressor and compares the performance between FP32 and INT8. -|Deep Learning | oneAPI docker image | [IntelAIKitContainer_GettingStarted](IntelAIKitContainer_GettingStarted) | Configuration script to automatically configure the environment. -|Data Analytics | Modin | [IntelModin_GettingStarted](IntelModin_GettingStarted) | Run Modin-accelerated Pandas functions and note the performance gain. -|Data Analytics | Modin |[IntelModin_Vs_Pandas](IntelModin_Vs_Pandas)| Compares the performance of Intel® Distribution of Modin* and the performance of Pandas. +|Inference Optimization| Intel® Neural Compressor | [INC-Sample-for-PyTorch](INC-Quantization-Sample-for-PyTorch) | Performs INT8 quantization on a Hugging Face BERT model. +|Inference Optimization| Intel® Neural Compressor | [INC-Sample-for-Tensorflow](INC-Sample-for-Tensorflow) | Quantizes a FP32 model into INT8 by Intel® Neural Compressor and compares the performance between FP32 and INT8. +|Data Analytics
Classical Machine Learning
Deep Learning
Inference Optimization | oneAPI docker image | [IntelAIKitContainer_GettingStarted](IntelAIKitContainer_GettingStarted) | Configuration script to automatically configure the environment. +|Data Analytics
Classical Machine Learning | Modin | [IntelModin_GettingStarted](IntelModin_GettingStarted) | Run Modin-accelerated Pandas functions and note the performance gain. +|Data Analytics
Classical Machine Learning | Modin |[IntelModin_Vs_Pandas](IntelModin_Vs_Pandas)| Compares the performance of Intel® Distribution of Modin* and the performance of Pandas. |Classical Machine Learning| Intel® Optimization for XGBoost* | [IntelPython_XGBoost_GettingStarted](IntelPython_XGBoost_GettingStarted) | Set up and trains an XGBoost* model on datasets for prediction. |Classical Machine Learning| daal4py | [IntelPython_daal4py_GettingStarted](IntelPython_daal4py_GettingStarted) | Batch linear regression using the Python API package daal4py from oneAPI Data Analytics Library (oneDAL). -|Deep Learning| Intel® Optimization for TensorFlow* | [IntelTensorFlow_GettingStarted](IntelTensorFlow_GettingStarted) | A simple training example for TensorFlow. -|Deep Learning|Intel® Extension of PyTorch | [IntelPyTorch_GettingStarted](Intel_Extension_For_PyTorch_GettingStarted) | A simple training example for Intel® Extension of PyTorch. +|Deep Learning
Inference Optimization| Intel® Optimization for TensorFlow* | [IntelTensorFlow_GettingStarted](IntelTensorFlow_GettingStarted) | A simple training example for TensorFlow. +|Deep Learning
Inference Optimization |Intel® Extension of PyTorch | [IntelPyTorch_GettingStarted](Intel_Extension_For_PyTorch_GettingStarted) | A simple training example for Intel® Extension of PyTorch. |Classical Machine Learning| Scikit-learn (OneDAL) | [Intel_Extension_For_SKLearn_GettingStarted](Intel_Extension_For_SKLearn_GettingStarted) | Speed up a scikit-learn application using Intel oneDAL. -|Deep Learning|Intel® Extension of TensorFlow | [Intel® Extension For TensorFlow GettingStarted](Intel_Extension_For_TensorFlow_GettingStarted) | Guides users how to run a TensorFlow inference workload on both GPU and CPU. -|Deep Learning|oneCCL Bindings for PyTorch | [Intel oneCCL Bindings For PyTorch GettingStarted](Intel_oneCCL_Bindings_For_PyTorch_GettingStarted) | Guides users through the process of running a simple PyTorch* distributed workload on both GPU and CPU. | +|Deep Learning
Inference Optimization |Intel® Extension of TensorFlow | [Intel® Extension For TensorFlow GettingStarted](Intel_Extension_For_TensorFlow_GettingStarted) | Guides users how to run a TensorFlow inference workload on both GPU and CPU. +|Deep Learning
Inference Optimization |oneCCL Bindings for PyTorch | [Intel oneCCL Bindings For PyTorch GettingStarted](Intel_oneCCL_Bindings_For_PyTorch_GettingStarted) | Guides users through the process of running a simple PyTorch* distributed workload on both GPU and CPU. | *Other names and brands may be claimed as the property of others. [Trademarks](https://www.intel.com/content/www/us/en/legal/trademarks.html) diff --git a/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/README.md b/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/README.md index acfb23d012..9d241c4fdc 100644 --- a/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/README.md +++ b/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/README.md @@ -1,32 +1,25 @@ # `Mandelbrot` Sample -Mandelbrot is an infinitely complex fractal pattern that is derived from a -simple formula. This `Mandelbrot` sample demonstrates how to use SYCL*-compliant code for offloading computations to a GPU (or other devices) and further demonstrates how to optimize and improve processing time using parallelism. +Mandelbrot is an infinitely complex fractal pattern that is derived from a simple formula. This `Mandelbrot` sample demonstrates how to use SYCL*-compliant code for offloading computations to a GPU (or other devices) and further demonstrates how to optimize and improve processing time using parallelism. | Property | Description -|:--- |:--- -| What you will learn | How to offload the computation to GPU using the Intel® oneAPI DPC++/C++ Compiler -| Time to complete | 15 minutes +|:--- |:--- +| What you will learn | How to offload the computation to GPU using the Intel® oneAPI DPC++/C++ Compiler +| Time to complete | 15 minutes For comprehensive information in oneAPI programming, see the [Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide). (Use search or the table of contents to find relevant information.) ## Purpose -This `Mandelbrot` sample is a SYCL-compliant application that generates a fractal image by -initializing a matrix of 512 x 512, where the computation at each point (pixel) -is entirely independent of the computation at other points. The sample includes -both parallel and serial calculations of the set, which allows for direct results comparison. The parallel implementation demonstrates the use of -Unified Shared Memory (USM) or buffers. You can modify parameters such as the -number of rows, columns, and iterations to evaluate the difference in -performance and load between USM and buffers. - +This `Mandelbrot` sample is a SYCL-compliant application that generates a fractal image by initializing a matrix of 512 x 512, where the computation at each point (pixel) is entirely independent of the computation at other points. The sample includes +both parallel and serial calculations of the set, which allows for direct results comparison. The parallel implementation demonstrates the use of Unified Shared Memory (USM) or buffers. You can modify parameters such as the number of rows, columns, and iterations to evaluate the difference in performance and load between USM and buffers. ## Prerequisites | Property | Description -|:--- |:--- -| OS | Ubuntu* 18.04
Windows* 10 -| Hardware | Skylake with GEN9 or newer -| Software | Intel® oneAPI DPC++/C++ Compiler +|:--- |:--- +| OS | Ubuntu* 18.04
Windows* 10 +| Hardware | Skylake with GEN9 or newer +| Software | Intel® oneAPI DPC++/C++ Compiler ## Key Implementation Details @@ -34,18 +27,14 @@ The program attempts first to run on an available GPU, and it will fall back to The program output displays the compilation device and elapsed render time for the Mandelbrot image, which helps compare different offload implementations based on the complexity of the computation. -The basic SYCL implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. +The basic SYCL implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. ## Build the `Mandelbrot` Sample ### Setting Environment Variables -For working with the Command-Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by -sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -56,6 +45,9 @@ sourcing the `setvars` script every time you open a new terminal window. This pr > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> >For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. @@ -63,12 +55,8 @@ You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develo If you wish to fine tune the list of components and the version of those components, use a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. -### Include Files -The include folder is located on your development system at `%ONEAPI_ROOT%\dev-utilities\latest\include`. - ### Using Visual Studio Code* (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. @@ -149,120 +137,8 @@ Rendered image output to file: mandelbrot.png (output too large to display in te Successfully computed Mandelbrot set. ``` -## Build the `Mandelbrot` Sample in Intel® DevCloud -If running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - -1. Open a terminal on a Linux system. - -2. Log in to the Intel® DevCloud. - ``` - ssh devcloud - ``` - -3. Download the samples from GitHub. - ``` - git clone https://github.com/oneapi-src/oneAPI-samples.git - ``` - -4. Change directories to the sample directory. - ``` - cd ~/oneAPI-samples/DirectProgramming/DPC++/CombinationalLogic/mandelbrot - ``` - -### Build and Run the Sample in Batch Mode (optional) -The following instruction describe the optional process of submitting build and run jobs -in a Portable Bash Script (PBS). A job is a script that is submitted to PBS through the qsub utility. By default, the qsub utility does not inherit the current environment variables or your current working directory. For this reason, it is necessary to submit jobs as scripts that handle the setup of the environment variables. In order to address the working directory issue, you can either use absolute paths or pass the `-d \` option to qsub to set the working directory. - -### Create the Job Scripts - -1. Create a **build.sh** script in a text editor. - ``` - nano build.sh - ``` - -2. Add the following text to the **build.sh** file. - ``` - source /opt/intel/inteloneapi/setvars.sh > /dev/null 2>&1 - mkdir build - cd build - cmake .. - make - ``` - -3. Save and close the **build.sh** file. - -4. Create a **run.sh** script in a text editor. - ``` - nano run.sh - ``` - -5. Add the following text to the **run.sh** file. - ``` - source /opt/intel/inteloneapi/setvars.sh > /dev/null 2>&1 - cd build - make run - ``` - -6. Save and close the **run.sh** file. - -### Build and Run the Sample - -Jobs submitted in batch mode are placed in a queue waiting for the necessary resources (compute nodes) to become available. The jobs are executed on a first-come, first-run basis on the first available node(s) having the requested property or label. - -1. Build the sample on a GPU node. - ``` - qsub -l nodes=1:gpu:ppn=2 -d . build.sh - ``` - - `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node to the job. - - `-d .` configures the current folder as the working directory for the task. - -2. Use the qstat utility to inspect the job progress. - ``` - watch -n 1 qstat -n -1 - ``` - - The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. - -When the build job completes, there will be a **build.sh.oXXXXXX** file in the directory. - -> **Note**: Some files are written to the disk when each job terminates. ->- **.sh.eXXXX** = the job stderr -> - **.sh.oXXXX** = the job stdout -> - where **XXXX** is the job ID printed to the screen after each qsub command. - -3. Once the job completes, run the sample on a GPU node. - ``` - qsub -l nodes=1:gpu:ppn=2 -d . run.sh - ``` -4. Inspect the output of the sample. - ``` - cat run.sh.oXXXX - ``` -### Example Output in Intel® DevCloud - -You should see output similar to the following: -``` -Platform Name: Intel(R) OpenCL HD Graphics - Platform Version: OpenCL 2.1 - Device Name: Intel(R) Gen9 HD Graphics NEO - Max Work Group: 256 - Max Compute Units: 24 - -Parallel Mandelbrot set using buffers. -Rendered image output to file: mandelbrot.png (output too large to display in text) - Serial time: 0.0430331s - Parallel time: 0.00224131s -Successfully computed Mandelbrot set. -``` -5. Optionally, remove the stdout and stderr files and clean-up the project files. - ``` - rm build.sh.*; rm run.sh.*; make clean - ``` -6. Disconnect from the Intel® DevCloud. - ``` - exit - ``` ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/mandelbrot.vcxproj b/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/mandelbrot.vcxproj index 31f9d770df..f0f6b4d94c 100644 --- a/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/mandelbrot.vcxproj +++ b/DirectProgramming/C++SYCL/CombinationalLogic/mandelbrot/mandelbrot.vcxproj @@ -70,7 +70,7 @@ true pch.h Level3 - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -88,7 +88,7 @@ true pch.h Level3 - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/README.md b/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/README.md index 047ec93b3a..6a4a7867f8 100644 --- a/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/README.md +++ b/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/README.md @@ -1,29 +1,24 @@ # `Sepia Filter` Sample -The `Sepia Filter` sample is a program demonstrating how to convert a color image to a Sepia tone -image, which is a monochromatic image with a distinctive Brown Gray color. The -sample program works by offloading the compute intensive conversion of each pixel to +The `Sepia Filter` sample is a program demonstrating how to convert a color image to a Sepia tone image, which is a monochromatic image with a distinctive Brown Gray color. The sample program works by offloading the compute intensive conversion of each pixel to Sepia tone using SYCL*-compliant code for CPU and GPU. For comprehensive information about oneAPI programming, see the [Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide). (Use search or the table of contents to find relevant information quickly.) -| Property | Description -|:--- |:--- +| Property | Description +|:--- |:--- | What you will learn | How to write a custom device selector class, offload compute intensive parts of an application, and measure kernel execution time | Time to complete | 20 minutes ## Purpose -The `Sepia Filter` sample is a SYCL-compliant application that accepts a color image as an input -and converts it to a sepia tone image by applying the sepia filter coefficients -to every pixel of the image. The sample offloads the compute intensive part of the application, the processing of individual pixels, to an accelerator with the help of lambda and functor kernels. The sample also demonstrates how to use a custom device selector, which sets precedence for a GPU device over other available devices on the system. The device selected for offloading the kernel is displayed in the output and the time taken to execute each of the kernels. The application outputs a sepia tone image of the input image. +The `Sepia Filter` sample is a SYCL-compliant application that accepts a color image as an input and converts it to a sepia tone image by applying the sepia filter coefficients to every pixel of the image. The sample offloads the compute intensive part of the application, the processing of individual pixels, to an accelerator with the help of lambda and functor kernels. The sample also demonstrates how to use a custom device selector, which sets precedence for a GPU device over other available devices on the system. The device selected for offloading the kernel is displayed in the output and the time taken to execute each of the kernels. The application outputs a sepia tone image of the input image. The sample demonstrates: - Writing a custom device selector class. - Offloading compute intensive parts of the application using both lamba and functor kernels. - Measuring kernel execution time by enabling profiling. - ## Prerequisites | Optimized for | Description @@ -34,68 +29,33 @@ The sample demonstrates: ## Key Implementation Details -The basic SYCL implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. This sample demonstrates a custom device selector implementation by overwriting the SYCL device selector class, offloading computation using both lambda and functor kernels, and using event objects to time command group execution, enabling profiling. - -## Setting Environment Variables - -Configure Command-Line Interface (CLI) development for tools in the Intel® oneAPI Toolkits using environment variables. - -Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. Doing so ensures that your compiler, libraries, and tools are ready for development. - -### Linux* - -Source the script from the installation location, which is typically in one of these folders: - -For system wide installations: `. /opt/intel/oneapi/setvars.sh` - -For private installations: `. ~/intel/oneapi/setvars.sh` - -> **Note**: If you are using a non-POSIX shell, such as csh, use the following command: -> - `$ bash -c 'source /setvars.sh ; exec csh'` - -If environment variables are set correctly, you will see a confirmation message. - -> **Note**: You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. - -> **Note**: If you wish to fine tune the list of components and the version of those components, use a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. - - -### Windows* -Run the setvars.bat script from the root folder of your oneAPI installation, which is typically: - -`"C:\Program Files (x86)\Intel\oneAPI\setvars.bat"` - -For Windows PowerShell* users, execute this command: - -`cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` - -If environment variables are set correctly, you will see a confirmation message. - -#### Troubleshooting -If you receive an error message, troubleshoot the problem using the Diagnostics Utility for Intel® oneAPI Toolkits, which provides system checks to find missing -dependencies and permissions errors. See the [Diagnostics Utility for Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/diagnostic-utility-user-guide/top.html). - - +The basic SYCL implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. This sample demonstrates a custom device selector implementation by overwriting the SYCL device selector class, offloading computation using both lambda and functor kernels, and using event objects to time command group execution, enabling profiling. ## Build the `Sepia Filter` Sample -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > -> Linux: +> Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` > - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > -> Windows: +> Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. > ->For more information on environment variables, see Use the setvars Script for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is located at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (Optional) You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. @@ -133,7 +93,7 @@ make VERBOSE=1 - From the top menu, select **Debug > Start without Debugging**. - Build the program using MSBuild - - Open **x64 Native Tools Command Prompt for VS2017** or whatever is appropriate for your IDE version. + - Open **x64 Native Tools Command Prompt for VS2017** or whatever is appropriate for your IDE version. - Enter the following command: `MSBuild sepia-filter.sln /t:Rebuild /p:Configuration="Release"` @@ -168,4 +128,4 @@ Sepia tone successfully applied to image:[input/silverfalls1.png] Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/sepia-filter.vcxproj b/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/sepia-filter.vcxproj index 829af33765..9841cdd4e6 100644 --- a/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/sepia-filter.vcxproj +++ b/DirectProgramming/C++SYCL/CombinationalLogic/sepia-filter/sepia-filter.vcxproj @@ -58,7 +58,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -77,7 +77,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/README.md b/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/README.md index fe53bfe6a7..16686355f8 100644 --- a/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/README.md +++ b/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/README.md @@ -1,33 +1,21 @@ # `Complex Multiplication` Sample -The `Complex Multiplication` sample demonstrates how to multiply two large vectors of complex numbers in parallel and verifies the results. The program also implements -a custom device selector to target a specific vendor device. This program is +The `Complex Multiplication` sample demonstrates how to multiply two large vectors of complex numbers in parallel and verifies the results. The program also implements a custom device selector to target a specific vendor device. This program is implemented using SYCL* and C++ for Intel CPU and accelerators. - - | Property | Description -|:--- |:--- -| What you will learn | Using custom type classes and offloads complex number computations to GPU using SYCL* -| Time to complete | 15 minutes - +|:--- |:--- +| What you will learn | Using custom type classes and offloads complex number computations to GPU using SYCL* +| Time to complete | 15 minutes ## Purpose -This sample program shows how to create a custom device selector, how to target GPU or CPU of a specific vendor, and how to pass in a -vector of custom Complex class objects to do the parallel -executions on the device. The device used for the compilation is displayed in -the output. +This sample program shows how to create a custom device selector, how to target GPU or CPU of a specific vendor, and how to pass in a vector of custom Complex class objects to do the parallel executions on the device. The device used for the compilation is displayed in the output. -Complex multiplication multiplies two vectors with complex numbers. The -code will attempt to run the calculation on both the GPU and CPU and then -verifies the results. The size of the computation can be adjusted for -heavier workloads. If successful, the program displays the name of the offload device and along with a success message. (This sample uses buffers to manage memory. (For more information regarding different memory management options, refer to the [`Vector Add`](https://github.com/oneapi-src/oneAPI-samples/tree/master/DirectProgramming/DPC%2B%2B/DenseLinearAlgebra/vector-add) sample.) +Complex multiplication multiplies two vectors with complex numbers. The code will attempt to run the calculation on both the GPU and CPU and then verifies the results. The size of the computation can be adjusted for heavier workloads. If successful, the program displays the name of the offload device and along with a success message. (This sample uses buffers to manage memory. (For more information regarding different memory management options, refer to the [`Vector Add`](https://github.com/oneapi-src/oneAPI-samples/tree/master/DirectProgramming/DPC%2B%2B/DenseLinearAlgebra/vector-add) sample.) This `Complex Multiplication` sample includes both C++ and SYCL* implementations. - - ## Prerequisites | Optimized for | Description @@ -42,16 +30,12 @@ This program shows how we can use custom types of classes in a SYCL*-compliant p The `Complex` class, described in `Complex.hpp` is a custom class, and this program shows how we can use custom types of classes in a SYCL*-compliant program. - ## Build the `Complex Multiplication` Sample for CPU and GPU ### Setting Environment Variables -For working with the Command-Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by -sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -62,6 +46,9 @@ sourcing the `setvars` script every time you open a new terminal window. This pr > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> >For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. @@ -69,12 +56,8 @@ You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develo If you wish to fine tune the list of components and the version of those components, use a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. -### Include Files -The include folder is located on your development system at `%ONEAPI_ROOT%\dev-utilities\latest\include`. - ### Using Visual Studio Code* (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. @@ -131,60 +114,9 @@ There are no editable parameters for this sample. Complex multiplication successfully run on the device ``` -## Build the `Complex Multiplication` Sample in Intel® DevCloud - -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - -To launch build and run jobs on Intel® DevCloud submit scripts to Portable Bash Script (PBS) through the qsub utility. - -> **Note**: All parameters are already specified in the build and run scripts. - -1. Open a terminal on a Linux system. - -2. Log in to the Intel® DevCloud. - ``` - ssh devcloud - ``` - -3. Download the samples from GitHub. - ``` - git clone https://github.com/oneapi-src/oneAPI-samples.git - ``` -4. Change directories to the sample directory. - -5. Build the sample on a gpu node. - - ``` - qsub build.sh - ``` -6. Use the qstat utility to inspect the job progress. - ``` - watch -n 1 qstat -n -1 - ``` - - The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. - -When the build job completes, there will be a **build.sh.oXXXXXX** file in the directory. - -> **Note**: Some files are written to the disk when each job terminates. -> - **.sh.eXXXX** = the job stderr -> - **.sh.oXXXX** = the job stdout -> - where **XXXX** is the job ID printed to the screen after each qsub command. - - -7. After the build job completes, run the sample on a gpu node: - - ``` - qsub run.sh - ``` - -3. Inspect the output of the sample using the `cat` command. - - ``` - cat run.sh.oXXXX - ``` ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/complex_mult.vcxproj b/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/complex_mult.vcxproj index 159883684d..17f7dcdc3f 100644 --- a/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/complex_mult.vcxproj +++ b/DirectProgramming/C++SYCL/DenseLinearAlgebra/complex_mult/complex_mult.vcxproj @@ -69,7 +69,7 @@ true true pch.h - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -87,7 +87,7 @@ true true pch.h - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/DenseLinearAlgebra/guided_odd_even_merge_sort_SYCLMigration/sample.json b/DirectProgramming/C++SYCL/DenseLinearAlgebra/guided_odd_even_merge_sort_SYCLMigration/sample.json index 8eed170c55..5a2bd29cbf 100644 --- a/DirectProgramming/C++SYCL/DenseLinearAlgebra/guided_odd_even_merge_sort_SYCLMigration/sample.json +++ b/DirectProgramming/C++SYCL/DenseLinearAlgebra/guided_odd_even_merge_sort_SYCLMigration/sample.json @@ -1,7 +1,7 @@ { "guid": "17DC2EC8-9139-4BED-ABC2-6ECFB3A9ACB0", "name": "Odd Even Merge Sort", - "categories": ["Toolkit/oneAPI-samples/DirectProgramming/C++SYCL/Dense Linear Algebra"], + "categories": ["Toolkit/oneAPI-samples/oneAPI Direct Programming/C++SYCL/Dense Linear Algebra"], "description": "This is the preferred algorithm of choice for sorting batches of short-sized to mid-sized (key, value) array pairs.", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": {} } ], diff --git a/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/README.md b/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/README.md index 3c65763640..b18aeb6b03 100644 --- a/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/README.md +++ b/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/README.md @@ -10,15 +10,13 @@ The `Matrix Multiply` is a simple program that multiplies together two large mat ### Purpose -The `Matrix Multiply` sample program includes SYCL*-compliant and OpenMP C++ implementations. Each implementation is contained in an appropriately named file: `matrix_mul_sycl.cpp` and `matrix_mul_omp.cpp`. The separation provides a way to compare existing offload techniques such as OpenMP with SYCL* within a relatively simple sample. +The `Matrix Multiply` sample program includes SYCL*-compliant and OpenMP C++ implementations. Each implementation is contained in an appropriately named file: `matrix_mul_sycl.cpp` and `matrix_mul_omp.cpp`. The separation provides a way to compare existing offload techniques such as OpenMP with SYCL* within a relatively simple sample. -The code will attempt to execute on an available GPU first and fallback to the -system CPU if a compatible GPU is not detected. The device used for the -compilation is displayed in the output. +The code will attempt to execute on an available GPU first and fallback to the system CPU if a compatible GPU is not detected. The device used for the compilation is displayed in the output. ## Prerequisites -| Optimized for | Description +| Optimized for | Description |:--- |:--- | OS | Linux* Ubuntu* 18.04
Windows 10* | Hardware | Skylake with GEN9 or newer @@ -27,7 +25,7 @@ compilation is displayed in the output. ## Key implementation details -Since the sample multiples two large matrices, this sample is a slightly more complex computation than the [`Vector Add`](https://github.com/oneapi-src/oneAPI-samples/tree/master/DirectProgramming/DPC%2B%2B/DenseLinearAlgebra/vector-add) sample. This sample uses buffers to manage memory. (For more information on different memory management options, refer to the `Vector Add` sample.) +Since the sample multiples two large matrices, this sample is a slightly more complex computation than the [Vector Add](https://github.com/oneapi-src/oneAPI-samples/tree/master/DirectProgramming/C++SYCL/DenseLinearAlgebra/vector-add) sample. This sample uses buffers to manage memory. (For more information on different memory management options, refer to the `Vector Add` sample.) The default sample builds the SYCL*-compliant application, and separate OpenMP build instructions are included below. @@ -35,31 +33,29 @@ The code attempts to run the calculation on both the GPU and CPU and verify the ## Build the `Matrix Multiply` Samples -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` > - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: -> - `C:\Program Files (x86)\Intel\oneAPI\setvars.bat` -> - For PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > ->For more information on environment variables, see Use the setvars Script for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - -### Include Files -The include folder is located at `"%ONEAPI_ROOT%\dev-utilities\latest\include"` on your development system. You will need to use some of the resources from this location to build the sample. - -### Running Samples In DevCloud -If running a sample in the Intel DevCloud, remember that you must specify -the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive -mode. +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -For specific instructions, jump to [Run the sample in the DevCloud](#run-on-devcloud) +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -For more information, see the [Intel® oneAPI Base Toolkit Get Started Guide](https://devcloud.intel.com/oneapi/get-started/hpc-toolkit/) +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Using Visual Studio Code* (Optional) @@ -138,71 +134,8 @@ P = m_size / 2; ``` > **Note**: The size value must be in multiples of **8**. -### Run the `Matrix Multiply` Sample in Intel® DevCloud -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see Intel® oneAPI Base Toolkit [Get Started](https://devcloud.intel.com/oneapi/get_started/). - -## Example Output - -### SYCL* -``` -Running on device: Intel(R) Gen9 HD Graphics NEO -Problem size: c(150,600) = a(150,300) * b(300,600) -Result of matrix multiplication using SYCL: Success - The results are correct! -``` - -### OpenMP -``` -Problem size: c(150,600) = a(150,300) * b(300,600) -Running on 1 device(s) -The default device id: 0 -Result of matrix multiplication using OpenMP: Success - The results are correct! -Result of matrix multiplication using GPU offloading: Success - The results are correct! -``` - -### Running the sample in the DevCloud - -#### Build and run - -To launch build and run jobs on DevCloud submit scripts to PBS through the qsub utility. -> Note that all parameters are already specified in the build and run scripts. -1. Build the sample on a gpu node. - - ```bash - qsub build.sh - ``` - -2. When the build job completes, there will be a `build.sh.oXXXXXX` file in the directory. After the build job completes, run the sample on a gpu node: - - ```bash - qsub run.sh - ``` - -3. To build and run for OpenMP use the `build_omp.sh` and `run_omp.sh` scripts accordingly. - -#### Additional information - -1. In order to inspect the job progress, use the qstat utility. - - ```bash - watch -n 1 qstat -n -1 - ``` - - > Note: The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. -2. When a job terminates, a couple of files are written to the disk: - - .sh.eXXXX, which is the job stderr - - .sh.oXXXX, which is the job stdout - - > Here XXXX is the job ID, which gets printed to the screen after each qsub command. -3. To inspect the output of the sample use cat command. - - ```bash - cat run.sh.oXXXX - ``` - ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_dpcpp.vcxproj b/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_sycl.vcxproj similarity index 96% rename from DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_dpcpp.vcxproj rename to DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_sycl.vcxproj index e189a78c3a..4bec3d84d4 100644 --- a/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_dpcpp.vcxproj +++ b/DirectProgramming/C++SYCL/DenseLinearAlgebra/matrix_mul/matrix_mul_sycl.vcxproj @@ -107,7 +107,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -144,7 +144,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/README.md b/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/README.md index 2f8af5ca47..de46e83865 100644 --- a/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/README.md +++ b/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/README.md @@ -1,7 +1,6 @@ # `All Pairs Shortest Paths` Sample -The `All Pairs Shortest Paths` sample uses the Floyd-Warshall algorithm to find the -shortest paths between pairs of vertices in a graph. The code in the sample uses a parallel blocked algorithm that enables the application to offload compute intensive work to the GPU efficiently. +The `All Pairs Shortest Paths` sample uses the Floyd-Warshall algorithm to find the shortest paths between pairs of vertices in a graph. The code in the sample uses a parallel blocked algorithm that enables the application to offload compute intensive work to the GPU efficiently. | Property | Description |:--- |:--- @@ -9,11 +8,9 @@ shortest paths between pairs of vertices in a graph. The code in the sample uses | Time to complete | 15 minutes ## Purpose -This sample uses the blocked Floyd-Warshall all pairs shortest paths algorithm to -compute a matrix representing the minimum distance from any node to all other -nodes in the graph. +This sample uses the blocked Floyd-Warshall all pairs shortest paths algorithm to compute a matrix representing the minimum distance from any node to all other nodes in the graph. -Using parallel blocked processing, blocks can be calculated simultaneously by distributing task computations to the GPU. The application executes sequentially and in parallel with runtimes both displayed in the output, which allows you to compare the difference. +Using parallel blocked processing, blocks can be calculated simultaneously by distributing task computations to the GPU. The application executes sequentially and in parallel with runtimes both displayed in the output, which allows you to compare the difference. The parallel implementation of the blocked Floyd-Warshall algorithm has three phases. Given that a prior round of these computation phases completes, the following is true: @@ -21,7 +18,7 @@ The parallel implementation of the blocked Floyd-Warshall algorithm has three ph - Phase 2 executes only after phase 1 completes. - Phase 3 depends on phase 2, and executes only after phase 2 completes. -The inner loop of the sequential implementation is: `g[i][j] = min(g[i][j], g[i][k] + g[k][j])`. +The inner loop of the sequential implementation is: `g[i][j] = min(g[i][j], g[i][k] + g[k][j])`. Careful observation shows that for the kth iteration of the outer loop, the computation depends on cells either on the kth column, `g[i][k]` or on the kth row, `g[k][j]` of the graph. The phases occur in the following sequence: @@ -44,42 +41,34 @@ Key SYCL* concepts demonstrated in the code sample include using device selector For comprehensive information about oneAPI programming, see the [Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide). (Use search or the table of contents to find relevant information quickly.) -## Setting Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `All Pairs Shortest Paths` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - -> **Note**: You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. - -> **Note**: To tune the list of components and the version of those components, use a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. - -### Running Samples in DevCloud - -If running a sample in the Intel DevCloud, remember that you must specify the compute node (CPU, GPU, FPGA) and run in batch or interactive mode. - -For specific instructions, jump to [Run the sample in the DevCloud](#run-on-devcloud) +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -For more information, see the [Intel® oneAPI Base Toolkit Get Started Guide](https://devcloud.intel.com/oneapi/get-started/base-toolkit/) +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Using Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -87,7 +76,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -123,7 +112,6 @@ Build the program using **Visual Studio 2017** or newer. #### Troubleshooting If you receive an error message, troubleshoot the problem using the **Diagnostics Utility for Intel® oneAPI Toolkits**. The diagnostic utility provides configuration and system checks to help find missing dependencies, permissions errors, and other issues. See the [Diagnostics Utility for Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/diagnostic-utility-user-guide/top.html) for more information on using the utility. - ## Run the `All Pairs Shortest Paths` Program ### On Linux @@ -138,75 +126,10 @@ If you receive an error message, troubleshoot the problem using the **Diagnostic all-pairs-shortest-paths.exe ``` -### Run the `All Pairs Shortest Paths` Sample in Intel® DevCloud -If running a sample in the Intel® DevCloud, you must specify the compute node -(CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more -information, see the Intel® oneAPI Base Toolkit [Get Started -Guide](https://devcloud.intel.com/oneapi/get_started/). - -### Example Output -The output displays the device on which the program ran. -``` -Device: Intel(R) Gen9 -Repeating computation 8 times to measure run time ... -Iteration: 1 -Iteration: 2 -Iteration: 3 -Iteration: 4 -Iteration: 5 -Iteration: 6 -Iteration: 7 -Iteration: 8 -Successfully computed all pairs shortest paths in parallel! -Time sequential: 0.583029 sec -Time parallel: 0.159223 sec -``` - -### Running the sample in the DevCloud - -#### Build and run - -To launch build and run jobs on DevCloud submit scripts to PBS through the qsub utility. -> Note that all parameters are already specified in the build and run scripts. - -1. Build the sample on a gpu node. - - ```bash - qsub build.sh - ``` - -2. When the build job completes, there will be a `build.sh.oXXXXXX` file in the directory. After the build job completes, run the sample on a gpu node: - - ```bash - qsub run.sh - ``` - -#### Additional information - -1. In order to inspect the job progress, use the qstat utility. - - ```bash - watch -n 1 qstat -n -1 - ``` - - > Note: The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. -2. When a job terminates, a couple of files are written to the disk: - - .sh.eXXXX, which is the job stderr - - .sh.oXXXX, which is the job stdout - - > Here XXXX is the job ID, which gets printed to the screen after each qsub command. -3. To inspect the output of the sample use cat command. - - ```bash - cat run.sh.oXXXX - ``` - ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. Third party program Licenses can be found here: -[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/all-pairs-shortest-paths.vcxproj b/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/all-pairs-shortest-paths.vcxproj index 3f3f218c8d..48c1926a91 100644 --- a/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/all-pairs-shortest-paths.vcxproj +++ b/DirectProgramming/C++SYCL/GraphAlgorithms/all-pairs-shortest-paths/all-pairs-shortest-paths.vcxproj @@ -55,7 +55,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -69,7 +69,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/README.md b/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/README.md index a791dfbb6a..61c2dcfb68 100644 --- a/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/README.md +++ b/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/README.md @@ -7,28 +7,16 @@ This code sample demonstrates how to use a bitonic sort using SYCL* to offload t | Time to complete | 15 minutes ## Purpose -The algorithm converts a randomized sequence of numbers into a bitonic sequence -(two ordered sequences) and then merges these two ordered sequences into an -ordered sequence. +The algorithm converts a randomized sequence of numbers into a bitonic sequence (two ordered sequences) and then merges these two ordered sequences into an ordered sequence. The bitonic sort algorithm works according to the following summary: +- The algorithm decomposes the randomized sequence of size 2\*\*n into 2\*\*(n-1) pairs where each pair consists of 2 consecutive elements. Each pair is a bitonic sequence. -- The algorithm decomposes the randomized sequence of size 2\*\*n into 2\*\*(n-1) -pairs where each pair consists of 2 consecutive elements. Each pair is -a bitonic sequence. +- **Step 0**: For each pair (sequence of size 2), the two elements are swapped so that the two consecutive pairs form a bitonic sequence in increasing order. The next two pairs form the second bitonic sequence in decreasing order. The next two pairs form the third bitonic sequence in increasing order, and so forth. At the end of this step, there are 2\*\*(n-1) bitonic sequences of size 2, and the sequences follow an order of increasing, decreasing, increasing, ..., decreasing. They form 2\*\*(n-2) bitonic sequences of size 4. -- **Step 0**: For each pair (sequence of size 2), the two elements are swapped so -that the two consecutive pairs form a bitonic sequence in increasing order. The next two pairs form the second bitonic sequence in decreasing order. The next -two pairs form the third bitonic sequence in increasing order, and so forth. At the -end of this step, there are 2\*\*(n-1) bitonic sequences of size 2, and the sequences follow an order of increasing, decreasing, increasing, ..., decreasing. They form 2\*\*(n-2) bitonic sequences of size 4. +- **Step 1**: For each new 2\*\*(n-2) bitonic sequences of size 4, (each new sequence consists of 2 consecutive previous sequences), the algorithm swaps the elements so that at the end of step 1, there are 2\*\*(n-2) bitonic sequences of size 4. The sequences follow an order: increasing, decreasing, increasing, ..., decreasing. They form 2\*\*(n-3) bitonic sequences of size 8. The same logic applies until the algorithm reaches the last step. -- **Step 1**: For each new 2\*\*(n-2) bitonic sequences of size 4, (each new -sequence consists of 2 consecutive previous sequences), the algorithm swaps the elements so -that at the end of step 1, there are 2\*\*(n-2) bitonic sequences of size 4. The sequences follow an order: increasing, decreasing, increasing, ..., decreasing. They form 2\*\*(n-3) bitonic sequences of size 8. The same logic applies until the algorithm reaches the last step. - -- **Step n**: In the last step, there is one bitonic sequence of size 2\*\*n. The -elements in the sequence are swapped until the sequences are in increasing -order. +- **Step n**: In the last step, there is one bitonic sequence of size 2\*\*n. The elements in the sequence are swapped until the sequences are in increasing order. ## Prerequisites | Optimized for | Description @@ -38,60 +26,47 @@ order. | Software | Intel® oneAPI DPC++/C++ Compiler ## Key Implementation Details -The basic SYCL* implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. Unified Shared Memory (USM) and -Buffer Object are used for data management. - -The code attempts to execute on an available GPU and it will fall back to the system CPU -if it cannot detect a compatible GPU. - -### Using Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +The basic SYCL* implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. Unified Shared Memory (USM) and Buffer Object are used for data management. -The basic steps to build and run a sample using VS Code include: - 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. - 2. Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. - 3. Open a terminal in VS Code (**Terminal > New Terminal**). - 4. Run the sample in the VS Code terminal using the instructions below. - -To learn more about the extensions and how to configure the oneAPI environment, see the -[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). +The code attempts to execute on an available GPU and it will fall back to the system CPU if it cannot detect a compatible GPU. -## Setting Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - -> **Note**: You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. +## Build the `Bitonic Sort` Program for CPU and GPU -> **Note**: If you want to fine tune the list of components and the version of those components, use a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -## Build the `Bitonic Sort` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. -### Running Samples In DevCloud -If running a sample in the Intel DevCloud, remember that you must specify the compute node (CPU, GPU, -FPGA) as well as whether to run in batch or interactive mode. +### Using Visual Studio Code* (VS Code) (Optional) +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. -For specific instructions, jump to [Run the sample in the DevCloud](#run-on-devcloud) +The basic steps to build and run a sample using VS Code include: + 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. + 2. Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. + 3. Open a terminal in VS Code (**Terminal > New Terminal**). + 4. Run the sample in the VS Code terminal using the instructions below. -For more information, see the Intel® oneAPI -Base Toolkit Get Started Guide (https://devcloud.intel.com/oneapi/get-started/base-toolkit/) +To learn more about the extensions and how to configure the oneAPI environment, see the +[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* 1. Change to the sample directory. @@ -149,11 +124,6 @@ Guide](https://www.intel.com/content/www/us/en/develop/documentation/diagnostic- ``` bitonic-sort 21 47 ``` -### Run the `Bitonic Sort` Sample in Intel® DevCloud -If running a sample in the Intel® DevCloud, you must specify the compute node -(CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more -information, see the Intel® oneAPI Base Toolkit [Get Started -Guide](https://devcloud.intel.com/oneapi/get_started/). ### Application Parameters The input values for `` and `` are configurable. Default values for the sample are `` = 21 and `` = 47. @@ -182,53 +152,10 @@ CPU serial time: 0.628803 sec Success! ``` -### Running the sample in the DevCloud - -#### Build and run - -To launch build and run jobs on DevCloud submit scripts to PBS through the qsub utility. -> Note that all parameters are already specified in the build and run scripts. - -1. Build the sample on a gpu node. - - ```bash - qsub build.sh - ``` - -2. When the build job completes, there will be a `build.sh.oXXXXXX` file in the directory. After the build job completes, run the sample on a gpu node: - - ```bash - qsub run.sh - ``` - -3. To build and run for FPGA emulator use accordingly the `build_fpga_emu.sh` and `run_fpga_emu.sh` scripts, for FPGA hardware use the `build_fpga.sh` and `run_fpga.sh` scripts. - -#### Additional information - -1. In order to inspect the job progress, use the qstat utility. - - ```bash - watch -n 1 qstat -n -1 - ``` - - > Note: The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. -2. When a job terminates, a couple of files are written to the disk: - - .sh.eXXXX, which is the job stderr - - .sh.oXXXX, which is the job stdout - - > Here XXXX is the job ID, which gets printed to the screen after each qsub command. -3. To inspect the output of the sample use cat command. - - ```bash - cat run.sh.oXXXX - ``` - ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. Third party program Licenses can be found here: -[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/bitonic-sort.vcxproj b/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/bitonic-sort.vcxproj index 6c4d66bf50..4a84fb8ae0 100644 --- a/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/bitonic-sort.vcxproj +++ b/DirectProgramming/C++SYCL/GraphTraversal/bitonic-sort/bitonic-sort.vcxproj @@ -58,7 +58,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -71,7 +71,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/README.md b/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/README.md index 9a4b355306..93a6ccbc0d 100644 --- a/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/README.md +++ b/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/README.md @@ -1,10 +1,6 @@ # `Hidden Markov Models` Sample -The `Hidden Markov Models` sample presents a statistical model using a Markov -process to present graphable nodes that are otherwise in an unobservable state -or “hidden”. This technique helps with pattern recognition such as speech, -handwriting, gesture recognition, parts-of-speech tagging, partial discharges, and -bioinformatics. The sample offloads the complexity of the Markov process to the -GPU. + +The `Hidden Markov Models` sample presents a statistical model using a Markov process to present graphable nodes that are otherwise in an unobservable state or “hidden”. This technique helps with pattern recognition such as speech, handwriting, gesture recognition, parts-of-speech tagging, partial discharges, and bioinformatics. The sample offloads the complexity of the Markov process to the GPU. | Property | Description |:--- |:--- @@ -15,37 +11,21 @@ GPU. The sample can use GPU offload to compute sequential steps of multiple graph traversals simultaneously. -The directed edges of this graph are possible transitions between nodes or -states defined with the following parameters: +The directed edges of this graph are possible transitions between nodes or states defined with the following parameters: - the number of states is N -- the transition matrix A is a square matrix of size - N -- Each element with indexes (i,j) of this matrix determines the probability to - move from the state i to the state j on any step of the Markov process (i and +- the transition matrix A is a square matrix of size N +- Each element with indexes (i,j) of this matrix determines the probability to move from the state i to the state j on any step of the Markov process (i and j can be the same if the state does not change on the taken step) -The main assumption in the method is that there are visible observations that -depend on the current Markov process. The dependency can be described as a -conditional probability distribution (represented by emission matrix). The -problem is to find out the most likely chain of the hidden Markov states using -the given observations set. +The main assumption in the method is that there are visible observations that depend on the current Markov process. The dependency can be described as a conditional probability distribution (represented by emission matrix). The problem is to find out the most likely chain of the hidden Markov states using the given observations set. -This code sample implements the Viterbi algorithm, a dynamic programming -algorithm for finding the most likely sequence of hidden states—called the -Viterbi path—that results in a sequence of observed events, especially in Markov -information sources and HMM. +This code sample implements the Viterbi algorithm, a dynamic programming algorithm for finding the most likely sequence of hidden states—called the +Viterbi path—that results in a sequence of observed events, especially in Markov information sources and HMM. -- Initially, the dataset for algorithm processing is generated: initial states - probability distribution Pi, transition matrix A, emission matrix B, and the - sequence or the observations produced by hidden Markov process. -- First, the matrix of Viterbi values on the first states is initialized using - distribution Pi and emission matrix B. The matrix of back pointers is - initialized with default values -1. -- Then, for each time step, the Viterbi matrix is set to the maximal possible - value using A, B, and Pi. -- Finally, the state with maximum Viterbi value on the last step is set as a path to the Viterbi final state. The previous nodes of this path are determined - using the back pointers matrix correspondent rows for each step except the - last one. +- Initially, the dataset for algorithm processing is generated: initial states probability distribution Pi, transition matrix A, emission matrix B, and the sequence or the observations produced by hidden Markov process. +- First, the matrix of Viterbi values on the first states is initialized using distribution Pi and emission matrix B. The matrix of back pointers is initialized with default values -1. +- Then, for each time step, the Viterbi matrix is set to the maximal possible value using A, B, and Pi. +- Finally, the state with maximum Viterbi value on the last step is set as a path to the Viterbi final state. The previous nodes of this path are determined using the back pointers matrix correspondent rows for each step except the last one. > **Note**: The implementation uses logarithms of the probabilities to process > small numbers correctly and replace multiplication operations with addition @@ -59,56 +39,36 @@ information sources and HMM. | Software | Intel® oneAPI DPC++ Compiler ## Key Implementation Details -The basic SYCL* implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. - -## Setting Environment Variables -When working with the command-line interface (CLI), you should configure the -oneAPI toolkits using environment variables. Set up your CLI environment by -sourcing the `setvars` script every time you open a new terminal window. This -practice ensures that your compiler, libraries, and tools are ready for -development. +The basic SYCL* implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. ## Build the `Hidden Markov Models` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI environment by -> sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source -> /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program -> Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the -> setvars Script with Linux* or -> macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) -> or [Use the setvars Script with -> Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - -> **Note**: You can use [Modulefiles -> scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) -> to set up your development environment. The modulefiles scripts work with all -> Linux shells. - -> **Note**: If you want to fine tune the list of components and the version of -> those components, use a [setvars config -> file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) -> to set up your development environment. +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your -development system. You might need to use some of the resources from this -location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Using Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment @@ -138,7 +98,7 @@ If an error occurs, you can get more details by running `make` with the make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio*** Build the program using **Visual Studio 2017** or newer. @@ -180,55 +140,6 @@ Use **Visual Studio 2017** or newer. 2. Right-click on the solution file and open the solution in the IDE. 3. From the top menu, select **Debug** -> **Start without Debugging**. -### Run the `Hidden Markov Models` Sample in Intel® DevCloud (Optional) -When running a sample in the Intel® DevCloud, you must specify the compute node -(CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more -information, see the Intel® oneAPI Base Toolkit [Get Started -Guide](https://devcloud.intel.com/oneapi/get_started/). - -#### Build and Run Samples in Batch Mode (Optional) -You can submit build and run jobs through a Portable Bash Script (PBS). A job is -a script that submitted to PBS through the `qsub` utility. By default, the -`qsub` utility does not inherit the current environment variables or your -current working directory, so you might need to submit jobs to configure the -environment variables. To indicate the correct working directory, you can use -either absolute paths or pass the `-d \` option to `qsub`. - -1. Open a terminal on a Linux* system. - -2. Log in to the Intel® DevCloud. - ``` - ssh devcloud - ``` -3. Download the samples from GitHub. - ``` - git clone https://github.com/oneapi-src/oneAPI-samples.git - ``` -4. Change to the sample directory. - -5. Configure the sample for a GPU node. (This is a single line script.) -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - - `-I` (upper case I) requests an interactive session. - - `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. - - `-d .` makes the current folder as the working directory for the task. - - > **Note**: To inspect job progress, use the qstat utility. - > ``` - > watch -n 1 qstat -n -1 - > ``` - > The command displays the results every second. The job is complete when no - > new results display. - -6. Perform build steps you would on Linux. (Including optionally cleaning the - project.) -7. Run the sample. -8. Disconnect from the Intel® DevCloud. -``` -exit -``` - ## Example Output ### Example Output for CPU on Linux ``` @@ -240,96 +151,10 @@ The sample completed successfully! [100%] Built target run ``` -### Running the Hidden Markov Model sample in the DevCloud - -1. Open a terminal on your Linux system. 2. Log in to DevCloud. -``` -ssh devcloud -``` -3. Download the samples. -``` -git clone https://github.com/oneapi-src/oneAPI-samples.git -``` - -4. Change directories to the Hidden Markov Model sample directory. -``` -cd ~/oneAPI-samples/DirectProgramming/DPC++/GraphTraversal/hidden-markov-models -``` -### Build and run the sample in batch mode - -The following describes the process of submitting build and run jobs to PBS. A -job is a script that is submitted to PBS through the qsub utility. By default, -the qsub utility does not inherit the current environment variables or your -current working directory. For this reason, it is necessary to submit jobs as -scripts that handle the setup of the environment variables. In order to address -the working directory issue, you can either use absolute paths or pass the -d -\ option to qsub to set the working directory. - -#### Build and run using prepared scripts - -To launch build and run jobs on DevCloud submit scripts to PBS through the qsub utility. Jobs submitted in batch mode are placed in a queue waiting for the necessary -resources (compute nodes) to become available. The jobs will be executed on a first come basis on the first available node(s) having the requested property or label. -> Note that all parameters are already specified in the build and run scripts. - -1. Build the sample on a gpu node. - - ```bash - qsub build.sh - ``` - -If an error occurs, you can get more details by running `make` with the -`VERBOSE=1` argument: -``` -make VERBOSE=1 -``` - -2. When the build job completes, there will be a `build.sh.oXXXXXX` file in the directory. After the build job completes, run the sample on a gpu node: - - ```bash - qsub run.sh - ``` - -3. To build and run for FPGA emulator use accordingly the `build_fpga_emu.sh` and `run_fpga_emu.sh` scripts, for FPGA hardware use the `build_fpga.sh` and `run_fpga.sh` scripts. - -#### Additional information - -1. In order to inspect the job progress, use the qstat utility. - - ```bash - watch -n 1 qstat -n -1 - ``` - - > Note: The watch `-n 1` command is used to run `qstat -n -1` and display its results every second. If no results are displayed, the job has completed. - -2. When a job terminates, a couple of files are written to the disk: - - .sh.eXXXX, which is the job stderr - - .sh.oXXXX, which is the job stdout - - > Here XXXX is the job ID, which gets printed to the screen after each qsub command. -3. To inspect the output of the sample use cat command. - - ```bash - cat run.sh.oXXXX - ``` - - You should see output similar to this: - - ``` - [100%] Built target hidden-markov-models - Scanning dependencies of target run - Device: Intel(R) UHD Graphics P630 [0x3e96] Intel(R) Level-Zero - The Viterbi path is: - 16 4 17 0 16 8 16 4 17 0 1 4 17 8 16 8 16 8 12 11 - The sample completed successfully! - [100%] Built target run - ``` - ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. Third party program Licenses can be found here: -[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/hidden-markov-models.vcxproj b/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/hidden-markov-models.vcxproj index 667d37de70..003947cf49 100644 --- a/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/hidden-markov-models.vcxproj +++ b/DirectProgramming/C++SYCL/GraphTraversal/hidden-markov-models/hidden-markov-models.vcxproj @@ -96,7 +96,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Disabled Level3 @@ -126,7 +126,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Disabled Level3 diff --git a/DirectProgramming/C++SYCL/Jupyter/cuda-to-sycl-migration-training/sample.json b/DirectProgramming/C++SYCL/Jupyter/cuda-to-sycl-migration-training/sample.json index b212d57d29..b8fefa70f5 100755 --- a/DirectProgramming/C++SYCL/Jupyter/cuda-to-sycl-migration-training/sample.json +++ b/DirectProgramming/C++SYCL/Jupyter/cuda-to-sycl-migration-training/sample.json @@ -1,7 +1,7 @@ { "guid": "f0bf5cb2-59cb-488e-8f55-0752b8f55681", "name": "CUDA to SYCL Migration", - "categories": [ "Toolkit/oneAPI Direct Programming/DPC++/Tutorials Jupyter Notebooks" ], + "categories": [ "Toolkit/oneAPI Direct Programming/C++SYCL/Tutorials Jupyter Notebooks" ], "description": "CUDA_To_SYCL_Migration Tutorials using Jupyter Notebooks", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": { "properties": { "projectOptions": [ { "projectType": "makefile" } ] } } } ], diff --git a/DirectProgramming/C++SYCL/Jupyter/gpu-optimization-sycl-training/sample.json b/DirectProgramming/C++SYCL/Jupyter/gpu-optimization-sycl-training/sample.json index 4bd15cad5b..a306f1103a 100755 --- a/DirectProgramming/C++SYCL/Jupyter/gpu-optimization-sycl-training/sample.json +++ b/DirectProgramming/C++SYCL/Jupyter/gpu-optimization-sycl-training/sample.json @@ -1,7 +1,7 @@ { "guid": "6ebfe36c-85f8-46cf-90c6-67ed4840487c", "name": "GPU Optimization using SYCL", - "categories": [ "Toolkit/oneAPI Direct Programming/DPC++/Tutorials Jupyter Notebooks" ], + "categories": [ "Toolkit/oneAPI Direct Programming/C++SYCL/Tutorials Jupyter Notebooks" ], "description": "GPU Optimization using SYCL training course with code samples", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": { "properties": { "projectOptions": [ { "projectType": "makefile" } ] } } } ], diff --git a/DirectProgramming/C++SYCL/Jupyter/oneapi-essentials-training/07_oneDPL_Library/gamma-correction/gamma-correction.vcxproj b/DirectProgramming/C++SYCL/Jupyter/oneapi-essentials-training/07_oneDPL_Library/gamma-correction/gamma-correction.vcxproj index 65557f1e15..313ec50a12 100644 --- a/DirectProgramming/C++SYCL/Jupyter/oneapi-essentials-training/07_oneDPL_Library/gamma-correction/gamma-correction.vcxproj +++ b/DirectProgramming/C++SYCL/Jupyter/oneapi-essentials-training/07_oneDPL_Library/gamma-correction/gamma-correction.vcxproj @@ -45,15 +45,17 @@ Application true - Intel(R) oneAPI DPC++ Compiler + Intel(R) oneAPI DPC++ Compiler 2024 Unicode + true Application false - Intel(R) oneAPI DPC++ Compiler + Intel(R) oneAPI DPC++ Compiler 2024 true Unicode + true @@ -114,19 +116,11 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\tbb\latest\include;%(AdditionalIncludeDirectories) Console true - /link /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib/intel64/vc14" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\redist\intel64\vc14\tbb.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - - - copy tbb.dll to binary folder - @@ -157,21 +151,13 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\tbb\latest\include;%(AdditionalIncludeDirectories) Console true true true - /link /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib/intel64/vc14" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\redist\intel64\vc14\tbb.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - - - copy tbb.dll to binary folder - diff --git a/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/MonteCarloPi.vcxproj b/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/MonteCarloPi.vcxproj index fbbe50c3ed..6e7df53381 100644 --- a/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/MonteCarloPi.vcxproj +++ b/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/MonteCarloPi.vcxproj @@ -40,7 +40,7 @@ - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Disabled false @@ -50,7 +50,7 @@ - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ MaxSpeed false diff --git a/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/README.md b/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/README.md index a5b5b95f56..c0c5a07600 100644 --- a/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/README.md +++ b/DirectProgramming/C++SYCL/MapReduce/MonteCarloPi/README.md @@ -16,7 +16,7 @@ This method of estimation works for calculating pi because the expected value of The Monte Carlo procedure for estimating pi is easily parallelized, as each calculation of a random coordinate point can be considered a discrete work item. The computations involved with each work item are entirely independent of one another except for in summing the total number of points inscribed within the circle. This code sample demonstrates how to utilize the SYCL compliant reduction extension in the compiler for this purpose. -The code attempts to execute on an available GPU and will fall back to the system CPU if a compatible GPU is not detected. The device used for the compilation is displayed in the output, along with the elapsed time to complete the computation. +The code attempts to execute on an available GPU and will fall back to the system CPU if a compatible GPU is not detected. The device used for the compilation is displayed in the output, along with the elapsed time to complete the computation. ## Prerequisites | Optimized for | Description @@ -29,26 +29,33 @@ The code attempts to execute on an available GPU and will fall back to the syste The basic SYCL standard implementation explained in the code includes device selector, buffer, accessor, kernel, and reduction. ## Build the `Monte Carlo Pi` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Using Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment,create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -56,7 +63,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -72,7 +79,7 @@ the `VERBOSE=1` argument: ``` make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio*** Build the program using **Visual Studio 2017** or newer. @@ -94,7 +101,7 @@ The sample has several configurable parameters in the `monte_carlo_pi.cpp` sourc |Parameter |Description |:--- |:--- -|`size_n` | Defines the sample size for the Monte Carlo procedure. +|`size_n` | Defines the sample size for the Monte Carlo procedure. |`size_wg` | Defines the size of workgroups inside the kernel code. The number of workgroups is calculated by dividing `size_n` by `size_wg`, so size_n must be greater than or equal to `size_wg`. Increasing `size_n` will increase computation time as well as the accuracy of the pi estimation. Changing `size_wg` will have different performance effects depending on the device used for offloading. |`img_dimensions` | Defines the size of the output image for data visualization. |`circle_outline`| Defines the thickness of the circular border in the output image for data visualization. Setting it to zero will remove it entirely. @@ -114,8 +121,6 @@ The sample has several configurable parameters in the `monte_carlo_pi.cpp` sourc ``` MonteCarloPi.exe ``` -### Run the `Monte Carlo Pi` Sample in Intel® DevCloud -If running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). ## Example Output In addition to displaying output similar to the following, the program creates a rendered image plot of the computation to a file: `MonteCarloPi.bmp`. @@ -134,4 +139,4 @@ The simulation plot graph has been written to 'MonteCarloPi.bmp' Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/MapReduce/guided_MonteCarloMultiGPU_SYCLMigration/sample.json b/DirectProgramming/C++SYCL/MapReduce/guided_MonteCarloMultiGPU_SYCLMigration/sample.json index 1d42ff6116..5c5b8e3629 100644 --- a/DirectProgramming/C++SYCL/MapReduce/guided_MonteCarloMultiGPU_SYCLMigration/sample.json +++ b/DirectProgramming/C++SYCL/MapReduce/guided_MonteCarloMultiGPU_SYCLMigration/sample.json @@ -1,7 +1,7 @@ { "guid": "81E7955F-AD50-4223-9219-BB9DF13CE161", "name": "MontecarloMultiGPU", - "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/MapReduce"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/Map Reduce"], "description": "Evaluates fair call price for a given set of European Options using the MonteCarlo approach", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": {} } ], diff --git a/DirectProgramming/C++SYCL/MapReduce/guided_quasirandomGenerator_SYCLMigration/sample.json b/DirectProgramming/C++SYCL/MapReduce/guided_quasirandomGenerator_SYCLMigration/sample.json index 64b10d5c0f..826f7993af 100644 --- a/DirectProgramming/C++SYCL/MapReduce/guided_quasirandomGenerator_SYCLMigration/sample.json +++ b/DirectProgramming/C++SYCL/MapReduce/guided_quasirandomGenerator_SYCLMigration/sample.json @@ -1,7 +1,7 @@ { "guid": "C4E5E5BE-4A2D-4362-97B2-52289E113B94", "name": "quasirandomGenerator", - "categories": ["Toolkit/oneAPI-samples/DirectProgramming/C++SYCL/MapReduce"], + "categories": ["Toolkit/oneAPI-samples/oneAPI Direct Programming/C++SYCL/Map Reduce"], "description": "Implements Niederreiter Quasirandom Sequence Generator and Inverse Cumulative Normal Distribution functions for the generation of Standard Normal Distributions.", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": {} } ], diff --git a/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/Nbody.vcxproj b/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/Nbody.vcxproj index bb1478f12f..50f8f9870c 100644 --- a/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/Nbody.vcxproj +++ b/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/Nbody.vcxproj @@ -74,7 +74,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -93,7 +93,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/README.md b/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/README.md index a40b761ac3..c61c041a1c 100644 --- a/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/README.md +++ b/DirectProgramming/C++SYCL/N-BodyMethods/Nbody/README.md @@ -21,30 +21,34 @@ This algorithm is highly data parallel, so the code a good candidate to offload ## Key Implementation Details The basic SYCL* compliant implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `Nbody` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -52,7 +56,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -69,7 +73,7 @@ the `VERBOSE=1` argument: make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio** Build the program using **Visual Studio 2017** or newer. @@ -103,54 +107,6 @@ If you receive an error message, troubleshoot the problem using the **Diagnostic Nbody.exe ``` -### Run 'Nbody' Sample in Intel® DevCloud (Optional) -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - -#### Build and Run Samples in Batch Mode (Optional) -You can submit build and run jobs through a Portable Bash Script (PBS). A job is a script that submitted to PBS through the `qsub` utility. By default, the `qsub` utility does not inherit the current environment variables or your current working directory, so you might need to submit jobs to configure the environment variables. To indicate the correct working directory, you can use either absolute paths or pass the `-d \` option to `qsub`. - -If you choose to use scripts, jobs terminate with writing a couple of files to the disk: -- `.sh.eXXXX` is the job stderr -- `.sh.oXXXX` is the job stdout - - Here `XXXX` is the job ID, which gets printed to the screen after each `qsub` command. - -You can inspect output of the sample. -``` -cat run.sh.oXXXX -``` -#### Build and Run on Intel® DevCloud -1. Open a terminal on a Linux* system. -2. Log in to the Intel® DevCloud. - ``` - ssh devcloud - ``` -3. Download the samples from GitHub. - ``` - git clone https://github.com/oneapi-src/oneAPI-samples.git - ``` -4. Change to the sample directory. -5. Configure the sample for a GPU node. (This is a single line script.) - ``` - qsub -I -l nodes=1:gpu:ppn=2 -d . - ``` - - `-I` (upper case I) requests an interactive session. - - `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. - - `-d .` makes the current folder as the working directory for the task. - -> **Note**: To inspect job progress, use the qstat utility. -> ``` -> watch -n 1 qstat -n -1 -> ``` -> The command displays the results every second. The job is complete when no new results display. - -6. Perform build steps you would on Linux. (Including optionally cleaning the project.) -7. Run the sample. -8. Disconnect from the Intel® DevCloud. - ``` - exit - ``` - ## Example Output ### Application Parameters You can modify the `NBody` sample simulation parameters in `GSimulation.cpp`. Configurable parameters include: @@ -187,33 +143,9 @@ s dt kenergy time (s) GFLOPS =============================== Built target run ``` -### Example Output on Intel® DevCloud -``` -Scanning dependencies of target run -=============================== - Initialize Gravity Simulation - nPart = 16000; nSteps = 10; dt = 0.1 ------------------------------------------------- - s dt kenergy time (s) GFLOPS ------------------------------------------------- - 1 0.1 26.405 0.43625 17.019 - 2 0.2 313.77 0.02133 348.07 - 3 0.3 926.56 0.021546 344.59 - 4 0.4 1866.4 0.02152 345 - 5 0.5 3135.6 0.021458 346 - 6 0.6 4737.6 0.021434 346.38 - 7 0.7 6676.6 0.02143 346.45 - 8 0.8 8957.7 0.021482 345.6 - 9 0.9 11587 0.021293 348.68 - 10 1 14572 0.021324 348.16 - -# Total Time (s) : 0.62911 -# Average Performance : 346.36 +- 1.3384 -=============================== -Built target run -``` + ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/PrefixSum.vcxproj b/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/PrefixSum.vcxproj index f8197e77cb..06633f79b4 100644 --- a/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/PrefixSum.vcxproj +++ b/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/PrefixSum.vcxproj @@ -51,7 +51,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -64,7 +64,7 @@ - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/README.md b/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/README.md index 219a5956b1..b88e0cda4e 100644 --- a/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/README.md +++ b/DirectProgramming/C++SYCL/ParallelPatterns/PrefixSum/README.md @@ -8,8 +8,7 @@ offload the computation to a GPU. In this implementation, a random sequence of 2 | Time to complete | 15 minutes ## Purpose -Given a randomized sequence of numbers x0, x1, x2, ..., xn, this algorithm computes and returns -a new sequence y0, y1, y2, ..., yn so that: +Given a randomized sequence of numbers x0, x1, x2, ..., xn, this algorithm computes and returns a new sequence y0, y1, y2, ..., yn so that: y0 = x0
y1 = x0 + x1
@@ -42,30 +41,34 @@ The basic concepts explained in the code include device selector, buffer, access The code attempts to execute on an available GPU and the code falls back to the system CPU if a compatible GPU is not detected. -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Building the `PrefixSum` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -73,7 +76,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -91,7 +94,7 @@ the `VERBOSE=1` argument: make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio*** Build the program using **Visual Studio 2017** or newer. @@ -139,20 +142,8 @@ of the results in the CPU. The results are verified if yk = yk-1 + xk match. If PrefixSum.exe 21 47 ``` -### Running Samples in Intel® DevCloud -If running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. For more information, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - -## Example Output -``` -Sequence size: 2097152, seed: 47 -Num iteration: 21 -Device: Intel(R) Gen9 HD Graphics NEO -Kernel time: 170 ms - -Success! -``` ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/README.md b/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/README.md index de1ab6cc62..9dee4c543b 100644 --- a/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/README.md +++ b/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/README.md @@ -19,9 +19,9 @@ The concepts demonstrated by the sample are: | Optimized for | Description |:--- |:--- -| OS | Ubuntu* 18.04
Windows* 10 -| Hardware | Skylake with GEN9 or newer -| Software | Intel® oneAPI DPC++/C++ Compiler +| OS | Ubuntu* 18.04
Windows* 10 +| Hardware | Skylake with GEN9 or newer +| Software | Intel® oneAPI DPC++/C++ Compiler ## Key Implementation Details @@ -29,29 +29,31 @@ The loop unrolling mechanism is used to increase program parallelism by duplicat The code in this sample will attempt to run on a compatible GPU. If the program cannot find a compatible GPU, it will fall back to the CPU. -## Set Environment Variables - -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `Loop Unroll` Sample -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -### Include Files +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) @@ -64,7 +66,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the Linux* instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -129,33 +131,10 @@ If you receive an error message, troubleshoot the problem using the **Diagnostic loop-unroll.exe ``` - -### Build and Run the `Loop Unroll` Sample in Intel® DevCloud (Optional) - -When running a sample in the Intel® DevCloud, you should specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. - -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -|Available Nodes |Command Options -|:--- |:--- -|GPU |`qsub -l nodes=1:gpu:ppn=2 -d .` -|CPU |`qsub -l nodes=1:xeon:ppn=2 -d .` - ->**Note**: For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - #### Build and Run the Sample Follow the Linux instructions to build and run the program. -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - - ## Example Output ``` @@ -179,4 +158,4 @@ PASSED: The results are correct. Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/loop-unroll.vcxproj b/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/loop-unroll.vcxproj index 2ffded98dd..fff2650dad 100644 --- a/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/loop-unroll.vcxproj +++ b/DirectProgramming/C++SYCL/ParallelPatterns/loop-unroll/loop-unroll.vcxproj @@ -55,7 +55,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -70,7 +70,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/README.md b/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/README.md index 47783a0f1d..4f5c7c1860 100644 --- a/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/README.md +++ b/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/README.md @@ -17,9 +17,9 @@ Sparse linear algebra algorithms are common in high-performance computing in fie | Software | Intel® oneAPI DPC++/C++ Compiler ## Key Implementation Details -This sample demonstrates the concepts of using a device selector, unified shared memory, kernel, and command groups in order to implement a solution using a parallel merge method. +This sample demonstrates the concepts of using a device selector, unified shared memory, kernel, and command groups in order to implement a solution using a parallel merge method. -To allow comparison between methods, the application runs sequentially and in parallel with run times for each method displayed in the output. The program output also includes the device on which code ran. +To allow comparison between methods, the application runs sequentially and in parallel with run times for each method displayed in the output. The program output also includes the device on which code ran. > **Note**: The workgroup size requirement is **256**. If your hardware cannot support this size, the application shows an error. @@ -34,30 +34,34 @@ In the parallel merge, each thread independently identifies its scope of the mer The program will attempt to run on a compatible GPU. If a compatible GPU is not detected or available, the code will execute on the CPU instead. -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `Merge SPMV` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -65,7 +69,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -121,19 +125,6 @@ If you receive an error message, troubleshoot the problem using the **Diagnostic merge-spmv.exe ``` -### Build and Run the `Merge SPMV` Sample in Intel® DevCloud (Optional) -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - ## Example Output The following output is for a GPU. CPU results are similar. ``` @@ -165,4 +156,4 @@ Time parallel: 0.00909913 sec Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/merge-spmv.vcxproj b/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/merge-spmv.vcxproj index 85a92b2f48..e625d46a12 100644 --- a/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/merge-spmv.vcxproj +++ b/DirectProgramming/C++SYCL/SparseLinearAlgebra/merge-spmv/merge-spmv.vcxproj @@ -55,7 +55,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -69,7 +69,7 @@ Level3 - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/README.md b/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/README.md index bdbc66c7c3..326e796907 100644 --- a/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/README.md +++ b/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/README.md @@ -7,7 +7,7 @@ Discrete Cosine Transform (DCT) and Quantization are the first two steps in the | Time to complete | 15 minutes ## Purpose -Discrete Cosine Transform (DCT) is a lossy compression algorithm used to represent every data point value using the sum of cosine functions, which are linearly orthogonal. +Discrete Cosine Transform (DCT) is a lossy compression algorithm used to represent every data point value using the sum of cosine functions, which are linearly orthogonal. The sample program shows the possible effect of quality reduction in the image when one performs DCT, followed by quantization as found in JPEG compression. @@ -44,33 +44,34 @@ The program will attempt to run on a compatible GPU. If a compatible GPU is not >**Note**: For comprehensive information about oneAPI programming, see the [Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide). (Use search or the table of contents to find relevant information quickly.) -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `Discrete Cosine Transform` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). ->**Note**: You can get the common resources from the [oneAPI-samples](https://github.com/oneapi-src/oneAPI-samples/tree/master/common) GitHub repository. +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -78,7 +79,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -97,7 +98,7 @@ the `VERBOSE=1` argument: make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio*** Build the program using **Visual Studio 2017** or newer. @@ -149,22 +150,6 @@ where: DCT.exe ../../res/willyriver.bmp ../../res/willyriver_processed.bmp ``` -### Build and Run the `Discrete Cosine Transform` Sample in Intel® DevCloud (Optional) - -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. - -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - ## Example Output ``` Filename: willyriver.bmp W: 5184 H: 3456 @@ -181,4 +166,4 @@ The processed image has been written to willyriver_processed.bmp Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/msvs/DCT.vcxproj b/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/msvs/DCT.vcxproj index 82c3193c06..4333bc1b10 100644 --- a/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/msvs/DCT.vcxproj +++ b/DirectProgramming/C++SYCL/SpectralMethods/DiscreteCosineTransform/msvs/DCT.vcxproj @@ -75,7 +75,7 @@ true stdcpp17 true - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -98,7 +98,7 @@ true stdcpp17 true - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/SpectralMethods/guided_OceanFFT_SYCLMigration/sample.json b/DirectProgramming/C++SYCL/SpectralMethods/guided_OceanFFT_SYCLMigration/sample.json index 06346e9e40..49a4e2641f 100644 --- a/DirectProgramming/C++SYCL/SpectralMethods/guided_OceanFFT_SYCLMigration/sample.json +++ b/DirectProgramming/C++SYCL/SpectralMethods/guided_OceanFFT_SYCLMigration/sample.json @@ -1,7 +1,7 @@ { "guid": "FCC565D0-95E4-4ED2-9426-9FD6D85F7C39", "name": "guided_OceanFFT_SYCLMigration", - "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/SpectralMethods"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/Spectral Methods"], "description": "This sample shows the demonstrates the use of SYCL queues for Ocean height field on GPU devices.", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": {} } ], diff --git a/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/1d_HeatTransfer.vcxproj b/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/1d_HeatTransfer.vcxproj index 4c01a69ba9..5b79ee7def 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/1d_HeatTransfer.vcxproj +++ b/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/1d_HeatTransfer.vcxproj @@ -60,7 +60,7 @@ true true pch.h - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -77,7 +77,7 @@ true true pch.h - %ONEAPI_ROOT%\dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/README.md b/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/README.md index d9c313812f..f2d0aea3e4 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/README.md +++ b/DirectProgramming/C++SYCL/StructuredGrids/1d_HeatTransfer/README.md @@ -9,9 +9,7 @@ This `1D-Heat-Transfer` sample demonstrates the simulation of a one-dimensional ## Purpose -This `1D-Heat-Transfer` sample is an application that simulates the heat -propagation on a one-dimensional isotropic and homogeneous medium. The code sample includes both parallel and serial calculations of heat -propagation. +This `1D-Heat-Transfer` sample is an application that simulates the heat propagation on a one-dimensional isotropic and homogeneous medium. The code sample includes both parallel and serial calculations of heat propagation. The following equation is used in the simulation of heat propagation: @@ -41,41 +39,38 @@ where: | Software | Intel® oneAPI DPC++/C++ Compiler ## Key Implementation Details -The basic SYCL* implementation explained in the code includes a device -selector, buffer, accessor, USM allocation, kernel, and command -groups. +The basic SYCL* implementation explained in the code includes a device selector, buffer, accessor, USM allocation, kernel, and command groups. The program attempts to offload the computations to a GPU first. If the program cannot detect a compatible GPU, the program runs on the CPU (host device). -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. +## Build the `1D-Heat-Transfer` Program for CPU and GPU ->**Note**: For comprehensive information about oneAPI programming, see the [Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide). (Use search or the table of contents to find relevant information quickly.) +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -## Build the `1D-Heat-Transfer` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). ->**Note**: You can get the common resources from the [oneAPI-samples](https://github.com/oneapi-src/oneAPI-samples/tree/master/common) GitHub repository. +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -83,10 +78,10 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). -### On Linux* +### On Linux* 1. Change to the sample directory. 2. Build the program. ``` @@ -103,7 +98,7 @@ the `VERBOSE=1` argument: make VERBOSE=1 ``` -### On Windows* +### On Windows* **Using Visual Studio*** Build the program using **Visual Studio 2017** or newer. @@ -153,21 +148,6 @@ display a `PASSED!` message. 1d_HeatTransfer 100 1000 ``` -### Build and Run the `1D-Heat-Transfer` Sample in Intel® DevCloud (Optional) -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. - -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - ## Example Output ``` Number of points: 100 @@ -188,4 +168,4 @@ The parallel to serial comparisons are saved to `usm_error_diff.txt` and `buffer Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/StructuredGrids/guided_HSOpticalFlow_SYCLMigration/sample.json b/DirectProgramming/C++SYCL/StructuredGrids/guided_HSOpticalFlow_SYCLMigration/sample.json index d7d4faa5a5..15744b9848 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/guided_HSOpticalFlow_SYCLMigration/sample.json +++ b/DirectProgramming/C++SYCL/StructuredGrids/guided_HSOpticalFlow_SYCLMigration/sample.json @@ -1,7 +1,7 @@ { "guid": "737599E9-1045-46A5-91F1-6D0DEE649261", "name": "HSOpticalFlow", - "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/StructuredGrids"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/Structured Grids"], "description": "Variational optical flow estimation example. Uses textures for image operations. Shows how simple PDE solver can be accelerated with SYCL.", "toolchain": [ "dpcpp" ], "languages": [ { "cpp": {} } ], diff --git a/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/README.md b/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/README.md index 44833d2e76..c32c984c2f 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/README.md +++ b/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/README.md @@ -7,7 +7,7 @@ The `ISO2DFD` sample demonstrates two-dimensional finite-difference wave propaga | Time to complete | 10 minutes ## Purpose -ISO2DFD is a finite difference stencil kernel for solving the 2D acoustic isotropic wave equation. The sample uses a Partial Differential Equation (PDE), with a finite-difference method, to illustrate the essential elements of SYCL* queues, buffers, accessors, and kernels. +ISO2DFD is a finite difference stencil kernel for solving the 2D acoustic isotropic wave equation. The sample uses a Partial Differential Equation (PDE), with a finite-difference method, to illustrate the essential elements of SYCL* queues, buffers, accessors, and kernels. > **Note**: You can find a complete code walk-through of this sample at [Code Sample: Two-Dimensional Finite-Difference Wave Propagation in Isotropic Media (ISO2DFD)](https://software.intel.com/en-us/articles/code-sample-two-dimensional-finite-difference-wave-propagation-in-isotropic-media-iso2dfd). @@ -30,32 +30,34 @@ The sample runs on the GPU and CPU to calculate a result. The results from the t The output includes the GPU device name. -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `ISO2DFD` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. ->**Note**: You can get the common resources from the [oneAPI-samples](https://github.com/oneapi-src/oneAPI-samples/tree/master/common) GitHub repository. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -63,7 +65,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -130,22 +132,6 @@ To specify a grid size of 1000x1000 and 2000 time steps iterations, you would us iso2dfd.exe 1000 1000 2000 ``` -### Build and Run the `ISO2DFD` Sample in Intel® DevCloud (Optional) - -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. - -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - ### Example Output ``` Initializing ... @@ -175,4 +161,4 @@ You can find graphical output examples for the program at [Code Sample: Two-Dime Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/iso2dfd.vcxproj b/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/iso2dfd.vcxproj index 7d9232f0db..7e54c7922f 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/iso2dfd.vcxproj +++ b/DirectProgramming/C++SYCL/StructuredGrids/iso2dfd_dpcpp/iso2dfd.vcxproj @@ -60,7 +60,7 @@ true true pch.h - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -77,7 +77,7 @@ true true pch.h - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/README.md b/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/README.md index 5d9cdedf0e..f672a036b7 100644 --- a/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/README.md +++ b/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/README.md @@ -38,32 +38,34 @@ The program output includes the device name that ran the code along with the gri | Scalar baseline -O2 | 1.0 | SYCL | 2x speedup -## Set Environment Variables -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - ## Build the `ISO3DFD` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `bash -c 'source /setvars.sh ; exec csh'` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -### Include Files -The include folder is at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. You might need to use some of the resources from this location to build the sample. +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. ->**Note**: You can get the common resources from the [oneAPI-samples](https://github.com/oneapi-src/oneAPI-samples/tree/master/common) GitHub repository. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -71,7 +73,7 @@ The basic steps to build and run a sample using VS Code include: 3. Open a terminal in VS Code (**Terminal > New Terminal**). 4. Run the sample in the VS Code terminal using the instructions below. -To learn more about the extensions and how to configure the oneAPI environment, see the +To learn more about the extensions and how to configure the oneAPI environment, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On Linux* @@ -139,22 +141,6 @@ Usage: `iso3dfd.exe n1 n2 n3 b1 b2 b3 iterations [omp|sycl] [gpu|cpu]` ``` iso3dfd_sycl.exe 256 256 256 32 8 64 10 gpu ``` - -### Build and Run the `ISO3DFD` Sample in Intel® DevCloud (Optional) -When running a sample in the Intel® DevCloud, you must specify the compute node (CPU, GPU, FPGA) and whether to run in batch or interactive mode. You can specify a GPU node using a single line script. - -``` -qsub -I -l nodes=1:gpu:ppn=2 -d . -``` - -- `-I` (upper case I) requests an interactive session. -- `-l nodes=1:gpu:ppn=2` (lower case L) assigns one full GPU node. -- `-d .` makes the current folder as the working directory for the task. - -For more information on how to specify compute nodes read, [Launch and manage jobs](https://devcloud.intel.com/oneapi/documentation/job-submission/) in the Intel® DevCloud for oneAPI Documentation. - -For more information on using Intel® DevCloud, see the Intel® oneAPI Base Toolkit [Get Started Guide](https://devcloud.intel.com/oneapi/get_started/). - ## Example Output ``` Grid Sizes: 256 256 256 @@ -195,4 +181,4 @@ Final wavefields from SYCL device and CPU are equivalent: Success Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/iso3dfd.vcxproj b/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/iso3dfd.vcxproj index efe33c5c14..b3b7bafc79 100755 --- a/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/iso3dfd.vcxproj +++ b/DirectProgramming/C++SYCL/StructuredGrids/iso3dfd_dpcpp/iso3dfd.vcxproj @@ -57,7 +57,7 @@ true true pch.h - include;$(ONEAPI_ROOT)dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -74,7 +74,7 @@ true true pch.h - include;$(ONEAPI_ROOT)dev-utilities\latest\include;%(AdditionalIncludeDirectories) + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/fft2d/sample.json b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/fft2d/sample.json index 9eb145380d..99c89a70a0 100755 --- a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/fft2d/sample.json +++ b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/fft2d/sample.json @@ -1,7 +1,7 @@ { "guid": "1739EEF9-BCEF-413E-9F24-DE1656DDD3AA", "name": "FFT2D", - "categories": ["Toolkit/oneAPI Direct Programming/DPC++ FPGA/Reference Designs"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL FPGA/Reference Designs"], "description": "Reference design implementing a 2D FFT on Intel® FPGAs", "toolchain": ["icpx"], "os": ["linux", "windows"], diff --git a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/matmul/sample.json b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/matmul/sample.json index e000c5aa34..df293415d8 100755 --- a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/matmul/sample.json +++ b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/matmul/sample.json @@ -1,7 +1,7 @@ { "guid": "77C05AED-3CBF-4C3C-8E6E-28253893807D", "name": "Matrix Multiply", - "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL_FPGA/Reference Designs"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL FPGA/Reference Designs"], "description": "Reference design demonstrating high-performance general matrix multiplication on an Intel® FPGA", "toolchain": ["icpx"], "os": ["linux", "windows"], diff --git a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/pca/sample.json b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/pca/sample.json index 273283961d..bff47128ea 100755 --- a/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/pca/sample.json +++ b/DirectProgramming/C++SYCL_FPGA/ReferenceDesigns/pca/sample.json @@ -1,7 +1,7 @@ { "guid": "6362F0D3-467B-4BFE-BE05-60B23989C8D5", "name": "PCA", - "categories": ["Toolkit/oneAPI Direct Programming/DPC++ FPGA/Reference Designs"], + "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL FPGA/Reference Designs"], "description": "Reference design implementing the Principle Component Analysis (PCA) of matrices on Intel® FPGAs", "toolchain": ["icpx"], "os": ["linux", "windows"], diff --git a/Libraries/oneDPL/dynamic_selection/nstream/README.md b/Libraries/oneDPL/dynamic_selection/nstream/README.md index f2fd8bce53..ed78ae6cab 100644 --- a/Libraries/oneDPL/dynamic_selection/nstream/README.md +++ b/Libraries/oneDPL/dynamic_selection/nstream/README.md @@ -31,8 +31,7 @@ The varying policies are helpful as follows: [Detailed Descriptions of the Policies](https://www.intel.com/content/www/us/en/docs/onedpl/developer-guide/current/policies.html) are available in the Intel® oneAPI DPC++ Library Developer Guide and Reference. ->NOTE: Given the simplicity of this example, performance benefits may not be gained depending on the available devices. -> +> NOTE: Given the simplicity of this example, performance benefits may not be gained depending on the available devices. Dynamic Device Selection support customization to allow frameworks or application developers to define custom logic for making device selections. Complete reference documentation is available in the [oneAPI DPC++ Library Developer Guide](https://www.intel.com/content/www/us/en/docs/onedpl/developer-guide/2022-2/overview.html). @@ -45,19 +44,29 @@ The basic SYCL standards implemented in the code include the use of the followin ## Building the `nstreams_device_selection` Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > -> Linux: +> Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` > - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > -> Windows: +> Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. > ->For more information on environment variables, see Use the setvars Script for [Linux or macOS](https://www.intel.com/content/www/us/en/docs/oneapi/programming-guide/2023-1/use-the-setvars-script-with-linux-or-macos.html#GUID-D01C791A-E72A-4EA5-A45A-AEF22F1E8506), or [Windows](https://www.intel.com/content/www/us/en/docs/oneapi/programming-guide/2023-1/use-the-setvars-script-with-windows.html#GUID-A76C1E1B-5235-4A16-9AA3-F5BD35F8C7F1). +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Using Visual Studio Code* (Optional) @@ -166,7 +175,6 @@ Using Static Policy (CPU) to iterate on CPU device with vector length: 10000 Avg time: lower better (ns): 1.33287e+06 ``` - ## License Code samples are licensed under the MIT license. See diff --git a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/README.md b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/README.md index 8dbd808f87..1408664128 100644 --- a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/README.md +++ b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/README.md @@ -9,7 +9,6 @@ For comprehensive information about oneAPI programming, see the [Intel® oneA | What you will learn | How to offload the computation to specific devices and use policies to different dynamic offload strategies. | Time to complete | 30 minutes - ## Purpose The `Sepia Filter` sample is a SYCL-compliant application that accepts a color image as an input and converts it to a sepia tone image by applying the sepia filter coefficients to every pixel of the image. The sample offloads the compute intensive part of the application, the processing of individual pixels, to an accelerator with the help of lambda and functor kernels. @@ -47,31 +46,35 @@ The sample distribution includes some sample images in the **/input** folder. An By default, three output images are written to the same folder as the application. - #### Troubleshooting If you receive an error message, troubleshoot the problem using the Diagnostics Utility for Intel® oneAPI Toolkits, which provides system checks to find missing dependencies and permissions errors. See the [Diagnostics Utility for Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/diagnostic-utility-user-guide/top.html). - - ## Build the `Sepia Filter` Sample -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > -> Linux: +> Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` > - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > -> Windows: +> Windows*: > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. > ->For more information on environment variables, see Use the setvars Script for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -### Include Files -The include folder is located at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (Optional) You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. @@ -101,7 +104,6 @@ If an error occurs, you can get more details by running `make` with the `VERBOSE make VERBOSE=1 ``` - ## Run the Sample 1. Run the program. diff --git a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj index 0cb50f4078..508c6bb83e 100644 --- a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj +++ b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj @@ -62,7 +62,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ _UNICODE;UNICODE;%(PreprocessorDefinitions);WINDOWS @@ -84,7 +84,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ _UNICODE;UNICODE;%(PreprocessorDefinitions);WINDOWS diff --git a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj.user b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj.user new file mode 100644 index 0000000000..64f37e9036 --- /dev/null +++ b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-filter.vcxproj.user @@ -0,0 +1,15 @@ + + + + $(SolutionDir)$(Platform)\$(Configuration)\ + WindowsLocalDebugger + + + + + $(SolutionDir)$(Platform)\$(Configuration)\ + WindowsLocalDebugger + + + + \ No newline at end of file diff --git a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj index 5f41d105e1..2f82aa8401 100644 --- a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj +++ b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj @@ -11,7 +11,7 @@ - + {320f8748-f9fd-4f0a-85bc-0167e0d1c539} @@ -63,7 +63,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ _UNICODE;UNICODE;%(PreprocessorDefinitions);WINDOWS @@ -83,7 +83,7 @@ true pch.h DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ _UNICODE;UNICODE;%(PreprocessorDefinitions);WINDOWS diff --git a/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj.user b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj.user new file mode 100644 index 0000000000..e508476d6d --- /dev/null +++ b/Libraries/oneDPL/dynamic_selection/sepia-filter-ds/sepia-policies.vcxproj.user @@ -0,0 +1,11 @@ + + + + $(SolutionDir)$(Platform)\$(Configuration)\ + WindowsLocalDebugger + + + $(SolutionDir)$(Platform)\$(Configuration)\ + WindowsLocalDebugger + + \ No newline at end of file diff --git a/Libraries/oneDPL/gamma-correction/README.md b/Libraries/oneDPL/gamma-correction/README.md index c63ed6c738..242c688a86 100644 --- a/Libraries/oneDPL/gamma-correction/README.md +++ b/Libraries/oneDPL/gamma-correction/README.md @@ -26,25 +26,12 @@ Parallel STL offers efficient support for both parallel and vectorized execution `std::for_each` Parallel STL algorithms are used in the code. -## Using Visual Studio Code* (Optional) - -You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. - -The basic steps to build and run a sample using VS Code include: - - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. - - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. - - Open a Terminal in VS Code (**Terminal>New Terminal**). - - Run the sample in the VS Code terminal using the instructions below. - - (Linux only) Debug your GPU application with GDB for Intel® oneAPI Toolkits using the **Generate Launch Configurations** extension. - -To learn more about the extensions, see the -[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). - ## Building the 'Gamma Correction' Program for CPU and GPU -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -55,8 +42,29 @@ To learn more about the extensions, see the > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. + +## Using Visual Studio Code* (Optional) + +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. + +The basic steps to build and run a sample using VS Code include: + - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. + - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. + - Open a Terminal in VS Code (**Terminal>New Terminal**). + - Run the sample in the VS Code terminal using the instructions below. + - (Linux only) Debug your GPU application with GDB for Intel® oneAPI Toolkits using the **Generate Launch Configurations** extension. + +To learn more about the extensions, see the +[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### Running Samples In Intel® DevCloud If running a sample in the Intel® DevCloud, remember that you must specify the compute node (CPU, GPU, FPGA) as well whether to run in batch or interactive mode. For more information see the Intel® oneAPI Base Toolkit Get Started Guide (https://devcloud.intel.com/oneapi/get-started/base-toolkit/). @@ -115,4 +123,4 @@ Image after applying gamma correction on the device is in the fractal_gamma.bmp Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Libraries/oneDPL/gamma-correction/gamma-correction.vcxproj b/Libraries/oneDPL/gamma-correction/gamma-correction.vcxproj index 4fa148ec62..8af5cb61e2 100644 --- a/Libraries/oneDPL/gamma-correction/gamma-correction.vcxproj +++ b/Libraries/oneDPL/gamma-correction/gamma-correction.vcxproj @@ -34,6 +34,7 @@ true Intel(R) oneAPI DPC++ Compiler 2024 Unicode + true Application @@ -41,6 +42,7 @@ Intel(R) oneAPI DPC++ Compiler 2024 true Unicode + true @@ -80,15 +82,8 @@ Console true - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) /Od - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - - - copy tbb12_debug.dll to binary folder - @@ -108,14 +103,7 @@ true true true - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - - - copy tbb12.dll to binary folder - diff --git a/Libraries/oneTBB/tbb-async-sycl/README.md b/Libraries/oneTBB/tbb-async-sycl/README.md index 90e89bd6f7..7ce1640b92 100755 --- a/Libraries/oneTBB/tbb-async-sycl/README.md +++ b/Libraries/oneTBB/tbb-async-sycl/README.md @@ -17,23 +17,12 @@ The purpose of this sample is to show how during execution, a computational kern ## Key Implementation Details Explains a oneTBB Flow Graph and SYCL*-compliant C++ implementation. -## Using Visual Studio Code* (Optional) -You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. - -The basic steps to build and run a sample using VS Code include: - - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. - - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. - - Open a Terminal in VS Code (**Terminal>New Terminal**). - - Run the sample in the VS Code terminal using the instructions below. - - (Linux only) Debug your GPU application with GDB for Intel® oneAPI toolkits using the **Generate Launch Configurations** extension. +## Building the `TBB-Async-Sycl` Program -To learn more about the extensions, see the -[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -## Building the `TBB-Async-Sycl` Program -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -44,7 +33,29 @@ To learn more about the extensions, see the > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. + +## Using Visual Studio Code* (Optional) + +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. + +The basic steps to build and run a sample using VS Code include: + - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. + - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. + - Open a Terminal in VS Code (**Terminal>New Terminal**). + - Run the sample in the VS Code terminal using the instructions below. + - (Linux only) Debug your GPU application with GDB for Intel® oneAPI Toolkits using the **Generate Launch Configurations** extension. + +To learn more about the extensions, see the +[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On a Linux System * Build tbb-async-sycl program @@ -90,4 +101,4 @@ If an error occurs, troubleshoot the problem using the Diagnostics Utility for I Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Libraries/oneTBB/tbb-async-sycl/tbb-async-sycl.vcxproj b/Libraries/oneTBB/tbb-async-sycl/tbb-async-sycl.vcxproj index 29c514db32..8b0b735955 100755 --- a/Libraries/oneTBB/tbb-async-sycl/tbb-async-sycl.vcxproj +++ b/Libraries/oneTBB/tbb-async-sycl/tbb-async-sycl.vcxproj @@ -23,6 +23,7 @@ true Intel(R) oneAPI DPC++ Compiler 2024 Unicode + true Application @@ -30,6 +31,7 @@ Intel(R) oneAPI DPC++ Compiler 2024 true Unicode + true @@ -58,20 +60,15 @@ true pch.h false - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) /Od - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - @@ -84,9 +81,8 @@ true pch.h false - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -94,11 +90,7 @@ true true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - diff --git a/Libraries/oneTBB/tbb-resumable-tasks-sycl/README.md b/Libraries/oneTBB/tbb-resumable-tasks-sycl/README.md index d089e76de5..04dae24dfc 100755 --- a/Libraries/oneTBB/tbb-resumable-tasks-sycl/README.md +++ b/Libraries/oneTBB/tbb-resumable-tasks-sycl/README.md @@ -13,27 +13,15 @@ The `tbb-resumable-tasks-sycl` sample illustrates how the computational kernel c ## Purpose The purpose of this sample is to show how during execution, a computational kernel can be split between CPU and GPU using TBB resumable tasks and TBB parallel_for. -### Using Visual Studio Code* (Optional) - -You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, -and browse and download samples. - -The basic steps to build and run a sample using VS Code include: - - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. - - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. - - Open a Terminal in VS Code (**Terminal>New Terminal**). - - Run the sample in the VS Code terminal using the instructions below. - -To learn more about the extensions and how to configure the oneAPI environment, see the -[Using Visual Studio Code with Intel® oneAPI Toolkits](https://software.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). - ## Key implementation details TBB resumable tasks in SYCL* explained. ## Building the tbb-resumable-tasks-sycl program -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -44,7 +32,28 @@ TBB resumable tasks in SYCL* explained. > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. + +### Using Visual Studio Code* (Optional) + +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. + +The basic steps to build and run a sample using VS Code include: + - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. + - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. + - Open a Terminal in VS Code (**Terminal>New Terminal**). + - Run the sample in the VS Code terminal using the instructions below. + +To learn more about the extensions and how to configure the oneAPI environment, see the +[Using Visual Studio Code with Intel® oneAPI Toolkits](https://software.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On a Linux System * Build tbb-resumable-tasks-sycl program @@ -91,4 +100,4 @@ If an error occurs, troubleshoot the problem using the Diagnostics Utility for I Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Libraries/oneTBB/tbb-resumable-tasks-sycl/tbb-resumable-tasks-sycl.vcxproj b/Libraries/oneTBB/tbb-resumable-tasks-sycl/tbb-resumable-tasks-sycl.vcxproj index 60d2ada768..d11f5f7b77 100755 --- a/Libraries/oneTBB/tbb-resumable-tasks-sycl/tbb-resumable-tasks-sycl.vcxproj +++ b/Libraries/oneTBB/tbb-resumable-tasks-sycl/tbb-resumable-tasks-sycl.vcxproj @@ -23,6 +23,7 @@ true Intel(R) oneAPI DPC++ Compiler 2024 Unicode + true Application @@ -30,6 +31,7 @@ Intel(R) oneAPI DPC++ Compiler 2024 true Unicode + true @@ -58,19 +60,14 @@ true pch.h false - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) DisableAllWarnings Console true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) /Od - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - @@ -83,7 +80,6 @@ true pch.h false - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) DisableAllWarnings @@ -92,11 +88,7 @@ true true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - @@ -110,4 +102,4 @@ - + \ No newline at end of file diff --git a/Libraries/oneTBB/tbb-task-sycl/README.md b/Libraries/oneTBB/tbb-task-sycl/README.md index 83477a912c..cc3d85e3e1 100755 --- a/Libraries/oneTBB/tbb-task-sycl/README.md +++ b/Libraries/oneTBB/tbb-task-sycl/README.md @@ -16,24 +16,12 @@ The purpose of this sample is to show how similar computational kernels can be e ## Key Implementation Details The implementation based on TBB tasks and SYCL explained. -### Using Visual Studio Code* (Optional) - -You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, -and browse and download samples. - -The basic steps to build and run a sample using VS Code include: - - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. - - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. - - Open a Terminal in VS Code (**Terminal>New Terminal**). - - Run the sample in the VS Code terminal using the instructions below. +## Building the TBB-Task-Sycl Program -To learn more about the extensions and how to configure the oneAPI environment, see -[Using Visual Studio Code with Intel® oneAPI Toolkits](https://software.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -## Building the TBB-Task-Sycl Program -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -44,7 +32,28 @@ To learn more about the extensions and how to configure the oneAPI environment, > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. + +### Using Visual Studio Code* (Optional) + +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. + +The basic steps to build and run a sample using VS Code include: + - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. + - Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. + - Open a Terminal in VS Code (**Terminal>New Terminal**). + - Run the sample in the VS Code terminal using the instructions below. + +To learn more about the extensions and how to configure the oneAPI environment, see +[Using Visual Studio Code with Intel® oneAPI Toolkits](https://software.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). ### On a Linux System * Build tbb-task-sycl program @@ -92,4 +101,4 @@ If an error occurs, troubleshoot the problem using the Diagnostics Utility for I Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Libraries/oneTBB/tbb-task-sycl/tbb-task-sycl.vcxproj b/Libraries/oneTBB/tbb-task-sycl/tbb-task-sycl.vcxproj index dc6d4781e6..1b4e910b3c 100755 --- a/Libraries/oneTBB/tbb-task-sycl/tbb-task-sycl.vcxproj +++ b/Libraries/oneTBB/tbb-task-sycl/tbb-task-sycl.vcxproj @@ -23,6 +23,7 @@ true Intel(R) oneAPI DPC++ Compiler 2024 Unicode + true Application @@ -30,6 +31,7 @@ Intel(R) oneAPI DPC++ Compiler 2024 true Unicode + true @@ -57,21 +59,16 @@ true true pch.h - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) false DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) /Od - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - @@ -83,10 +80,9 @@ true true pch.h - /I"$(ONEAPI_ROOT)/tbb/latest/include" %(AdditionalOptions) false DisableAllWarnings - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -94,11 +90,7 @@ true true false - /link tbb.lib /libpath:"$(ONEAPI_ROOT)/tbb/latest/lib" %(AdditionalOptions) - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(SolutionDir)$(Platform)\$(Configuration)\" - @@ -112,4 +104,4 @@ - + \ No newline at end of file diff --git a/Tools/Advisor/matrix_multiply_advisor/README.md b/Tools/Advisor/matrix_multiply_advisor/README.md index b47177d27b..79f4af75ee 100644 --- a/Tools/Advisor/matrix_multiply_advisor/README.md +++ b/Tools/Advisor/matrix_multiply_advisor/README.md @@ -1,6 +1,5 @@ # `Matrix Multiply` Sample -A sample containing multiple implementations of matrix multiplication code -sample and is implemented using SYCL* for CPU and GPU. +A sample containing multiple implementations of matrix multiplication code sample and is implemented using SYCL* for CPU and GPU. | Optimized for | Description |:--- |:--- @@ -12,21 +11,37 @@ sample and is implemented using SYCL* for CPU and GPU. ## Purpose -The Matrix Multiplication sample performs basic matrix multiplication. Three -versions are provided that use different SYCL features. +The Matrix Multiplication sample performs basic matrix multiplication. Three versions are provided that use different SYCL features. ## Key Implementation details -The basic SYCL implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. +The basic SYCL implementation explained in the code includes device selector, buffer, accessor, kernel, and command groups. -## Include Files -The include folder is located at -`%ONEAPI_ROOT%\dev-utilities\latest\include` on your development system. +## How to Build -### Running Samples In Intel® DevCloud -Running samples in the Intel® DevCloud requires you to specify a compute node. -For specific instructions, jump to [Run the Matrix Multiply Advisor sample on the DevCloud](#run-matmul-advisor-on-devcloud). +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. +> +> Linux*: +> - For system wide installations: `. /opt/intel/oneapi/setvars.sh` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` +> +> Windows*: +> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ## Using Visual Studio Code* (Optional) @@ -43,23 +58,6 @@ The basic steps to build and run a sample using VS Code include: To learn more about the extensions, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). - -## How to Build -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. -> -> Linux*: -> - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: `. ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` -> -> Windows*: -> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` -> -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). - This sample contains three versions of matrix multiplication: - `multiply1` – basic implementation of matrix multiply using SYCL @@ -69,7 +67,6 @@ This sample contains three versions of matrix multiplication: Edit the line in `src/multiply.hpp` to select the version of the multiply function: `#define MULTIPLY multiply1`. - ### On a Linux* System To build the SYCL version: cd @@ -93,7 +90,7 @@ dependencies and permissions errors. * Select Menu "Project > Build" to build the selected configuration * Select Menu "Debug > Start Without Debugging" to run the program -### on Windows - command line - Build the program using MSBuild +### On Windows - command line - Build the program using MSBuild DPCPP Configurations: Release - MSBuild matrix_multiply.sln /t:Rebuild /p:Configuration="Release" Debug - MSBuild matrix_multiply.sln /t:Rebuild /p:Configuration="Debug" @@ -111,125 +108,6 @@ Running on Intel(R) Gen9 Elapsed Time: 0.539631s ``` -## Running an Intel® Advisor analysis -See the [Intel® Advisor Cookbook](https://software.intel.com/en-us/advisor-cookbook). - -### Running the Matrix Multiply Advisor sample in the DevCloud -This sample contains 3 version of matrix multiplication: - -- `multiply1` – basic implementation of matrix multiply using SYCL -- `multiply1_1` – basic implementation that replaces the buffer store with a local accessor “acc” to reduce memory traffic -- `multiply1_2` – the basic implementation, plus adding the local accessor and matrix tiling - -Edit the line in `src/multiply.hpp` to select the version of the multiply function: -`#define MULTIPLY multiply1`. - -1. Open a terminal on your Linux system. -2. Log in to DevCloud. -``` -ssh devcloud -``` -3. Download the samples. -``` -git clone https://github.com/oneapi-src/oneAPI-samples.git -``` - -4. Change directories to the Matrix Multiply Advisor sample directory. -``` -cd ~/oneAPI-samples/Tools/Advisor/matrix_multiply_advisor -``` -#### Build and run the sample in batch mode -The following describes the process of submitting build and run jobs to PBS. -A job is a script that is submitted to PBS through the qsub utility. By default, the qsub utility does not inherit the current environment variables or your current working directory. For this reason, it is necessary to submit jobs as scripts that handle the setup of the environment variables. In order to address the working directory issue, you can either use absolute paths or pass the -d \ option to qsub to set the working directory. - -#### Create the Job Scripts -1. Create a build.sh script with your preferred text editor: -``` -nano build.sh -``` -2. Add this text into the build.sh file: -``` -source /opt/intel/inteloneapi/setvars.sh > /dev/null 2>&1 -mkdir build -cd build -cmake .. -make -``` - -3. Save and close the build.sh file. - -4. Create a run.sh script with your preferred text editor: -``` -nano run.sh -``` - -5. Add this text into the run.sh file: -``` -source /opt/intel/inteloneapi/setvars.sh > /dev/null 2>&1 -cd build -make run -``` -6. Save and close the run.sh file. - -#### Build and run -Jobs submitted in batch mode are placed in a queue waiting for the necessary resources (compute nodes) to become available. The jobs will be executed on a first come basis on the first available node(s) having the requested property or label. -1. Build the sample on a gpu node. - -``` -qsub -l nodes=1:gpu:ppn=2 -d . build.sh -``` - -Note: -l nodes=1:gpu:ppn=2 (lower case L) is used to assign one full GPU node to the job. -Note: The -d . is used to configure the current folder as the working directory for the task. - -2. In order to inspect the job progress, use the qstat utility. -``` -watch -n 1 qstat -n -1 -``` -Note: The watch -n 1 command is used to run qstat -n -1 and display its results every second. If no results are displayed, the job has completed. - -3. After the build job completes successfully, run the sample on a gpu node: -``` -qsub -l nodes=1:gpu:ppn=2 -d . run.sh -``` -4. When a job terminates, a couple of files are written to the disk: - - .sh.eXXXX, which is the job stderr - - .sh.oXXXX, which is the job stdout - - Here XXXX is the job ID, which gets printed to the screen after each qsub command. - -5. Inspect the output of the sample. -``` -cat run.sh.oXXXX -``` -You should see output similar to this: - -``` -Scanning dependencies of target run -Address of buf1 = 0x7f570456f010 -Offset of buf1 = 0x7f570456f180 -Address of buf2 = 0x7f5703d6e010 -Offset of buf2 = 0x7f5703d6e1c0 -Address of buf3 = 0x7f570356d010 -Offset of buf3 = 0x7f570356d100 -Address of buf4 = 0x7f5702d6c010 -Offset of buf4 = 0x7f5702d6c140 -Using multiply kernel: multiply1 -Running on Intel(R) UHD Graphics P630 [0x3e96] -Elapsed Time: 1.79388s -Built target run -``` - -6. Remove the stdout and stderr files and clean up the project files. -``` -rm build.sh.*; rm run.sh.*; make clean -``` -7. Disconnect from the Intel DevCloud. -``` -exit -``` ## Running an Intel® Advisor analysis See the [Intel® Advisor Cookbook](https://software.intel.com/en-us/advisor-cookbook). @@ -241,4 +119,4 @@ Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. Third party program Licenses can be found here: -[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +[third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Tools/Advisor/matrix_multiply_advisor/matrix_multiply.vcxproj b/Tools/Advisor/matrix_multiply_advisor/matrix_multiply.vcxproj index 9a13abd69f..43a2906171 100644 --- a/Tools/Advisor/matrix_multiply_advisor/matrix_multiply.vcxproj +++ b/Tools/Advisor/matrix_multiply_advisor/matrix_multiply.vcxproj @@ -61,7 +61,7 @@ WIN32;DPCPP;%(PreprocessorDefinitions) DisableAllWarnings /std:c++17 %(AdditionalOptions) - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -85,7 +85,7 @@ DisableAllWarnings Default %(AdditionalOptions) - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/Tools/ApplicationDebugger/array-transform/README.md b/Tools/ApplicationDebugger/array-transform/README.md index 61fc376f96..160067af5f 100644 --- a/Tools/ApplicationDebugger/array-transform/README.md +++ b/Tools/ApplicationDebugger/array-transform/README.md @@ -1,8 +1,6 @@ # `array-transform` Sample -This is a small SYCL*-compliant code sample for exercising application debugging using -Intel® Distribution for GDB*. It is highly recommended that you go -through this sample *after* you familiarize yourself with the basics of +This is a small SYCL*-compliant code sample for exercising application debugging using Intel® Distribution for GDB*. It is highly recommended that you go through this sample *after* you familiarize yourself with the basics of SYCL programming, and *before* you start using the debugger. @@ -11,26 +9,16 @@ SYCL programming, and *before* you start using the debugger. | What you will learn | Essential debugger features for effective debugging on CPU, GPU (Linux only), and FPGA emulator | Time to complete | 20 minutes for CPU or FPGA emulator; 30 minutes for GPU -This sample accompanies +This sample accompanies [Get Started with Intel® Distribution for GDB* on Linux* OS Host](https://software.intel.com/en-us/get-started-with-debugging-dpcpp) of the application debugger. ## Purpose -The `array-transform` sample is a SYCL-conforming application with a small -computation kernel that is designed to illustrate key debugger -features such as breakpoint definition, thread switching, -scheduler-locking and SIMD lane views. The sample is intended -for exercising the debugger, not for performance benchmarking. - -The debugger supports debugging kernels that run on the CPU, GPU, or -accelerator devices. Use the ONEAPI_DEVICE_SELECTOR environment variable -to select device. The default device is Level Zero GPU device, if available. -For more details on possible values of this variable see [Environment Variables](https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector). -The selected device is displayed in the output. Concrete instructions -about how to run the program and example outputs are given further -below. For complete setup and usage instructions, see [Get Started with Intel® Distribution for GDB* on Linux* OS Host](https://software.intel.com/en-us/get-started-with-debugging-dpcpp) -of the application debugger. +The `array-transform` sample is a SYCL-conforming application with a small computation kernel that is designed to illustrate key debugger features such as breakpoint definition, thread switching, scheduler-locking and SIMD lane views. The sample is intended for exercising the debugger, not for performance benchmarking. + +The debugger supports debugging kernels that run on the CPU, GPU, or accelerator devices. Use the ONEAPI_DEVICE_SELECTOR environment variable to select device. The default device is Level Zero GPU device, if available. For more details on possible values of this variable see [Environment Variables](https://intel.github.io/llvm-docs/EnvironmentVariables.html#oneapi-device-selector). +The selected device is displayed in the output. Concrete instructions about how to run the program and example outputs are given further below. For complete setup and usage instructions, see [Get Started with Intel® Distribution for GDB* on Linux* OS Host](https://software.intel.com/en-us/get-started-with-debugging-dpcpp) of the application debugger. ## Prerequisites @@ -53,31 +41,14 @@ correctly on CPU and only after that switch the offload to GPU. ## Key Implementation Details -The basic SYCL implementation explained in the code includes device -selection, buffer, accessor, and command groups. The kernel contains -data access via read/write accessors and a conditional statement to -illustrate (in) active SIMD lanes on a GPU. - -## Using Visual Studio Code* (Optional) - -You can use Visual Studio Code (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +The basic SYCL implementation explained in the code includes device selection, buffer, accessor, and command groups. The kernel contains data access via read/write accessors and a conditional statement to illustrate (in) active SIMD lanes on a GPU. -The basic steps to build and run a sample using VS Code include: - - Download a sample using the extension **Code Sample Browser for Intel oneAPI Toolkits**. - - Configure the oneAPI environment with the extension **Environment Configurator for Intel oneAPI Toolkits**. - - Open a Terminal in VS Code (**Terminal>New Terminal**). - - Run the sample in the VS Code terminal using the instructions below. - - (Linux only) Debug your GPU application with GDB for Intel® oneAPI toolkits using the **Generate Launch Configurations** extension. - -To learn more about the extensions, see the -[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). +## Building and Running the `array-transform` Program +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. -## Building and Running the `array-transform` Program -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` @@ -88,36 +59,37 @@ To learn more about the extensions, see the > - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` > - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). -### Setup +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. -Preliminary setup steps are needed for the debugger to function. -Please see the setup instructions in the Get Started Guide based on -your OS: -- [Get Started with Intel® Distribution for GDB* on Linux* OS Host](https://www.intel.com/content/www/us/en/develop/documentation/get-started-with-debugging-dpcpp-linux/) -- [Get Started with Intel® Distribution for GDB* on Windows* OS Host](https://www.intel.com/content/www/us/en/develop/documentation/get-started-with-debugging-dpcpp-windows/) +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. -### Include Files +## Using Visual Studio Code* (Optional) -The include folder is located at -`%ONEAPI_ROOT%\dev-utilities\latest\include` on your development -system. +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. -### Running Samples In DevCloud +The basic steps to build and run a sample using VS Code include: + - Download a sample using the extension **Code Sample Browser for Intel oneAPI Toolkits**. + - Configure the oneAPI environment with the extension **Environment Configurator for Intel oneAPI Toolkits**. + - Open a Terminal in VS Code (**Terminal>New Terminal**). + - Run the sample in the VS Code terminal using the instructions below. + - (Linux only) Debug your GPU application with GDB for Intel® oneAPI toolkits using the **Generate Launch Configurations** extension. -If running a sample in the Intel DevCloud, remember that you must -specify the compute node (CPU, GPU, FPGA) and whether to run in -batch or interactive mode. For the array transform sample, a node -with GPU and an interactive shell is recommended. +To learn more about the extensions, see the +[Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). -``` -$ qsub -I -l nodes=1:gpu:ppn=2 -``` +### Setup -For more information, see the Intel® oneAPI -Base Toolkit Get Started Guide -(https://devcloud.intel.com/oneapi/get-started/base-toolkit/). +Preliminary setup steps are needed for the debugger to function. +Please see the setup instructions in the Get Started Guide based on +your OS: +- [Get Started with Intel® Distribution for GDB* on Linux* OS Host](https://www.intel.com/content/www/us/en/develop/documentation/get-started-with-debugging-dpcpp-linux/) +- [Get Started with Intel® Distribution for GDB* on Windows* OS Host](https://www.intel.com/content/www/us/en/develop/documentation/get-started-with-debugging-dpcpp-windows/) ### Auto-Attach @@ -380,11 +352,8 @@ Thread 2.153 hit Breakpoint 1, with SIMD lanes [0-7], main::{lambda(auto:1&)#1}: --- -\* Intel is a trademark of Intel Corporation or its subsidiaries. Other -names and brands may be claimed as the property of others. - ## License Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). +Third party program licenses are at [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Tools/ApplicationDebugger/array-transform/array-transform.vcxproj b/Tools/ApplicationDebugger/array-transform/array-transform.vcxproj index 5cfb0e6786..95dbe7d54f 100644 --- a/Tools/ApplicationDebugger/array-transform/array-transform.vcxproj +++ b/Tools/ApplicationDebugger/array-transform/array-transform.vcxproj @@ -63,7 +63,7 @@ pch.h stdcpp17 /Od - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -82,7 +82,7 @@ true pch.h stdcpp17 - $(ONEAPI_ROOT)dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/Tools/VTuneProfiler/matrix_multiply_vtune/README.md b/Tools/VTuneProfiler/matrix_multiply_vtune/README.md index 6deaf85d99..c3ca78e9e9 100644 --- a/Tools/VTuneProfiler/matrix_multiply_vtune/README.md +++ b/Tools/VTuneProfiler/matrix_multiply_vtune/README.md @@ -17,16 +17,37 @@ versions are provided that use different SYCL features. ## Key Implementation details The basic SYCL implementation explained in the code includes device selector, -buffer, accessor, kernel, and command groups. +buffer, accessor, kernel, and command groups. -## Include Files -The include folder is located at `%ONEAPI_ROOT%\dev-utilities\latest\include` on your development -system. +## How to Build + +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. +> +> Linux*: +> - For system wide installations: `. /opt/intel/oneapi/setvars.sh` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` +> +> Windows*: +> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ## Using Visual Studio Code* (Optional) -You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, -and browse and download samples. +You can use Visual Studio Code (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: - Download a sample using the extension **Code Sample Browser for Intel® oneAPI Toolkits**. @@ -38,22 +59,6 @@ The basic steps to build and run a sample using VS Code include: To learn more about the extensions, see the [Using Visual Studio Code with Intel® oneAPI Toolkits User Guide](https://www.intel.com/content/www/us/en/develop/documentation/using-vs-code-with-intel-oneapi/top.html). -## How to Build - -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script located in -> the root of your oneAPI installation. -> -> Linux*: -> - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: `. ~/intel/oneapi/setvars.sh` -> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` -> -> Windows*: -> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` -> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` -> -> For more information on configuring environment variables, see [Use the setvars Script with Linux* or MacOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html) or [Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). This sample contains three versions of matrix multiplication: @@ -114,4 +119,4 @@ vtune -collect gpu-hotspots -- ./matrix.dpcpp Code samples are licensed under the MIT license. See [License.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/License.txt) for details. -Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). \ No newline at end of file +Third party program Licenses can be found here: [third-party-programs.txt](https://github.com/oneapi-src/oneAPI-samples/blob/master/third-party-programs.txt). diff --git a/Tools/VTuneProfiler/matrix_multiply_vtune/matrix_multiply.vcxproj b/Tools/VTuneProfiler/matrix_multiply_vtune/matrix_multiply.vcxproj index 9a13abd69f..43a2906171 100644 --- a/Tools/VTuneProfiler/matrix_multiply_vtune/matrix_multiply.vcxproj +++ b/Tools/VTuneProfiler/matrix_multiply_vtune/matrix_multiply.vcxproj @@ -61,7 +61,7 @@ WIN32;DPCPP;%(PreprocessorDefinitions) DisableAllWarnings /std:c++17 %(AdditionalOptions) - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console @@ -85,7 +85,7 @@ DisableAllWarnings Default %(AdditionalOptions) - $(ONEAPI_ROOT)\dev-utilities\latest\include + $(ONEAPI_ROOT)\include\;$(ONEAPI_ROOT)\dev-utilities\latest\include\ Console diff --git a/Tools/VTuneProfiler/tachyon/README.md b/Tools/VTuneProfiler/tachyon/README.md index c49c08ddb8..d21c7930c0 100644 --- a/Tools/VTuneProfiler/tachyon/README.md +++ b/Tools/VTuneProfiler/tachyon/README.md @@ -1,6 +1,6 @@ # `Tachyon` Sample -The `Tachyon` sample shows how to improve the performance of serial programs by using parallel processing with OpenMP* or Intel® oneAPI Threading Building Blocks (Intel® oneTBB). The `Tachyon` sample is an implementation of the tachyon program; it is a 2-D raytracer program that renders objects described in data files. +The `Tachyon` sample shows how to improve the performance of serial programs by using parallel processing with OpenMP* or Intel® oneAPI Threading Building Blocks (Intel® oneTBB). The `Tachyon` sample is an implementation of the tachyon program; it is a 2-D raytracer program that renders objects described in data files. | Area | Description |:--- |:--- @@ -9,9 +9,9 @@ The `Tachyon` sample shows how to improve the performance of serial programs by ## Purpose -The `Tachyon` sample shows how to use OpenMP or Intel® oneAPI Threading Building Blocks (oneTBB) to improve the performance of serial applications by using parallel processing. +The `Tachyon` sample shows how to use OpenMP or Intel® oneAPI Threading Building Blocks (oneTBB) to improve the performance of serial applications by using parallel processing. -The sample starts with a serial CPU implementation of the tachyon program and shows how to use OpenMP or Intel® oneTBB to implement effective threading in the program. +The sample starts with a serial CPU implementation of the tachyon program and shows how to use OpenMP or Intel® oneTBB to implement effective threading in the program. The sample application displays the execution time required to render the object. This time is an indication of the speedup obtained with parallel implementations compared to a baseline established with the initial serial implementation. @@ -35,47 +35,49 @@ The time to generate the image varies according to the parallel scheduling metho | Hardware | Intel® CPU | Software | Intel® oneAPI DPC++/C++ Compiler
Intel oneAPI Threading Building Blocks (oneTBB)
Intel VTune™ Profiler

For Linux the `libXext.so` and `libX11.so` libraries must be installed to display the rendered graphic. - - ## Key Implementation Details The sample implements the following OpenMP and oneTBB features. OpenMP: -Uses the **omp parallel for** pragma to thread the horizontal rendering of pixels. +Uses the **omp parallel for** pragma to thread the horizontal rendering of pixels. -oneTBB: +oneTBB: Uses the **tbb::parallel_for** function to thread the horizontal rendering of pixels. >**Note**: For comprehensive information about oneAPI programming, see the *[Intel® oneAPI Programming Guide](https://software.intel.com/en-us/oneapi-programming-guide)*. (Use search or the table of contents to find relevant information quickly.) - -## Set Environment Variables - -When working with the command-line interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures that your compiler, libraries, and tools are ready for development. - - ## Build the Tachyon Sample -> **Note**: If you have not already done so, set up your CLI -> environment by sourcing the `setvars` script in the root of your oneAPI installation. +### Setting Environment Variables +When working with the Command Line Interface (CLI), you should configure the oneAPI toolkits using environment variables. Set up your CLI environment by sourcing the `setvars` script every time you open a new terminal window. This practice ensures your compiler, libraries, and tools are ready for development. + +> **Note**: If you have not already done so, set up your CLI environment by sourcing the `setvars` script located in the root of your oneAPI installation. > > Linux*: > - For system wide installations: `. /opt/intel/oneapi/setvars.sh` -> - For private installations: ` . ~/intel/oneapi/setvars.sh` +> - For private installations: `. ~/intel/oneapi/setvars.sh` +> - For non-POSIX shells, like csh, use the following command: `$ bash -c 'source /setvars.sh ; exec csh'` > > Windows*: -> - `C:\Program Files (x86)\Intel\oneAPI\setvars.bat` -> - Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` +> - `C:\Program Files(x86)\Intel\oneAPI\setvars.bat` +> - For Windows PowerShell*, use the following command: `cmd.exe "/K" '"C:\Program Files (x86)\Intel\oneAPI\setvars.bat" && powershell'` > -> For more information on configuring environment variables, see *[Use the setvars Script with Linux* or macOS*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html)* or *[Use the setvars Script with Windows*](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html)*. +> Microsoft Visual Studio: +> - Open a command prompt window and execute `setx SETVARS_CONFIG " "`. This only needs to be set once and will automatically execute the `setvars` script every time Visual Studio is launched. +> +>For more information on environment variables, see "Use the setvars Script" for [Linux or macOS](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos.html), or [Windows](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-windows.html). + +You can use [Modulefiles scripts](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-modulefiles-with-linux.html) to set up your development environment. The modulefiles scripts work with all Linux shells. + +If you wish to fine tune the list of components and the version of those components, use +a [setvars config file](https://www.intel.com/content/www/us/en/develop/documentation/oneapi-programming-guide/top/oneapi-development-environment-setup/use-the-setvars-script-with-linux-or-macos/use-a-config-file-for-setvars-sh-on-linux-or-macos.html) to set up your development environment. ### Use Visual Studio Code* (VS Code) (Optional) -You can use Visual Studio Code* (VS Code) extensions to set your environment, -create launch configurations, and browse and download samples. +You can use Visual Studio Code* (VS Code) extensions to set your environment, create launch configurations, and browse and download samples. The basic steps to build and run a sample using VS Code include: 1. Configure the oneAPI environment with the extension **Environment Configurator for Intel® oneAPI Toolkits**. @@ -95,9 +97,9 @@ To learn more about the extensions and how to configure the oneAPI environment, cmake .. make ``` - -To build a specific version of the program, run cmake with the version name. For example: + +To build a specific version of the program, run cmake with the version name. For example: ``` make tachyon.serial @@ -148,20 +150,20 @@ Run the serial version of the program to establish a baseline execution time. #### On Linux -Run the serial version of the program to establish a baseline execution time. +Run the serial version of the program to establish a baseline execution time. 1. Change to the build directory in your sample directory. -2. Run the executable, providing the balls.dat data file. +2. Run the executable, providing the balls.dat data file. ``` - ./tachyon.serial ../dat/balls.dat + ./tachyon.serial ../dat/balls.dat ``` - You will see the following output: + You will see the following output: ``` - Scene contains 7386 bounded objects. - tachyon.serial ../dat/balls.dat: 3.706 seconds + Scene contains 7386 bounded objects. + tachyon.serial ../dat/balls.dat: 3.706 seconds ``` #### On Windows @@ -180,32 +182,32 @@ Compare the code in `tachyon.openmp.cpp` to `tachyon.serial.cpp`. `tachyon.openm #### On Linux -1. Change to the build directory in your sample directory. +1. Change to the build directory in your sample directory. 2. Run the basic OpenMP version. ``` - ./tachyon.openmp ../dat/balls.dat + ./tachyon.openmp ../dat/balls.dat ``` - - You will see the following output: - + + You will see the following output: + ``` - Scene contains 7386 bounded objects. - tachyon.openmp ../dat/balls.dat: 0.283 seconds + Scene contains 7386 bounded objects. + tachyon.openmp ../dat/balls.dat: 0.283 seconds ``` -3. Run optimized OpenMP version. +3. Run optimized OpenMP version. ``` - ./tachyon.openmp_solution ../dat/balls.dat + ./tachyon.openmp_solution ../dat/balls.dat ``` - - You will see the following output: + + You will see the following output: ``` - Scene contains 7386 bounded objects. + Scene contains 7386 bounded objects. tachyon.openmp_solution ../dat/balls.dat: 0.153 seconds ``` -4. Compare the render time between the basic OpenMP and optimized OpenMP versions. The optimized version shows an improvement in render time. +4. Compare the render time between the basic OpenMP and optimized OpenMP versions. The optimized version shows an improvement in render time. @@ -216,7 +218,7 @@ Compare the code in `tachyon.openmp.cpp` to `tachyon.serial.cpp`. `tachyon.openm #### On Windows 1. First run the basic OpenMP implementation. Run the build_with_openmp project in VS, or run **build_with_openmp.exe ..\..\dat\balls.dat** directly. There should be a noticeable improvement in the rendering time. To see how threads performed with the omp parallel for pragma, run a hotspots analysis with Intel VTune Profiler: - + ![image](https://github.com/jenniferdimatteo/oneAPI-samples/assets/32850114/1e3e15b1-045e-4714-b8c2-a716454066b2) The elapsed time is almost half of the serial implementation at 2.021s. The CPU histogram still shows a large amount of time where only one CPU was utilized, but the application does make simultaneous use of up to 14 CPUs. The Bottom-up tab has a timeline view which shows thread behavior over time: @@ -233,7 +235,7 @@ The elapsed time for the optimized version is 1.875s, which is a small improveme ![image](https://github.com/jenniferdimatteo/oneAPI-samples/assets/32850114/1e63669c-74e4-4466-bce0-5095d9d9fbd1) -The threads now complete at the same time, although there is some spinning as one thread completes its work. +The threads now complete at the same time, although there is some spinning as one thread completes its work. ### Run the Intel® oneAPI Threading Building Blocks Versions @@ -241,36 +243,36 @@ Run the Intel® oneAPI Threading Building Blocks (Intel® oneTBB) versions of th #### On Linux -1. Change to the build directory in your sample directory. -2. Run the basic Intel TBB version. - +1. Change to the build directory in your sample directory. +2. Run the basic Intel TBB version. + ``` - ./tachyon.tbb ../dat/balls.dat + ./tachyon.tbb ../dat/balls.dat ``` - - You will see the following output: - - ``` - Scene contains 7386 bounded objects. - tachyon.tbb ../dat/balls.dat: 6.504 seconds + + You will see the following output: + ``` - -3. Run the optimized Intel® oneTBB version. + Scene contains 7386 bounded objects. + tachyon.tbb ../dat/balls.dat: 6.504 seconds + ``` + +3. Run the optimized Intel® oneTBB version. ``` - ./tachyon.tbb_optimized ../dat/balls.dat + ./tachyon.tbb_optimized ../dat/balls.dat + ``` + + You will see the following output: + ``` - - You will see the following output: - - ``` - Scene contains 7386 bounded objects. - tachyon.tbb_optimized ../dat/balls.dat: 0.158 seconds + Scene contains 7386 bounded objects. + tachyon.tbb_optimized ../dat/balls.dat: 0.158 seconds ``` -4. Compare the render time between the basic Intel oneTBB and optimized Intel oneTBB versions. The optimized version shows an improvement in render time. +4. Compare the render time between the basic Intel oneTBB and optimized Intel oneTBB versions. The optimized version shows an improvement in render time. -The basic version of the Intel oneTBB program uses the oneTBB version of a mutex lock, which prevents multiple threads from working on the code at the same time. In comparison, the optimized version of the oneTBB program removes mutex lock to allow all threads to work concurrently. +The basic version of the Intel oneTBB program uses the oneTBB version of a mutex lock, which prevents multiple threads from working on the code at the same time. In comparison, the optimized version of the oneTBB program removes mutex lock to allow all threads to work concurrently. #### On Windows 1. Run the build_with_tbb project in VS or run **build_with_tbb.exe ..\..\dat\balls.dat** directly. Running a hotspots analysis with the Intel VTune Profiler shows worse performance than the serial implementation, with an elapsed time of 5.290s: @@ -299,4 +301,3 @@ The bottom-up view shows a thread timeline similar to the dynamic openmp impleme here for license information.

- diff --git a/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb.vcxproj b/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb.vcxproj index 86caf79f64..60d8ae5213 100644 --- a/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb.vcxproj +++ b/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb.vcxproj @@ -118,9 +118,6 @@ MachineX86 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(OutDir)\" - @@ -153,9 +150,6 @@ MachineX64 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(OutDir)\" - @@ -189,9 +183,6 @@ MachineX86 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(OutDir)\" - @@ -225,9 +216,6 @@ MachineX64 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(OutDir)\" - diff --git a/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb_optimized.vcxproj b/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb_optimized.vcxproj index a7ace57bb4..a12df82733 100644 --- a/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb_optimized.vcxproj +++ b/Tools/VTuneProfiler/tachyon/windows/msvs/build_with_tbb_optimized.vcxproj @@ -119,9 +119,6 @@ MachineX86 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(OutDir)\" - @@ -154,9 +151,6 @@ MachineX64 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12_debug.dll" "$(OutDir)\" - @@ -190,10 +184,6 @@ MachineX86 - - Copying DLLs and PDBs - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(OutDir)\" - @@ -227,9 +217,6 @@ MachineX64 - - copy /y "$(ONEAPI_ROOT)\tbb\latest\bin\tbb12.dll" "$(OutDir)\" -