Na programação paralela com aceleradores, como em CUDA, é preciso considerar os espaços de endereçamento acessíveis pelo código executando em CPU e pelo código executado em GPU.

// código 1:

int N = 1<<20;
float *x, *y, *d_x, *d_y;

x = (float*)malloc(N*sizeof(float));
y = (float*)malloc(N*sizeof(float));

cudaMalloc(&d_x, N*sizeof(float));
cudaMalloc(&d_y, N*sizeof(float));

// inicia elementos dos vetores x e y
cudaMemcpy(d_x, x, N*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_y, y, N*sizeof(float), cudaMemcpyHostToDevice);

// invoca kernel para manipulação de x e y
kern <<< ..., ... >>> (N, d_x, d_y);

cudaMemcpy(y, d_y, N*sizeof(float), cudaMemcpyDeviceToHost);

// código 2:

int N = 1<<20;
float *x, *y;

cudaMallocManaged(&x, N*sizeof(float));
cudaMallocManaged(&y, N*sizeof(float));

// inicia elementos dos vetores x e y
...

// invoca kernel para manipulação de x e y
kern <<< ..., ... >>> (N, x, y);

cudaDeviceSynchronize();

Observe os 2 trechos de código apresentados anteriormente e indique a alternativa INCORRETA (próxima página):

Considere o trecho de código C a seguir, instrumentado e compilado com com recursos das extensões OpenMP, e assinale a alternativa INCORRETA:

double dotProd(double *a, int *b, long int N) {
    long int i;
    double dot = 0.0;

    #pragma omp parallel for simd reduction(+:dot)
    for(i = 0; i < N; i++)
        dot += a[i] * b[i];

    return dot;
}

Na programação com aceleradores, usando CUDA, por exemplo, é comum que se utilize um modelo SIMT, em que os núcleos de processamento do acelerador sejam usados para executar o mesmo código sobre partes distintas dos dados. Considerando o trecho de código a seguir, que é parte de uma soma de vetores, indique a alternativa CORRETA:

#define N (1<<20)
...

__global__
void add(int n, float *x, float *y) {
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    int stride = blockDim.x * gridDim.x;

    for (int i = index; i < n; i += stride)
        y[i] = x[i] + y[i];
}
...
main() {

. . .

    int blockSize = 256;
    int numBlocks = (N + blockSize - 1) / blockSize;

    add <<< numBlocks, blockSize >>> (N, x, y);
    ...
}

Considere o trecho de código C para multiplicação de 2 matrizes apresentado a seguir, instrumentado com diretivas OpenMP, e assinale a alternativa INCORRETA:

...
int i, j, k;
...
1   // #pragma omp parallel for private(j,k)
2   for (i=0; i<N; i++)
3       // #pragma omp parallel for private(k)
4       for (j=0; j<N; j++) {
5           soma = 0;
6           // #pragma omp parallel for reduction(+:soma)
7           for (k=0; k<N; k++)
8               soma += A[i][k] * B[k][j];
9           C[i][j] = soma;
10      }

A respeito das operações de comunicação coletiva, como MPI_Scatter e MPI_Gather, apresentadas a seguir, indique a alternativa INCORRETA:

int MPI_Scatter(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

int MPI_Gather(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

No contexto de um cluster gerenciado pelo SLURM (Simple Linux Utility for Resource Management), qual é a função do usuário slurm e por que ele é importante para a segurança e a administração do sistema?

Considere um ambiente de supercomputação gerenciado pelo SLURM (Simple Linux Utility for Resource Management). Qual das seguintes opções melhor descreve a função da diretiva #SBATCH --ntasks-per-node em um script de job SLURM e como ela pode influenciar a alocação de recursos e o desempenho de uma aplicação paralela?

Considere o uso de diretivas OpenMP em um loop paralelizado. Qual das seguintes diretivas é mais apropriada para garantir que uma seção crítica de código, que atualiza uma variável compartilhada, seja executada por apenas um thread de cada vez, sem comprometer o paralelismo do restante do loop?

Qual das seguintes afirmações melhor descreve o conceito de "warps" no contexto da execução de programas CUDA em GPUs?

Em arquiteturas modernas de HPC que combinam CPU multinúcleo e aceleradores GPU, o gargalo de desempenho muitas vezes ocorre na transferência de dados. Qual prática é fundamental para minimizar a latência nesse cenário?