lucifer1004 opened a new pull request, #273:
URL: https://github.com/apache/tvm-ffi/pull/273
# Add Julia Language Bindings for TVM FFI
## Summary
This PR adds production-ready Julia bindings for TVM FFI, providing a safe,
efficient, and idiomatic Julia interface for TVM's Foreign Function Interface.
## Features
### Core Functionality
- ✅ **Module Loading** - Load compiled TVM modules (`.so` files)
- ✅ **Function Calling** - Call TVM functions with type safety
- ✅ **Zero-Copy Tensors** - Efficient array passing via DLPack
- ✅ **CPU Execution** - Full CPU backend support
- ✅ **GPU Support** - Multi-backend GPU support (CUDA, ROCm, Metal, oneAPI)
- ✅ **Automatic Memory Management** - GC-based, no manual reference counting
- ✅ **Error Handling** - Julia exceptions with detailed backtraces
### Advanced Features
- ✅ **Zero-Copy Slices** - Support for array views (`@view`) like Rust
bindings
- ✅ **Automatic Array Conversion** - Pass arrays directly to functions
- ✅ **Multi-GPU Backend** - Hardware-agnostic GPU support via GPUArrays.jl
- ✅ **Performance Optimization** - Manual holder creation for hot loops
## Quick Example
```julia
using TVMFFI
# Load module and get function
mod = load_module("build/add_one_cpu.so")
add_one = mod["add_one_cpu"]
# Call with Julia arrays (auto-conversion!)
x = Float32[1, 2, 3, 4, 5]
y = zeros(Float32, 5)
add_one(x, y)
println(y) # [2.0, 3.0, 4.0, 5.0, 6.0]
```
## GPU Support
Works seamlessly with multiple GPU backends:
```julia
using CUDA # or AMDGPU, Metal, oneAPI
# GPU arrays work with same API
x_gpu = CUDA.CuArray(Float32[1, 2, 3, 4, 5])
y_gpu = CUDA.zeros(Float32, 5)
add_one_cuda(x_gpu, y_gpu) # Auto-detects CUDA!
```
## Design Principles
The Julia bindings follow these core principles:
1. **Simplicity** - Direct C API calls via `ccall`, no intermediate layers
2. **Safety** - Automatic memory management via Julia's GC
3. **Zero-Copy** - Efficient interop with Julia arrays and slices
4. **Idiomatic** - Multiple dispatch, standard Julia interfaces
5. **Unified API** - Same API for CPU and GPU, arrays and slices
## Implementation Highlights
### Memory Safety
- Unified reference counting with explicit ownership control (`own`
parameter)
- GC-safe automatic array conversion with `GC.@preserve`
- Self-contained `DLTensorHolder` prevents memory safety issues
- Comprehensive test coverage including GC stress tests
### Zero-Copy Operations
- Support for Julia `SubArray` (slices/views)
- Automatic stride calculation using `Base.strides()`
- Works for both CPU and GPU arrays
### Clean API Design
- High-level `TVMModule` API similar to Rust/Python
- Automatic device detection for GPU arrays
- One holder type for CPU and GPU (no redundant types)
- Automatic array conversion with optimization path
## Testing
Covering:
- Device creation and data types
- String/Bytes handling
- Error propagation
- Type conversions
- DLTensorHolder (CPU arrays and slices)
- Automatic array conversion
- Reference counting
- Module API
All tests pass. Additional integration tests in `examples/`:
- `load_add_one.jl` - CPU execution with slices
- `load_add_one_cuda.jl` - GPU execution with slices
- `test_gc_safety.jl` - GC safety verification
## Documentation
- **Complete Guide**: `docs/guides/julia_guide.md` - Installation, usage,
advanced topics
- **Examples**: 4 working examples in `julia/TVMFFI/examples/`
- **API Documentation**: Comprehensive docstrings for all public APIs
- **README**: Quick start guide in `julia/README.md`
## Code Quality
- ✅ All pre-commit hooks pass
- ✅ ASF headers on all files
- ✅ Markdown formatting compliant
- ✅ No linter errors
- ✅ Follows Julia best practices (no Manifest.toml checked in)
## Comparison with Other Languages
| Feature | C++ | Python | Rust | Julia |
|---------|-----|--------|------|-------|
| Zero-copy arrays | ✅ | ✅ | ✅ | ✅ |
| Slice support | 🟡 | ✅ | ✅ | ✅ |
| Auto-conversion | 🟡 | ✅ | 🟡 | ✅ |
| GPU support | ✅ | ✅ | ✅ | ✅ |
| Multi-GPU backend | 🟡 | 🟡 | 🟡 | ✅ |
| Memory safety | Manual | GC | Ownership | GC |
| API simplicity | 🟡 | ✅ | 🟡 | ✅ |
Julia bindings achieve feature parity with Rust while providing the most
convenient API.
## File Structure
```
julia/
├── TVMFFI/
│ ├── Project.toml # Package metadata
│ ├── src/
│ │ ├── TVMFFI.jl # Main module
│ │ ├── LibTVMFFI.jl # C API bindings
│ │ ├── module.jl # High-level Module API
│ │ ├── function.jl # Function calling
│ │ ├── tensor.jl # DLTensorHolder
│ │ ├── error.jl # Error handling
│ │ └── ... # Other modules
│ ├── test/
│ │ └── runtests.jl # Test suite
│ └── examples/
│ ├── load_add_one.jl # CPU example
│ ├── load_add_one_cuda.jl # GPU example
│ └── test_gc_safety.jl # GC safety tests
└── README.md # Quick start guide
```
## Dependencies
- Julia 1.10 or later
- CUDA.jl, AMDGPU.jl, Metal.jl, or oneAPI.jl (optional, for GPU support)
## Breaking Changes
None - this is a new language binding.
## Related
- Follows patterns established by Rust bindings
- Similar API to Python bindings
- Full DLPack compatibility
## Checklist
- ✅ Implementation complete and tested
- ✅ Documentation (guide + docstrings + examples)
- ✅ Unit tests
- ✅ Integration tests (working examples)
- ✅ Pre-commit hooks pass
- ✅ Follows Julia best practices
- ✅ Zero extra dependencies (only stdlib)
- ✅ Memory safety verified
- ✅ Feature parity with other languages
## Reviewers
@mention-reviewers-here
---
**This PR adds a complete, production-ready Julia interface to TVM FFI with
excellent memory safety, clean API design, and comprehensive testing.**
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
