Verified Commit 33f3578c authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

Move admire types into dedicated 'admire_types' CMake target 

This makes it much simpler to share type definitions between the library
and the daemons.

- C++ types are now declared in admire_types.hpp
- C & C++ types are defined in types.cpp. The reason for them being in
  the same file is that the C type-creation functions use logging
  facilities that are C++ code. Until we offer a C interface for them,
  C-type functions need to be compiled with a C++ compiler.
parent d99687f9

src/lib/CMakeLists.txt

+14 −3
Original line number Diff line number Diff line
@@ -22,16 +22,27 @@ 
# SPDX-License-Identifier: GPL-3.0-or-later                                    #

################################################################################



add_library(admire_types STATIC)



target_sources(admire_types PUBLIC admire_types.h admire_types.hpp PRIVATE

  types.cpp)



target_link_libraries(admire_types PRIVATE common::network::rpc_types

  Margo::Margo common::logger)



set_target_properties(admire_types PROPERTIES POSITION_INDEPENDENT_CODE ON)



# the client library implementing the actual API

add_library(adm_iosched SHARED)



target_sources(adm_iosched

  PUBLIC admire.h admire_types.h admire.hpp

  PRIVATE admire.cpp c_wrapper.cpp detail/impl.hpp detail/impl.cpp errors.c)

  PUBLIC admire.h admire_types.h admire.hpp admire_types.hpp

  PRIVATE admire.cpp c_wrapper.cpp detail/impl.hpp detail/impl.cpp errors.c types.cpp)



target_include_directories(adm_iosched PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})



target_link_libraries(adm_iosched PRIVATE common::network::engine common::network::rpc_types PUBLIC

target_link_libraries(adm_iosched PRIVATE common::network::engine

  common::network::rpc_types admire_types PUBLIC

  tl::expected)



install(

src/lib/admire.cpp

+2 −57
Original line number Diff line number Diff line
@@ -172,61 +172,6 @@ rpc_registration_cb(scord::network::rpc_client* client) { 


namespace admire {



job_requirements::job_requirements(std::vector<admire::dataset> inputs,

                                   std::vector<admire::dataset> outputs)

    : m_inputs(std::move(inputs)), m_outputs(std::move(outputs)) {}



job_requirements::job_requirements(

        std::vector<admire::dataset> inputs,

        std::vector<admire::dataset> outputs,

        std::optional<storage::adhoc::context> adhoc_context)

    : m_inputs(std::move(inputs)), m_outputs(std::move(outputs)),

      m_adhoc_context(adhoc_context) {}



job_requirements::job_requirements(ADM_job_requirements_t reqs) {



    m_inputs.reserve(reqs->r_inputs->l_length);



    for(size_t i = 0; i < reqs->r_inputs->l_length; ++i) {

        m_inputs.emplace_back(reqs->r_inputs->l_datasets[i].d_id);

    }



    m_outputs.reserve(reqs->r_outputs->l_length);



    for(size_t i = 0; i < reqs->r_outputs->l_length; ++i) {

        m_outputs.emplace_back(reqs->r_outputs->l_datasets[i].d_id);

    }

}





ADM_job_requirements_t

job_requirements::to_rpc_type() const {



    using scord::utils::c_ptr;

    using scord::utils::c_ptr_vector;

    using dataset_vector = c_ptr_vector<adm_dataset, ADM_dataset_destroy>;



    dataset_vector inputs;

    inputs.reserve(m_inputs.size());



    for(const auto& in : m_inputs) {

        inputs.emplace_back(ADM_dataset_create(in.m_id.c_str()));

    }



    dataset_vector outputs;

    outputs.reserve(m_outputs.size());



    for(const auto& out : m_outputs) {

        outputs.emplace_back(ADM_dataset_create(out.m_id.c_str()));

    }



    if(m_adhoc_context) {

    }



    return ADM_job_requirements_create(inputs.data(), inputs.size(),

                                       outputs.data(), outputs.size(), nullptr);

}



void

ping(const server& srv) {
@@ -251,7 +196,7 @@ register_job(const server& srv, const job_requirements& reqs) { 
}



ADM_return_t

update_job(const server& srv, ADM_job_t job, const job_requirements& reqs) {

update_job(const server& srv, const job& job, const job_requirements& reqs) {

    (void) srv;

    (void) job;

    (void) reqs;
@@ -277,7 +222,7 @@ update_job(const server& srv, ADM_job_t job, const job_requirements& reqs) { 
}



ADM_return_t

remove_job(const server& srv, ADM_job_t job) {

remove_job(const server& srv, const job& job) {

    (void) srv;

    (void) job;

src/lib/admire.hpp

+11 −63
Original line number Diff line number Diff line
@@ -23,78 +23,26 @@ 
 *****************************************************************************/



#include <admire.h>

#include <tl/expected.hpp>

#include <optional>

#include <cstdarg>

#include <string>

#include <utility>

#include "admire_types.hpp"

#include "network/proto/rpc_types.h"



#ifndef SCORD_ADMIRE_HPP

#define SCORD_ADMIRE_HPP



namespace admire {



using job_id = int64_t;



struct server {

    std::string m_protocol;

    std::string m_address;

};



struct job {

    job_id m_id;

};



struct dataset {

    explicit dataset(std::string id) : m_id(std::move(id)) {}

    std::string m_id;

};



namespace storage::adhoc {



enum class execution_mode : std::underlying_type<ADM_adhoc_mode_t>::type {

    in_job_shared = ADM_ADHOC_MODE_IN_JOB_SHARED,

    in_job_dedicated = ADM_ADHOC_MODE_IN_JOB_DEDICATED,

    separate_new = ADM_ADHOC_MODE_SEPARATE_NEW,

    separate_existing = ADM_ADHOC_MODE_SEPARATE_EXISTING

};

/******************************************************************************/

/* Public type definitions and type-related functions                         */

/******************************************************************************/



enum class access_mode : std::underlying_type<ADM_adhoc_mode_t>::type {

    read_only = ADM_ADHOC_ACCESS_RDONLY,

    write_only = ADM_ADHOC_ACCESS_WRONLY,

    read_write = ADM_ADHOC_ACCESS_RDWR,

};

// See admire_types.hpp



struct context {

    execution_mode m_exec_mode;

    access_mode m_access_mode;

    std::uint32_t m_nodes;

    std::uint32_t m_walltime;

    bool m_should_flush;

};



} // namespace storage::adhoc



struct job_requirements {



    job_requirements(std::vector<admire::dataset> inputs,

                     std::vector<admire::dataset> outputs);



    job_requirements(std::vector<admire::dataset> inputs,

                     std::vector<admire::dataset> outputs,

                     std::optional<storage::adhoc::context> adhoc_context);



    explicit job_requirements(ADM_job_requirements_t reqs);



    ADM_job_requirements_t

    to_rpc_type() const;



    std::vector<admire::dataset> m_inputs;

    std::vector<admire::dataset> m_outputs;

    std::optional<storage::adhoc::context> m_adhoc_context;

};

/******************************************************************************/

/* Public prototypes                                                          */

/******************************************************************************/



namespace admire {



void

ping(const server& srv);
@@ -103,10 +51,10 @@ admire::job 
register_job(const server& srv, const job_requirements& reqs);



ADM_return_t

update_job(const server& srv, ADM_job_t job, const job_requirements& reqs);

update_job(const server& srv, const job&, const job_requirements& reqs);



ADM_return_t

remove_job(const server& srv, ADM_job_t job);

remove_job(const server& srv, const job& job);



ADM_return_t

register_adhoc_storage(const server& srv, ADM_job_t job,

src/lib/admire_types.hpp

0 → 100644
+183 −0
Original line number Diff line number Diff line 
/******************************************************************************

 * Copyright 2021-2022, Barcelona Supercomputing Center (BSC), Spain

 *

 * This software was partially supported by the EuroHPC-funded project ADMIRE

 *   (Project ID: 956748, https://www.admire-eurohpc.eu).

 *

 * This file is part of scord.

 *

 * scord is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * scord is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with scord.  If not, see <https://www.gnu.org/licenses/>.

 *

 * SPDX-License-Identifier: GPL-3.0-or-later

 *****************************************************************************/



#ifndef SCORD_ADMIRE_TYPES_HPP

#define SCORD_ADMIRE_TYPES_HPP



#include <string>

#include <cstdint>

#include <vector>

#include <filesystem>

#include <fmt/format.h>

#include <utils/c_ptr.hpp>

#include "admire_types.h"



namespace admire {



using job_id = std::uint64_t;



struct server {



    server(std::string protocol, std::string address);



    explicit server(const ADM_server_t& srv);



    std::string m_protocol;

    std::string m_address;

};



struct job {



    explicit job(job_id id);



    explicit job(ADM_job_t job);



    job_id m_id;

};



struct dataset {

    explicit dataset(std::string id) : m_id(std::move(id)) {}



    std::string

    to_string() const {

        return "foo";

    }



    std::string m_id;

};



struct storage {



    enum class type : std::underlying_type<ADM_storage_type_t>::type {

        gekkofs = ADM_STORAGE_GEKKOFS,

        dataclay = ADM_STORAGE_DATACLAY,

        expand = ADM_STORAGE_EXPAND,

        hercules = ADM_STORAGE_HERCULES,

        lustre = ADM_STORAGE_LUSTRE,

        gpfs = ADM_STORAGE_GPFS

    };



    storage(storage::type type, std::string id);



    virtual ~storage() = default;



    virtual ADM_storage_t

    to_rpc_type() const = 0;



    std::string m_id;

    type m_type;

};



struct adhoc_storage : public storage {



    enum class execution_mode : std::underlying_type<ADM_adhoc_mode_t>::type {

        in_job_shared = ADM_ADHOC_MODE_IN_JOB_SHARED,

        in_job_dedicated = ADM_ADHOC_MODE_IN_JOB_DEDICATED,

        separate_new = ADM_ADHOC_MODE_SEPARATE_NEW,

        separate_existing = ADM_ADHOC_MODE_SEPARATE_EXISTING

    };



    enum class access_type : std::underlying_type<ADM_adhoc_mode_t>::type {

        read_only = ADM_ADHOC_ACCESS_RDONLY,

        write_only = ADM_ADHOC_ACCESS_WRONLY,

        read_write = ADM_ADHOC_ACCESS_RDWR,

    };



    struct context {



        context(execution_mode exec_mode, access_type access_type,

                std::uint32_t nodes, std::uint32_t walltime, bool should_flush);



        explicit context(ADM_adhoc_context_t ctx);



        ADM_adhoc_context_t

        to_rpc_type() const;



        execution_mode m_exec_mode;

        access_type m_access_type;

        std::uint32_t m_nodes;

        std::uint32_t m_walltime;

        bool m_should_flush;

    };



    adhoc_storage(storage::type type, std::string id, execution_mode exec_mode,

                  access_type access_type, std::uint32_t nodes,

                  std::uint32_t walltime, bool should_flush);



    adhoc_storage(storage::type type, std::string id, ADM_adhoc_context_t ctx);





    ADM_storage_t

    to_rpc_type() const final;



    context m_ctx;

};



struct pfs_storage : public storage {



    struct context {



        explicit context(std::filesystem::path mount_point);



        explicit context(ADM_pfs_context_t ctx);



        ADM_pfs_context_t

        to_rpc_type() const;



        std::filesystem::path m_mount_point;

    };



    pfs_storage(storage::type type, std::string id,

                std::filesystem::path mount_point);



    pfs_storage(storage::type type, std::string id, ADM_pfs_context_t ctx);



    ADM_storage_t

    to_rpc_type() const final;



    context m_ctx;

};



struct job_requirements {



    job_requirements(std::vector<admire::dataset> inputs,

                     std::vector<admire::dataset> outputs);



    job_requirements(std::vector<admire::dataset> inputs,

                     std::vector<admire::dataset> outputs,

                     std::unique_ptr<storage> storage);



    explicit job_requirements(ADM_job_requirements_t reqs);



    ADM_job_requirements_t

    to_rpc_type() const;



    std::vector<admire::dataset> m_inputs;

    std::vector<admire::dataset> m_outputs;

    std::unique_ptr<admire::storage> m_storage;

};



} // namespace admire



#endif // SCORD_ADMIRE_TYPES_HPP

src/lib/c_wrapper.cpp

+31 −624

File changed.

Preview size limit exceeded, changes collapsed.