pointwise.hpp

#pragma once
#include <dlprim/tensor.hpp>
#include <dlprim/context.hpp>
namespace dlprim {
namespace core {

    void bind_as_dtype(cl::Kernel &k,int &p,double value,DataType dt);
    void pointwise_operation(std::vector<Tensor> xs,
                             std::vector<Tensor> ys,
                             std::vector<double>  ws,
                             std::string const &code,
                             ExecutionContext const &ec);
    void pointwise_operation_broadcast( std::vector<Tensor> xs,
                                        std::vector<Tensor> ys,
                                        std::vector<double>  ws,
                                        std::string const &code,
                                        ExecutionContext const &e);

    class PointwiseOperationBroadcastReduce {
    public:
        
        virtual ~PointwiseOperationBroadcastReduce() {}
        virtual size_t workspace() = 0;
        //  \param parameters - the weight paramerters, size should match weights_count
        virtual void enqueue(std::vector<Tensor> xs,
                             std::vector<Tensor> ys,
                             Tensor &workspace,
                             std::vector<double> parameters,
                             std::vector<double> alpha,
                             std::vector<double> beta,
                             ExecutionContext const &e) = 0;

        //  \param weights_count - size of parameters vector in enqueue
        static std::unique_ptr<PointwiseOperationBroadcastReduce> create(
                        Context &ctx,
                        std::vector<TensorSpecs> xs,
                        std::vector<TensorSpecs> ys,
                        int weights_count,DataType weights_type,
                        std::string const &compute_code,
                        std::string const &reduce_init,
                        std::string const &reduce);

    };

} // core
} // dlprim