README
T
FloatBuffer
T
IntBuffer
T
MlpBuffers
T
MlpTrainBuffers
V
alloc_floats
V
alloc_ints
V
copy_from_buffer
V
copy_to_buffer
V
free_floats
V
free_ints
V
get_float
V
get_int
V
layer1_fused
V
layer2_fused
V
mlp_buffers_create
V
mlp_buffers_free
V
mlp_buffers_get_output
V
mlp_buffers_init
V
mlp_forward_fused
V
mlp_train_buffers_create
V
mlp_train_buffers_free
V
mlp_train_buffers_get_weights
V
mlp_train_buffers_init_weights
V
mlp_train_step
V
saxpy
V
sdot
V
set_float
V
set_int
V
sgemm
V
sgemm_direct
V
sgemm_direct_batch
V
sgemv
V
sgemv_trans
V
snrm2

blas

BLAS bindings for MoonBit (Accelerate/OpenBLAS)

blas

linear-algebra

matrix

native

Download zip

Author

mizchi

Version

0.1.3

License

MIT

Repository

github.com/mizchi/blas

Last updated

2 months ago

Downloads

#mizchi/blas

BLAS (Basic Linear Algebra Subprograms) bindings for MoonBit.

macOS: Apple Accelerate.framework
Linux: OpenBLAS

#Installation

moon add mizchi/blas

#Usage

// Matrix multiplication: C = A @ B
let a = [1.0, 2.0, 3.0, 4.0]  // 2x2 matrix
let b = [5.0, 6.0, 7.0, 8.0]  // 2x2 matrix
let c = [0.0, 0.0, 0.0, 0.0]  // result
@blas.sgemm(a, b, c, 2, 2, 2)
// c = [19.0, 22.0, 43.0, 50.0]

For repeated multiplication with persistent C-side buffers, one FFI call can execute multiple SGEMMs:

let a_buf = @blas.alloc_floats(m * k)
let b_buf = @blas.alloc_floats(k * n)
let c_buf = @blas.alloc_floats(m * n)
@blas.copy_to_buffer(a_buf, a)
@blas.copy_to_buffer(b_buf, b)
@blas.sgemm_direct_batch(a_buf, b_buf, c_buf, m, n, k, iterations=16)

#High-performance MLP forward pass

// Create C-side buffers (zero-copy after initialization)
let bufs = @blas.mlp_buffers_create(batch_size, input_dim, hidden_dim, output_dim)
@blas.mlp_buffers_init(bufs, input, weight1, bias1, weight2, bias2)

// Forward pass (all computation in C memory)
@blas.mlp_forward_fused(bufs)

// Get output
let output = Array::make(batch_size * output_dim, 0.0)
@blas.mlp_buffers_get_output(bufs, output)

// Cleanup
@blas.mlp_buffers_free(bufs)

#Batch training (forward + backward + update)

let bufs = @blas.mlp_train_buffers_create(batch_size, input_dim, hidden_dim, output_dim)
@blas.mlp_train_buffers_init_weights(bufs, weight1, bias1, weight2, bias2)

// Single call does forward, backward, and parameter update
let (loss_sum, correct_count) = @blas.mlp_train_step(bufs, batch_input, batch_labels, learning_rate)

@blas.mlp_train_buffers_free(bufs)

#Quick Commands

just           # check + test
just bench     # run benchmark
just bench-square  # compare Array, direct, and batch16 square SGEMM
just docker-build  # build Linux container
just docker-test   # test on Linux
just docker-bench  # benchmark on Linux

#Platform Support

Important: You must add the appropriate link flags to your package's moon.pkg:

#macOS

options(
  link: { "native": { "cc-link-flags": "-framework Accelerate" } },
)

Uses Apple Accelerate.framework (no additional setup required).

#Linux

options(
  link: { "native": { "cc-link-flags": "-lopenblas -llapack -lm" } },
)

Requires OpenBLAS and LAPACK:

# Ubuntu/Debian
sudo apt-get install libopenblas-dev liblapack-dev

# Or use Docker
just docker-build
just docker-test

#Header Resolution

The C stub uses preprocessor directives for cross-platform support:

#ifdef __APPLE__
  #include <Accelerate/Accelerate.h>  // macOS system framework
#else
  #include <cblas.h>                   // OpenBLAS
#endif

Platform	Header	Library	Notes
macOS	<Accelerate/Accelerate.h>	-framework Accelerate	System default
Linux	<cblas.h>	-lopenblas -lm	Requires libopenblas-dev

Both provide the standard CBLAS API (cblas_sgemm, cblas_sgemv, etc.).

#Benchmark

MNIST 2-layer MLP (784→128→10), batch size 128:

Backend	Time/epoch	vs Pure MoonBit
Pure MoonBit CPU	130s	1x
BLAS batch	0.7s	186x

#API

#Low-level BLAS operations

sgemm(a, b, c, m, n, k) - Matrix multiply: C = A @ B
sgemm_direct_batch(a, b, c, m, n, k, iterations) - Repeated SGEMM in one FFI call
sgemv(a, x, y, m, n) - Matrix-vector multiply: y = A @ x
saxpy(alpha, x, y) - Vector add: y = alpha * x + y
sdot(x, y) - Dot product
snrm2(x) - L2 norm

#High-level MLP operations

mlp_buffers_create/init/free - C-side buffer management
mlp_forward_fused - Fused forward pass (layer1+layer2)
mlp_train_buffers_create/init_weights/get_weights/free - Training buffer management
mlp_train_step - Complete training step (forward + backward + update)

#License

MIT

FloatBuffer

source

pub struct FloatBuffer(Int64)

Opaque handle to C-side float buffer

IntBuffer

source

pub struct IntBuffer(Int64)

Opaque handle to C-side int buffer (for labels)

MlpBuffers

source

pub struct MlpBuffers {
  input : FloatBuffer
  weight1 : FloatBuffer
  bias1 : FloatBuffer
  hidden : FloatBuffer
  weight2 : FloatBuffer
  bias2 : FloatBuffer
  output : FloatBuffer
  batch : Int
  input_dim : Int
  hidden_dim : Int
  output_dim : Int
}

MlpTrainBuffers

source

pub struct MlpTrainBuffers {
  weight1 : FloatBuffer
  bias1 : FloatBuffer
  weight2 : FloatBuffer
  bias2 : FloatBuffer
  input : FloatBuffer
  hidden : FloatBuffer
  output : FloatBuffer
  probs : FloatBuffer
  grad_w1 : FloatBuffer
  grad_b1 : FloatBuffer
  grad_w2 : FloatBuffer
  grad_b2 : FloatBuffer
  delta2 : FloatBuffer
  delta1 : FloatBuffer
  labels : IntBuffer
  result : FloatBuffer
  batch : Int
  input_dim : Int
  hidden_dim : Int
  output_dim : Int
}

Training buffers for batch BLAS training

alloc_floats

source

fn alloc_floats(count : Int) -> FloatBuffer

Allocate a C-side float buffer

alloc_ints

source

fn alloc_ints(count : Int) -> IntBuffer

Allocate a C-side int buffer

copy_from_buffer

source

fn copy_from_buffer(arr : Array[Float], buf : FloatBuffer) -> Unit

Copy from C buffer to MoonBit Array[Float]

copy_to_buffer

source

fn copy_to_buffer(buf : FloatBuffer, arr : Array[Float]) -> Unit

Copy from MoonBit Array[Float] to C buffer

free_floats

source

fn free_floats(buf : FloatBuffer) -> Unit

Free a C-side float buffer

free_ints

source

fn free_ints(buf : IntBuffer) -> Unit

Free a C-side int buffer

get_float

source

fn get_float(buf : FloatBuffer, idx : Int) -> Float

Get float at index from C buffer

get_int

source

fn get_int(buf : IntBuffer, idx : Int) -> Int

Get int at index from C buffer

layer1_fused

source

fn layer1_fused(input : FloatBuffer, weight : FloatBuffer, bias : FloatBuffer, output : FloatBuffer, batch : Int, in_dim : Int, out_dim : Int) -> Unit

Fused layer1: output = ReLU(input @ weight + bias) input: batch x in_dim, weight: in_dim x out_dim, bias: out_dim, output: batch x out_dim

layer2_fused

source

fn layer2_fused(input : FloatBuffer, weight : FloatBuffer, bias : FloatBuffer, output : FloatBuffer, batch : Int, in_dim : Int, out_dim : Int) -> Unit

Fused layer2: output = input @ weight + bias (no activation) input: batch x in_dim, weight: in_dim x out_dim, bias: out_dim, output: batch x out_dim

mlp_buffers_create

source

fn mlp_buffers_create(batch : Int, input_dim : Int, hidden_dim : Int, output_dim : Int) -> MlpBuffers

Create MLP buffers in C memory for zero-copy forward

mlp_buffers_free

source

fn mlp_buffers_free(bufs : MlpBuffers) -> Unit

Free MLP buffers

mlp_buffers_get_output

source

fn mlp_buffers_get_output(bufs : MlpBuffers, out : Array[Float]) -> Unit

Copy output from C buffers back to MoonBit array

mlp_buffers_init

source

fn mlp_buffers_init(bufs : MlpBuffers, input_data : Array[Float], weight1_data : Array[Float], bias1_data : Array[Float], weight2_data : Array[Float], bias2_data : Array[Float]) -> Unit

Initialize MLP buffers with data (called once before benchmarking)

mlp_forward_fused

source

fn mlp_forward_fused(bufs : MlpBuffers) -> Unit

Run MLP forward pass using C-side buffers (no data copy)

mlp_train_buffers_create

source

fn mlp_train_buffers_create(batch : Int, input_dim : Int, hidden_dim : Int, output_dim : Int) -> MlpTrainBuffers

Create training buffers

mlp_train_buffers_free

source

fn mlp_train_buffers_free(bufs : MlpTrainBuffers) -> Unit

Free training buffers

mlp_train_buffers_get_weights

source

fn mlp_train_buffers_get_weights(bufs : MlpTrainBuffers, weight1 : Array[Float], bias1 : Array[Float], weight2 : Array[Float], bias2 : Array[Float]) -> Unit

Copy weights from training buffers back to arrays

mlp_train_buffers_init_weights

source

fn mlp_train_buffers_init_weights(bufs : MlpTrainBuffers, weight1 : Array[Float], bias1 : Array[Float], weight2 : Array[Float], bias2 : Array[Float]) -> Unit

Initialize weights in training buffers

mlp_train_step

source

fn mlp_train_step(bufs : MlpTrainBuffers, input : Array[Float], labels : Array[Int], lr : Float) -> (Float, Int)

Run a complete training step: forward + backward + update Returns (loss_sum, correct_count)

saxpy

source

fn saxpy(alpha : Float, x : Array[Float], y : Array[Float]) -> Unit

Vector add: y = alpha * x + y

sdot

source

fn sdot(x : Array[Float], y : Array[Float]) -> Float

Dot product: x . y

set_float

source

fn set_float(buf : FloatBuffer, idx : Int, val : Float) -> Unit

Set float at index in C buffer

set_int

source

fn set_int(buf : IntBuffer, idx : Int, val : Int) -> Unit

Set int at index in C buffer

sgemm

source

fn sgemm(a : Array[Float], b : Array[Float], c : Array[Float], m : Int, n : Int, k : Int) -> Unit

Matrix multiply: C = A @ B A: m x k, B: k x n, C: m x n (row-major)

sgemm_direct

source

fn sgemm_direct(a : FloatBuffer, b : FloatBuffer, c : FloatBuffer, m : Int, n : Int, k : Int) -> Unit

Matrix multiply on C buffers: C = A @ B A: m x k, B: k x n, C: m x n (row-major)

sgemm_direct_batch

source

fn sgemm_direct_batch(a : FloatBuffer, b : FloatBuffer, c : FloatBuffer, m : Int, n : Int, k : Int, iterations~ : Int) -> Unit

Repeats C = A @ B in one native call while reusing all C-side buffers.

sgemv

source

fn sgemv(a : Array[Float], x : Array[Float], y : Array[Float], m : Int, n : Int) -> Unit

Matrix-vector multiply: y = A @ x A: m x n, x: n, y: m (row-major)

sgemv_trans

source

fn sgemv_trans(a : Array[Float], x : Array[Float], y : Array[Float], m : Int, n : Int) -> Unit

Matrix-vector multiply (transposed): y = A^T @ x A: m x n, x: m, y: n (row-major)

snrm2

source

fn snrm2(x : Array[Float]) -> Float

L2 norm: ||x||_2

Source Files

blas.mbt

Site source Report issue Packages Build queue Skills Statistics

blas

#mizchi/blas

#Installation

#Usage

#High-performance MLP forward pass

#Batch training (forward + backward + update)

#Quick Commands

#Platform Support

#macOS

#Linux

#Header Resolution

#Benchmark

#API

#Low-level BLAS operations

#High-level MLP operations

#License

#FloatBuffer

#IntBuffer

#MlpBuffers

#MlpTrainBuffers

#alloc_floats

#alloc_ints

#copy_from_buffer

#copy_to_buffer

#free_floats

#free_ints

#get_float

#get_int

#layer1_fused

#layer2_fused

#mlp_buffers_create

#mlp_buffers_free

#mlp_buffers_get_output

#mlp_buffers_init

#mlp_forward_fused

#mlp_train_buffers_create

#mlp_train_buffers_free

#mlp_train_buffers_get_weights

#mlp_train_buffers_init_weights

#mlp_train_step

#saxpy

#sdot

#set_float

#set_int

#sgemm

#sgemm_direct

#sgemm_direct_batch

#sgemv

#sgemv_trans

#snrm2

Source Files

FloatBuffer

IntBuffer

MlpBuffers

MlpTrainBuffers

alloc_floats

alloc_ints

copy_from_buffer

copy_to_buffer

free_floats

free_ints

get_float

get_int

layer1_fused

layer2_fused

mlp_buffers_create

mlp_buffers_free

mlp_buffers_get_output

mlp_buffers_init

mlp_forward_fused

mlp_train_buffers_create

mlp_train_buffers_free

mlp_train_buffers_get_weights

mlp_train_buffers_init_weights

mlp_train_step

saxpy

sdot

set_float

set_int

sgemm

sgemm_direct

sgemm_direct_batch

sgemv

sgemv_trans

snrm2