noob@LAPTOP-DNCQ5AAC:/mnt/d/gatechFall2022/ihpc/lab1fa22/part2$ nvidia-smi
Thu Apr 20 00:04:03 2023
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 525.100 Driver Version: 528.76 CUDA Version: 12.0 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 NVIDIA GeForce ... On | 00000000:01:00.0 Off | N/A |
| N/A 41C P8 2W / 50W | 0MiB / 4096MiB | 0% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes: |
| GPU GI CI PID Type Process name GPU Memory |
| ID ID Usage |
|=============================================================================|
| 0 N/A N/A 227 G /Xwayland N/A |
+-----------------------------------------------------------------------------+
Diz algo como "tenha cuidado para não instalar outro que substitua o padrão" aqui https://docs.nvidia.com/cuda/wsl-user-guide/index.html
Este é meu padrão antes de começar a tentar instalar o cuda novamente em minha máquina com Windows 11? Alguém tem um link para uma boa resposta sobre como instalar o cuda no WSL2?
Talvez eu tenha que pesquisar minhas próprias perguntas, mas lembre-se de que nunca funcionou como esperado e tive que usar o Windows.
A tarefa que desejo executar com o Cuda está abaixo:
/*
My Chatgpt prompt:
"implement helman-jaja list rank where the function signature is "void cudaListRank (long head, const long* next, long* rank, size_t n)" where the first parameter head is the index into array representation of a linked list and points to its head, the second parameter next is a "next array" that gives the index of the next node in the array representation of a linked list, the third parameter rank is an array holding the rank of each node in the array representation of a linked list and the fourth parameter n is the length of the array representation of a linked list."
The code written by ChatGPT below:
*/
#include <unistd.h>
#include "listutils.h"
#include <math.h>
#include <cuda.h>
#include <curand.h>
void cudaListRank(long head, const long* next, long* rank, size_t n) {
// Allocate memory for the linked list nodes and next array on the device
long* devNext;
long* devRank;
cudaMalloc((void**)&devNext, n * sizeof(long));
cudaMalloc((void**)&devRank, n * sizeof(long));
// Copy the input linked list next array from host to device
cudaMemcpy(devNext, next, n * sizeof(long), cudaMemcpyHostToDevice);
// Initialize rank array on the device to all 1's
cudaMemset(devRank, 1, n * sizeof(long));
// Launch a CUDA kernel that performs the scan phase of Helman-Jaja list rank
int block_size = 256;
int num_blocks = (n + block_size - 1) / block_size;
helmanJajaScan<<<num_blocks, block_size>>>(head, devNext, devRank);
// Launch another CUDA kernel that performs the increment phase of Helman-Jaja list rank
helmanJajaIncrement<<<num_blocks, block_size>>>(devNext, devRank);
// Copy the updated rank array from device to host
cudaMemcpy(rank, devRank, n * sizeof(long), cudaMemcpyDeviceToHost);
// Free the allocated memory on the device
cudaFree(devNext);
cudaFree(devRank);
}
//more kernels
/*
Note that in helmanJajaScan, we're traversing the linked list one node at a time and accumulating the ranks. In helmanJajaIncrement, we're traversing the list in reverse order and adding the accumulated ranks to each node's rank.
Also note that cudaMemcpyHostToDevice and cudaMemcpyDeviceToHost are used for transferring data between host and device memory. Finally, cudaMalloc and cudaFree are used to allocate and free device memory respectively.
*/
__global__ void helmanJajaScan(long head, const long* next, long* rank) {
int tid = threadIdx.x + blockIdx.x * blockDim.x;
// Traverse the linked list
while (head != -1) {
long curr = head;
for (int i = 0; i < tid && curr != -1; i++) {
curr = next[curr];
}
if (curr == -1 || next[curr] == -1) break;
rank[next[curr]] += rank[curr];
__syncthreads();
}
}
__global__ void helmanJajaIncrement(const long* next, long* rank) {
int tid = threadIdx.x + blockIdx.x * blockDim.x;
// Traverse the linked list
while (tid < gridDim.x * blockDim.x) {
long curr = tid;
for (int i = 0; i < blockDim.x && curr != -1; i++) {
curr = next[curr];
}
if (curr == -1) break;
rank[curr] += rank[next[curr]];
tid += gridDim.x * blockDim.x;
}
}
Agora, quando tento compilar com um arquivo Make, estou obtendo
noob@LAPTOP-DNCQ5AAC:/mnt/d/gatechFall2022/ihpc/lab1fa22/part2$ make correctness IMPL=hj
nvcc -Iutils -O0 -g -std=c++11 -o student/cuda_hj.o -c student/cuda_hj.cu
make: nvcc: Not a directory
make: *** [Makefile:8: student/cuda_hj.o] Error 127
Também estou vendo sublinhados ondulados em vermelho para as declarações de importação relacionadas a cuda no VSCode, mas não tenho certeza se isso indica se meu WSL-remote-VSCode e o Cuda padrão estão funcionando bem.
Também baixei e tentei instalar dois pacotes cuda diferentes (versões WSL) da Nvidia para instalar, mas nenhum deles deu certo (copiei e colei cada instrução de terminal da página de download):
cuda_12.1.0_530.30.02_linux.run
cuda-repo-wsl-ubuntu-12-1-local_12.1.0-1_amd64.deb
Primeiro, considere se você realmente precisa ou não do CUDA Toolkit completo para o seu projeto. Muitas tarefas CUDA podem ser realizadas apenas com as bibliotecas WSL CUDA fornecidas que são injetadas em cada instância WSL.
Por exemplo, sem o CUDA Toolkit instalado, veja:
Você verá, entre outros,
libcuda.so
lá. Essa biblioteca injetada é conectada ao driver NVIDIA do Windows . É por esse motivo que a página de instalação do CUDA Toolkit o avisa contra a instalação de um driver Linux no WSL - isso pode interromper a integração WSL/CUDA.Você encontrará instruções na página de documentação CUDA da WSL da Microsoft sobre como usar a integração CUDA (e/ou DirectML) existente com:
Eu testei a integração PyTorch e TensorFlow pessoalmente, mas não o contêiner Docker neste momento.
Novamente, essa é uma funcionalidade "pronta para uso" para o WSL, desde que você tenha uma versão compatível do Windows (a maioria das versões recentes com suporte neste momento) e um driver NVIDIA Windows recente. Você não precisa instalar o CUDA Toolkit para trabalhar com esses aspectos.
Bem, bem perto. Tanto quanto eu posso dizer, sim, é o driver WSL que está anexado ao driver do Windows. Caso contrário, não acredito que veria a GPU física.
No entanto, está um pouco desatualizado - um novo driver do Windows foi lançado em 18 de novembro. Depois de instalar o CUDA Toolkit no meu Ubuntu/WSL, recebi uma mensagem informando que precisava de um driver >= 530 para dar suporte ao Toolkit mais recente.
Portanto, se você deseja instalar o CUDA Toolkit completo, por exemplo, para criar aplicativos nativos usando o compilador NVIDIA (NVCC), precisará atualizar o Windows Game Ready Driver (e reiniciar o Windows, é claro).
Então, você deve seguir as instruções no site que você vinculou. Certifique-se de baixar a versão WSL do kit de ferramentas CUDA , pois todos os "padrão" para Ubuntu incluem o driver Linux .
Os relatórios são de que o compilador NVIDIA pode não ser encontrado na
.deb
versão, mas também é possível que ele simplesmente não inclua as mesmas instruções que a.run
versão (para adicioná-lo ao caminho). Por fim, baixei a.run
versão.Você também precisará de:
Então você pode:
Por favor, use as instruções na página de download real, no entanto, para garantir que você obtenha a versão mais recente (em vez da versão mais recente no momento em que isso foi escrito).
Depois, siga as instruções fornecidas pelo instalador para adicionar os
PATH
itens necessáriosLIB_PATH
.Observe que, embora eu tenha instalado o Toolkit e acredito que tenha sido bem-sucedido, não tenho um projeto de teste para experimentá-lo. Conforme mencionado nos comentários, há muitos usos possíveis para o Toolkit e, sem ter detalhes sobre o caso de uso pretendido, não posso confirmar isso para você.