Process/scheduler fails to compile when using std::pmr::polymorphic_allocator

[coldcola233]

EnTT version: 3.16.0

#include <entt/entt.hpp>
#include <memory_resource>

template<class Delta, class Allocator>
struct MyProcess : entt::basic_process<Delta, Allocator> {
    using process_type = entt::basic_process<Delta, Allocator>;
    using allocator_type = typename process_type::allocator_type;
    using delta_type   = typename process_type::delta_type;

    MyProcess(const allocator_type &alloc, delta_type delay)
        : process_type{alloc}, remaining{delay} {}

    void update(delta_type d, void*) override {
        remaining -= d;
        if (remaining <= delta_type{0}) this->succeed();
    }
private:
    delta_type remaining;
};

using Sched = entt::basic_scheduler<float, std::pmr::polymorphic_allocator<void>>;
using Proc  = MyProcess<float, std::pmr::polymorphic_allocator<void>>;

int main() {
    std::pmr::unsynchronized_pool_resource pool;
    std::pmr::polymorphic_allocator<void> alloc{&pool};
    Sched sched{alloc};
    sched.attach<Proc>(1.0f);   // <-- error here
}

The method attach is implemented as:

    template<typename Type, typename... Args>
    type &attach(Args &&...args) {
        const auto &allocator = handlers.second();
        return *handlers.first().emplace_back(std::allocate_shared<Type>(allocator, allocator, std::forward<Args>(args)...));
    }

MyProcess satisfies std::uses_allocator_v, so std::allocate_shared will attempt to propagate std::pmr::polymorphic_allocator<void>.
But it failed.

[skypjack]

Hello, sorry for the late reply.

But it failed.

Can you elaborate on this, perhaps explaining the error you're getting or something similar?
Also, does it work with previous versions of EnTT? Not sure about it from your description.

[coldcola233]

Sorry. I'm no good at Englist and did not carefully check my description. So my description looks strange.
It probably won't be compatible with the old version; the update mentions that process has been redesigned.

Look at "entt/process/process.hpp" in line 224.

return *(next.first() = std::allocate_shared<Type>(allocator, allocator, std::forward<Args>(args)...));

The std::allocate_shared try to spread allocator, but it failed.
For example:

std::allocate_shared<Type>(allocator1, allocator2, std::forward<Args>(args)...))

If the Type meet std::uses_allocator_v<Type, AllocType> == true, so use std::pmr::polymorphic_allocator will cause Type construct with arguments (allocator1, allocator2, args...).

Pass parameter allocator1 will be automatically handled by std::allocator_shared.
The allocator parameter was passed repeatedly, and caused compile error.

The std::allocate_shared doesn't seem to try to spread std::allocator. So when using std::allocator, it work normally.

[skypjack]

I have no idea why this happens, nor how much of it has to do with EnTT, but I'll look into it. Thanks for bringing it up. 👍
For now I'm leaving it in triage, because I really don't know if there's anything I can do about it or what else.