{"id":22468077,"url":"https://github.com/isaacalves7/nvidia-cuda","last_synced_at":"2026-04-30T17:31:30.961Z","repository":{"id":244291241,"uuid":"814815089","full_name":"IsaacAlves7/nvidia-cuda","owner":"IsaacAlves7","description":"👁️‍🗨️📗 It's a repository of Nvidia CUDA programming.","archived":false,"fork":false,"pushed_at":"2024-06-13T19:06:17.000Z","size":7,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-03-27T15:52:56.553Z","etag":null,"topics":["anaconda","gpu-programming","numba","numpy","nvidia-cuda","python3"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/IsaacAlves7.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-06-13T19:03:05.000Z","updated_at":"2024-06-13T19:06:40.000Z","dependencies_parsed_at":"2024-06-13T22:24:50.906Z","dependency_job_id":null,"html_url":"https://github.com/IsaacAlves7/nvidia-cuda","commit_stats":null,"previous_names":["isaacalves7/nvidia-cuda"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/IsaacAlves7/nvidia-cuda","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fnvidia-cuda","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fnvidia-cuda/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fnvidia-cuda/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fnvidia-cuda/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/IsaacAlves7","download_url":"https://codeload.github.com/IsaacAlves7/nvidia-cuda/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fnvidia-cuda/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32472396,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-30T13:12:12.517Z","status":"ssl_error","status_checked_at":"2026-04-30T13:12:06.837Z","response_time":57,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["anaconda","gpu-programming","numba","numpy","nvidia-cuda","python3"],"created_at":"2024-12-06T11:14:59.909Z","updated_at":"2026-04-30T17:31:30.938Z","avatar_url":"https://github.com/IsaacAlves7.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"# 👁️‍🗨️ Nvidia CUDA \n\n\u003cimg src=\"https://img.shields.io/badge/Numba-3.10.7-00A3E0?style=flat\u0026logo=Numba\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/NumPy-3.10.7-00A3E0?style=flat\u0026logo=numpy\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Anaconda-3.10.7-44A833?style=flat\u0026logo=Anaconda\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/CUDA-3.10.7-76B900?style=flat\u0026logo=nvidia\u0026logoColor=white\"\u003e\n\n\u003cimg src=\"https://upload.wikimedia.org/wikipedia/en/b/b9/Nvidia_CUDA_Logo.jpg\" align=\"right\" height=\"77\"\u003e\n\nO **Nvidia CUDA** é uma plataforma de computação paralela e um modelo de programação para ser usado com GPUs - Unidade de Processamento Gráfica. Com ele, toda a parte “pesada” do código é executada nos diversos núcleos da placa de vídeo enquanto apenas a parte sequencial do código é executada no processador, obtendo um ganho significativo de performance.\n\n\u003e **CUDA** anteriormente conhecida como Arquitetura de Dispositivo de Computação Unificada é uma API destinada a computação paralela.\n\n\u003e O uso da GPU tem custos indiretos. Se o cálculo não for pesado o suficiente, o custo (em tempo) de usar uma GPU pode ser maior do que o ganho. Por outro lado, se o cálculo for pesado, você pode ver uma grande melhoria na velocidade.\n\nVários termos importantes no tópico de programação CUDA estão listados aqui:\n\n- Host: a CPU\n- Device: a GPU\n- Host memory: a memória principal do sistema\n- Device memory: memória integrada em um cartão GPU\n- Kernel: uma função GPU lançada pelo host e executada no dispositivo\n- Device function: uma função GPU executada no dispositivo que só pode ser chamada a partir do dispositivo (ou seja, a partir de um kernel ou outra função do dispositivo).\n\n\u003cimg src=\"https://upload.wikimedia.org/wikipedia/commons/f/fe/Numba_logo.svg\" height=\"77\" align=\"right\"\u003e\n\nO **Numba** oferece suporte à programação de GPU CUDA compilando diretamente um subconjunto restrito de código Python em kernels CUDA e funções de dispositivo seguindo o modelo de execução CUDA. Kernels escritos em Numba parecem ter acesso direto aos arrays **NumPy**. Matrizes NumPy são transferidas entre a CPU e a GPU automaticamente. Numba funciona permitindo que você especifique assinaturas de tipo para funções Python, o que permite a compilação em tempo de execução (isto é, “Just-in-Time” ou compilação JIT).\n\n\u003e **Numba** é um projeto de código aberto, licenciado por BSD, que se baseia fortemente nas capacidades do compilador LLVM.\n\n**Exemplo**: O decorador `@vectorize`, no código a seguir, gera uma versão compilada e vetorizada da função escalar em tempo de execução para que possa ser usada para processar matrizes de dados em paralelo na GPU.\n\n```python\nimport numpy as np\nfrom numba import vectorize\n\n@vectorize(['float32(float32, float32)'], target='cuda')\ndef Add(a, b):\nreturn a + b\n\n# Initialize arrays\nN = 100000\nA = np.ones(N, dtype=np.float32)\nB = np.ones(A.shape, dtype=A.dtype)\nC = np.empty_like(A, dtype=A.dtype)\n\n# Add arrays on GPU\nC = Add(A, B)\n```\n\n\u003cimg src=\"https://www.svgrepo.com/show/354127/numpy.svg\" height=\"77\" align=\"right\"\u003e\n\nPara compilar e executar a mesma função na CPU, simplesmente mudamos o destino para 'cpu', o que produz desempenho no nível do código C vetorizado e compilado na CPU. Essa flexibilidade ajuda a produzir código mais reutilizável e permite desenvolver em máquinas sem GPUs.\n\n\u003e Um dos pontos fortes da plataforma de computação paralela CUDA é a variedade de bibliotecas aceleradas por GPUs disponíveis.\n\nOutro projeto da equipe Numba, chamado **pyculib**, fornece uma interface Python para as bibliotecas CUDA cuBLAS (álgebra linear densa), cuFFT (Fast Fourier Transform) e cuRAND (geração de número aleatório).\n\nMuitos aplicativos serão capazes de obter uma aceleração significativa apenas usando essas bibliotecas, sem escrever nenhum código específico da GPU. Por exemplo, o código a seguir gera um milhão de números aleatórios uniformemente distribuídos na GPU usando o gerador de números pseudoaleatórios “XORWOW”.\n\n```python\nimport numpy as np\nfrom pyculib import rand as curand\n\nprng = curand.PRNG(rndtype=curand.PRNG.XORWOW)\nrand = np.empty(100000)\nprng.uniform(rand)\nprint rand[:10]\n```\n\n\u003cimg src=\"https://anaconda.org/static/img/anaconda-symbol.svg\" height=\"77\" align=\"right\"\u003e\n\nA capacidade do Numba de compilar código dinamicamente significa que você não abre mão da flexibilidade do Python. Esse é um grande passo para fornecer a combinação ideal de programação de alta produtividade e computação de alto desempenho.\n\nO back-end da GPU do Numba utiliza o NVIDIA Compiler SDK baseado em LLVM. Os wrappers pyculib em torno das bibliotecas CUDA também são de código aberto e licenciados por BSD.\n\nPara começar a usar o Numba, a primeira etapa é baixar e instalar a distribuição **Anaconda Python**, uma \"distribuição Python totalmente gratuita, pronta para empresas, para processamento de dados em grande escala, análise preditiva e computação científica\" que inclui muitos pacotes populares (Numpy, SciPy, Matplotlib, IPython etc).\n\nDigite o comando para baixar o Numba:\n\n```sh\napt-get install libgl1-mesa-glx libegl1-mesa libxrandr2 libxrandr2 libxss1 libxcursor1 libxcomposite1 libasound2 libxi6 libxtst6\n```\n\nAgora, você pode ativar a instalação, fazendo um source no arquivo `~/.bashrc: source ~/.bashrc`\n\nAssim que tiver feito isso, você será levado ao ambiente de programação padrão de base do Anaconda, e seu prompt de comando mudará para o seguinte: `(base) summy@ubuntu:~$`\n\nEmbora o Anaconda venha com esse ambiente de programação padrão de base, você deve criar ambientes separados para seus programas e mantê-los isolados um do outro. Você pode, ainda, verificar sua instalação fazendo o uso do comando `conda`, por exemplo, com `list`:\n\n```sh\nconda list\n```\n\nVocê receberá a saída de todos os pacotes disponíveis através da instalação do Anaconda.\n\n\u003cpre\u003e\n# packages in environment at /home/sammy/anaconda3:\n# Name                    Version                  Build  Channel\n_ipyw_jlab_nb_ext_conf    0.1.0                    py37_0\n_libgcc_mutex             0.1                        main\nalabaster                 0.7.12                   py37_0\nanaconda                  2020.02                  py37_0\n...\n\u003c/pre\u003e\n\nAgora que o Anaconda está instalado, podemos seguir em frente para a configuração dos ambientes dele.\n\n\u003e **Atenção**: Os ambientes virtuais do Anaconda lhe permitem manter projetos organizados pelas versões do Python e pelos pacotes necessários. Para cada ambiente do Anaconda que você configurar, especifique qual versão do Python usar e mantenha todos os arquivos de programação relacionados dentro desse diretório.\n\nPrimeiro, podemos verificar quais versões do Python estão disponíveis para que possamos usar: `conda search \"^python$\"`\n\n\u003e Vamos criar um ambiente usando a versão mais recente do Python 3.\n\nPodemos conseguir isso atribuindo a versão 3 ao argumento python. Vamos chamar o ambiente de `my_env`, mas você pode usar um nome mais descritivo para o ambiente, especialmente se estiver usando ambientes para acessar mais de uma versão do Python.\n\n```sh\nconda create --name my_env python=3\n```\n\nVocê receberá uma saída com informações sobre o que está baixado e quais pacotes serão instalados e, em seguida, será solicitado a prosseguir com `y` ou `n`. Assim que concordar, digite `y`.\n\nO utilitário `conda` agora irá obter os pacotes para o ambiente e informá-lo assim que estiver concluído. Você pode ativar seu novo ambiente digitando o seguinte:\n\n```sh\nconda activate my_env\n```\n\nCom seu ambiente ativado, seu prefixo do prompt de comando irá refletir que você não está mais no ambiente base, mas no novo ambiente que acabou de criar.\n\n\u003cpre\u003e\n(my_env) summy@ubuntu:~$\n\u003c/pre\u003e\n\nDentro do ambiente, você pode verificar se está usando a versão do Python que tinha intenção de usar: `(my_env) summy@ubuntu:~$ python –version`\n\nQuando estiver pronto para desativar seu ambiente do Anaconda, você pode fazer isso digitando: `(my_env) summy@ubuntu:~$ conda deactivate`\n\nObserve que pode substituir a palavra source por `.` para obter os mesmos resultados. Para focar em uma versão mais específica do Python, você pode passar uma versão específica para o argumento python, como 3.5, por exemplo:\n\n```sh\nconda create -n my_env35 python=3.5\n```\n\nVocê pode inspecionar todos os ambientes que configurou com este comando:\n\n\u003cpre\u003e\n(base) summy@ubuntu:~$ conda info –envs\n\n\n# conda environments:\n#\nbase                  *  /home/sammy/anaconda3\nmy_env                   /home/sammy/anaconda3/envs/my_env\nmy_env35                 /home/sammy/anaconda3/envs/my_env35\n\u003c/pre\u003e\n\nO asterisco indica o ambiente ativo atual. Cada ambiente que você criar com o `conda create` virá com vários pacotes padrão:\n\n- `_libgcc_mutex`\n- `ca-certificates`\n- `certifi`\n- `libedit`\n- `libffi`\n- `libgcc-ng`\n- `libstdcxx-ng`\n- `ncurses`\n- `openssl`\n- `pip`\n- `python`\n- `readline`\n- `setuptools`\n- `sqlite`\n- `tk`\n- `wheel`\n- `xz`\n- `zlib`\n\nVocê pode acrescentar pacotes adicionais, como o Numpy, por exemplo, com o seguinte comando:\n\n```sh\nconda install --name my_env35 numpy\n```\n\nSe você já sabe que gostaria de um ambiente Numpy após a criação, pode concentrá-lo em seu comando `conda create`:\n\n```sh\nconda create --name my_env python=3 numpy\n```\n\nSe você não estiver mais trabalhando em um projeto específico e não tiver mais necessidade do ambiente associado, pode removê-lo. Para fazer isso, digite o seguinte:\n\n```sh\nconda remove --name my_env35 --all\n```\n\n\u003e **Atenção**: Agora, quando você digitar o comando `conda info --envs`, o ambiente que removeu não será mais listado.\n\nVocê deve garantir regularmente que o Anaconda esteja atualizado para que você esteja trabalhando com todas as versões mais recentes do pacote. Para fazer isso, deve primeiro atualizar o utilitário conda: `(base) summy@ubuntu:~$ conda update conda`\n\nQuando solicitado a fazer isso, digite `y` para continuar com a atualização. Assim que a atualização do `conda` estiver concluída, você pode atualizar a distribuição do Anaconda:\n\n```sh\nconda update anaconda\n```\n\n\u003e **Atenção**: Novamente, quando solicitado a fazer isso, digite `y` para continuar. Isso garantirá que você esteja usando as versões mais recentes do `conda` e do Anaconda.\n\nDepois de instalar o Anaconda, instale os pacotes CUDA necessários digitando:\n\n```sh\nconda install numba cudatoolkit pyculib\n```\n\n\u003e O **Anaconda** (anteriormente Continuum Analytics) reconheceu que alcançar grandes acelerações em alguns cálculos requer uma interface de programação mais expressiva com controle mais detalhado sobre o paralelismo do que as bibliotecas e a vetorização automática de `loop` podem fornecer.\n\u003e\n\u003e Portanto, o Numba possui outro conjunto importante de recursos que constitui o que é conhecido não oficialmente como “CUDA Python”.\n\nNumba expõe o modelo de programação CUDA, assim como em CUDA C / C ++, mas usando a sintaxe Python pura, para que os programadores possam criar kernels paralelos personalizados e ajustados sem deixar o conforto e as vantagens do Python para trás. O CUDA JIT da Numba (disponível via decorador ou chamada de função) compila funções CUDA Python em tempo de execução, especializando-as para os tipos que você usa, e sua API CUDA Python fornece controle explícito sobre transferências de dados e fluxos CUDA, entre outros recursos.\n\nO exemplo de código a seguir demonstra isso com um kernel de conjunto Mandelbrot simples. Observe que a função `mandel_kernel` usa as estruturas `cuda.threadIdx`, `cuda.blockIdx`, `cuda.blockDim` e `cuda.gridDim` fornecidas por Numba para calcular os índices globais de pixel `X` e `Y` para o segmento atual. Como em outras linguagens CUDA, lançamos o kernel inserindo uma \"configuração de execução\" (linguagem CUDA para o número de threads e blocos de threads a serem usados para executar o kernel) entre colchetes, entre o nome da função e a lista de argumentos: `mandel_kernel` [griddim, blockdim] (- 2.0, 1.0, -1.0, 1.0, d_image, 20). Você também pode ver o uso das funções de API `to_host` e `to_device` para copiar dados de e para a GPU.\n\n```python\n@cuda.jit\ndef mandel_kernel(min_x, max_x, min_y, max_y, image, iters):\n\theight = image.shape[0]\n\twidth = image.shape[1]\n\n\tpixel_size_x = (max_x - min_x) / width\n\tpixel_size_y = (max_y - min_y) / height\n\n\tstartX = cuda.blockDim.x * cuda.blockIdx.x + cuda.threadIdx.x\n\tstartY = cuda.blockDim.y * cuda.blockIdx.y + cuda.threadIdx.y\n\tgridX = cuda.gridDim.x * cuda.blockDim.x;\n\tgridY = cuda.gridDim.y * cuda.blockDim.y;\n\n\tfor x in range(startX, width, gridX):\n\t\treal = min_x + x * pixel_size_x\n\t\tfor y in range(startY, height, gridY):\n\t\t\timag = min_y + y * pixel_size_y\n\t\t\timage[y, x] = mandel(real, imag, iters)\n\n\tgimage = np.zeros((1024, 1536), dtype = np.uint8)\n\tblockdim = (32, 8)\n\tgriddim = (32,16)\n\n\tstart = timer()\n\td_image = cuda.to_device(gimage)\n\tmandel_kernel[griddim, blockdim](-2.0, 1.0, -1.0, 1.0, d_image, 20)\n\td_image.to_host()\n\tdt = timer() - start\n\n\tprint \"Mandelbrot created on GPU in %f s\" % dt\n\n\timshow(gimage)\n```\n\n\u003e Em um servidor com uma GPU NVIDIA Tesla P100 e uma CPU Intel Xeon E5-2698 v3, este código CUDA Python Mandelbrot é executado quase 1700 vezes mais rápido do que a versão Python pura. 1700x pode parecer uma aceleração irreal, mas tenha em mente que estamos comparando o código Python compilado, paralelo e acelerado por GPU ao código Python interpretado de thread único na CPU.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fisaacalves7%2Fnvidia-cuda","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fisaacalves7%2Fnvidia-cuda","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fisaacalves7%2Fnvidia-cuda/lists"}