fastalloc 1.5.0

High-performance memory pooling library with type-safe handles, predictable latency, and zero fragmentation. Perfect for game engines, real-time systems, and high-churn workloads.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

# Contributing to FastAlloc

Thank you for considering contributing to FastAlloc! We appreciate your time and effort in making this project better.

## Table of Contents

- [Code of Conduct](#code-of-conduct)
- [Getting Started](#getting-started)
- [Development Workflow](#development-workflow)
- [Coding Standards](#coding-standards)
- [Testing](#testing)
- [Pull Request Process](#pull-request-process)
- [Reporting Bugs](#reporting-bugs)
- [Feature Requests](#feature-requests)
- [Documentation](#documentation)
- [Community](#community)

## Code of Conduct

This project and everyone participating in it is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.

## Getting Started

1. Fork the repository on GitHub
2. Clone your fork locally
   ```bash
   git clone https://github.com/your-username/fastalloc.git
   cd fastalloc
   ```
3. Install Rust using [rustup](https://rustup.rs/)
4. Install development tools:
   ```bash
   rustup component add rustfmt clippy
   ```

## Development Workflow

1. Create a new branch for your changes:
   ```bash
   git checkout -b feature/your-feature-name
   ```
2. Make your changes following the coding standards
3. Run tests and verify everything works
4. Commit your changes with a descriptive message
5. Push to your fork and open a pull request

## Coding Standards

- Follow the [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
- Use `rustfmt` for consistent code formatting
- Run `cargo clippy` to catch common mistakes and improve code quality
- Document all public APIs with rustdoc comments
- Write unit tests for new functionality
- Keep commits focused and atomic

## Testing

Run the test suite:

```bash
# Run all tests
cargo test --all-features

# Run tests for no_std
cargo test --no-default-features

# Run benchmarks
cargo bench

# Run MIRI to detect undefined behavior
cargo +nightly miri test

# Run fuzzing (if available)
cargo +nightly fuzz run <target>
```

## Pull Request Process

1. Ensure all tests pass
2. Update documentation as needed
3. Add tests for new features or bug fixes
4. Ensure your code is properly formatted
5. Open a pull request with a clear description of changes
6. Reference any related issues
7. Wait for code review and address any feedback

## Reporting Bugs

Please open an issue on GitHub with the following information:

- Description of the bug
- Steps to reproduce
- Expected behavior
- Actual behavior
- Environment details (Rust version, OS, etc.)
- Any relevant logs or error messages

## Feature Requests

We welcome feature requests! Please open an issue describing:

- The feature you'd like to see
- Why this feature is valuable
- Any potential implementation ideas

## Documentation

Good documentation is crucial. When contributing:

- Document all public APIs
- Include code examples
- Update the README for user-facing changes
- Add or update examples in the `examples/` directory

## Community

- Join our [Discord server](https://discord.gg/your-invite-link)
- Follow us on [Twitter](https://twitter.com/your-handle)
- Read our [blog](https://your-blog-url.com)

## License

By contributing to FastAlloc, you agree that your contributions will be licensed under its [MIT/Apache-2.0 dual license](LICENSE-APACHE).