refpool 0.2.3

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

# 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.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.