webgpu

package
v0.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 1, 2025 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Rendered for windows/amd64

Overview

Package webgpu implements the WebGPU backend for GPU-accelerated tensor operations. Uses go-webgpu (github.com/go-webgpu/webgpu) for zero-CGO WebGPU bindings.

Package webgpu provides embedded WGSL compute shaders for tensor operations.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsAvailable 

func IsAvailable() (available bool)

IsAvailable checks if WebGPU is available on this system.

func ListAdapters 

func ListAdapters() (adapters []*wgpu.AdapterInfoGo, err error)

ListAdapters returns information about all available GPU adapters.

Types

type Backend 

type Backend struct {
	// contains filtered or unexported fields
}

Backend implements tensor operations on GPU using WebGPU.

func New 

func New() (backend *Backend, err error)

New creates a new WebGPU backend. Returns an error if WebGPU is not available or initialization fails.

func (*Backend) AdapterInfo 

func (b *Backend) AdapterInfo() *wgpu.AdapterInfoGo

AdapterInfo returns information about the GPU adapter.

func (*Backend) Add 

func (b *Backend) Add(a, other *tensor.RawTensor) *tensor.RawTensor

Add performs element-wise addition on GPU.

func (*Backend) AddScalar added in v0.3.0 

func (b *Backend) AddScalar(_ *tensor.RawTensor, _ any) *tensor.RawTensor

AddScalar adds a scalar to tensor elements (not yet implemented).

func (*Backend) And added in v0.3.0 

func (b *Backend) And(_, _ *tensor.RawTensor) *tensor.RawTensor

And performs element-wise logical AND (not yet implemented).

func (*Backend) Argmax added in v0.3.0 

func (b *Backend) Argmax(_ *tensor.RawTensor, _ int) *tensor.RawTensor

Argmax returns indices of maximum values along dimension (not yet implemented).

func (*Backend) BatchMatMul added in v0.4.0 

func (b *Backend) BatchMatMul(_, _ *tensor.RawTensor) *tensor.RawTensor

BatchMatMul performs batched matrix multiplication on GPU. TODO: Implement WGSL compute shader for batched matmul.

func (*Backend) Cast added in v0.3.0 

func (b *Backend) Cast(_ *tensor.RawTensor, _ tensor.DataType) *tensor.RawTensor

Cast converts tensor to different data type (not yet implemented).

func (*Backend) Cat added in v0.3.0 

func (b *Backend) Cat(_ []*tensor.RawTensor, _ int) *tensor.RawTensor

Cat concatenates tensors (stub - not implemented for WebGPU yet).

func (*Backend) Chunk added in v0.3.0 

func (b *Backend) Chunk(_ *tensor.RawTensor, _, _ int) []*tensor.RawTensor

Chunk splits tensor (stub - not implemented for WebGPU yet).

func (*Backend) Conv2D 

func (b *Backend) Conv2D(_, _ *tensor.RawTensor, _, _ int) *tensor.RawTensor

Conv2D performs 2D convolution on GPU. TODO: Implement WGSL compute shader for convolution.

func (*Backend) Cos added in v0.3.0 

func (b *Backend) Cos(_ *tensor.RawTensor) *tensor.RawTensor

Cos computes element-wise cosine (stub - not implemented for WebGPU yet).

func (*Backend) Device 

func (b *Backend) Device() tensor.Device

Device returns the compute device.

func (*Backend) Div 

func (b *Backend) Div(a, other *tensor.RawTensor) *tensor.RawTensor

Div performs element-wise division on GPU.

func (*Backend) DivScalar added in v0.3.0 

func (b *Backend) DivScalar(_ *tensor.RawTensor, _ any) *tensor.RawTensor

DivScalar divides tensor elements by a scalar (not yet implemented).

func (*Backend) Equal added in v0.3.0 

func (b *Backend) Equal(_, _ *tensor.RawTensor) *tensor.RawTensor

Equal performs element-wise equality comparison (not yet implemented).

func (*Backend) Exp added in v0.3.0 

func (b *Backend) Exp(_ *tensor.RawTensor) *tensor.RawTensor

Exp computes element-wise exponential (stub - not implemented for WebGPU yet).

func (*Backend) Expand added in v0.3.0 

func (b *Backend) Expand(_ *tensor.RawTensor, _ tensor.Shape) *tensor.RawTensor

Expand broadcasts tensor to new shape (not yet implemented).

func (*Backend) Gather added in v0.3.0 

func (b *Backend) Gather(_ *tensor.RawTensor, _ int, _ *tensor.RawTensor) *tensor.RawTensor

Gather selects elements along dim using index tensor (not implemented yet).

func (*Backend) Greater added in v0.3.0 

func (b *Backend) Greater(_, _ *tensor.RawTensor) *tensor.RawTensor

Greater performs element-wise greater-than comparison (not yet implemented).

func (*Backend) GreaterEqual added in v0.3.0 

func (b *Backend) GreaterEqual(_, _ *tensor.RawTensor) *tensor.RawTensor

GreaterEqual performs element-wise greater-or-equal comparison (not yet implemented).

func (*Backend) Log added in v0.3.0 

func (b *Backend) Log(_ *tensor.RawTensor) *tensor.RawTensor

Log computes natural logarithm element-wise (not yet implemented).

func (*Backend) Lower added in v0.3.0 

func (b *Backend) Lower(_, _ *tensor.RawTensor) *tensor.RawTensor

Lower performs element-wise less-than comparison (not yet implemented).

func (*Backend) LowerEqual added in v0.3.0 

func (b *Backend) LowerEqual(_, _ *tensor.RawTensor) *tensor.RawTensor

LowerEqual performs element-wise less-or-equal comparison (not yet implemented).

func (*Backend) MatMul 

func (b *Backend) MatMul(a, other *tensor.RawTensor) *tensor.RawTensor

MatMul performs matrix multiplication on GPU.

func (*Backend) MaxPool2D 

func (b *Backend) MaxPool2D(_ *tensor.RawTensor, _, _ int) *tensor.RawTensor

MaxPool2D performs 2D max pooling on GPU. TODO: Implement WGSL compute shader for max pooling.

func (*Backend) MeanDim added in v0.3.0 

func (b *Backend) MeanDim(_ *tensor.RawTensor, _ int, _ bool) *tensor.RawTensor

MeanDim computes mean along a dimension (stub - not implemented for WebGPU yet).

func (*Backend) MemoryStats 

func (b *Backend) MemoryStats() MemoryStats

MemoryStats returns current GPU memory usage statistics.

func (*Backend) Mul 

func (b *Backend) Mul(a, other *tensor.RawTensor) *tensor.RawTensor

Mul performs element-wise multiplication on GPU.

func (*Backend) MulScalar added in v0.3.0 

func (b *Backend) MulScalar(_ *tensor.RawTensor, _ any) *tensor.RawTensor

MulScalar multiplies tensor elements by a scalar (not yet implemented).

func (*Backend) Name 

func (b *Backend) Name() string

Name returns the backend name.

func (*Backend) Not added in v0.3.0 

func (b *Backend) Not(_ *tensor.RawTensor) *tensor.RawTensor

Not performs element-wise logical NOT (not yet implemented).

func (*Backend) NotEqual added in v0.3.0 

func (b *Backend) NotEqual(_, _ *tensor.RawTensor) *tensor.RawTensor

NotEqual performs element-wise inequality comparison (not yet implemented).

func (*Backend) Or added in v0.3.0 

func (b *Backend) Or(_, _ *tensor.RawTensor) *tensor.RawTensor

Or performs element-wise logical OR (not yet implemented).

func (*Backend) ReLU 

func (b *Backend) ReLU(x *tensor.RawTensor) *tensor.RawTensor

ReLU applies ReLU activation: max(0, x).

func (*Backend) Release 

func (b *Backend) Release()

Release releases all WebGPU resources. Must be called when the backend is no longer needed.

func (*Backend) Reshape 

func (b *Backend) Reshape(t *tensor.RawTensor, newShape tensor.Shape) *tensor.RawTensor

Reshape returns a tensor with new shape. This is typically a metadata-only operation (zero-copy).

func (*Backend) Rsqrt added in v0.3.0 

func (b *Backend) Rsqrt(_ *tensor.RawTensor) *tensor.RawTensor

Rsqrt computes element-wise reciprocal square root (stub - not implemented for WebGPU yet).

func (*Backend) Sigmoid 

func (b *Backend) Sigmoid(x *tensor.RawTensor) *tensor.RawTensor

Sigmoid applies sigmoid activation: 1 / (1 + exp(-x)).

func (*Backend) Sin added in v0.3.0 

func (b *Backend) Sin(_ *tensor.RawTensor) *tensor.RawTensor

Sin computes element-wise sine (stub - not implemented for WebGPU yet).

func (*Backend) Softmax 

func (b *Backend) Softmax(x *tensor.RawTensor, dim int) *tensor.RawTensor

Softmax applies softmax along the specified dimension. Currently supports 2D tensors with dim=-1 (last dimension).

func (*Backend) Sqrt added in v0.3.0 

func (b *Backend) Sqrt(_ *tensor.RawTensor) *tensor.RawTensor

Sqrt computes element-wise square root (stub - not implemented for WebGPU yet).

func (*Backend) Squeeze added in v0.3.0 

func (b *Backend) Squeeze(_ *tensor.RawTensor, _ int) *tensor.RawTensor

Squeeze removes dimension (stub - not implemented for WebGPU yet).

func (*Backend) Sub 

func (b *Backend) Sub(a, other *tensor.RawTensor) *tensor.RawTensor

Sub performs element-wise subtraction on GPU.

func (*Backend) SubScalar added in v0.3.0 

func (b *Backend) SubScalar(_ *tensor.RawTensor, _ any) *tensor.RawTensor

SubScalar subtracts a scalar from tensor elements (not yet implemented).

func (*Backend) Sum added in v0.3.0 

func (b *Backend) Sum(_ *tensor.RawTensor) *tensor.RawTensor

Sum computes the sum of all elements (not yet implemented).

func (*Backend) SumDim added in v0.3.0 

func (b *Backend) SumDim(_ *tensor.RawTensor, _ int, _ bool) *tensor.RawTensor

SumDim sums along a dimension (stub - not implemented for WebGPU yet).

func (*Backend) Tanh 

func (b *Backend) Tanh(x *tensor.RawTensor) *tensor.RawTensor

Tanh applies tanh activation.

func (*Backend) Transpose 

func (b *Backend) Transpose(t *tensor.RawTensor, axes ...int) *tensor.RawTensor

Transpose transposes the tensor by permuting its dimensions. Currently supports only 2D tensors (matrix transpose). For multi-dimensional transpose with custom axes, use the general case (TODO).

func (*Backend) Unsqueeze added in v0.3.0 

func (b *Backend) Unsqueeze(_ *tensor.RawTensor, _ int) *tensor.RawTensor

Unsqueeze adds dimension (stub - not implemented for WebGPU yet).

func (*Backend) Where added in v0.3.0 

func (b *Backend) Where(_, _, _ *tensor.RawTensor) *tensor.RawTensor

Where performs conditional element selection (not implemented yet).

type BufferPool 

type BufferPool struct {
	// contains filtered or unexported fields
}

BufferPool manages GPU buffer reuse to reduce allocation overhead. Buffers are categorized by size and usage flags.

func NewBufferPool 

func NewBufferPool(device *wgpu.Device) *BufferPool

NewBufferPool creates a new buffer pool for the given device.

func (*BufferPool) Acquire 

func (p *BufferPool) Acquire(size uint64, usage wgpu.BufferUsage) *wgpu.Buffer

Acquire gets a buffer from the pool or creates a new one. Returns a buffer that matches or exceeds the requested size and usage.

func (*BufferPool) Clear 

func (p *BufferPool) Clear()

Clear releases all pooled buffers. Should be called when the backend is released.

func (*BufferPool) Release 

func (p *BufferPool) Release(buffer *wgpu.Buffer, size uint64, usage wgpu.BufferUsage)

Release returns a buffer to the pool for reuse. If the pool is full, the buffer is immediately released.

func (*BufferPool) Stats 

func (p *BufferPool) Stats() (allocated, released, hits, misses uint64, pooledCount int)

Stats returns statistics about buffer pool usage.

type BufferSize 

type BufferSize int

BufferSize represents different buffer size categories for pooling. 

const (
	// SmallBuffer for tensors < 4KB.
	SmallBuffer BufferSize = iota
	// MediumBuffer for tensors 4KB-1MB.
	MediumBuffer
	// LargeBuffer for tensors > 1MB.
	LargeBuffer
)

type MemoryStats 

type MemoryStats struct {
	// Total bytes allocated since backend creation
	TotalAllocatedBytes uint64
	// Peak memory usage in bytes
	PeakMemoryBytes uint64
	// Number of currently active buffers
	ActiveBuffers int64
	// Buffer pool statistics
	PoolAllocated uint64
	PoolReleased  uint64
	PoolHits      uint64
	PoolMisses    uint64
	PooledBuffers int
}

MemoryStats represents GPU memory usage statistics.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.