kigit_orphan_registry.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.TXT for contributors.
 *
 * This program 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.
 *
 * This program 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 this program; if not, you may find one here:
 * http://www.gnu.org/licenses/gpl-3.0.html
 * or you may search the http://www.gnu.org website for the version 3 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef KIGIT_ORPHAN_REGISTRY_H_
#define KIGIT_ORPHAN_REGISTRY_H_
 
#include <import_export.h>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <utility>
#include <vector>
 
#include <wx/log.h>
 
#include <trace_helpers.h>

class APIEXPORT KIGIT_ORPHAN_REGISTRY
{
public:
    KIGIT_ORPHAN_REGISTRY();
 
    ~KIGIT_ORPHAN_REGISTRY();
 
    KIGIT_ORPHAN_REGISTRY( const KIGIT_ORPHAN_REGISTRY& ) = delete;
    KIGIT_ORPHAN_REGISTRY& operator=( const KIGIT_ORPHAN_REGISTRY& ) = delete;

    template <typename F>
    bool Register( const std::string& aLabel, F&& aWork )
    {
        auto state = std::make_shared<SHARED_STATE>();
 
        std::lock_guard<std::mutex> lock( m_mutex );
 
        if( m_shuttingDown )
            return false;
 
        reapLocked();
 
        // Reserve the slot before starting the thread so we don't leak a
        // joinable std::thread if vector growth throws; emplace the entry
        // with the state already wired up and then assign m_thread.
 
        m_entries.emplace_back();
        ENTRY& entry = m_entries.back();
        entry.m_label = aLabel;
        entry.m_created = std::chrono::steady_clock::now();
        entry.m_state = state;
 
        try
        {
            entry.m_thread = std::thread(
                    [state,
                     work = std::forward<F>( aWork ),
                     label = aLabel]() mutable
                    {
                        try
                        {
                            work();
                        }
                        catch( ... )
                        {
                            wxLogTrace( traceGit,
                                        "Orphan git thread [%s] threw an exception",
                                        label.c_str() );
                        }
 
                        {
                            std::lock_guard<std::mutex> doneLock( state->m_doneMutex );
                            state->m_done.store( true, std::memory_order_release );
                        }
 
                        state->m_doneCv.notify_all();
                    } );
        }
        catch( ... )
        {
            m_entries.pop_back();
            throw;
        }
 
        wxLogTrace( traceGit, "Registered orphan git thread [%s]", aLabel.c_str() );
        return true;
    }

    size_t TrackedCount() const;

    size_t JoinAll( std::chrono::milliseconds aTimeout );
 
private:
    struct SHARED_STATE
    {
        std::atomic<bool>                m_done{ false };
        std::mutex                       m_doneMutex;
        std::condition_variable          m_doneCv;
    };
 
    struct ENTRY
    {
        std::thread                           m_thread;
        std::string                           m_label;
        std::chrono::steady_clock::time_point m_created;
        std::shared_ptr<SHARED_STATE>         m_state;
    };
 
    // Remove finished entries by joining their threads.  Must be called
    // with m_mutex held.
    void reapLocked();
 
    mutable std::mutex           m_mutex;
    std::vector<ENTRY>           m_entries;
    bool                         m_shuttingDown = false;
};
 
#endif // KIGIT_ORPHAN_REGISTRY_H_