Intel Developer Zone

https://www.intel.com/content/www/us/en/developer/
Admin
Your Official Source for Developing on Intel® Hardware and Software. Explore Intel's most popular...
Tokens:5,007,772
Snippets:73,878
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Run the installation script

Source: https://www.intel.com/content/www/us/en/developer/articles/reference-implementation/intel-edge-ai-box.html

Execute the installation script to begin the setup process.

```bash
__
./edgesoftware install
```

--------------------------------

### Setup Python Environment for NPU

Source: https://www.intel.com/content/www/us/en/developer/articles/technical/vtune-ai-profile-npu.html

Navigate to the NPU example directory and install the necessary dependencies.

```bash
cd nncf/examples/post_training_quantization/openvino/mobilenet_v2/
pip install -r requirements.txt
```

--------------------------------

### Run Interactive Installation Script

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/intel-math-kernel-library-intel-mkl-2019-install-guide.html

Execute the installation script to begin the interactive setup process.

```bash
./install.sh
```

--------------------------------

### Hello World NVMe* Drive Example

Source: https://www.intel.com/content/www/us/en/developer/topic-technology/storage/overview.html

A basic 'Hello World' sample demonstrating the use of the Storage Performance Development Kit (SPDK) user space NVMe* driver. This is useful for developers starting with high-performance NVMe* storage applications.

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include <linux/fs.h>

#include "spdk/stdinc.h"
#include "spdk/thread.h"
#include "spdk/log.h"
#include "spdk/string.h"
#include "spdk/nvme.h"
#include "spdk/nvme_spec.h"

static void
identify_controller_done(void *ctx, const struct spdk_nvme_cpl *cpl)
{
    struct spdk_nvme_ctrlr *ctrlr = ctx;
    if (spdk_nvme_completion_is_error(cpl)) {
        SPDK_ERRLOG("Failed to identify controller: %s\n",
                    spdk_nvme_cpl_get_perror(cpl));
        spdk_nvme_detach(ctrlr);
        return;
    }

    // Process identify data here
    SPDK_NOTICELOG("Controller identified successfully.\n");

    // Example: Print controller name
    struct spdk_nvme_ิดentify *identify;
    identify = spdk_nvme_ctrlr_get_identify(ctrlr);
    if (identify) {
        SPDK_NOTICELOG("Controller name: %.*s\n",
                       (int)sizeof(identify->mn),
                       identify->mn);
    }

    // Detach controller after identification (for this example)
    spdk_nvme_detach(ctrlr);
}

static void
probe_cb(void *cb_ctx, struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_transport_identify *transport_info)
{
    // For this example, we only care about identifying the controller.
    // In a real application, you would initialize the controller here
    // and potentially attach namespaces.
    spdk_nvme_identify_ctrlr(ctrlr, identify_controller_done, ctrlr);
}

static void
usage(const char *program_name)
{
    printf("%s [options]\n", program_name);
    printf("options:\n");
    printf("\t-h              Help\n");
    printf("\t-r              Use RDMA transport\n");
    printf("\t-d <dev>        NVMe device to use (e.g., /dev/nvme0n1)\n");
    printf("\t-t <trtype>     Transport type (e.g., "PCIe", "RDMA", "FC", "TCP")\n");
    printf("\t-a <adrfam>     Address family (e.g., "IPv4", "IPv6")\n");
    printf("\t-s <svcid>      Service ID\n");
    printf("\t-i <host>       Host address\n");
}

int main(int argc, char **argv)
{
    struct spdk_nvme_opts opts;
    struct spdk_nvme_resvkey resvkey;
    int op = 0;
    char *dev = NULL;
    char *trtype = NULL;
    char *adrfam = NULL;
    char *svcid = NULL;
    char *host = NULL;
    bool use_rdma = false;

    spdk_nvme_opts_init(&opts);

    while ((op = getopt(argc, argv, "hrd:t:a:s:i:")) != -1) {
        switch (op) {
        case 'h':
            usage(argv[0]);
            return 0;
        case 'r':
            use_rdma = true;
            break;
        case 'd':
            dev = optarg;
            break;
        case 't':
            trtype = optarg;
            break;
        case 'a':
            adrfam = optarg;
            break;
        case 's':
            svcid = optarg;
            break;
        case 'i':
            host = optarg;
            break;
        default:
            usage(argv[0]);
            return 1;
        }
    }

    if (use_rdma) {
        opts.transport = SPDK_NVME_TRANSPORT_RDMA;
        if (!trtype) trtype = "RDMA";
        if (!adrfam) adrfam = "IPv4";
        if (!svcid) svcid = "1";
    }

    if (dev == NULL && trtype == NULL) {
        // Default to using PCIe if no transport is specified
        opts.transport = SPDK_NVME_TRANSPORT_PCIE;
    } else if (trtype != NULL) {
        if (strcmp(trtype, "RDMA") == 0) {
            opts.transport = SPDK_NVME_TRANSPORT_RDMA;
            if (adrfam == NULL || svcid == NULL || host == NULL) {
                fprintf(stderr, "RDMA transport requires -a, -s, and -i options.\n");
                usage(argv[0]);
                return 1;
            }
            opts.rdma.adrfam = spdk_nvme_adrfam_str_to_val(adrfam);
            opts.rdma.svcid = svcid;
            opts.rdma.host = host;
        } else if (strcmp(trtype, "TCP") == 0) {
            opts.transport = SPDK_NVME_TRANSPORT_TCP;
            if (adrfam == NULL || svcid == NULL || host == NULL) {
                fprintf(stderr, "TCP transport requires -a, -s, and -i options.\n");
                usage(argv[0]);
                return 1;
            }
            opts.tcp.adrfam = spdk_nvme_adrfam_str_to_val(adrfam);
            opts.tcp.svcid = svcid;
            opts.tcp.host = host;
        } else {
            fprintf(stderr, "Unsupported transport type: %s\n", trtype);
            usage(argv[0]);
            return 1;
        }
    } else if (dev != NULL) {
        opts.transport = SPDK_NVME_TRANSPORT_PCIE;
    }

    // Initialize SPDK environment
    // In a real application, you would configure coremask, etc.
    if (spdk_nvme_init(NULL, &opts) != 0) {
        fprintf(stderr, "Failed to initialize SPDK NVMe subsystem.\n");
        return 1;
    }

    // Register a callback for discovering NVMe controllers
    spdk_nvme_probe(NULL, NULL, probe_cb);

    // Run the SPDK event loop
    // This will block until all NVMe controllers are detached
    spdk_thread_run_event_loop(spdk_get_thread());

    // Clean up SPDK environment
    spdk_nvme_fini();

    return 0;
}

```

--------------------------------

### WebNN Hello World Example

Source: https://www.intel.com/content/www/us/en/developer/videos/fast-hardware-agnostic-ai-web-apps-with-webnn.html

This is a basic example demonstrating the core functionality of the WebNN API. It's useful for understanding the initial setup and basic operations.

```javascript
/*
 * Copyright © 2024 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// This is a placeholder for the actual WebNN Hello World example code.
// The full example would typically involve:
// 1. Checking for WebNN API support.
// 2. Creating a WebNN context.
// 3. Defining the neural network graph (operations, inputs, outputs).
// 4. Preparing input data.
// 5. Compiling the model.
// 6. Running inference.
// 7. Processing the output.

console.log("WebNN Hello World example placeholder.");
console.log("Refer to the WebNN GitHub repository for the complete implementation.");

```

--------------------------------

### Install ACPICA Tools

Source: https://www.intel.com/content/www/us/en/developer/topic-technology/open/acpica/download.html

After building the tools, use 'make install' to install them into the default location, typically /usr/bin.

```bash
cd acpica-unix-VERSION
$ make install
```

--------------------------------

### Intel Open VKL Tutorial Example

Source: https://www.intel.com/content/www/us/en/developer/videos/power-of-the-image-high-performance-visualization.html

Provides a basic structure for using Intel Open VKL for volume rendering.

```C++
#include <openvkl/openvkl.h>
#include <iostream>

int main() {
    // Example: Initialize Open VKL
    vklLoadModule("common");
    vklLoadModule("tiledML");
    vklLoadModule("denoiser");
    vklInit();
    // ... further Open VKL API calls for volume data and rendering ...
    vklShutdown();
    return 0;
}
```

--------------------------------

### Windows GNU Flex/Bison Installation Path

Source: https://www.intel.com/content/www/us/en/developer/topic-technology/open/acpica/download.html

Indicates the required installation directory for GNU Flex/Bison on Windows, emphasizing the need for a path without spaces. This is a workaround for a Bison bug.

```text
c:\GnuWin32
```

--------------------------------

### Clone Repository for Contribution

Source: https://www.intel.com/content/www/us/en/developer/topic-technology/open/celadon/community.html

Clone the developer branch repository to your local setup to begin contributing.

```bash
git clone https://github.com/ <YOUR-USERNAME>/vaapi.git  

```

--------------------------------

### Example of Pairwise Distance

Source: https://www.intel.com/content/www/us/en/developer/videos/parallel-essentials-for-python.html

Illustrates a practical example of calculating pairwise distances. This snippet provides a concrete implementation that can be adapted for various applications.

```python
import numpy as np
from dpex.testing import KernelTest

def test_pairwise_distance():
    n = 100
    m = 150
    k = 75
    X = np.random.rand(n, k).astype(np.float32)
    Y = np.random.rand(m, k).astype(np.float32)
    D = np.zeros((n, m), dtype=np.float32)

    # Call the kernel (assuming pairwise_distance_kernel is defined elsewhere)
    # pairwise_distance_kernel[blocks, threads](X, Y, D)

    # Assertions or further processing would follow here
    print("Pairwise distance calculation example executed.")

test_pairwise_distance()
```

--------------------------------

### Push Changes to GitHub Fork

Source: https://www.intel.com/content/www/us/en/developer/topic-technology/open/celadon/community.html

Push your committed changes from your local setup to your fork on GitHub.

```bash
git push  

```

--------------------------------

### Take Screenshot Every 10 Frames

Source: https://www.intel.com/content/www/us/en/developer/videos/framework-quick-tip-screenshot-layer.html

Use this command to capture screenshots at a regular interval. Specify the starting frame and the interval between screenshots.

```bash
gpa-player.exe –pre-layer screenshot:frames=50:10 <stream folder>
```

--------------------------------

### Take Screenshots of Frames 30 to 40

Source: https://www.intel.com/content/www/us/en/developer/videos/framework-quick-tip-screenshot-layer.html

Capture a range of frames by specifying the start and end frame numbers. This is useful for analyzing a sequence of frames.

```bash
gpa-player.exe –pre-layer screenshot:frames=30-40
```

--------------------------------

### Collect Metrics Over Multiple Frames

Source: https://www.intel.com/content/www/us/en/developer/videos/framework-quick-tip-gpa-metrics-collector.html

Extend metrics collection over a contiguous range of frames by specifying the starting frame and the number of frames to collect.

```bash
gpa-metrics-collector "<path to stream>" -f <start_frame> -n <number_of_frames>
```

--------------------------------

### Access GDB Documentation Paths

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/intel-system-studio-2019-installation-guide-and-release-notes-for-linux-host-gdb.html

Paths relative to the installation directory for accessing GDB documentation and getting started guides.

```text
/documentation_2019/en/debugger/gdb-ia/gdb.pdf
/documentation_2019/en/debugger/gdb-igfx/gdb.pdf
/documentation_2019/en/debugger/system_studio_2019/gdb-ia/get_started.htm
```

--------------------------------

### Install the Reference Implementation

Source: https://www.intel.com/content/www/us/en/developer/articles/reference-implementation/social-distancing-for-retail-settings.html

Execute the installer script to set up the software.

```bash
./edgesoftware install
```

--------------------------------

### Setup Hugepage Memory

Source: https://www.intel.com/content/www/us/en/developer/articles/technical/testing-dpdk-performance-and-features-with-testpmd.html

Use the dpdk-setup.sh script to reserve hugepage memory for the DPDK TestPMD application. Refer to the DPDK Getting Started Guide for more details.

```bash
sudo ./usertools/dpdk-setup.sh
```

--------------------------------

### Install Reference Implementation

Source: https://www.intel.com/content/www/us/en/developer/articles/reference-implementation/network-slicing-radio-resource-management.html

Navigate to the directory, set execution permissions, and run the installer.

```bash
cd network-slicing-radio-resource-management
```

```bash
chmod 755 edgesoftware
```

```bash
./edgesoftware install
```

--------------------------------

### Prepare Installation Package

Source: https://www.intel.com/content/www/us/en/developer/articles/reference-implementation/wireless-network-ready-intelligent-traffic-management-21-12.html

Switch to the smartedge-open user and move the downloaded reference implementation package to the home directory.

```bash
su - smartedge-open
mv path-of-downloaded-directory/wireless_network_ready_intelligent_traffic_management.zip /home/smartedge-open
```

--------------------------------

### Run FFT Environment Setup Script

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/terasic-de10-nano-get-started-guide.html

Execute this script to set up the necessary environment for the FFT example applications. It installs drivers, mounts a ram disk, extracts archives, and runs demo scripts.

```shell
./setup_target_fft_env.sh
```

--------------------------------

### Install the Toolkit

Source: https://www.intel.com/content/www/us/en/developer/articles/reference-implementation/graphics-sr-iov-enablement-toolkit.html

Clone the repository and execute the installation script on a fresh system.

```bash
git clone https://github.com/intel/kubevirt-gfx-sriov.git   
cd gfx-sriov
./scripts/easy_install.sh
```

--------------------------------

### Example: Install Intel Distribution for Python 3

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/installing-free-libraries-and-python-yum-repo.html

Example command to install the Intel® Distribution for Python* 3.

```bash
yum install intelpython3
```

--------------------------------

### Example: Install Specific Intel Distribution for Python 3 Version

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/installing-free-libraries-and-python-yum-repo.html

Example command to install a specific version of the Intel® Distribution for Python* 3.

```bash
yum install intelpython3-2020.0-014
```

--------------------------------

### Record Installation Options

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/intel-math-kernel-library-intel-mkl-2019-install-guide.html

Run an interactive installation and record the selected options into a configuration file.

```bash
./install.sh --duplicate “./my_silent_config.cfg”
```

--------------------------------

### Example: Install Specific Intel MKL Version

Source: https://www.intel.com/content/www/us/en/developer/articles/guide/installing-free-libraries-and-python-yum-repo.html

Example command to install a specific version of Intel® oneAPI Math Kernel Library (oneMKL).

```bash
yum install intel-mkl-2020.0-088
```

--------------------------------

### Set Up Installation Directories

Source: https://www.intel.com/content/www/us/en/developer/articles/technical/linux-ffmpeg-vaapi-qsv-installation-environment.html

Define the root installation directory and source directory for building and installing software.

```bash
#export ROOT_INSTALL_DIR=/opt/media/
#mkdir -p $ROOT_INSTALL_DIR
#export SRC_DIR=$HOME/media_src/
#mkdir -p $SRC_DIR
```

--------------------------------

### UART Setup and Blocking I/O Example

Source: https://www.intel.com/content/www/us/en/developer/articles/technical/using-uarts-on-intel-quark-microcontroller-d2000.html

Provides a complete example demonstrating the setup of a UART interface and the use of blocking I/O functions for sending and receiving data.

```c
#include <drivers/uart.h>
#include <drivers/gpio.h>
#include <clk.h>
#include <soc/interrupt.h>

#define UART_INSTANCE QM_UART_0
#define BAUD_RATE UART_BAUD_115200

int main(void)
{
    // Initialize clock and UART
    clk_gate_all();
    qm_uart_config_t cfg = {
        .baud_divisor = qm_uart_get_baudf(BAUD_RATE),
        .line_control = QM_UART_8_BIT_NO_PARITY,
        .hw_fc = false
    };
    qm_uart_set_config(UART_INSTANCE, &cfg);

    // Example: Send a string
    uint8_t msg[] = "Hello from Quark D2000!\n";
    qm_uart_write_buffer(UART_INSTANCE, msg, sizeof(msg) - 1);

    // Example: Receive a character
    uint8_t received_char;
    if (qm_uart_read(UART_INSTANCE, &received_char) == QM_RC_SUCCESS) {
        QM_PRINTF("Received: %c\n", received_char);
    }

    return 0;
}
```
Tokens:
Raw