SharingStrategy.hpp

#pragma once
 
#include "SharingEntity.hpp"
#include "containers/ClauseDatabase.hpp"
#include "sharing/SharingStatistics.hpp"
#include "utils/Logger.hpp"
#include <algorithm>
#include <atomic>
#include <memory>
#include <mutex>
#include <set>
 
 
class SharingStrategy : public SharingEntity
{
  public:
    SharingStrategy(const std::vector<std::shared_ptr<SharingEntity>>& producers,
                    const std::vector<std::shared_ptr<SharingEntity>>& consumers,
                    const std::shared_ptr<ClauseDatabase>& clauseDB)
        : SharingEntity(consumers)
        , m_producers(producers.begin(), producers.end())
        , m_clauseDB(clauseDB)
    {
        LOGDEBUG1("Be sure to call connectConstructorProducers after construction, this is due to the base class "
                "shared_from_this.");
    }
 
    virtual ~SharingStrategy() {}
 
    virtual bool doSharing() = 0;
 
    virtual std::chrono::microseconds getSleepingTime() { return std::chrono::microseconds(__globalParameters__.sharingSleep); };
 
    virtual void printStats()
    {
        LOGSTAT("Strategy Basic Stats: receivedCls %d, sharedCls %d, filteredAtImport: %d",
                stats.receivedClauses.load(),
                stats.sharedClauses,
                stats.filteredAtImport.load());
    }
 
    void connectConstructorProducers()
    {
        std::shared_lock<std::shared_mutex> lock(m_producersMutex);
        for (auto& weakProducer : m_producers) {
            if (auto producer = weakProducer.lock())
                producer->addClient(shared_from_this());
        }
    }
 
    virtual void addProducer(std::shared_ptr<SharingEntity> producer)
    {
        std::unique_lock<std::shared_mutex> lock(m_producersMutex);
        m_producers.push_back(producer);
        LOGDEBUG2("[SharingStrategy] Added new producer");
    }
 
    virtual void connectProducer(std::shared_ptr<SharingEntity> producer)
    {
        producer->addClient(shared_from_this());
        LOGDEBUG2("[SharingStrategy] Producer %u is connected!", producer->getSharingId());
    }
 
    virtual void removeProducer(std::shared_ptr<SharingEntity> producer)
    {
        std::unique_lock<std::shared_mutex> lock(m_producersMutex);
        producer->removeClient(shared_from_this());
        m_producers.erase(
            std::remove_if(m_producers.begin(),
                           m_producers.end(),
                           [&producer](const std::weak_ptr<SharingEntity>& wp) { return wp.lock() == producer; }),
            m_producers.end());
        LOGDEBUG2("[SharingStrategy] Removed producer");
    }
 
  protected:
    bool exportClauseToClient(const ClauseExchangePtr& clause, std::shared_ptr<SharingEntity> client) override
    {
        if (clause->from != client->getSharingId())
            return client->importClause(clause);
        else
            return false;
    }
 
    std::shared_ptr<ClauseDatabase> m_clauseDB;
 
    SharingStatistics stats;
 
    /* Producers Management */
 
    std::vector<std::weak_ptr<SharingEntity>> m_producers;
 
    mutable std::shared_mutex m_producersMutex;
};