Experimenting with subtensor_engine

[exclowd]

At the highest level, the interface is:

1. The engines that act as traits call to the various resources managed by the subtensor.
2. The subtensor(i.e., tensor_core<subtensor_engine> which manages the resources and provides a unified interface.

Sense of ownership: This engine type should reflect the view nature of the subtensor. But for some parameters below, it may seem as though as it redirects ownership and does not create a view object, the engine dictates the element access and layout types. This way, the interface would dictate that the ownership is passed to the view, which would not be a good design.

Template parameter:

1. Parameter name E represents engine type
2. Parameter name T represents a tensor type.
3. Parameter name EX represents an extents type.

I'll cover the following engines

engine_1

template<typename EX, typename L, typename C>
struct subtensor_engine_1
{
  using extents_type      = EX;
  using layout_type      = L;
  using container_type   = C;
  using spans_type  = ... ;
};

I had some observations:

1. Interface-wise, It does not seem right to implement this kind of engine as we might get away without creating one. We may shift the span type to the tensor itself.

template<typename E, typename L, typename C>
struct subtensor_engine_1
{
  using extents_type      = E;
  using layout_type      = L;
  using container_type   = C;
};

This is the tensor_engine.

engine_2

template <class E>
struct subtensor_engine
{
	using extents_type = typename E::extents_type; // type of the parent extents
	using layout_type = typename E::layout_type; // type of the parent layout
	using container_type = typename E::container_type; // type of the parent container
};

template <class E>
class tensor_core<subtensor_engine<E>> {
public:
        // types
	using engine_type = subtensor_engine<E>;
	using self_type   = tensor_core<engine_type>;
        
        using container_type = typename engine_type::container_type;
	using layout_type    = typename engine_type::layout_type;
	using extents_type   = typename engine_type::extents_type;
	using strides_type   = typename extents_type::base_type;

	using container_traits_type = container_traits<container_type>;

	using size_type       = typename container_traits_type::size_type;
	using difference_type = typename container_traits_type::difference_type;
	using value_type      = typename container_traits_type::value_type;

	using reference = ... // See below
	using const_reference = typename container_traits_type::const_reference;

	using pointer = ... // See below
	using const_pointer = typename container_traits_type::const_pointer;

	using span_type = span<std::size_t>;

	tensor_core(const tensor_core& tens,  span_type ... spans) {}

        template <typename eng>
        tensor_core(const tensor_core<eng>& tens,  span_type ... spans) {}
};

If the parent tensor is const, then nested type aliases pointer and
reference are equivalent to const_pointer and const_reference, respectively. for a relatively complete implementation, see this branch here

engine_5

template <class T>
struct subtensor_engine
{
	using extents_type = typename T::extents_type; // type of the parent extents
	using layout_type = typename T::layout_type; // type of the parent layout
	using container_type = typename T::container_type; // type of the parent container
};

template <class T>
class tensor_core<subtensor_engine<T>> {
public:
        // types
	using engine_type = subtensor_engine<T>;
	using self_type   = tensor_core<engine_type>;
        
        using container_type = typename engine_type::container_type;
	using layout_type    = typename engine_type::layout_type;
	using extents_type   = typename engine_type::extents_type;
	using strides_type   = typename extents_type::base_type;

	using container_traits_type = container_traits<container_type>;

	using size_type       = typename container_traits_type::size_type;
	using difference_type = typename container_traits_type::difference_type;
	using value_type      = typename container_traits_type::value_type;

	using reference = ... // See below
	using const_reference = typename container_traits_type::const_reference;

	using pointer = ... // See below
	using const_pointer = typename container_traits_type::const_pointer;

	using span_type = span<std::size_t>;

	tensor_core(const tensor_core& tens, span_type ... spans) {}

        template <typename eng>
        tensor_core(const tensor_core<eng>& tens,  span_type ... spans) {}
};

If the parent tensor is const, then nested type aliases pointer and
reference are equivalent to const_pointer and const_reference, respectively. for a relatively complete implementation, see this branch
here.

[bassoy]

Considering subtensor_engine_5

using tensor_t   = tensor_core<engine<...>>;

auto tensor = tensor_t(...);
auto subtensor1 = tensor();
auto subtensor2 = subtensor1();

[exclowd]

using t1 = tensor_core<subtensor_engine<tensor_core<subtensor_engine<tensor_core<tensor_engine<extents_core<long unsigned int>,basic_column_major<>, std::vector<float, std::allocator<float> > > > > > > >

using t2 = decltype(subtensor2);

std::is_same_v<t1,t2>

[bassoy]

In my opinion, there are too many types nested.

[bassoy]

What about:

using subtensor_t = tensor_core<tensor_core<engine_type>>;

using tensor_t = tensor_core<engine_type>;
using subtensor_t = tensor_core<tensor_t>;

would that be possible?

[bassoy]

What about:

using subtensor_t = tensor_core<subtensor_engine<tensor_core<engine_type>>>;

using tensor_t = tensor_core<engine_type>;
using subengine_t = subtensor_engine<tensor_t>;
using subtensor_t = tensor_core<subengine_t>;

would that be possible?

[bassoy]

No nesting subtensor_engine types