Explore Snippets

26 public snippets shared by the community.

Sort:Recent Popular

Language:All CUDA C++Python

nvidia-smi

#include <iostream>
#include <cstdlib>
#include <cuda_runtime.h>

#define N (1 << 20)
#define LIMIT 750000

__global__ void findElements(
    int *arr,
    int n,
    int limit,
    unsigned int *result)
{
    __shared__ unsigned int count;

    if (threadIdx.x == 0)
        count = 0;

    __syncth
...

#include <iostream>
#include <cstdlib>
#include <cuda_runtime.h>

#define ARRAY_SIZE (1 << 20)
#define THRESHOLD 750000

__global__ void count_above_threshold_kernel(
    const int* d_array,
    int size,
    int threshold,
    unsigned int* d_global_count)
{
    __shared__ unsigned int block_count;
...

#include <cuda_runtime.h>

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <chrono>
#include <random>
#include <iomanip>

using namespace std;

// ============================================================
// CUDA ERROR CHECK
// // بررسی خطاهای CUDA
// =======
...

#include <cuda_runtime.h>
#include <curand_kernel.h>

#include <openssl/evp.h>

#include <atomic>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <string>
#include <thread
...

#include <stdio.h>

__global__ void vecAdd(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    int n = 1024;
    size_t bytes = n * sizeof(float);

    float *h_a = (float*)malloc(bytes);
   
...

import torch

print(f"PyTorch version : {torch.__version__}")
print(f"CUDA available  : {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU             : {torch.cuda.get_device_name(0)}")

# Simple tensor op on GPU
x = torch.randn(1024, 1024, device="cuda")
y = torch.randn(10
...

import torch
import platform
import os
import time

print("=" * 60)
print("LANIE GPU CAPABILITY PROBE")
print("=" * 60)

print("Python:", platform.python_version())
print("PyTorch:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())

if not torch.cuda.is_available():
    raise S
...

#include <iostream>
#include <cuda_runtime.h>
using namespace std;

__global__ void addition(int a, int b, int *c)
{
    *c = a + b;
}

int main()
{
    int a, b;
    int *c;

    cudaMallocManaged(&c, sizeof(int));

    cout << "Enter first number: ";
    cin >> a;

    cout << "Enter second number
...

Limport torch
import triton
import triton.language as tl

def online_softmax_kernel(
  X_ptr, O_ptr,
  stride_X, stride_o,
  stride_on, stride_od,
  N_COLS,
  BLOCK_SIZE, tl.constexpr
):
  pass
  row_id = tl.program_id(0)
  row_start_x = X_ptr + row_idx * stride_xn
  row_start_out = Out_ptr + row_id
...

#include <stdio.h>

#define A(i,j) a[(i)*n+(j)]
#define B(i,j) b[(i)*n+(j)]

float compare_matrices(int m, int n, float *a, float *b)
{
    int i, j;
    float max_diff = 0.0, diff;
    int printed = 0;

    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            diff = a
...

#include <stdio.h>

__global__ void vecAdd(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    int n = 1024;
    size_t bytes = n * sizeof(float);

    float *h_a = (float*)malloc(bytes);
   
...

#include <cuda_runtime.h>
#define N 64

// Kernel is launched as:  matMul<<<dim3(ceil(N/16),ceil(N/16)), dim3(16,16)>>>(A, B, C)
// gridDim  = (ceil(N/16), ceil(N/16))   blockDim = (16, 16)
// Row:  int row = blockIdx.y * blockDim.y + threadIdx.y;
// Col:  int col = blockIdx.x * blockDim.x + threadI
...

#include <stdio.h>


__global__ void vecAdd2D(float *a, float *b, float *c, int width, int height) { 
  int i = blockIdx.x * blockDim.x + threadIdx.x; int j = blockIdx.y * blockDim.y + threadIdx.y;
  if (i < width && j < height) 
  { int idx = j * width + i;
    c[idx] = a[idx] + b[idx];
  }
}

int 
...

#include <stdio.h>

__global__ void vecAdd(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    int n = 1024;
    size_t bytes = n * sizeof(float);

    float *h_a = (float*)malloc(bytes);
   
...

/*
Name : Salsabil Ali
ID : 2300127
*/

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

#define N 3

__global__ void matmul(const int *A, const int *B, int *C) {
    int cx = threadIdx.x;
    int ry = threadIdx.y;

    if (ry < N && cx < N) {
        int v = 0;
        for (int k = 0; k < N; ++k) {
        
...

#include <stdio.h>

__global__ void vecAdd(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        c[i] = a[i] + b[i];
    }
}

int main() {
    int n = 1024;
    size_t bytes = n * sizeof(float);

    float *h_a = (float*)malloc(bytes);
   
...

#include <stdio.h>

__global__ void hello_from_gpu()
{
    int thread_id = threadIdx.x;
    int block_id = blockIdx.x;

    printf("Hello from GPU Thread %d inside Block %d!\n",
           thread_id,
           block_id);
}

int main()
{
    printf("Master CPU: Preparing to launch GPU Kernel...\n");
...

#include <cuda_runtime.h>

// Kernel is launched as:  vectorAdd<<<ceil(n/256), 256>>>(a, b, c, n)
// gridDim.x  = ceil(n / 256)   (one block per 256 elements)
// blockDim.x = 256
// Thread ID:  int i = blockIdx.x * blockDim.x + threadIdx.x;
__global__ void vectorAdd(const float* a, const float* b, f
...

#include <cuda_runtime.h>

// Kernel is launched as:  vectorAdd<<<ceil(n/256), 256>>>(a, b, c, n)
// gridDim.x  = ceil(n / 256)   (one block per 256 elements)
// blockDim.x = 256
// Thread ID:  int i = blockIdx.x * blockDim.x + threadIdx.x;
__global__ void vectorAdd(const float* a, const float* b, f
...

import torch
import torch.nn as nn
import numpy as np
import time
import json
import os

# Ensure absolute structural performance on available hardware acceleration layers
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# --- FIRST-PRINCIPLE MULTI-PHYSICS CONSTANTS ---
PHI = (
...

import torch
import torch.nn as nn
import numpy as np
import time
import json
import os

# Ensure absolute structural performance on available hardware acceleration layers
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# --- FIRST-PRINCIPLE MULTI-PHYSICS CONSTANTS ---
PHI = (
...

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include <vector>
#include <cmath>

#define BORDE_SUPERIOR 100.0f
#define BORDES 0.0f

#define BLOCK_W 16
#define BLOCK_H 16
#define INNER_W 14
#define INNER_H 14

int MatrixSide = 1024;
int N_Steps = 5;

// --------
...

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include <vector>
#include <cmath>

#define BORDE_SUPERIOR 100.0f
#define BORDES 0.0f

#define BLOCK_W 16
#define BLOCK_H 16
#define INNER_W 14
#define INNER_H 14

int MatrixSide = 1024;
int N_Steps = 5;

// --------
...