dbe::tool::graph::segregated_graph_write Class Reference

#include <segregate.hpp>

Public Member Functions
	segregated_graph_write (std::string const &ofn_prefix, size_t const minc=0, size_t const maxc=0)
int	operator() (gtool const &) const

Private Attributes
std::string const	this_dest_prefix
size_t const	this_min_component_size
size_t const	this_max_component_size

Detailed Description

Definition at line 23 of file segregate.hpp.

Constructor & Destructor Documentation

segregated_graph_write()

dbe::tool::graph::segregated_graph_write::segregated_graph_write	(	std::string const &	ofn_prefix,
		size_t const	minc = 0,
		size_t const	maxc = 0 )

Construct an object from the filename prefix ,the mininimum and maximum size components to be included in the output. Separate files are generated for it component

Parameters

ofn	is an std::string of the filename prefix
minc	is the minimum size for a component to be considered
maxc	is the maximum sized component to be included in the output

Definition at line 28 of file segregate.cpp.

  : this_dest_prefix(oprfx)
  , this_min_component_size(minc)
  , this_max_component_size(maxc)
{
}

Member Function Documentation

operator()()

int dbe::tool::graph::segregated_graph_write::operator()

(

gtool const &

tool

)

const

Definition at line 36 of file segregate.cpp.

{
  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;
}

Member Data Documentation

this_dest_prefix

std::string const dbe::tool::graph::segregated_graph_write::this_dest_prefix

private

Definition at line 39 of file segregate.hpp.

this_max_component_size

size_t const dbe::tool::graph::segregated_graph_write::this_max_component_size

private

Definition at line 41 of file segregate.hpp.

this_min_component_size

size_t const dbe::tool::graph::segregated_graph_write::this_min_component_size

private

Definition at line 40 of file segregate.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/segregate.hpp
• /github/workspace/dunedaq/sourcecode/dbe/apps/graphtool/segregate.cpp