segregate.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: yes (from src/graphtool/segregate.cpp to apps/graphtool/segregate.cpp).
 
/*
 * segregate.cpp
 *
 *  Created on: 14 Jun 2016
 *      Author: Leonidas Georgopoulos
 */
 
#include "dbe/segregate.hpp"
#include "dbe/dbcontroller.hpp"
 
#include <boost/graph/connected_components.hpp>
#include <boost/graph/filtered_graph.hpp>
 
#include <array>
#include <future>
 
#define GTOOL_MAX_THREADS 10
 
namespace dbe {
namespace tool {
namespace graph {
 
segregated_graph_write::segregated_graph_write(std::string const& oprfx, size_t const minc, size_t const maxc)
  : this_dest_prefix(oprfx)
  , this_min_component_size(minc)
  , this_max_component_size(maxc)
{
}
 
int
segregated_graph_write::operator()(gtool const& tool) const
{
  typedef long unsigned int t_int;
  gtool::t_graph const& G = tool.getgraph();
  std::vector<t_int> compindices(boost::num_vertices(G));
  t_int total_connected = boost::connected_components(G, &compindices[0]);
 
  std::vector<gtool::t_graph> components(total_connected);
  std::vector<gtool::t_registry> component_registries(total_connected);
 
  // Build the components as seperate graphs
  for (t_int vector_i = 0; vector_i != compindices.size(); ++vector_i) {
    t_int component_j = compindices[vector_i];
    std::string oname = boost::get(&gtool::vertex_label::uid, G)[vector_i];
    std::string cname = boost::get(&gtool::vertex_label::cname, G)[vector_i];
    gtool::add_object_and_friends(
      components[component_j], dbe::inner::dbcontroller::get({ oname, cname }), component_registries[component_j]);
  }
 
  // from the graphs built output only those that are within the range specified
 
  int max_punits = GTOOL_MAX_THREADS;
 
  std::vector<std::future<void>> punits;
 
  unsigned long long int c = 0;
 
  for (auto const& g : components) {
    size_t const component_size = g.vertex_set().size();
 
    if (component_size > this_min_component_size and component_size < this_max_component_size) {
      if (--max_punits) {
        std::string output_file{ this_dest_prefix + std::string("_") + std::to_string(++c) + std::string(".dot") };
 
        try {
          punits.push_back(std::async(std::launch::async, graph::write, g, output_file));
        } catch (std::system_error const& e) {
          if (e.code() == std::errc::resource_unavailable_try_again) {
 
            ERROR("Could not launch another thread", e.what(), "for file:", output_file, "try to launch in deferred");
 
            punits.push_back(std::async(std::launch::deferred, graph::write, g, output_file));
 
            WARN("File write policy change",
                 "Program execution correction",
                 " for file:",
                 output_file,
                 " launched in deferred");
 
          } else {
            throw e;
          }
        }
      } else {
        // The standard dictates ( C++11 ) that wait is called on the destructor
        // and the futures launched are either async or defered, which puts them
        // always in a valid state. All that is needed to do is clear the vector
        // of futures to initiate calling the destructors.
        punits.clear();
        max_punits = GTOOL_MAX_THREADS;
      }
    }
  }
 
  return EXIT_SUCCESS;
}
 
} /* namespace graph */
} /* namespace tool */
} /* namespace dbe */