fs_config rpc now uses Hermes instead of Margo (48d56a8b) · Commits · David Auer / gekkofs

include/client/preload_context.hpp

+9 −0

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@
		#ifndef IFS_PRELOAD_CTX_HPP
		#define IFS_PRELOAD_CTX_HPP

		#include <hermes.hpp>
		#include <spdlog/spdlog.h>
		#include <map>
		#include <mercury.h>
		@@ -61,7 +62,10 @@ class PreloadContext {
		std::vector<std::string> mountdir_components_;
		std::string mountdir_;

		#if 1 // TODO(amiranda): remove
		std::vector<hg_addr_t> hosts_;
		#endif
		std::vector<hermes::endpoint> hosts2_;
		uint64_t local_host_id_;

		bool interception_enabled_;
		@@ -85,8 +89,13 @@ class PreloadContext {
		void cwd(const std::string& path);
		const std::string& cwd() const;

		#if 1 // TODO(amiranda) remove
		const std::vector<hg_addr_t>& hosts() const;
		void hosts(const std::vector<hg_addr_t>& addrs);
		#endif

		const std::vector<hermes::endpoint>& hosts2() const;
		void hosts2(const std::vector<hermes::endpoint>& addrs);

		uint64_t local_host_id() const;
		void local_host_id(uint64_t id);

include/client/preload_util.hpp

+5 −0

Original line number	Diff line number	Diff line
		@@ -41,6 +41,11 @@ struct MetadentryUpdateFlags {

		// Margo instances
		extern margo_instance_id ld_margo_rpc_id;

		// Hermes instance
		namespace hermes { class async_engine; }
		extern std::unique_ptr<hermes::async_engine> ld_network_service;

		// RPC IDs
		extern hg_id_t rpc_config_id;
		extern hg_id_t rpc_mk_node_id;

include/client/rpc/hg_rpcs.hpp

0 → 100644

+220 −0

Original line number	Diff line number	Diff line
		/*
		Copyright 2018-2019, Barcelona Supercomputing Center (BSC), Spain
		Copyright 2015-2019, Johannes Gutenberg Universitaet Mainz, Germany

		This software was partially supported by the
		EC H2020 funded project NEXTGenIO (Project ID: 671951, www.nextgenio.eu).

		This software was partially supported by the
		ADA-FS project under the SPPEXA project funded by the DFG.

		SPDX-License-Identifier: MIT
		*/

		#ifndef GKFS_RPCS_HPP
		#define GKFS_RPCS_HPP

		// C includes
		#include <mercury.h>
		#include <mercury_proc_string.h>
		#include <mercury_macros.h>

		// C++ includes
		#include <string>

		// hermes includes
		#include <hermes.hpp>

		#ifndef HG_GEN_PROC_NAME
		#define HG_GEN_PROC_NAME(struct_type_name) \
		hg_proc_ ## struct_type_name
		#endif


		#include <global/global_defs.hpp>
		#include <global/rpc/rpc_types.hpp>

		namespace hermes { namespace detail {

		struct hg_void_t { };

		static HG_INLINE hg_return_t
		hg_proc_void_t(hg_proc_t proc, void *data)
		{
		(void) proc;
		(void) data;

		return HG_SUCCESS;
		}

		}} // namespace hermes::detail

		//==============================================================================
		// definitions for fs_config
		struct fs_config {

		// forward declarations of public input/output types for this RPC
		class input;
		class output;

		// traits used so that the engine knows what to do with the RPC
		using self_type = fs_config;
		using handle_type = hermes::rpc_handle<self_type>;
		using input_type = input;
		using output_type = output;
		using mercury_input_type = hermes::detail::hg_void_t;
		using mercury_output_type = rpc_config_out_t;

		// RPC public identifier
		constexpr static const uint64_t public_id = 3033006080;

		// RPC internal Mercury identifier
		constexpr static const hg_id_t mercury_id = public_id;

		// RPC name
		constexpr static const auto name = hg_tag::fs_config;

		// requires response?
		constexpr static const auto requires_response = true;

		// Mercury callback to serialize input arguments
		constexpr static const auto mercury_in_proc_cb =
		hermes::detail::hg_proc_void_t;

		// Mercury callback to serialize output arguments
		constexpr static const auto mercury_out_proc_cb =
		HG_GEN_PROC_NAME(rpc_config_out_t);

		class input {

		template <typename ExecutionContext>
		friend hg_return_t hermes::detail::post_to_mercury(ExecutionContext*);

		public:
		input() { }
		input(input&& rhs) = default;
		input(const input& other) = default;
		input& operator=(input&& rhs) = default;
		input& operator=(const input& other) = default;

		explicit
		input(const hermes::detail::hg_void_t& other) { }

		explicit
		operator hermes::detail::hg_void_t() {
		return {};
		}
		};

		class output {

		template <typename ExecutionContext>
		friend hg_return_t hermes::detail::post_to_mercury(ExecutionContext*);

		public:
		output() :
		m_mountdir(),
		m_rootdir(),
		m_atime_state(),
		m_mtime_state(),
		m_ctime_state(),
		m_link_cnt_state(),
		m_blocks_state(),
		m_uid(),
		m_gid() {}

		output(const std::string& mountdir,
		const std::string& rootdir,
		bool atime_state,
		bool mtime_state,
		bool ctime_state,
		bool link_cnt_state,
		bool blocks_state,
		uint32_t uid,
		uint32_t gid) :
		m_mountdir(mountdir),
		m_rootdir(rootdir),
		m_atime_state(atime_state),
		m_mtime_state(mtime_state),
		m_ctime_state(ctime_state),
		m_link_cnt_state(link_cnt_state),
		m_blocks_state(blocks_state),
		m_uid(uid),
		m_gid(gid) {}

		output(output&& rhs) = default;
		output(const output& other) = default;
		output& operator=(output&& rhs) = default;
		output& operator=(const output& other) = default;

		explicit
		output(const rpc_config_out_t& out) {
		m_mountdir = out.mountdir;
		m_rootdir = out.rootdir;
		m_atime_state = out.atime_state;
		m_mtime_state = out.mtime_state;
		m_ctime_state = out.ctime_state;
		m_link_cnt_state = out.link_cnt_state;
		m_blocks_state = out.blocks_state;
		m_uid = out.uid;
		m_gid = out.gid;
		}

		std::string
		mountdir() const {
		return m_mountdir;
		}

		std::string
		rootdir() const {
		return m_rootdir;
		}

		bool
		atime_state() const {
		return m_atime_state;
		}

		bool
		mtime_state() const {
		return m_mtime_state;
		}

		bool
		ctime_state() const {
		return m_ctime_state;
		}

		bool
		link_cnt_state() const {
		return m_link_cnt_state;
		}

		bool
		blocks_state() const {
		return m_blocks_state;
		}

		uint32_t
		uid() const {
		return m_uid;
		}

		uint32_t
		gid() const {
		return m_gid;
		}

		private:
		std::string m_mountdir;
		std::string m_rootdir;
		bool m_atime_state;
		bool m_mtime_state;
		bool m_ctime_state;
		bool m_link_cnt_state;
		bool m_blocks_state;
		uint32_t m_uid;
		uint32_t m_gid;
		};
		};
		#endif // GKFS_RPCS_HPP

src/client/CMakeLists.txt

+2 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@ set(PRELOAD_SRC
		preload.cpp
		resolve.cpp
		preload_util.cpp
		rpc/hg_rpcs.cpp
		rpc/ld_rpc_management.cpp
		rpc/ld_rpc_data_ws.cpp
		rpc/ld_rpc_metadentry.cpp
		@@ -31,6 +32,7 @@ set(PRELOAD_HEADERS
		../../include/client/preload.hpp
		../../include/client/resolve.hpp
		../../include/client/preload_util.hpp
		../../include/client/rpc/hg_rpcs.hpp
		../../include/client/rpc/ld_rpc_management.hpp
		../../include/client/rpc/ld_rpc_data_ws.hpp
		../../include/client/rpc/ld_rpc_metadentry.hpp

src/client/preload.cpp

+52 −0

Original line number	Diff line number	Diff line
		@@ -23,9 +23,12 @@
		#include <client/rpc/ld_rpc_management.hpp>
		#include <client/preload_util.hpp>
		#include <client/intercept.hpp>
		#include <client/rpc/hg_rpcs.hpp>
		#include <hermes.hpp>

		#include <fstream>


		using namespace std;
		//
		// thread to initialize the whole margo shazaam only once per process
		@@ -49,6 +52,7 @@ hg_id_t rpc_chunk_stat_id;
		// Margo instances
		margo_instance_id ld_margo_rpc_id;

		std::unique_ptr<hermes::async_engine> ld_network_service;

		static inline void exit_error_msg(int errcode, const string& msg) {
		CTX->log()->error(msg);
		@@ -117,6 +121,22 @@ void register_client_rpcs(margo_instance_id mid) {
		rpc_chunk_stat_in_t,
		rpc_chunk_stat_out_t,
		NULL);

		fmt::print(stdout, "rpc_config_id: {}\n", rpc_config_id);
		fmt::print(stdout, "rpc_mk_node_id: {}\n", rpc_mk_node_id);
		fmt::print(stdout, "rpc_stat_id: {}\n", rpc_stat_id);
		fmt::print(stdout, "rpc_rm_node_id: {}\n", rpc_rm_node_id);
		fmt::print(stdout, "rpc_decr_size_id: {}\n", rpc_decr_size_id);
		fmt::print(stdout, "rpc_update_metadentry_id: {}\n", rpc_update_metadentry_id);
		fmt::print(stdout, "rpc_get_metadentry_size_id: {}\n", rpc_get_metadentry_size_id);
		fmt::print(stdout, "rpc_update_metadentry_size_id: {}\n", rpc_update_metadentry_size_id);
		fmt::print(stdout, "rpc_mk_symlink_id: {}\n", rpc_mk_symlink_id);
		fmt::print(stdout, "rpc_write_data_id: {}\n", rpc_write_data_id);
		fmt::print(stdout, "rpc_read_data_id: {}\n", rpc_read_data_id);
		fmt::print(stdout, "rpc_trunc_data_id: {}\n", rpc_trunc_data_id);
		fmt::print(stdout, "rpc_get_dirents_id: {}\n", rpc_get_dirents_id);
		fmt::print(stdout, "rpc_chunk_stat_id: {}\n", rpc_chunk_stat_id);

		}

		/**
		@@ -149,6 +169,33 @@ bool init_margo_client(const std::string& na_plugin) {
		return true;
		}




		/**
		* Initializes the Hermes client for a given transport prefix
		* @param transport_prefix
		* @return true if succesfully initialized; false otherwise
		*/
		bool init_hermes_client(const std::string& transport_prefix) {

		try {
		ld_network_service =
		std::make_unique<hermes::async_engine>(
		hermes::get_transport_type(transport_prefix));
		ld_network_service->run();
		} catch (const std::exception& ex) {
		fmt::print(stderr, "Failed to initialize Hermes RPC client {}\n",
		ex.what());
		return false;
		}

		rpc_config_id = fs_config::public_id;

		return true;
		}


		/**
		* This function is only called in the preload constructor and initializes Argobots and Margo clients
		*/
		@@ -159,6 +206,11 @@ void init_ld_environment_() {
		exit_error_msg(EXIT_FAILURE, "Unable to initializa Margo RPC client");
		}

		// initialize Hermes interface to Mercury
		if (!init_hermes_client(RPC_PROTOCOL)) {
		exit_error_msg(EXIT_FAILURE, "Unable to initialize Hermes RPC client");
		}

		try {
		load_hosts();
		} catch (const std::exception& e) {