aakaar 0.1.2__tar.gz

aakaar-0.1.2/MANIFEST.in

@@ -0,0 +1,5 @@
+cat > MANIFEST.in << 'EOF'
+include src/*.h
+include src/*.cuh
+include README.md
+EOF

aakaar-0.1.2/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: aakaar
+Version: 0.1.2
+Summary: A custom CUDA-accelerated ML library
+Author: Aarav Aggarwal
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: nvidia-curand-cu12
+Requires-Dist: nvidia-cuda-runtime-cu12
+
+# Aakaar
+
+Aakaar is a custom, standalone deep learning tensor library built from the ground up using Python, C++, and raw CUDA. It is designed to provide a lightweight, transparent architecture for high-performance GPU computations without relying on heavy external frameworks like PyTorch or TensorFlow.
+
+## Core Architecture
+
+Aakaar bypasses standard NumPy arrays by implementing a custom C++ Tensor object that resides directly in GPU VRAM. Python interacts with this data via Pybind11, acting as a lightweight remote control. This prevents severe performance bottlenecks over the PCI-e bus, keeping data on the GPU until explicitly requested back to the host CPU.
+
+Current capabilities include:
+* Custom GPU-native Tensor class lifecycle management.
+* CUDA-accelerated uniform random number generation via cuRAND.
+* Direct host-to-device and device-to-host memory mapping.
+
+## Installation
+
+To build Aakaar from source, you must have the NVIDIA CUDA Toolkit (nvcc) and a compatible C++ compiler (e.g., g++) installed.
+
+1. Clone the repository:
+```bash
+git clone [https://github.com/YOUR_USERNAME/aakaar.git](https://github.com/YOUR_USERNAME/aakaar.git)
+cd aakaar
+pip install setuptools wheel pybind11
+pip install -e .
+```
+
+quick start
+```bash
+import aakaar
+
+# Initialize the CUDA engine and allocate a GPU Tensor
+print("Generating 100,000 random numbers on the GPU...")
+data = aakaar.rand(100000, device="cpu", seed=1337)
+
+# The data remains on the GPU as an Aakaar Tensor
+print(type(data)) 
+# <class 'aakaar._C.Tensor'>
+
+# Bring the data across the PCI-e bus to the CPU for inspection
+cpu_data = data.cpu()
+print(cpu_data[:5])
+```

aakaar-0.1.2/README.md

@@ -0,0 +1,41 @@
+# Aakaar
+
+Aakaar is a custom, standalone deep learning tensor library built from the ground up using Python, C++, and raw CUDA. It is designed to provide a lightweight, transparent architecture for high-performance GPU computations without relying on heavy external frameworks like PyTorch or TensorFlow.
+
+## Core Architecture
+
+Aakaar bypasses standard NumPy arrays by implementing a custom C++ Tensor object that resides directly in GPU VRAM. Python interacts with this data via Pybind11, acting as a lightweight remote control. This prevents severe performance bottlenecks over the PCI-e bus, keeping data on the GPU until explicitly requested back to the host CPU.
+
+Current capabilities include:
+* Custom GPU-native Tensor class lifecycle management.
+* CUDA-accelerated uniform random number generation via cuRAND.
+* Direct host-to-device and device-to-host memory mapping.
+
+## Installation
+
+To build Aakaar from source, you must have the NVIDIA CUDA Toolkit (nvcc) and a compatible C++ compiler (e.g., g++) installed.
+
+1. Clone the repository:
+```bash
+git clone [https://github.com/YOUR_USERNAME/aakaar.git](https://github.com/YOUR_USERNAME/aakaar.git)
+cd aakaar
+pip install setuptools wheel pybind11
+pip install -e .
+```
+
+quick start
+```bash
+import aakaar
+
+# Initialize the CUDA engine and allocate a GPU Tensor
+print("Generating 100,000 random numbers on the GPU...")
+data = aakaar.rand(100000, device="cpu", seed=1337)
+
+# The data remains on the GPU as an Aakaar Tensor
+print(type(data)) 
+# <class 'aakaar._C.Tensor'>
+
+# Bring the data across the PCI-e bus to the CPU for inspection
+cpu_data = data.cpu()
+print(cpu_data[:5])
+```

aakaar-0.1.2/aakaar/__init__.py

@@ -0,0 +1,16 @@
+from . import _C
+import numpy as np
+
+def rand(size: int, device: str = "cpu", seed: int = 42):
+    # 1. Create the Tensor (The C++ constructor handles allocation)
+    t = _C.Tensor(size, device)
+    
+    # 2. Route to the correct backend
+    if device == "cuda":
+        # Call your existing CUDA random generator
+        _C.generate_random(t, seed)
+    else:
+        # Call the CPU random generator
+        _C.fill_cpu_random(t, seed)
+        
+    return t

aakaar-0.1.2/aakaar.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: aakaar
+Version: 0.1.2
+Summary: A custom CUDA-accelerated ML library
+Author: Aarav Aggarwal
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: nvidia-curand-cu12
+Requires-Dist: nvidia-cuda-runtime-cu12
+
+# Aakaar
+
+Aakaar is a custom, standalone deep learning tensor library built from the ground up using Python, C++, and raw CUDA. It is designed to provide a lightweight, transparent architecture for high-performance GPU computations without relying on heavy external frameworks like PyTorch or TensorFlow.
+
+## Core Architecture
+
+Aakaar bypasses standard NumPy arrays by implementing a custom C++ Tensor object that resides directly in GPU VRAM. Python interacts with this data via Pybind11, acting as a lightweight remote control. This prevents severe performance bottlenecks over the PCI-e bus, keeping data on the GPU until explicitly requested back to the host CPU.
+
+Current capabilities include:
+* Custom GPU-native Tensor class lifecycle management.
+* CUDA-accelerated uniform random number generation via cuRAND.
+* Direct host-to-device and device-to-host memory mapping.
+
+## Installation
+
+To build Aakaar from source, you must have the NVIDIA CUDA Toolkit (nvcc) and a compatible C++ compiler (e.g., g++) installed.
+
+1. Clone the repository:
+```bash
+git clone [https://github.com/YOUR_USERNAME/aakaar.git](https://github.com/YOUR_USERNAME/aakaar.git)
+cd aakaar
+pip install setuptools wheel pybind11
+pip install -e .
+```
+
+quick start
+```bash
+import aakaar
+
+# Initialize the CUDA engine and allocate a GPU Tensor
+print("Generating 100,000 random numbers on the GPU...")
+data = aakaar.rand(100000, device="cpu", seed=1337)
+
+# The data remains on the GPU as an Aakaar Tensor
+print(type(data)) 
+# <class 'aakaar._C.Tensor'>
+
+# Bring the data across the PCI-e bus to the CPU for inspection
+cpu_data = data.cpu()
+print(cpu_data[:5])
+```

aakaar-0.1.2/aakaar.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+aakaar/__init__.py
+aakaar.egg-info/PKG-INFO
+aakaar.egg-info/SOURCES.txt
+aakaar.egg-info/dependency_links.txt
+aakaar.egg-info/requires.txt
+aakaar.egg-info/top_level.txt
+src/allocator.h
+src/bindings.cpp
+src/cpu_kernel.cpp
+src/random_kernel.cu
+src/rng.h
+src/tensor.h

aakaar-0.1.2/aakaar.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aakaar-0.1.2/aakaar.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+nvidia-curand-cu12
+nvidia-cuda-runtime-cu12

aakaar-0.1.2/aakaar.egg-info/top_level.txt

@@ -0,0 +1 @@
+aakaar

aakaar-0.1.2/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=64", "wheel", "pybind11>=2.10"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aakaar"
+version = "0.1.2"
+description = "A custom CUDA-accelerated ML library"
+readme = "README.md"
+authors = [{name = "Aarav Aggarwal"}]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "nvidia-curand-cu12",
+    "nvidia-cuda-runtime-cu12",
+]

aakaar-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aakaar-0.1.2/setup.py

@@ -0,0 +1,71 @@
+import os
+import subprocess
+import sysconfig # <--- ADD THIS
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import pybind11
+
+class CUDABuildExtension(build_ext):
+    def build_extensions(self):
+        nvcc_flags = [
+            '-O3',
+            '-gencode=arch=compute_75,code=sm_75', 
+            '-gencode=arch=compute_86,code=sm_86', 
+            '-gencode=arch=compute_89,code=sm_89', 
+            '-Xcompiler=-fPIC'                     
+        ]
+
+        for ext in self.extensions:
+            # 1. Grab all include directories from the Extension definition
+            includes = [f"-I{d}" for d in ext.include_dirs]
+            # 2. Explicitly add Python's core header directory (needed for pybind11)
+            includes.append(f"-I{sysconfig.get_path('include')}")
+
+            cu_sources = [s for s in ext.sources if s.endswith('.cu')]
+            cpp_sources = [s for s in ext.sources if s.endswith('.cpp')]
+            
+            objects = []
+            
+            for cu_file in cu_sources:
+                obj_file = cu_file.replace('.cu', '.o')
+                # 3. Add the `includes` list to the nvcc command!
+                nvcc_cmd = ['nvcc', '-c', cu_file, '-o', obj_file] + nvcc_flags + includes
+                print(f"Compiling CUDA: {' '.join(nvcc_cmd)}")
+                subprocess.check_call(nvcc_cmd)
+                objects.append(obj_file)
+                
+            ext.sources = cpp_sources
+            ext.extra_objects = objects
+
+        super().build_extensions()
+
+# Define the Python Extension
+aakaar_ext = Extension(
+    'aakaar._C',
+    sources=['src/bindings.cpp', 'src/cpu_kernel.cpp', 'src/random_kernel.cu'],
+    include_dirs=[
+        pybind11.get_include(),
+        '/usr/local/cuda/include'
+    ],
+    library_dirs=[
+        '/usr/local/cuda/lib64'
+    ],
+    libraries=['curand', 'cudart'],
+    language='c++'
+)
+
+setup(
+    name='aakaar',
+    version='0.1.0',
+    author='Aarav Aggarwal',
+    description='A custom standalone ML library featuring CUDA-accelerated operations.',
+    packages=['aakaar'],
+    ext_modules=[aakaar_ext],
+    cmdclass={'build_ext': CUDABuildExtension},
+    install_requires=[
+        'numpy', 
+        'nvidia-curand-cu12',
+        'nvidia-cuda-runtime-cu12'
+    ],
+    setup_requires=['pybind11']
+)   

aakaar-0.1.2/src/allocator.h

@@ -0,0 +1,56 @@
+#pragma once
+#include <cuda_runtime.h>
+#include <unordered_map>
+#include <vector>
+#include <stdexcept>
+#include <iostream>
+
+class CachingAllocator {
+private:
+    // Maps the size of a tensor to a list of available GPU pointers
+    std::unordered_map<int, std::vector<float*>> free_blocks;
+
+    // Private constructor (Singleton pattern)
+    CachingAllocator() {}
+
+public:
+    // Get the global instance of the allocator
+    static CachingAllocator& get_instance() {
+        static CachingAllocator instance;
+        return instance;
+    }
+
+    // Allocate memory (or reuse an old block)
+    float* allocate(int size) {
+        // 1. Check if we already have a block of this size in the pool
+        if (free_blocks.find(size) != free_blocks.end() && !free_blocks[size].empty()) {
+            // Pop a recycled pointer off the back of the list and return it instantly
+            float* ptr = free_blocks[size].back();
+            free_blocks[size].pop_back();
+            return ptr;
+        }
+
+        // 2. If no recycled block exists, we MUST ask the OS (cudaMalloc)
+        float* ptr;
+        cudaError_t err = cudaMalloc((void**)&ptr, size * sizeof(float));
+        if (err != cudaSuccess) {
+            throw std::runtime_error("Aakaar out of memory!");
+        }
+        return ptr;
+    }
+
+    // Free memory (put it in the pool, DON'T give it to the OS)
+    void free(float* ptr, int size) {
+        free_blocks[size].push_back(ptr);
+    }
+
+    // A utility to actually clear the cache and give memory back to the GPU
+    void empty_cache() {
+        for (auto& pair : free_blocks) {
+            for (float* ptr : pair.second) {
+                cudaFree(ptr); // ACTUALLY free the memory
+            }
+        }
+        free_blocks.clear();
+    }
+};

aakaar-0.1.2/src/bindings.cpp

@@ -0,0 +1,26 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <memory>
+#include "tensor.h"
+#include "allocator.h"
+
+namespace py = pybind11;
+
+void run_curand_uniform(std::shared_ptr<Tensor> t, unsigned long long seed);
+void fill_cpu_random(std::shared_ptr<Tensor> t, unsigned long long seed);
+
+void empty_cache() {
+    CachingAllocator::get_instance().empty_cache();
+}
+
+PYBIND11_MODULE(_C, m) {
+    py::class_<Tensor, std::shared_ptr<Tensor>>(m, "Tensor")
+        .def(py::init<int, std::string>())
+        .def_readonly("device", &Tensor::device)
+        .def("to_numpy", &Tensor::to_numpy);
+
+    m.def("generate_random", &run_curand_uniform, "Fill GPU Tensor with random numbers");
+    m.def("fill_cpu_random", &fill_cpu_random, "Fill CPU Tensor with random numbers");
+
+    m.def("empty_cache", &empty_cache, "Release cached GPU memory");
+}

aakaar-0.1.2/src/cpu_kernel.cpp

@@ -0,0 +1,11 @@
+#include <random>
+#include <memory>
+#include "tensor.h"
+
+void fill_cpu_random(std::shared_ptr<Tensor> t, unsigned long long seed) {
+    std::mt19937 gen(seed);
+    std::uniform_real_distribution<float> dis(0.0, 1.0);
+    for (int i = 0; i < t->size; ++i) {
+        t->data_ptr[i] = dis(gen);
+    }
+}

aakaar-0.1.2/src/random_kernel.cu

@@ -0,0 +1,19 @@
+#include <cuda_runtime.h>
+#include <curand.h>
+#include <memory>
+#include "tensor.h"
+#include "rng.h" // Import the random manager
+
+void run_curand_uniform(std::shared_ptr<Tensor> t, unsigned long long seed) {
+    // Fetch the persistent global generator
+    curandGenerator_t generator = CUDARandomManager::get_instance().get_generator(seed);
+
+    // Generate random numbers directly into the existing tensor's buffer
+    curandStatus_t status = curandGenerateUniform(generator, t->data_ptr, t->size);
+    if (status != CURAND_STATUS_SUCCESS) {
+        throw std::runtime_error("cuRAND generation failed");
+    }
+
+    // Ensure the GPU finishes execution before returning control to Python
+    cudaDeviceSynchronize();
+}

aakaar-0.1.2/src/rng.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <curand.h>
+#include <stdexcept>
+
+class CUDARandomManager {
+private:
+    curandGenerator_t generator;
+    bool initialized;
+
+    // Private constructor (Singleton)
+    CUDARandomManager() : initialized(false) {}
+
+public:
+    static CUDARandomManager& get_instance() {
+        static CUDARandomManager instance;
+        return instance;
+    }
+
+    // Initialize the generator only once
+    // Initialize the generator only once
+    curandGenerator_t get_generator(unsigned long long seed) {
+        if (!initialized) {
+            curandStatus_t status = curandCreateGenerator(&generator, CURAND_RNG_PSEUDO_DEFAULT);
+            if (status != CURAND_STATUS_SUCCESS) {  // <--- FIXED HERE
+                throw std::runtime_error("Failed to create cuRAND generator");
+            }
+            initialized = true;
+        }
+        
+        curandSetPseudoRandomGeneratorSeed(generator, seed);
+        return generator;
+    }
+
+    // Clean up the generator when the engine shuts down
+    ~CUDARandomManager() {
+        if (initialized) {
+            curandDestroyGenerator(generator);
+        }
+    }
+};

aakaar-0.1.2/src/tensor.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <cuda_runtime.h>
+#include <string>
+#include <stdexcept>
+#include <iostream>
+#include <pybind11/pybind11.h>
+#include <pybind11/numpy.h>
+#include "allocator.h" // Your CachingAllocator
+
+namespace py = pybind11;
+
+class Tensor {
+public:
+    float* data_ptr;
+    int size;
+    std::string device;
+
+    Tensor(int s, std::string dev) : size(s), device(dev) {
+        if (device == "cuda") {
+            data_ptr = CachingAllocator::get_instance().allocate(size);
+        } else {
+            data_ptr = new float[size]; // Standard heap allocation
+        }
+    }
+
+    ~Tensor() {
+        if (device == "cuda") {
+            CachingAllocator::get_instance().free(data_ptr, size);
+        } else {
+            delete[] data_ptr;
+        }
+    }
+
+    // Copy data back to a numpy array on the host, regardless of device
+    py::array_t<float> to_numpy() {
+        py::array_t<float> result(size);
+        auto buf = result.mutable_data();
+
+        if (device == "cuda") {
+            cudaError_t err = cudaMemcpy(buf, data_ptr, size * sizeof(float),
+                                          cudaMemcpyDeviceToHost);
+            if (err != cudaSuccess) {
+                throw std::runtime_error("cudaMemcpy failed in to_numpy(): " +
+                                          std::string(cudaGetErrorString(err)));
+            }
+        } else {
+            std::memcpy(buf, data_ptr, size * sizeof(float));
+        }
+        return result;
+    }
+};