refpool 0.3.1

Efficient memory pool with reference counting
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

# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project
adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

## [0.3.1] - 2020-04-23

### ADDED

-   There is now a `PoolBox` which works like `Box` but uses the pool to allocate.

## [0.3.0] - 2020-03-10

### REMOVED

-   The `PoolSync` mode has been removed entirely, along with the option to choose which mode to
    use, as `PoolUnsync` is now the only one remaining. `PoolSync` pools were too slow to be
    worthwhile, and I didn't trust the correctness of the threadsafe `PoolRef` implementation.

## [0.2.3] - 2020-01-07

### ADDED

-   `Pool` now implements `Debug`.

### FIXED

-   `Option<Pool>` and `Pool` are now once again the same size. Zero sized pools still don't cause
    any allocations.

## [0.2.2] - 2019-12-16

### ADDED

-   You can now `Pool::cast()` a pool handle into a pool handle for a different type, allowing you
    to construct values of multiple types from the same pool, provided they are of the exact same
    size and alignment.
-   `Pool`s of size 0 are now represented by null pointers, meaning they allocate nothing. It also
    means `Option<Pool>` is no longer identical in size to `Pool`, but `PoolRef` still retains that
    property. A `Pool` of size 0 is also conceptually identical to the `None` value of an
    `Option<Pool>`, except you can use it to construct values without having to unwrap it first, so
    there's no good reason you should ever need `Option<Pool>`.

## [0.2.1] - 2019-12-12

### FIXED

-   `Pool` and `PoolRef` now use `NonNull` instead of raw pointers, so that they can be wrapped in
    `Option` without growing in size.
-   Fixed a race condition where the last `PoolRef` referencing a pool might try to drop it before
    returning its allocation to it, causing a memory fault.

## [0.2.0] - 2019-11-29

### CHANGED

-   The pool is now reference counted, which means your `PoolRef`s won't suddenly become dangerously
    invalid when the pool goes out of scope. This also means that you can now clone a `Pool` and get
    another reference to the same pool.

### ADDED

-   There are now both `Sync` and `!Sync` versions of the pool. The latter, in
    `refpool::unsync::Pool`, is as performant as previously, while the thread safe version in
    `refpool::sync::Pool` is roughly 5-10x slower, but still manages to be about 25% faster than the
    Windows system allocator. You should prefer not to use it on platforms with faster system
    allocators, such as Linux. To enable the thread safe version, use the `sync` feature flag.
-   A method `Pool::fill()` has been added, which preallocates memory chunks to the capacity of the
    pool.

## [0.1.0] - 2019-11-26

Initial release.