Этот новый язык может убить монополию NVIDIA в области графического процессора

Эра высокопроизводительных вычислений была определена одним именем:Куда.

Платформа Nvidia разблокировала силу графических процессоров, став де -факто стандартом.

Более десяти лет программировать графический процессор, предназначенный для программы в CUDA.

Но сегодня, середина 2015 года - все меняется.

Компьютерный мир в настоящее время претерпевает радикальную трансформацию в отношении неоднородности.

Мы видим распространение специализированного оборудования:

• Intel Gaudi Series:

  Процессоры Intel Gaudi разработаны специально для глубокого обучения и вывода, предлагая конкурентную альтернативу графическим процессорам Nvidia.

• Amd instinct mi series:

  Серия графических процессоров MI AMD предназначена для высокопроизводительных вычислений и рабочих нагрузок ИИ, предоставляя альтернативу графическим процессорам NVIDIA.

• Процессор потокового потока Tensor Groq (TSP):

  Архитектура TSP Groq предназначена для вывода с низкой задержкой и высокой пропускной способности, особенно для моделей крупных языков.

• Google TPU (единицы обработки тензоров):

  TPU Google представляют собой специально разработанные чипы, оптимизированные для рабочих нагрузок машинного обучения, особенно в облачной инфраструктуре Google.

• AWS Tradium:

  AWS Tradium-это чип, предназначенный для обучения машинного обучения, обеспечивающего высокую производительность и экономическую эффективность.

И все больше и больше стартапов, которые строят пользовательские кремниевые чипсы каждый день.

Этот новый, разнообразный ландшафт требует новой философии программирования.

Многоуровневое промежуточное представление (MLIR) и язык программирования MOJO

Это не просто еще один конкурент; Они представляют собой фундаментальный сдвиг парадигмы.

Эта статья будет глубоко исследует архитектурную пропасть между Cuda и Mlir.

1. Мы будем использовать полные примеры рабочего кода, чтобы обеспечить конкретное, практическое сравнение.
2. Мы рассмотрим, почему Mlir - это прорыв на его почтенного предшественника LLVM.
3. Мы будем утверждать, что Mojo является превосходным долгосрочным решением.
4. Мы проанализируем, почему этот новый стек имеет изменение игры для стоимости и скорости.

Это воздействие распространяется на критические новые области, такие какГенеративныйAI, квантовые вычисленияи дажеБлокчейн.

Мы также будем смотреть в будущее, охватываягорнодобывающие асикиВНейроморфные вычисления, иСпециализированное оборудованиеДля разреженных потоков данных, которые графические процессоры плохо обрабатывают.

Это история конца эпохи и рассвета нового.

Чтобы понять величину этого сдвига, мы должны сначалаПоймите четырех ключевых игроков.

1. CUDA: мощный, собственник действующего действующего лица

Cuda означает вычисление архитектуры унифицированного устройства.

Это параллельная вычислительная платформа Nvidia и модель программирования.

Это позволяет разработчикам писать C ++-как код, называемый ядрами, которые работают на графических процессорах NVIDIA.

Сильные стороны CUDA:

Его экосистема библиотек зрелая и непревзойденная:

• Математические библиотеки:
  • Кублы: для базовых линейных подпрограмм алгебры (BLA).
  • Кюнда: для генерации случайных чисел.
  • Каффт: для быстрых преобразований Фурье.
  • Круспара: для редких матриц.
  • Cutensor: для тензоров.
  • Cusolver: для плотных и редких прямых решателей.
• Библиотеки параллельных алгоритмов:
  • NVGraph: для алгоритмов графика.
  • Уклон: для параллельных алгоритмов и структур данных.
• Библиотеки связи:
  • NVSHMEM: для программирования в глобальном адресном пространстве (PGAS).
  • NCCL: для коллективной связи с несколькими GPU и мультизлевой.
• Библиотеки глубокого обучения:
  • Cudnn: для глубоких расчетов нейронной сети.
  • Tensorrt: для оптимизированного глубокого учебного вывода.
  • Рива: Для разговорного ИИ.
  • Дали: для загрузки данных и увеличения для глубокого обучения.

Он обеспечивает прямой низкоуровневый контроль над оборудованием, что обеспечивает пиковую производительность для экспертов.

Фатальный недостаток Cuda: клетка

Заблокировка поставщика: CUDA Code работаеттолькона NVIDIA GPU.

Это кандалы разработчиков и целые отрасли промышленности к одному, дорогому поставщику оборудования.

Это уклоняется от конкуренции и ограничивает свободу выбирать лучшее оборудование для работы.

Проблема с двумя языками: главное узкое место в ИИ и научных вычислениях.

Исследователи-прототип на языке высокого уровня, как Python, за его простоту и скорость итерации.

Это создает болезненное и дорогостоящее разрыв, замедляя путь от исследований к развертыванию.

Сложность программирования:

CUDA является мощным, но общеизвестно сложным и многословным.

Разработчик вынужден быть Ручный диспетчер памяти, передающий данные между ЦП (хост) и графическим процессором (устройство).

Разработчик также должен быть аппаратным планировщиком, управлять блоками потока, сетки и синхронизацию.

Эта сложность является крутой кривой обучения и частым источником тонких ошибок.

2. LLVM: Фонд и его «семантический разрыв»

Проект LLVM представляет собой набор модульных и многократных компилятора технологий.

Его ядро-промежуточное представление LLVM (IR), низкоуровневый, похожий на сборник язык.

LLVM стал стандартом для современных бэкэндов компилятора, особенно для процессоров.

Фронтал компилятора (например, Clang для C ++) переводит исходный код в LLVM IR.

Бэкэнд LLVM затем оптимизирует этот IR и преобразует его в машинный код для определенного процессора.

Эта модульность была революционной в течение своего времени.

Тем не менее, LLVM был разработан для процессора, ориентированного на ЦП.

Его ИК слишком низкий для нового мира гетерогенного оборудования.

3. Mlir: универсальный переводчик для оборудования

Mlir родился в Google от необходимости компилировать TensorFlow для процессоров, графических процессоров и их TPU.

Они поняли, что одинокого, низкоуровневого ИК, и ИК LLVM, было недостаточно.

Прорыв Mlir является единой инфраструктурой для определения и составления нескольких IRS.

Эти композиционные IRS называютсядиалектыПолем

MLIR похож на универсальный переводчик, свободный во всем, от концепций высокого уровня до деталей машины низкого уровня.

Диалект высокого уровня может напрямую представлять концепции, специфичные для домена.

Фонили пример, «диалект TensorFlow» имеет операцию для TF.Conv2d.

«Линейный диалект алгебры» имеет операцию для Linalg.matmul.

Это сохраняет критическую семантическую информацию, которую LLVM отбрасывает.

Это позволяет мощной стратегии компилятора под названиемпрогрессивное снижение*.*

1. Компилятор начинается с изображения диалекта высокого уровня.
2. Он выполняет высокоуровневые, специфичные для домена оптимизации на этом диалекте.
3. Затем он постепенно «понижает» код через серию промежуточных диалектов.
4. Каждый промежуточный диалект выполняет свои собственные конкретные оптимизации.
5. Наконец, он достигает диалекта низкого уровня, как IR LLVM IR, для окончательного генерации машинного кода.

Этот процесс сохраняет контекст высокого уровня как можно дольше.

Это обеспечивает значительно превосходную оптимизацию для любой аппаратной цели.

4. Mojo: удобное лицо власти Mlir

Если Mlir является мощным, сложным двигателем, Mojo является гладким, интуитивно понятным пользовательским интерфейсом.

Моджо был создан Крисом Латтнером, оригинальным архитектором LLVM и Swift Language.

Он разработан из первых принципов, чтобы стать идеальным языком для эпохи Mlir.

В связи с этим это самый технологически продвинутый язык сегодня.

Ключевые особенности Mojo:

Суперсет питона

• Mojo стремится к полной совместимости с существующей экосистемой Python.
• Это убийственная особенность!
• Это позволяет разработчикам импортировать и использовать любую библиотеку Python, такую ​​как Numpy, Pandas или Matplotlib.
• Он полностью обходит проблему «холодного старта», с которой сталкиваются новые языки, используя обширную экосистему Python.

Особенности программирования True Systems:

• В отличие от Python, Mojo - это составленный язык с сильным статическим набором.
• Это устраняет целые классы ошибок во время выполнения и позволяет C ++-оптимизации производительности уровня.
• Он вводит современные концепции управления памятью, такие как право собственности и заимствования (от ржавчины) для безопасности памяти без накладных расходов коллекционера мусора.

Первоклассная интеграция Mlir:

• Моджо раскрывает всю мощь Mlir напрямую разработчику.
• Программисты могут писать высокоуровневый, питонический код для большей части своего применения.
• Когда требуется максимальная производительность, они могут упасть, чтобы использовать определенные диалекты MLIR и писать ядра низкого уровня.
• Важно отметить, что все это можно сделать в одном и том же файле, на одном языке.

Полный код примеры и анализ

Теория - это одно; Практика - это еще одна.

Следующие примеры полноценного рабочего кода -

Продемонстрирует глубокие различия между двумя парадигмами.

Пример 1: умножение матрицы

Это "Привет, мир!" высокопроизводительных вычислений, и это ясно раскрывает основную философию каждой платформы.

Полная реализация CUDA

Это полная, компилируемая программа CUDA для умножения матрицы.

(CUDA C ++)

// Filename: matmul.cu
// To compile: nvcc matmul.cu -o matmul_cuda

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

// Helper to check for CUDA errors
#define CUDA_CHECK(err) { \
    cudaError_t err_code = err; \
    if (err_code != cudaSuccess) { \
        std::cerr << "CUDA Error: " << cudaGetErrorString(err_code) << " at line " << __LINE__ << std::endl; \
        exit(EXIT_FAILURE); \
    } \
}

// CUDA Kernel for Matrix Multiplication (Device Code)
__global__ void matrixMulKernel(float* C, const float* A, const float* B, int N) {
    // Calculate the global row and column index of the element
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;

    // Boundary check to avoid accessing out-of-bounds memory
    if (row < N && col < N) {
        float p_value = 0.0f;
        // Each thread computes one element of the result matrix C
        for (int k = 0; k < N; ++k) {
            p_value += A[row * N + k] * B[k * N + col];
        }
        C[row * N + col] = p_value;
    }
}

// Main function (Host Code)
int main() {
    const int N = 256;
    const int size = N * N * sizeof(float);

    // Step 1. Allocate host memory
    std::vector<float> h_A(N * N);
    std::vector<float> h_B(N * N);
    std::vector<float> h_C(N * N);

    // Initialize host matrices
    for (int i = 0; i < N * N; ++i) {
        h_A[i] = static_cast<float>(rand()) / RAND_MAX;
        h_B[i] = static_cast<float>(rand()) / RAND_MAX;
    }

    // Step 2. Allocate device memory
    float *d_A, *d_B, *d_C;
    CUDA_CHECK(cudaMalloc((void**)&d_A, size));
    CUDA_CHECK(cudaMalloc((void**)&d_B, size));
    CUDA_CHECK(cudaMalloc((void**)&d_C, size));

    // Step 3. Copy matrices from host to device
    std::cout << "Copying data from host to device..." << std::endl;
    CUDA_CHECK(cudaMemcpy(d_A, h_A.data(), size, cudaMemcpyHostToDevice));
    CUDA_CHECK(cudaMemcpy(d_B, h_B.data(), size, cudaMemcpyHostToDevice));

    // Step 4. Define kernel launch configuration
    // Use 16x16 threads per block, a common choice
    dim3 threadsPerBlock(16, 16);
    // Calculate the number of blocks needed in each dimension
    dim3 numBlocks((N + threadsPerBlock.x - 1) / threadsPerBlock.x, (N + threadsPerBlock.y - 1) / threadsPerBlock.y);

    // Step 5. Launch the kernel on the device
    std::cout << "Launching kernel..." << std::endl;
    matrixMulKernel<<<numBlocks, threadsPerBlock>>>(d_C, d_A, d_B, N);
    CUDA_CHECK(cudaGetLastError());
    CUDA_CHECK(cudaDeviceSynchronize()); // Wait for the kernel to finish

    // Step 6. Copy the result matrix back from device to host
    std::cout << "Copying result from device to host..." << std::endl;
    CUDA_CHECK(cudaMemcpy(h_C.data(), d_C, size, cudaMemcpyDeviceToHost));

    // Step 7. Free device memory
    CUDA_CHECK(cudaFree(d_A));
    CUDA_CHECK(cudaFree(d_B));
    CUDA_CHECK(cudaFree(d_C));

    std::cout << "CUDA Matrix Multiplication finished successfully." << std::endl;
    // (Optional: Add verification step here)

    return 0;
}

Анализ кода CUDA:

В коде преобладают управление шаблоном и низкоуровневым.

Шаги 1, 2, 3, 6 и 7 предназначены исключительно для управления памятью по границе ЦП/графического процессора.

Это утомительно, склонно к ошибкам и скрывает основной алгоритм.

АглобальныйКлючевое слово, blockidx, ThreadIDX и <<<! >>> синтаксис-это специфичные для CUDA аппаратные абстракции.

Этот код принципиально и навсегда связан с аппаратной архитектурой Nvidia.

Фактический алгоритм - три вложенных петли - это крошечная часть общего кода.

Полная реализация моджо

Эта версия Mojo достигает того же результата с захватывающей дух простотой и силой.

(Моджо)

# Filename: matmul.mojo
# To run: mojo matmul.mojo

from memory import DType, Tensor
from random import rand
from time import now

fn matmul_naive(C: Tensor[DType.float32], A: Tensor[DType.float32], B: Tensor[DType.float32]):
    """A naive, high-level implementation of matrix multiplication."""
    let N = A.dim(0)
    let M = A.dim(1)
    let P = B.dim(1)

    for i in range(N):
        for j in range(P):
            var sum: Float32 = 0.0
            for k in range(M):
                sum += A.load(i, k) * B.load(k, j)
            C.store(i, j, sum)

fn main():
    let N = 256
    
    # 1. Allocate and initialize tensors.
    # Mojo's Tensor handles memory allocation automatically.
    # The compiler will place it in the most appropriate memory space.
    var A = Tensor[DType.float32](N, N)
    var B = Tensor[DType.float32](N, N)
    var C = Tensor[DType.float32](N, N)

    for i in range(N):
        for j in range(N):
            A.store(i, j, rand[DType.float32]())
            B.store(i, j, rand[DType.float32]())

    print("Starting Mojo Matrix Multiplication...")
    
    let start_time = now()
    
    # 2. Call the function.
    # The MLIR-based compiler optimizes this high-level code.
    # It can automatically tile, vectorize, and parallelize this code
    # for the target hardware (CPU, GPU, etc.).
    matmul_naive(C, A, B)

    let end_time = now()
    let duration_ms = (end_time - start_time) / 1_000_000.0

    print("Mojo Matrix Multiplication finished successfully.")
    print("Execution time:", duration_ms, "ms")
    # (Optional: Print a corner of the result matrix to verify)
    print("Result C[0,0]:", C.load(0,0))
}

И это все!

Подход моджо намного превосходит

Программируемость и фокус:

• Код MOJO чистый и напрямую выражает алгоритм.
• Программист фокусируется начто(Математика), а некак(Перевод памяти).
• Там нет ручного Cudamalloc, Cudamemcpy или Cudafree.
• Весь этот класс ошибок исчез.

Абстракция с производительностью:

• Простые вложенные петли - это не то, что выполняется.
• Компилятор на основе MLIR выполняет сложные преобразования.
• Это превращает этот простой код в очень оптимизированное ядро.
• Он может автоматически применять плитку, векторизацию и параллелизацию.
• Программист может добавлять подсказки (например, @Vectorize или @Parallize), чтобы направлять компилятор, достигая контроля без сложности.

Переносимость (конечное преимущество):

• Это важный момент.
• Тот же самый файл Matmul.mojo может быть повторно скомпилирован для запуска на графическом процессоре NVIDIA, графическом процессоре AMD, процессоре Intel с AVX512 или Google TPU.
• Логика остается прежней; Бэкэнд компилятора меняется.
• Код CUDA потребует полного, дорогостоящего переписывания для каждой новой целевой оборудования.
• Mojo предлагает «переносимость производительности», нарушение блокировки поставщика и защищать от кода в будущем.

Для получения дополнительной информации о Mojo, обратитесь к статье ниже:

https://hackernoon.com/meet-mojo-the-klange-that-could-replace-python-c-and-cuda?embedable=true

Пример 2: Gen AI и механизм внимания трансформатора

Механизм «внимания»-это сердце моделей, таких как GPT-4, и является основным вычислительным узким местом.

Реализация CUDA (концептуальное вспышка)

Flashatturement-это ориентир-алгоритм, который вручную и искусно организует движение данных между медленной основной памятью GPU (HBM) и его быстрой встроенной памятью (SRAM), чтобы уменьшить узкие места.

Ссылки на компоненты реализации полного алгоритма приведены ниже:

https://github.com/dao-ailab/flash-attention/blob/main/csrc/flash_attn/src/flash_fwd_kernel.h

https://github.com/dao-ailab/flash-attention/blob/main/csrc/flash_attn/flash_api.cpp

Вместе они имеют длину почти 3000 строк.

Репозиторий содержит тысячи файлов.

Кривая обучения и кривая адаптации оба крутые.

Ниже приведена упрощенная версия (сгенерирована AI):

(CUDA C ++)

// This is a simplified conceptual view of a FlashAttention-style CUDA kernel.
// The actual implementation is far more complex.

template<typename Kernel_traits>
__global__ void flash_attention_fwd_kernel(Flash_fwd_params params) {

    // 1. Incredibly complex setup code
    // Calculates dozens of pointers and indices for HBM and shared memory (SRAM)
    const int block_row_idx = blockIdx.x;
    const int head_idx = blockIdx.y;
    // ... many more calculations ...

    // 2. Explicitly allocate shared memory tiles for Q, K, V
    // The developer must manage this limited resource manually.
    extern __shared__ char smem[];
    float* sQ = (float*)smem;
    float* sK = sQ + kTileM * kTileK;
    float* sV = sK + kTileN * kTileK;

    // 3. Main loop over the sequence, manually loading blocks
    for (int k_block_idx = 0; k_block_idx < params.k_num_blocks; ++k_block_idx) {

        // Manually orchestrate asynchronous loads from HBM into SRAM
        // to hide memory latency. This is extremely difficult to get right.
        load_qkv_block_from_hbm(params, ...);
        __syncthreads(); // Hard synchronization barrier

        // Manually perform matrix multiplication in fast SRAM
        compute_sram_matmul(sQ, sK, ...);

        // Recompute softmax "online" to avoid writing the huge intermediate
        // attention score matrix back to slow HBM. This is the core trick.
        compute_online_softmax(...);
        __syncthrows();

        // Update the output block
        update_output_block(sV, ...);
    }

    // 4. Manually write the final output block back to HBM
    store_output_to_hbm(params, ...);
}

Анализ подхода CUDA/Flashtationlination:

• Это шедевр ручного аппаратного инженера.
• Он достигает невероятной производительности, обращаясь с помощью графического процессора как с помощью машины, запрограммированной вручную.
• Это делает код практически нечитаемым, неприемлемым и невозможным.
• Только несколько экспертов мирового класса могут написать или изменить такой код.
• Он представляет пик производительности в закрытой экосистеме, а также пик сложности и жесткости.

Концептуальная реализация моджо

Версия Mojo выражает то же самоеАлгоритмическая идея(Tiling, Online Softmax) на высоком уровне, делегируя аппаратную оркестровку компилятору Mlir.

(Моджо :)

from memory import DType, Tensor
from algorithm import parallelize

struct AttentionParams:
    var is_causal: Bool
    # ... other model parameters

# This function is a high-level, portable description of the FlashAttention algorithm.
fn flash_attention[T: DType](Q: Tensor[T], K: Tensor[T], V: Tensor[T], params: AttentionParams) -> Tensor[T]:
    # Define problem dimensions from input tensors
    let num_batches = Q.dim(0)
    let num_heads = Q.dim(2)
    let seqlen_q = Q.dim(1)
    let seqlen_k = K.dim(1)
    
    # Define tunable tiling parameters. The compiler can use these as hints.
    alias BLOCK_M: Int = 128
    alias BLOCK_N: Int = 64

    # The output tensor
    var O = Tensor[T](Q.dims)

    # The @parallelize decorator tells the compiler to map this function
    # over the available hardware parallelism (e.g., CUDA thread blocks or CPU cores).
    @parallelize(num_batches * num_heads)
    fn compute_head(batch_idx: Int, head_idx: Int):
        
        # Define per-worker accumulators. The compiler will map these
        # to the fastest available memory (e.g., registers or SRAM).
        var o_i = Tensor[T](seqlen_q, V.dim(3))
        var l_i = Tensor[T](seqlen_q) # Stores the denominator of the softmax
        var m_i = Tensor[T](seqlen_q) # Stores the max of each row for stable softmax
        o_i.zero()
        l_i.fill(0.0)
        m_i.fill(-50000.0) # Negative infinity

        # Loop over blocks of the Key/Value sequence
        for j in range(0, seqlen_k, BLOCK_N):
            # 1. Load tiles of K and V.
            # The compiler is responsible for generating the optimal code
            # to move this data from main memory to fast memory.
            let k_j = K.load_tile[BLOCK_N](batch_idx, j, head_idx)
            let v_j = V.load_tile[BLOCK_N](batch_idx, j, head_idx)
            
            # Loop over blocks of the Query sequence
            for i in range(0, seqlen_q, BLOCK_M):
                # 2. Load tile of Q.
                let q_i = Q.load_tile[BLOCK_M](batch_idx, i, head_idx)
                
                # 3. Compute attention scores for the tile. This is a simple matmul.
                let s_ij = q_i @ k_j.transpose()
                
                # Causal masking for decoder models like GPT
                if params.is_causal:
                    # Algorithmic logic, no hardware specifics
                    apply_causal_mask(s_ij, i, j)

                # 4. Perform the "online softmax" update.
                # This is pure mathematical logic, not memory management.
                let m_ij = row_max(s_ij)
                let p_ij = exp(s_ij - m_ij)
                let l_ij = row_sum(p_ij)
                
                let m_new = max(m_i, m_ij)
                let l_new = exp(m_i - m_new) * l_i + exp(m_ij - m_new) * l_ij

                # Update output tile
                o_i = (l_i / l_new * exp(m_i - m_new)) * o_i + (exp(m_ij - m_new) / l_new) * (p_ij @ v_j)

                # Update softmax stats
                l_i = l_new
                m_i = m_new

        # 5. Store the final output. The compiler manages the write-back.
        O.store_tile(batch_idx, head_idx, o_i)
    
    compute_head()
    return O

Один файл.

Менее 100 лока.

Нет заболеваний мозга.

Моджо меняет игру для ИИ:

Разделение проблем:

• Код моджо описываеталгоритмПолем
• Код CUDA описываетРучная аппаратная реализацияПолем
• Это глубокая разница.
• Программист Mojo может сосредоточиться на улучшении алгоритма:
• В то время как компилятор Mlir фокусируется на картировании его на кремний.

Скорость исследований и обслуживаемость:

• Исследователь ИИ может легко понять и изменить этот код MOJO, чтобы проверить новую идею.
• Модификация кода CUDA будет массовым, трудоемким инженерным проектом, требующим редкого набора навыков.
• Это резко ускоряет цикл исследований и разработок.

Аппаратная свобода:(Самый важный)

• Этот код MOJO не привязан к NVIDIA.
• Это можно скомпилировать для работы:
  • AMD GRPU
  • Google TPUS
  • Intel Gaudi
  • Пользовательские чипсы ИИ.
  • Любая архитектура есть!
• Диалекты Mlir могут быть расширены для поддержки любого нового оборудования:
• Сделать код моджо действительно будущим.

Специализированные аппаратные и будущие домены

Блокчейн, горнодобывающая промышленность и Asics

Блокчейны, такие как Биткойн, требуют огромной хэширующей мощности.

Цель состоит в том, чтобы найти «нерез», который, когда он хранения с другими данными дает результат ниже определенной цели.

Это поиск грубой силы, который идеально подходит для параллельного оборудования.

Первоначально шахтеры использовали процессоры, затем графические процессоры для их превосходной параллелизма.

Код CUDA для майнера SHA-256 является низкоуровневым, сфокусированный на бить и целочисленных операциях.

ASIC (специфичная для приложения интегрированная схема) - это чип, предназначенный для одной цели - для реализации алгоритма в оборудовании.

ASIC SHA-256 имеет хэширующую логику, буквально выпеченную в кремнии.

Это в тысячи раз более энергоэффективно, чем графический процессор для одной задачи.

Именно здесь заканчивается история о CUDA, но история Mlir/Mojo становится еще более интересной.

Процесс проектирования чипа называется синтезом высокого уровня (HLS).

Инструменты HLS преобразуют описание высокого уровня алгоритма в язык оборудования низкого уровня (например, Verilog или VHDL), используемый для изготовления чипа.

1. Разработчик мог бы написать алгоритм хэширования в Mojo.
2. Для майнинга графических процессоров они собирают его с помощью бэкэнда графического процессора.
3. Для создания ASIC они могли составитьточно такой же код моджоИспользуя бэкэнд HLS.
4. Инфраструктура MLIR будет снизить логику Mojo высокого уровня в Verilog.

Это объединяет весь стек, от программного обеспечения высокого уровня до индивидуального кремниевого дизайна.

Это обеспечивает быстрое прототипирование и развертывание новых алгоритмов на наиболее эффективное оборудование, будь то GPU или совершенно новый ASIC.

У Cuda нет ответа на это.

Это программное решение только для программируемого оборудования одного поставщика.

Нейроморфные вычисления и редкие данные

Это означает, что они невероятно эффективны, когда все тысячи потоков выполняют одну и ту же инструкцию по разным данным (например, умножение матрицы).

Тем не менее, они очень неэффективны при рабочих нагрузках с тяжелым ветвлением или нерегулярным доступом к данным.

Это из -за «дивергенции ниток».

Это убивает производительность для многих важных проблем.

Нейроморфные вычисления:

Это вдохновленная мозгом вычислительная парадигма.

Нейроморфные чипсы, такие как Loihi Intel, не основаны на часах и плотной матричной математике.

«Нейроны» стреляют «всплеск» только тогда, когда их входной потенциал пересекает порог.

Эти шипы перемещаются в другие «синапсы», которые затем могут привести к стрельбе других нейронов.

Это чрезвычайно разреженный, тяжелый филиал и асинхронный процесс.

Mlir - идеальное решение для этого.

1. «Нейроморфный диалект» может быть создан в Mlir.
2. Этот диалект будет иметь первоклассные операции для Spike, Synapse, NeuroNupdate.
3. Разработчик может написать нейроморфный алгоритм в Mojo, используя эти концепции высокого уровня.
4. Компилятор MLIR, с бэкэнд для определенного нейроморфного чипа, такого как Loihi, переведет эти концепции в нативные, управляемые событиями инструкции.

Это обеспечивает портативную модель программирования высокого уровня для совершенно нетрадиционной формы вычислений.

Модель CUDA не актуальна в этом домене.

Разреженные и графические данные:

Многие реальные проблемы связаны с разреженными данными: социальные сети, рекомендательные двигатели и научные симуляции.

Представление их в виде плотных матриц является расточительным.

Обработка их на графических процессорах приводит к нерегулярным моделям доступа к памяти, что побеждает оптимизацию памяти графического процессора и производительность.

Опять же, Mlir дает ответ.

1. «Графический диалект» или «Sparse Tensor Dialect» может накапливаться на этих структурах данных.
2. Затем компилятор может применять специализированные оптимизации для обработки разреженности.
3. Например, он может переупорядочивать узлы для улучшения локальности памяти или использовать сжатые форматы хранения.

Это то, что сегодня очень сложно.

А рядом с Cuda невозможно.

Квантовая вычислительная моделирование

Моделирование квантового компьютера на классическом компьютере имеет важное значение для разработки и тестирования квантовых алгоритмов.

Наиболее распространенным методом является моделирование вектора состояния.

Состояние квантовой системы n-qubit представлено вектором из 2^n комплексных чисел.

Квантовый алгоритм представляет собой последовательность «ворот».

Каждое ворота эквивалентно умножению массивного вектора состояния на очень большую, очень скудную матрицу.

Это рабочая нагрузка, которая является как вычислительно интенсивной, так и связанной с гибелью.

Nvidia инвестировала здесь в инвестиции в свою библиотеку Cuquantum, высокоэффективное решение на основе CUDA.

Cuquantum очень быстро на графических процессорах Nvidia, но у него классические ограничения CUDA:

1. Замок поставщика: Ваше квантовое моделирование привязано к оборудованию NVIDIA.
2. Оптимизация низкого уровня: компилятор видит только умножение матрицы-вектора.
3. Нет преимущества домена: он не имеет оптимизации для квантовой механики, основанный на LLVM (семантический разрыв).

Преимущество Mlir/Mojo для квантового моделирования:

Подход MLIR обеспечивает гораздо более высокий уровень интеллекта в компиляторе.

1. «Квантовый диалект» может быть определен в Mlir.
2. Этот диалект не будет представлять ворота как матрицы; Это будет представлять их как их квантовые объекты: хадамард, Cnot, Toffoli.
3. Разработчик напишет свою квантовую схему в Mojo, используя эти объекты высокого уровня.
4. Компилятор Mlir может затем выполнитьквантовая оптимизацияПрежде чем каких -либо матриц даже генерируются.

Например, компилятор будет знать, что применение затвора хадамарда (h) дважды подряд является операцией идентификации и может быть полностью исключено.

Он будет знать, что определенные последовательности ворот могут быть «слиты» в единый, более эффективный ворот.

После выполнения этих высокоуровневых алгебраических упрощений компилятор MLIR затем снизит упрощенную схему в оптимизированную последовательность работ разреженной матрицы для целевого оборудования.

Это обеспечивает как более высокую производительность (из -за более умной оптимизации), так и полной свободы оборудования.

NVIDIA инвестирует в квантовое оборудование для моделирования и программное стек.

Но его платформа CUDA-Q все еще основана на LLVM.

Окончательный вердикт: сегодня против неизбежного будущего

Вердикт сегодня (2025):

1. Куда - король холма, а холм большой.
2. Его зрелая экосистема, обширные библиотеки и массовое сообщество являются мощными активами.
3. Для команды, которая уже инвестирована в аппаратное обеспечение NVIDIA и должна немедленно отправить продукт, CUDA является прагматическим выбором.
4. Инерция десятилетия доминирования является мощной силой.
5. Моджо еще молод.
6. Его экосистема растет с невероятной скоростью, но она еще не может соответствовать широкой широте библиотек, проверенных сражением,.

Вердикт за долгое время:

1. Будущее гетерогенное.
2. Это не предположение; Это реальность.
3. Рост индивидуального кремния ИИ и обновленной конкуренции со стороны AMD и Intel сделало поставщика недопустимым бизнесом и техническим риском.
4. Проблемы будущего - данные SPARSE, нейроморфный ИИ, добыча блокчейнов и квантовые вычисления - не вписываются в жесткую модель SIMT сегодняшних графических процессоров.
5. Mlir-единственная существующая, поддерживаемая отрасли архитектуру, предназначенную для решения этой проблемы.
6. Его принятие Google, Apple, Intel, AMD и ARM является явным сигналом его центральной роли в будущем компиляторов.
7. Моджо - единственный язык, построенный (пока), чтобы использовать эту силу.

Моджо:

• Решает задачу с двумя языками
• Объединяет удобство использования с производительностью
• Предлагает шлюз во всю экосистему Mlir.

Переход от CUDA к миру, основанному на MLIR, будет постепенным, но это неизбежно.

Это фундаментальный переход от закрытой, ориентированной на оборудование модели к открытому программному будущему.

Недостатки моджо

1. Моджо все еще находится в стадии разработки.
2. У него еще даже нет занятий.
3. Его сторонние библиотеки мало, но растут в невероятных темпах.
4. Он имеет приложения повсюду Python, но он должен развиваться с Python.
5. Весь язык еще не является открытым исходным кодом, хотя эксперты говорят, что скоро изменится.
6. Он не поддерживает Windows (пока).
7. И это требует портирования в системы Android, IOS и Edge IoT.

Но будет ли это победителем в долгосрочной перспективе?

Я считаю, что это будет, и разработчики будут счастливее с Mojo, чем Cuda.

Заключение

И этот фундамент суждено быть Mlir и Mojo.

Самая простая причина -бюджет.

Вот почему, если NVIDIA Pivots, и скоро:

Ссылки

Официальные страницы проекта

• Mlir (многоуровневое промежуточное представление)
  • Текст описание:Официальная домашняя страница для проекта MLIR, организованная LLVM. Это канонический источник документации, переговоров и общего заявления о миссии проекта.
  • https://mlir.llvm.org/
• Язык программирования MOJO
  • Официальная документация для языка программирования MOJO от модульной компании, которая создала его. Это основной ресурс для изучения языка.2]
  • https://docs.modular.com/mojo/
• NVIDIA CUDA Toolkit
  • Официальный портал от NVIDIA для загрузки Toolkit CUDA, который включает в себя компиляторы, библиотеки и инструменты, необходимые для разработки CUDA.
  • https://developer.nvidia.com/cuda-toolkit
• Проект инфраструктуры компилятора LLVM
  • Основная домашняя страница для проекта LLVM, которая предоставляет обзор всей экосистемы, включая Clang, LLDB и другие субпроекты. Mlir является частью этого более крупного проекта.
  • https://llvm.org/
• Домашняя страница Криса Латтнера
  • Личная домашняя страница Криса Латтнера, создателя LLVM, Clang, Swift, Mlir и Mojo. Это обеспечивает его историю работы и связи с его разговорами и статьями, предлагая прямое понимание создания этих технологий.
  • https://nondot.org/sabre/

ИИ и механизм внимания (вспышка)

• Оригинальная бумага Flashattureation (Arxiv)
  • Оригинальная научная статья, «Флэш-осознание: быстрое и точное внимание памяти с i-waveness», которая ввела алгоритм. Это является основным источником для понимания технических деталей и преимуществ производительности.
  • https://arxiv.org/abs/2205.14135
• Flashattention-2 бумага (Arxiv)
  • Последующая статья, описывающая Flashattention-2, в которой подробно описывается дополнительная оптимизация для параллелизма и рабочих разделений, чтобы достичь еще большего ускорения на современных графических процессорах.
  • https://arxiv.org/abs/2307.08691
• Резейрий GitHub
  • Официальный репозиторий GitHub, содержащий исходный код для ядер Flashattention и Flashattention-2 Cuda.
  • https://github.com/dao-ailab/flash-atration

Квантовая вычислительная моделирование

• Официальная страница NVIDIA Cuquantum
  • Официальная страница продукта NVIDIA для Cuquantum SDK, излагая свои функции для ускоряющегося квантовых вычислительных моделей на графических процессорах.
  • https://developer.nvidia.com/cuquantum
• NVIDIA CUQUANTUM Документация
  • Подробная техническая документация для Cuquantum SDK, предоставляющая обзор высокого уровня и ссылки на API для библиотек.
  • https://docs.nvidia.com/cuda/cuquantum/index.html

Специализированное оборудование (Neuromorphic & Asics)

• Обзор нейроморфных вычислений Intel
  • Официальный обзор Intel их исследований нейроморфных вычислений, в которых обсуждаются цели программы и чипы исследований Loihi.
  • https://www.intel.com/content/www/us/en/research/neuromorphic-computing.html
• Проект Circt (Circuit IR Compilers and Tools)
  • Официальная домашняя страница для проекта Circt, инкубатора LLVM/MLIR, стремящегося применить технологию компилятора к дизайну аппаратного обеспечения, включая синтез высокого уровня (HLS) для FPGA и ASICS.
  • https://circt.llvm.org/
• Репозиторий Circt GitHub
  • Официальный репозиторий GitHub для проекта Circt, содержащий исходный код, диалекты и инструменты для проектирования аппаратного компилятора.
  • https://github.com/llvm/circt