Function test_free_mem

src/core/test/mem_alloc.cpp:528–569

using Callback = std::function<void()>;
void test_free_mem(
        CompNode::Locator loc0, CompNode::Locator loc1, DevicePolicy* policy,
        const Callback& before_run, const Callback& after_run) {
    size_t tot, free;
    policy->set_device(0);
    policy->get_mem_info(free, tot);

    // exception
    auto do_run = [loc0, loc1, policy, free]() {
        void* tmp;
        policy->raw_dev_malloc(&tmp, free / 3);
        auto dev_free = [&](void* ptr) { policy->raw_dev_free(ptr); };
        auto cn0 = CompNode::load(loc0), cn1 = CompNode::load(loc1);
        std::unique_ptr<void, decltype(dev_free)> tmp_owner{tmp, dev_free};
        auto check_free = [&](const char* msg, size_t expect) {
            auto get = cn0.get_mem_status_bytes().second;
            ASSERT_LE(
                    std::abs(
                            static_cast<intptr_t>(get) - static_cast<intptr_t>(expect)),
                    static_cast<intptr_t>(free) / 4)
                    << ssprintf(
                               "%s: get=%.2fMiB expect=%.2fMiB", msg,
                               get / 1024.0 / 1024, expect / 1024.0 / 1024);
        };

        check_free("direct get", free * 2 / 3);
        DeviceTensorStorage tensor{cn0};
        tensor.ensure_size(free / 3).ptr();
        check_free("after dev alloc", free / 3);
        tmp_owner.reset();
        check_free("after outer release", free * 2 / 3);
        tensor = {cn0};
        check_free("after all release", free);

        DeviceTensorStorage tensor1{cn1};
        tensor.ensure_size(free / 6).ptr();
        tensor1.ensure_size(free / 6).ptr();
        check_free("multiple streams", free * 2 / 3);
    };

    before_run();
    MGB_TRY { do_run(); }
    MGB_FINALLY(after_run(););
}