Unifying algorithm semantic for different APIs

[beomki-yeo]

Unifying algorithm semantic for different APIs

[stephenswat]

I would propose that we unify all algorithms in traccc under a standard interface, something like:

template<typename I, typename O>
class algorithm {
    void operator(const I & i, O & o);
};

Then, our algorithms can inherit from this class to provide us a consistent API:

namespace traccc::cuda {
    class component_connection : public algorithm<cell_container, cluster_container> {
        ...
    };
}

This would allow us to define compile-type types for composition, while allowing algorithm selection at runtime:

template<typename I, typename P, typename O>
class composition : public algorithm<I, O> {
    composition(algorithm<I, P> & a1, algorithm<P, O> & a2);
};

If we want to extend this concept, we can additionally define data location at compile time:

enum class storage {
    HOST,
    DEVICE,
    AGNOSTIC
};

template<typename I, typename O, storage Is=AGNOSTIC, storage Os=AGNOSTIC>
class algorithm {
    void operator(const I & i, O & o);
};

namespace traccc::cuda {
    class component_connection : public algorithm<cell_container, cluster_container, DEVICE, DEVICE> {
        ...
    };

    template<typename T>
    class host_to_device : public algorithm<T, T, HOST, DEVICE> {
        ...
    };
}

I think, in general, it is a good idea now to discuss how much we want to fix at compile time (giving us the security of having the type checker check our code for us), and how much we want to leave until runtime (so we can be more flexible at execution time).

[beomki-yeo]

I do like your suggestion.
Since even single algorithm may require various types of containers, can input and output type contain more than one container? For example:

template< typename I, typename O >  
class algorithm{    
public:
    virtual void operator()(const I& i, O& o){
        
    }
};

struct input_t{
    host_cell_container a;
    host_measurement_container b;
};

struct output_t{
    host_spacepoint_container b;
};

class test: public algorithm<input_t, output_t>{    
    
public:
    void operator()(const input_t& I, output_t& O) override {
        ...
    }
    
};

Of course the above code will force us to apply get_data() to every members of structure so it may not be a good solution.:p