Intel

Nesta seção:

Descrição
Versões Disponíveis
Componentes
Carregando Módulos
Compilação com Intel Compilers
- C
- C++
- Fortran
Compilação com OpenMP
Compilação com Intel MPI
Execução com Intel MPI
Uso do Intel MKL
OneAPI (Versão Moderna)
Flags de Otimização Intel
Job Array para Testar Diferentes Flags
Referências

Descrição 

Intel oferece um conjunto de compiladores e bibliotecas otimizados para processadores Intel, incluindo compiladores C/C++ e Fortran, bibliotecas matemáticas (MKL) e implementação MPI.

Versões Disponíveis 

intel/compilers/2017 (default)
intel/mpi/2017 (default)
intel/oneapi/hpc/2025.2
mkl/2022.2.0 (default)

Componentes 

Intel Compilers: icc (C), icpc (C++), ifort (Fortran)
Intel MPI: Implementação MPI otimizada
Intel MKL: Math Kernel Library (BLAS, LAPACK, FFT)
Intel IPP: Integrated Performance Primitives
Intel TBB: Threading Building Blocks

Carregando Módulos 

# Compiladores apenas
module load intel/compilers/2017

# Compiladores + MPI
module load intel/compilers/2017
module load intel/mpi/2017

# OneAPI
module load intel/oneapi/hpc/2025.2

# MKL
module load mkl/2022.2.0

Compilação com Intel Compilers 

C 

compile_intel_c.sh

#!/bin/bash
#SBATCH -J compile_intel_c
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa.c"
export OUTPUT="programa"

module load intel/compilers/2017
job-nanny icc -O3 -xHost -o programa programa.c

C++

compile_intel_cpp.sh

#!/bin/bash
#SBATCH -J compile_intel_cpp
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa.cpp"
export OUTPUT="programa"

module load intel/compilers/2017
job-nanny icpc -O3 -xHost -std=c++11 -o programa programa.cpp

Fortran 

compile_intel_fortran.sh

#!/bin/bash
#SBATCH -J compile_intel_fortran
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa.f90"
export OUTPUT="programa"

module load intel/compilers/2017
job-nanny ifort -O3 -xHost -o programa programa.f90

Compilação com OpenMP 

compile_intel_omp.sh

#!/bin/bash
#SBATCH -J compile_intel_omp
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa_omp.c"
export OUTPUT="programa_omp"

module load intel/compilers/2017
job-nanny icc -qopenmp -O3 -xHost -o programa_omp programa_omp.c

Compilação com Intel MPI 

compile_intel_mpi.sh

#!/bin/bash
#SBATCH -J compile_intel_mpi
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa_mpi.c"
export OUTPUT="programa_mpi"

module load intel/compilers/2017
module load intel/mpi/2017
job-nanny mpiicc -O3 -xHost -o programa_mpi programa_mpi.c

Execução com Intel MPI 

run_intel_mpi.sh

#!/bin/bash
#SBATCH -J run_intel_mpi
#SBATCH -N 2
#SBATCH --ntasks-per-node=28
#SBATCH -t 24:00:00
#SBATCH --mem-per-cpu=2G

export INPUT="programa_mpi"
export OUTPUT="mpi_output/"

module load intel/compilers/2017
module load intel/mpi/2017

job-nanny mpirun -np $SLURM_NTASKS ./programa_mpi

Uso do Intel MKL 

compile_with_mkl.sh

#!/bin/bash
#SBATCH -J compile_mkl
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="dgemm_example.c"
export OUTPUT="dgemm_example"

module load intel/compilers/2017
module load mkl/2022.2.0

job-nanny icc -O3 -xHost -mkl -o dgemm_example dgemm_example.c

dgemm_example.c

#include <stdio.h>
#include <stdlib.h>
#include <mkl.h>

int main() {
    int n = 2000;
    double *A, *B, *C;
    double alpha = 1.0, beta = 0.0;

    // Alocar matrizes
    A = (double*)mkl_malloc(n*n*sizeof(double), 64);
    B = (double*)mkl_malloc(n*n*sizeof(double), 64);
    C = (double*)mkl_malloc(n*n*sizeof(double), 64);

    // Inicializar
    for (int i = 0; i < n*n; i++) {
        A[i] = (double)i;
        B[i] = (double)(i+1);
    }

    // DGEMM: C = alpha*A*B + beta*C
    cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
                n, n, n, alpha, A, n, B, n, beta, C, n);

    printf("C[0] = %f\n", C[0]);

    mkl_free(A);
    mkl_free(B);
    mkl_free(C);

    return 0;
}

OneAPI (Versão Moderna)

compile_oneapi.sh

#!/bin/bash
#SBATCH -J compile_oneapi
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:10:00
#SBATCH --mem=2G

export INPUT="programa.c"
export OUTPUT="programa"

module load intel/oneapi/hpc/2025.2

# Compilador icx (C) e icpx (C++) baseados em LLVM
job-nanny icx -O3 -march=native -o programa programa.c

Flags de Otimização Intel 

Flags de otimização Intel
Flag	Descrição
`-O0`	Sem otimização
`-O1`	Otimização básica
`-O2`	Otimização recomendada
`-O3`	Otimização agressiva
`-xHost`	Otimiza para a arquitetura atual
`-xCode`	Otimiza para arquitetura específica (xAVX, xCORE, etc.)
`-ipo`	Otimização interprocedural
`-qopenmp`	Habilita OpenMP
`-mkl`	Linka com Intel MKL
`-fast`	Combinação de otimizações agressivas

Job Array para Testar Diferentes Flags 

test_intel_flags.sh

#!/bin/bash
#SBATCH -J test_intel_flags
#SBATCH --array=1-6
#SBATCH -N 1
#SBATCH -n 1
#SBATCH -t 00:30:00
#SBATCH --mem=4G

FLAGS=("-O0" "-O1" "-O2" "-O3" "-O3 -xHost" "-fast")
FLAG=${FLAGS[$SLURM_ARRAY_TASK_ID-1]}

export INPUT="benchmark.c"
export OUTPUT="benchmark_flag_${SLURM_ARRAY_TASK_ID}/"

module load intel/compilers/2017

mkdir -p benchmark_flag_${SLURM_ARRAY_TASK_ID}
cd benchmark_flag_${SLURM_ARRAY_TASK_ID}

# Compilar com flag específica
job-nanny icc $FLAG -o benchmark ../benchmark.c

# Executar e medir tempo
time ./benchmark > performance.txt 2>&1

Referências 

Documentação Intel Compilers: https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/
Intel MPI: https://software.intel.com/content/www/us/en/develop/documentation/mpi-developer-reference/
Intel MKL: https://software.intel.com/content/www/us/en/develop/documentation/mkl-developer-reference-c/

Ver também

GCC - Compiladores GNU
OpenMPI - MPI open-source
Processando Simulações - Como submeter jobs