Commit dab9e834 authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

Merge branch... 

Merge branch 'amanzano/37-refactor-library-rpc-implementation-of-admire-update_adhoc_storage' into 'main'

Resolve "Refactor library RPC implementation of `admire::update_adhoc_storage`"

This MR moves the implementation of the RPC construction for 
`ADM_update_adhoc_storage` to `admire::detail` in `impl.[ch]pp` 
similarly to other RPCs already refactored. This includes changing 
the C ADM_types to native C++ types.

Closes #37

See merge request !48
parents f46dafa3 ee7a9c03

examples/c/ADM_update_adhoc_storage.c

+20 −1
Original line number Diff line number Diff line
@@ -78,7 +78,12 @@ main(int argc, char* argv[]) { 
    fprintf(stdout, "ADM_register_adhoc_storage() remote procedure completed "

                    "successfully\n");



    ret = ADM_update_adhoc_storage(server, ctx, adhoc_storage);

    ADM_adhoc_context_t new_ctx = ADM_adhoc_context_create(

            ADM_ADHOC_MODE_SEPARATE_NEW, ADM_ADHOC_ACCESS_RDWR, adhoc_resources,

            200, false);

    assert(new_ctx);



    ret = ADM_update_adhoc_storage(server, new_ctx, adhoc_storage);



    if(ret != ADM_SUCCESS) {

        fprintf(stderr,
@@ -93,6 +98,20 @@ main(int argc, char* argv[]) { 
                    "successfully\n");



cleanup:

    for(int i = 0; i < NINPUTS; ++i) {

        ADM_dataset_destroy(inputs[i]);

    }



    for(int i = 0; i < NOUTPUTS; ++i) {

        ADM_dataset_destroy(outputs[i]);

    }



    ADM_storage_destroy(adhoc_storage);



    ADM_adhoc_context_destroy(ctx);



    ADM_adhoc_context_destroy(new_ctx);



    ADM_server_destroy(server);

    exit(exit_status);

}

examples/cxx/ADM_update_adhoc_storage.cpp

+36 −14
Original line number Diff line number Diff line
@@ -24,7 +24,11 @@ 


#include <fmt/format.h>

#include <admire.hpp>

#include "common.hpp"



#define NADHOC_NODES 25

#define NINPUTS      10

#define NOUTPUTS     5



int

main(int argc, char* argv[]) {
@@ -38,25 +42,43 @@ main(int argc, char* argv[]) { 


    admire::server server{"tcp", argv[1]};



    ADM_adhoc_context_t ctx{};

    ADM_storage_t adhoc_storage{};

    ADM_return_t ret = ADM_SUCCESS;

    const auto adhoc_nodes = prepare_nodes(NADHOC_NODES);

    const auto new_adhoc_nodes = prepare_nodes(NADHOC_NODES * 2);

    const auto inputs = prepare_datasets("input-dataset-{}", NINPUTS);

    const auto outputs = prepare_datasets("output-dataset-{}", NOUTPUTS);



    std::string name = "adhoc_storage_42";

    const auto adhoc_storage_ctx = admire::adhoc_storage::ctx{

            admire::adhoc_storage::execution_mode::separate_new,

            admire::adhoc_storage::access_type::read_write,

            admire::adhoc_storage::resources{adhoc_nodes}, 100, false};



    const auto new_adhoc_storage_ctx = admire::adhoc_storage::ctx{

            admire::adhoc_storage::execution_mode::separate_new,

            admire::adhoc_storage::access_type::read_write,

            admire::adhoc_storage::resources{new_adhoc_nodes}, 200, false};



    try {

        ret = admire::update_adhoc_storage(server, ctx, adhoc_storage);

    } catch(const std::exception& e) {

        const auto adhoc_storage = admire::register_adhoc_storage(

                server, name, admire::storage::type::gekkofs,

                adhoc_storage_ctx);



        const auto ret = admire::update_adhoc_storage(

                server, new_adhoc_storage_ctx, adhoc_storage);



        if(!ret) {

            fmt::print(stderr, "FATAL: ADM_update_adhoc_storage() failed: {}\n",

                   e.what());

                       ret.message());

            exit(EXIT_FAILURE);

        }



    if(ret != ADM_SUCCESS) {

        fmt::print(stdout,

                   "ADM_update_adhoc_storage() remote procedure not completed "

                   "ADM_update_adhoc_storage() remote procedure completed "

                   "successfully\n");

        exit(EXIT_SUCCESS);

    } catch(const std::exception& e) {

        fmt::print(stderr, "FATAL: ADM_register_adhoc_storage() failed: {}\n",

                   e.what());

        exit(EXIT_FAILURE);

    }



    fmt::print(stdout, "ADM_update_adhoc_storage() remote procedure completed "

                       "successfully\n");

}

src/common/api/admire_types.hpp

+1 −0
Original line number Diff line number Diff line
@@ -402,6 +402,7 @@ struct adhoc_storage : public storage { 
                  execution_mode exec_mode, access_type access_type,

                  adhoc_storage::resources res, std::uint32_t walltime,

                  bool should_flush);

    explicit adhoc_storage(ADM_storage_t storage);

    adhoc_storage(enum storage::type type, std::string name, std::uint64_t id,

                  ADM_adhoc_context_t ctx);

    adhoc_storage(enum storage::type type, std::string name, std::uint64_t id,

src/common/api/types.cpp

+18 −2
Original line number Diff line number Diff line
@@ -629,7 +629,6 @@ ADM_data_operation_destroy(ADM_data_operation_t op) { 
    return ret;

}





ADM_adhoc_context_t

ADM_adhoc_context_create(ADM_adhoc_mode_t exec_mode,

                         ADM_adhoc_access_t access_type,
@@ -1380,7 +1379,6 @@ private: 
    adhoc_storage::ctx m_ctx;

};





adhoc_storage::adhoc_storage(enum storage::type type, std::string name,

                             std::uint64_t id, execution_mode exec_mode,

                             access_type access_type,
@@ -1391,6 +1389,24 @@ adhoc_storage::adhoc_storage(enum storage::type type, std::string name, 
              adhoc_storage::ctx{exec_mode, access_type, std::move(res),

                                 walltime, should_flush})) {}



adhoc_storage::adhoc_storage(ADM_storage_t st)

    : storage(static_cast<enum storage::type>(st->s_type), st->s_name,

              st->s_id) {



    switch(st->s_type) {

        case ADM_STORAGE_LUSTRE:

        case ADM_STORAGE_GPFS:

            throw std::runtime_error(

                    fmt::format("Invalid type {} for adhoc_storage",

                                static_cast<enum storage::type>(st->s_type)));

            break;



        default:

            break;

    }

    m_pimpl = std::make_unique<impl>(adhoc_storage::ctx{st->s_adhoc_ctx});

}



adhoc_storage::adhoc_storage(enum storage::type type, std::string name,

                             std::uint64_t id, ADM_adhoc_context_t ctx)

    : storage(type, std::move(name), id),

src/common/net/proto/rpc_types.h

+10 −2
Original line number Diff line number Diff line
@@ -346,9 +346,17 @@ MERCURY_GEN_PROC( 
);



/// ADM_update_adhoc_storage

MERCURY_GEN_PROC(ADM_update_adhoc_storage_in_t, ((int32_t) (reqs)))

MERCURY_GEN_PROC(

    ADM_update_adhoc_storage_in_t,

        ((ADM_adhoc_context_t)(adhoc_storage_ctx))

        ((hg_uint64_t)(server_id))

);



MERCURY_GEN_PROC(ADM_update_adhoc_storage_out_t, ((int32_t) (ret)))

MERCURY_GEN_PROC(

    ADM_update_adhoc_storage_out_t,

        ((hg_uint64_t) (op_id))

        ((hg_int32_t) (retval))

);



/// ADM_remove_adhoc_storage

MERCURY_GEN_PROC(ADM_remove_adhoc_storage_in_t, ((int32_t) (reqs)))