I have another big change that I plan to add soon that I hope will reduce the allocations per subscription. If it works out, this could result in 1 allocation per subscription. It may have the side effect of improved debugability as well.

The idea is to have each observable expose a type that is composed of a unique type that contains a std::aligned_storage big enough for its own state combined with the state of the next observable in the expression. In debug mode the unique type would also contain a pointer of the actual state type that would be assigned the addressof the aligned_storage. This would allow a pointer to the combined_state to be used in the debugger to inspect the current state of the entire subscription.

The type might look like:

template<class... StateN>
struct combined_state : public std::enable_shared_from_this< combined_state >, public StateN...
{
};
template<class T, class... StateN>
std::shared_ptr<T> get_state<T>(std::shared_ptr<combined_state<StateN...>> combinedstate);

If subscribe is not passed a combined_state it would allocate the combined_state from its own observable and pass it through to on_subscribe. If a combined_state is passed into subscribe, then that would be passed directly to on_subscribe. on_subscribe would use get_state to extract the pointer to its unconstructed state, use placement new to construct its state in the pointer and pass the combined_state on to the next subscribe.

Design to minimize or eliminate virtual functions and heap allocations #2

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions