Verified Commit 6997821b authored by Alberto Miranda's avatar Alberto Miranda ♨️
Browse files

scord: Refactor internal types

parent c0807ec1

src/common/abt_cxx/shared_mutex.hpp

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
 *****************************************************************************/



#include <cassert>

#include <vector>

#include <abt.h>

#include <fmt/format.h>

src/scord/CMakeLists.txt

+2 −1
Original line number Diff line number Diff line
@@ -27,7 +27,8 @@ add_executable(scord) 


target_sources(scord PRIVATE scord.cpp rpc_handlers.hpp

  rpc_handlers.cpp job_manager.hpp adhoc_storage_manager.hpp

  pfs_storage_manager.hpp ${CMAKE_CURRENT_BINARY_DIR}/defaults.hpp)

  pfs_storage_manager.hpp ${CMAKE_CURRENT_BINARY_DIR}/defaults.hpp

  internal_types.hpp internal_types.cpp)



configure_file(defaults.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/defaults.hpp @ONLY)

src/scord/internal_types.cpp

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

 * Copyright 2021-2023, 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

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



#include <abt_cxx/shared_mutex.hpp>

#include <algorithm>

#include "internal_types.hpp"





namespace scord::internal {



job_info::job_info(scord::job job, scord::job::resources resources,

                   scord::job::requirements requirements)

    : m_job(std::move(job)), m_resources(std::move(resources)),

      m_requirements(std::move(requirements)) {}



scord::job

job_info::job() const {

    return m_job;

}



std::optional<scord::job::resources>

job_info::resources() const {

    return m_resources;

}



void

job_info::update(scord::job::resources resources) {

    m_resources = std::move(resources);

}



adhoc_storage_info::adhoc_storage_info(scord::adhoc_storage adhoc_storage)

    : m_adhoc_storage(std::move(adhoc_storage)) {}



scord::adhoc_storage

adhoc_storage_info::adhoc_storage() const {

    return m_adhoc_storage;

}



void

adhoc_storage_info::update(scord::adhoc_storage::resources new_resources) {

    m_adhoc_storage.update(std::move(new_resources));

}



scord::error_code

adhoc_storage_info::add_client_info(

        std::shared_ptr<scord::internal::job_info> job_info) {



    scord::abt::unique_lock lock(m_info_mutex);



    if(m_client_info) {

        LOGGER_ERROR("adhoc storage {} already has a client",

                     m_adhoc_storage.id());

        return error_code::adhoc_in_use;

    }



    m_client_info = std::move(job_info);



    return error_code::success;

}



void

adhoc_storage_info::remove_client_info() {

    scord::abt::unique_lock lock(m_info_mutex);

    m_client_info.reset();

}



std::shared_ptr<scord::internal::job_info>

adhoc_storage_info::client_info() const {

    scord::abt::shared_lock lock(m_info_mutex);

    return m_client_info;

}



pfs_storage_info::pfs_storage_info(scord::pfs_storage pfs_storage)

    : m_pfs_storage(std::move(pfs_storage)) {}



scord::pfs_storage

pfs_storage_info::pfs_storage() const {

    return m_pfs_storage;

}



void

pfs_storage_info::update(scord::pfs_storage::ctx pfs_context) {

    m_pfs_storage.update(std::move(pfs_context));

}



} // namespace scord::internal

src/scord/internal_types.hpp

+16 −52
Original line number Diff line number Diff line
@@ -26,27 +26,22 @@ 
#ifndef SCORD_INTERNAL_TYPES_HPP

#define SCORD_INTERNAL_TYPES_HPP



#include <abt_cxx/shared_mutex.hpp>

#include <optional>

#include <logger/logger.hpp>

#include <scord/types.hpp>



namespace scord::internal {



struct job_info {

    explicit job_info(scord::job job) : m_job(std::move(job)) {}



    job_info(scord::job job, scord::job::resources resources,

             scord::job::requirements requirements)

        : m_job(std::move(job)), m_resources(std::move(resources)),

          m_requirements(std::move(requirements)) {}

             scord::job::requirements requirements);



    scord::job

    job() const {

        return m_job;

    }

    job() const;



    std::optional<scord::job::resources>

    resources() const {

        return m_resources;

    }

    resources() const;



    std::optional<scord::job::requirements>

    requirements() const {
@@ -54,9 +49,7 @@ struct job_info { 
    }



    void

    update(scord::job::resources resources) {

        m_resources = std::move(resources);

    }

    update(scord::job::resources resources);



    scord::job m_job;

    std::optional<scord::job::resources> m_resources;
@@ -65,46 +58,22 @@ struct job_info { 


struct adhoc_storage_info {



    explicit adhoc_storage_info(scord::adhoc_storage adhoc_storage)

        : m_adhoc_storage(std::move(adhoc_storage)) {}

    explicit adhoc_storage_info(scord::adhoc_storage adhoc_storage);



    scord::adhoc_storage

    adhoc_storage() const {

        return m_adhoc_storage;

    }

    adhoc_storage() const;



    void

    update(scord::adhoc_storage::resources new_resources) {

        m_adhoc_storage.update(std::move(new_resources));

    }

    update(scord::adhoc_storage::resources new_resources);



    scord::error_code

    add_client_info(std::shared_ptr<scord::internal::job_info> job_info) {



        scord::abt::unique_lock lock(m_info_mutex);



        if(m_client_info) {

            LOGGER_ERROR("adhoc storage {} already has a client",

                         m_adhoc_storage.id());

            return error_code::adhoc_in_use;

        }



        m_client_info = std::move(job_info);



        return error_code::success;

    }

    add_client_info(std::shared_ptr<scord::internal::job_info> job_info);



    void

    remove_client_info() {

        scord::abt::unique_lock lock(m_info_mutex);

        m_client_info.reset();

    }

    remove_client_info();



    std::shared_ptr<scord::internal::job_info>

    client_info() const {

        scord::abt::shared_lock lock(m_info_mutex);

        return m_client_info;

    }

    client_info() const;



    scord::adhoc_storage m_adhoc_storage;

    std::shared_ptr<scord::internal::job_info> m_client_info;
@@ -113,18 +82,13 @@ struct adhoc_storage_info { 


struct pfs_storage_info {



    explicit pfs_storage_info(scord::pfs_storage pfs_storage)

        : m_pfs_storage(std::move(pfs_storage)) {}

    explicit pfs_storage_info(scord::pfs_storage pfs_storage);



    scord::pfs_storage

    pfs_storage() const {

        return m_pfs_storage;

    }

    pfs_storage() const;



    void

    update(scord::pfs_storage::ctx pfs_context) {

        m_pfs_storage.update(std::move(pfs_context));

    }

    update(scord::pfs_storage::ctx pfs_context);



    scord::pfs_storage m_pfs_storage;

    std::shared_ptr<scord::internal::job_info> m_client_info;