timer_registrar.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Rene Schmieding
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_TIMER_TIMER_REGISTRAR_H
#define MIO_TIMER_TIMER_REGISTRAR_H
 
#include "memilio/io/binary_serializer.h"
#include "memilio/io/default_serialize.h"
#include "memilio/timer/basic_timer.h"
#include "memilio/timer/registration.h"
#include "memilio/timer/table_printer.h"
#include "memilio/utils/compiler_diagnostics.h"
#include "memilio/utils/miompi.h"
 
#include <cassert>
#include <iostream>
#include <list>
#include <memory>
#include <mutex>
 
namespace mio
{
namespace timing
{
 
class TimerRegistrar
{
public:
    static TimerRegistrar& get_instance()
    {
        static TimerRegistrar t;
        return t;
    }
 
    void add_timer(TimerRegistration&& registration)
    {
        m_registration_lock.lock();
        m_register.emplace_back(std::move(registration));
        m_registration_lock.unlock();
    }
 
    const auto& get_register() const
    {
        return m_register;
    }
 
    void print_timers(std::ostream& out = std::cout) const
    {
        PRAGMA_OMP(single nowait)
        {
            m_printer->print(m_register, out);
        }
    }
 
    void print_gathered_timers(mpi::Comm comm, std::ostream& out = std::cout)
    {
        PRAGMA_OMP(single nowait)
        {
            std::list<BasicTimer> external_timers; // temporary storage for gathered registrations
            std::list<TimerRegistration> gathered_register; // combined registrations of all ranks
            gather_timers(comm, external_timers, gathered_register);
            if (mpi::is_root()) {
                m_printer->print(gathered_register, out);
            }
        }
    }
 
    void disable_final_timer_summary()
    {
        m_print_on_death = false;
    }
 
    void set_printer(std::unique_ptr<Printer>&& printer)
    {
        m_printer.swap(printer);
        // old value of m_printer (now stored in printer) is deleted at end of scope
    }
 
    TimerRegistrar(TimerRegistrar&)  = delete;
    TimerRegistrar(TimerRegistrar&&) = delete;
    void operator=(TimerRegistrar&)  = delete;
    void operator=(TimerRegistrar&&) = delete;
private:
    TimerRegistrar() = default;
 
    ~TimerRegistrar()
    {
        if (m_print_on_death) {
            PRAGMA_OMP(single nowait)
            {
                // print_timers already uses a "single nowait", but the cout for titling the table needs one, too
                std::cout << "Final Timer Summary\n";
                print_timers();
            }
        }
    }
 
    void gather_timers(mpi::Comm comm, std::list<BasicTimer>& external_timers,
                       std::list<TimerRegistration>& gathered_register) const
    {
#ifndef MEMILIO_ENABLE_MPI
        mio::unused(comm, external_timers);
#endif
        if (mpi::is_root()) {
            std::ranges::transform(m_register, std::back_inserter(gathered_register), [](const TimerRegistration& r) {
                return TimerRegistration{r.name, r.scope, r.timer, r.thread_id, 0};
            });
        }
        if (comm == nullptr) {
            if (mpi::is_root()) {
                log_error("Got nullptr as MPI Comm. Only timers on root rank are gathered.");
            }
            return;
        }
#ifdef MEMILIO_ENABLE_MPI
        // name, scope, timer, thread_id
        using GatherableRegistration = std::tuple<std::string, std::string, BasicTimer, int>;
        int comm_size;
        MPI_Comm_size(comm, &comm_size);
 
        if (mpi::is_root()) {
            for (int snd_rank = 1; snd_rank < comm_size; snd_rank++) { // skip root rank!
                int bytes_size;
                MPI_Recv(&bytes_size, 1, MPI_INT, snd_rank, 0, comm, MPI_STATUS_IGNORE);
                ByteStream bytes(bytes_size);
                MPI_Recv(bytes.data(), bytes.data_size(), MPI_BYTE, snd_rank, 0, mpi::get_world(), MPI_STATUS_IGNORE);
 
                auto rec_register = deserialize_binary(bytes, Tag<std::vector<GatherableRegistration>>{});
                if (!rec_register) {
                    log_error("Error receiving ensemble results from rank {}.", snd_rank);
                }
                std::ranges::transform(
                    rec_register.value(), std::back_inserter(gathered_register), [&](const GatherableRegistration& r) {
                        const auto& [name, scope, timer, thread_id] = r;
                        external_timers.push_back(timer);
                        return TimerRegistration{name, scope, external_timers.back(), thread_id, snd_rank};
                    });
            }
        }
        else {
            std::vector<GatherableRegistration> snd_register;
            std::ranges::transform(m_register, std::back_inserter(snd_register), [](const TimerRegistration& r) {
                return GatherableRegistration{r.name, r.scope, r.timer, r.thread_id};
            });
            ByteStream bytes = serialize_binary(snd_register);
            int bytes_size   = int(bytes.data_size());
            MPI_Send(&bytes_size, 1, MPI_INT, 0, 0, comm);
            MPI_Send(bytes.data(), bytes.data_size(), MPI_BYTE, 0, 0, comm);
        }
#endif
    }
 
    std::unique_ptr<Printer> m_printer = std::make_unique<TablePrinter>(); 
    bool m_print_on_death              = true; 
    std::list<TimerRegistration> m_register; 
    std::mutex m_registration_lock; 
};
 
} // namespace timing
} // namespace mio
 
#endif // MIO_TIMER_TIMER_REGISTRAR_H