Working on reference types in std::function deduction

4 files changed, 59 insertions, 48 deletions

diff --git a/modules/remote-sycl/c++/remote.hpp b/modules/remote-sycl/c++/remote.hpp
index d956314..a2b5a87 100644
--- a/modules/remote-sycl/c++/remote.hpp
+++ b/modules/remote-sycl/c++/remote.hpp
@@ -17,16 +17,16 @@ class remote<rmt::Sycl>;
 /**
  * Remote data class for the Sycl backend.
  */
-template<typename T, typename Encoding>
-class remote_data<T, Encoding, rmt::Sycl> {
+template<typename T, typename Encoding, typename Storage>
+class remote_data<T, Encoding, Storage, rmt::Sycl> {
 private:
 	id<T> id_;
-	id_map<T,Encoding>* map_;
+	id_map<T,Encoding,rmt::Sycl>* map_;
 public:
 	/**
 	 * Main constructor
 	 */
-	remote_data(const id<T>& id, id_map<T, Encoding>& map):
+	remote_data(const id<T>& id, id_map<T, Encoding, rmt::Sycl>& map):
 		id_{id},
 		map_{&map}
 	{}
@@ -34,14 +34,14 @@ public:
 	/**
 	 * Request data asynchronously
 	 */
-	conveyor<data<T,Encoding>> on_receive(); /// Stopped here
+	conveyor<data<T,Encoding,Storage>> on_receive(); /// Stopped here
 };
 
 /**
  * 
  */
 template<typename T, uint64_t N>
-class data<schema::Primitive<T,N>, encode::Native<rmt::Sycl>> {
+class data<schema::Primitive<T,N>, encode::Native, rmt::Sycl> {
 public:
 	using Schema = schema::Primitive<T,N>;
 	using NativeType = typename native_data_type<Schema>::type;
@@ -64,7 +64,7 @@ public:
 };
 
 template<typename T, uint64_t D>
-class data<schema::Array<T,D>, encode::Native<rmt::Sycl>> {
+class data<schema::Array<T,D>, encode::Native, rmt::Sycl> {
 public:
 	using Schema = schema::Array<T,D>;
 private:
@@ -86,8 +86,8 @@ public:
 		}
 	}
 
-	template<typename Encoding>
-	data(const data<Schema, Encoding>& from, cl::sycl::queue& q__):
+	template<typename Encoding, typename Storage>
+	data(const data<Schema, Encoding, Storage>& from, cl::sycl::queue& q__):
 		total_length_{from.size()},
 		device_data_{cl::sycl::malloc_device<typename native_data_type<T>::type>(from.size(), q__)},
 		queue_{&q__}
@@ -105,28 +105,32 @@ public:
 		}
 	}
 
-	data<T,encode::Native<rmt::Sycl>>& at(uint64_t i){
+	// data<T,encode::Native,rmt::Sycl>& at(uint64_t i){
+	typename native_data_type<T>::type& at(uint64_t i){
 		return device_data_[i];
 	}
+
+	uint64_t size() const {
+		return total_length_;
+	}
 };
 
 namespace impl {
-
-template<typename Iface, typename Encoding>
+template<typename Iface, typename Encoding, typename Storage>
 struct rpc_id_map_helper {
-	static_assert(always_false<Iface, Encoding>, "Only support Interface schema types.");
+	static_assert(always_false<Iface, Encoding,Storage>, "Only supports Interface schema types.");
 };
 
-template<typename... Members, typename Encoding>
-struct rpc_id_map_helper<schema::Interface<Members...>, Encoding> {
-	std::tuple<id_map<typename Members::ValueType::ResponseT, Encoding>...> maps;
+template<typename... Members, typename Encoding, typename Storage>
+struct rpc_id_map_helper<schema::Interface<Members...>, Encoding, Storage> {
+	std::tuple<id_map<typename Members::ValueType::ResponseT, Encoding, Storage>...> maps;
 };
 }
 /**
  * Rpc Client class for the Sycl backend.
  */
-template<typename Iface, typename Encoding>
-class rpc_client<Iface, Encoding, rmt::Sycl> {
+template<typename Iface, typename Encoding, typename Storage>
+class rpc_client<Iface, Encoding, Storage, rmt::Sycl> {
 public:
 private:
 	/**
@@ -141,12 +145,13 @@ public:
 	/**
 	 * Rpc call
 	 */
-	template<string_literal Name, typename ClientEncoding>
+	template<string_literal Name>
 	error_or<
 		id<
 			typename schema_member_type<Name, Iface>::type::ResponseT
 		>
-	> call(data_or_id<typename schema_member_type<Name, Iface>::type::RequestT, ClientEncoding> input){
+	> call(data_or_id<typename schema_member_type<Name, Iface>::type::RequestT, Encoding, Storage> input){
+		(void) input;
 		return make_error<err::not_implemented>("RpcClient side is not implemented");
 	}
 
@@ -159,7 +164,7 @@ template<typename Iface, typename Encoding>
 class rpc_server<Iface, Encoding, rmt::Sycl> {
 public:
 	using InterfaceCtxT = cl::sycl::queue*;
-	using InterfaceT = interface<Iface, Encoding, InterfaceCtxT>;
+	using InterfaceT = interface<Iface, Encoding, rmt::Sycl, InterfaceCtxT>;
 private:
 	/**
 	 * Command queue for the sycl backend
@@ -169,22 +174,23 @@ private:
 	/**
 	 * The interface including the relevant context class.
 	 */
-	interface<Iface, Encoding, InterfaceCtxT> cl_interface_;
+	interface<Iface, Encoding, rmt::Sycl, InterfaceCtxT> cl_interface_;
 
 	/**
 	 * Basic storage for response data.
 	 */
-	impl::rpc_id_map_helper<Iface, Encoding> storage_;
+	impl::rpc_id_map_helper<Iface, Encoding, rmt::Sycl> storage_;
 public:
-	rpc_server(interface<Iface, Encoding, InterfaceCtxT> cl_iface):
+	rpc_server(interface<Iface, Encoding, rmt::Sycl, InterfaceCtxT> cl_iface):
 		cmd_queue_{},
 		cl_interface_{std::move(cl_iface)},
 		storage_{}
 	{}
 
-	template<typename IdT>
-	remote_data<IdT, Encoding, rmt::Sycl> request_data(id<IdT> dat){
-		return {dat, std::get<id_map<IdT, Encoding>>(storage_.maps)};
+	template<typename IdT, typename Storage>
+	remote_data<IdT, Encoding, Storage, rmt::Sycl> request_data(id<IdT> dat){
+		/// @TODO Fix so I can receive data
+		return {dat, std::get<id_map<IdT, Encoding,rmt::Sycl>>(storage_.maps)};
 	}
 
 	/**
@@ -195,23 +201,30 @@ public:
 		id<
 			typename schema_member_type<Name, Iface>::type::ResponseT
 		>
-	> call(data_or_id<typename schema_member_type<Name, Iface>::type::RequestT, ClientAllocation> input){
+	> call(data_or_id<typename schema_member_type<Name, Iface>::type::RequestT, Encoding, ClientAllocation> input){
+		using FuncT = typename schema_member_type<Name, Iface>::type;
 
 		/**
+		 * Object needed if and only if the provided data type is not an id
+		 */
+		own<data<typename FuncT::RequestT, Encoding, rmt::Sycl>> dev_tmp_inp = nullptr;
+		/**
 		 * First check if it's data or an id.
 		 * If it's an id, check if it's registered within the storage and retrieve it.
 		 */
-		auto eoinp = [&,this]() -> error_or<data<typename schema_member_type<Name, Iface>::type::RequestT, Encoding>* > {
+		auto eoinp = [&,this]() -> error_or<data<typename FuncT::RequestT, Encoding, rmt::Sycl>* > {
 			if(input.is_id()){
 				// storage_.maps
-				auto& inner_map = std::get<id_map<typename schema_member_type<Name, Iface>::type::RequestT, Encoding >> (storage_.maps);
+				auto& inner_map = std::get<id_map<typename FuncT::RequestT, Encoding, rmt::Sycl>> (storage_.maps);
 				auto eov = inner_map.find(input.get_id());
 				if(eov.is_error()){
 					return std::move(eov.get_error());
 				}
 				return eov.get_value();
 			} else {
-				return &input.get_data();
+				auto& client_data = input.get_data();
+				dev_tmp_inp = heap<data<typename FuncT::RequestT, Encoding, rmt::Sycl>>(client_data, cmd_queue_);
+				return dev_tmp_inp.get();
 			}
 		}();
 		if(eoinp.is_error()){
@@ -219,7 +232,7 @@ public:
 		}
 		auto& inp = *(eoinp.get_value());
 
-		auto eod = cl_interface_.template call<Name>(std::move(inp), &cmd_queue_);
+		auto eod = cl_interface_.template call<Name>(inp, &cmd_queue_);
 
 		if(eod.is_error()){
 			return std::move(eod.get_error());
@@ -229,7 +242,7 @@ public:
 		 * Store returned data in rpc storage
 		 */
 		auto& val = eod.get_value();
-		auto& inner_map = std::get<id_map<typename schema_member_type<Name, Iface>::type::RequestT, Encoding >> (storage_.maps);
+		auto& inner_map = std::get<id_map<typename schema_member_type<Name, Iface>::type::RequestT, Encoding,rmt::Sycl>> (storage_.maps);
 		auto eoid = inner_map.insert(std::move(val));
 		if(eoid.is_error()){
 			return std::move(eoid.get_error());
diff --git a/modules/remote-sycl/examples/sycl_basic.cpp b/modules/remote-sycl/examples/sycl_basic.cpp
index 41aa2a1..677fd29 100644
--- a/modules/remote-sycl/examples/sycl_basic.cpp
+++ b/modules/remote-sycl/examples/sycl_basic.cpp
@@ -23,7 +23,7 @@ int main(){
 
 	saw::id<schema::Array<schema::UInt64>> next_id{0u};
 	{
-		auto eov = rpc_server.template call<"increment">(saw::data<schema::Array<schema::UInt64>, saw::encode::Native<saw::rmt::Sycl>>{1u});
+		auto eov = rpc_server.template call<"increment", saw::storage::Default>(saw::data<schema::Array<schema::UInt64>, saw::encode::Native>{1u});
 		if(eov.is_error()){
 			auto& err = eov.get_error();
 			std::cerr<<"Error: "<<err.get_category()<<" : "<<err.get_message()<<std::endl;
@@ -32,7 +32,7 @@ int main(){
 		next_id = eov.get_value();
 	}
 	{
-		auto eov = rpc_server.template call<"increment">(next_id);
+		auto eov = rpc_server.template call<"increment", saw::storage::Default>(next_id);
 		if(eov.is_error()){
 			auto& err = eov.get_error();
 			std::cerr<<"Error: "<<err.get_category()<<" : "<<err.get_message()<<std::endl;
diff --git a/modules/remote-sycl/examples/sycl_basic.hpp b/modules/remote-sycl/examples/sycl_basic.hpp
index c7cfadc..6932184 100644
--- a/modules/remote-sycl/examples/sycl_basic.hpp
+++ b/modules/remote-sycl/examples/sycl_basic.hpp
@@ -6,8 +6,8 @@ namespace schema {
 using namespace saw::schema;
 
 using BasicInterface = Interface<
-	Member<Function<Array<UInt64>, UInt64>, "increment">
+	Member<Function<Array<UInt64>, Array<UInt64>>, "increment">
 >;
 }
 
-saw::rpc_server<schema::BasicInterface, saw::encode::Native<saw::rmt::Sycl>, saw::rmt::Sycl> listen_basic_sycl(saw::remote<saw::rmt::Sycl>& ctx, saw::remote_address<saw::rmt::Sycl>& addr);
+saw::rpc_server<schema::BasicInterface, saw::encode::Native, saw::rmt::Sycl> listen_basic_sycl(saw::remote<saw::rmt::Sycl>& ctx, saw::remote_address<saw::rmt::Sycl>& addr);
diff --git a/modules/remote-sycl/examples/sycl_basic_kernel.cpp b/modules/remote-sycl/examples/sycl_basic_kernel.cpp
index 86e73b5..94583b9 100644
--- a/modules/remote-sycl/examples/sycl_basic_kernel.cpp
+++ b/modules/remote-sycl/examples/sycl_basic_kernel.cpp
@@ -1,22 +1,20 @@
 #include "sycl_basic.hpp"
 
-saw::rpc_server<schema::BasicInterface, saw::encode::Native<saw::rmt::Sycl>, saw::rmt::Sycl> listen_basic_sycl(saw::remote<saw::rmt::Sycl>& ctx, saw::remote_address<saw::rmt::Sycl>& addr){
-	saw::interface<schema::BasicInterface, saw::encode::Native<saw::rmt::Sycl>, cl::sycl::queue*> iface{
-		[](saw::data<saw::schema::Array<saw::schema::UInt64>, saw::encode::Native<saw::rmt::Sycl>> in, cl::sycl::queue* q) -> saw::data<saw::schema::UInt64, saw::encode::Native<saw::rmt::Sycl>> {
-			uint64_t inr = in.size();
-			cl::sycl::buffer<uint64_t,1>  d_inc{ &inr, 1u };
-			q->submit([&](cl::sycl::handler& h){
-				auto a_inc = d_inc.get_access<cl::sycl::access::mode::read_write>(h);
+saw::rpc_server<schema::BasicInterface, saw::encode::Native, saw::rmt::Sycl> listen_basic_sycl(saw::remote<saw::rmt::Sycl>& ctx, saw::remote_address<saw::rmt::Sycl>& addr){
+	saw::interface<schema::BasicInterface, saw::encode::Native, saw::rmt::Sycl, cl::sycl::queue*> iface{
+
+		[](saw::data<saw::schema::Array<saw::schema::UInt64>, saw::encode::Native, saw::rmt::Sycl> in, cl::sycl::queue* q) -> saw::data<saw::schema::Array<saw::schema::UInt64>, saw::encode::Native, saw::rmt::Sycl> {
 
-				h.parallel_for(cl::sycl::range<1>(1u), [=] (cl::sycl::id<1> it){
-					a_inc[0] += 1u;
+			q->submit([&](cl::sycl::handler& h){
+				h.parallel_for(cl::sycl::range<1>(1u), [&] (cl::sycl::id<1> it){
+					in.at(0u) += 1u;
 				});
 			});
 			q->wait();
-			return {inr};
+			return in;
 		}
 	};
-	auto rpc_server = ctx.template listen<schema::BasicInterface, saw::encode::Native<saw::rmt::Sycl>>(addr, std::move(iface));
+	auto rpc_server = ctx.template listen<schema::BasicInterface, saw::encode::Native>(addr, std::move(iface));
 	
 	return rpc_server;
 }