support allocator api

[SchrodingerZhu]

export FFIs to enable snmalloc being used as a separate allocator
https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html

[mjp41]

So I am wondering if we should add a test to give basic coverage of this API in the snmalloc repo, so we detect breaks before it reaches snmalloc-rs?

[SchrodingerZhu]

it there a way to trigger the build again?

[mjp41]

So on

https://github.com/microsoft/snmalloc/runs/4311202740?check_suite_focus=true

I have a Re-runall checks:

**

I'll hit it for you. Do you need some help with the Windows tests?

[SchrodingerZhu]

Ha, I guess sth interesting is happening on Win. I will have a look later when I can clear some space for MSVC on my PC ;).

[mjp41]

Running your test gives:

        _STL_ASSERT(_Left == _Right, "containers incompatible for swap");

failing on

  std::swap(cloned, moved);

in void test_allocator_vector()

[mjp41]

Could you add some comments to this test explaining what it is testing?

[davidchisnall]

Please can you add a comment explaining (and, ideally, linking to) the Rust APIs that this is intended to expose?

[davidchisnall]

Suggested change

	return ptr;
	{
	return ptr;
	}

As a general style point we should have braces around all if statement bodies because it reduces bugs introduced when someone edits the code later, but this case is a particularly good example of needing them for readability because the wrapped line in the condition is at the same indent level as the body of the conditiona.

[davidchisnall]

Those methods are exposed in the PAL, they could be called here.

[SchrodingerZhu]

Sure! I am still sorting out the design.

[SchrodingerZhu]

@mjp41 @davidchisnall I begin to wonder whether we should only expose sth like sn_rust_grow, sn_rust_shrink.

I wanted to support sth like:

 fn allocator_supports_vector() {
        let allocator = SnAllocator::new();
        let mut vec = std::vec::Vec::new_in(&allocator);
        let mut sum: usize = 0;
        for i in 1..512usize {
            vec.push(i);
            sum += i * i;
        }

        let res = vec.into_iter().flat_map(|x| {
            let mut v = std::vec::Vec::new_in(&allocator);
            for _ in 0..x {
                v.push(x);
            }
            v
        }).sum();

        assert_eq!(sum, res);
    }

But I begin to wonder whether it is a bad decision to let user use a Alloc* instead of make Alloc thread_local.