DotManager Class Reference

Singleton that manages parallel dot invocations and patching files for embedding image maps. More...

#include <src/dot.h>

Collaboration diagram for DotManager:

Public Member Functions
DotRunner *	createRunner (const QCString &absDotName, const QCString &md5Hash)
DotFilePatcher *	createFilePatcher (const QCString &fileName)
bool	run ()

Static Public Member Functions
static DotManager *	instance ()

Private Member Functions
	DotManager ()
virtual	~DotManager ()

Private Attributes
std::map< std::string, std::unique_ptr< DotRunner > >	m_runners
std::map< std::string, DotFilePatcher >	m_filePatchers
ThreadPool	m_workers

Detailed Description

Singleton that manages parallel dot invocations and patching files for embedding image maps.

Definition at line 34 of file dot.h.

Constructor & Destructor Documentation

DotManager()

DotManager::DotManager ( )

private

Definition at line 84 of file dot.cpp.

                       : m_runners(), m_filePatchers(), m_workers(static_cast<size_t>(Config_getInt(DOT_NUM_THREADS)))
{
}

References Config_getInt, m_filePatchers, m_runners, and m_workers.

Referenced by instance().

~DotManager()

DotManager::~DotManager ( )

privatevirtual

Definition at line 88 of file dot.cpp.

{
}

Member Function Documentation

createFilePatcher()

DotFilePatcher * DotManager::createFilePatcher

(

const QCString &

fileName

)

Definition at line 116 of file dot.cpp.

{
  std::lock_guard<std::mutex> lock(g_dotManagerMutex);
  auto patcher = m_filePatchers.find(fileName.str());
 
  if (patcher != m_filePatchers.end()) return &(patcher->second);
 
  auto rv = m_filePatchers.emplace(fileName.str(), fileName);
  assert(rv.second);
  return &(rv.first->second);
}

References g_dotManagerMutex, m_filePatchers, and QCString::str().

createRunner()

DotRunner * DotManager::createRunner	(	const QCString &	absDotName,
		const QCString &	md5Hash )

Definition at line 92 of file dot.cpp.

{
  std::lock_guard<std::mutex> lock(g_dotManagerMutex);
  DotRunner* rv = nullptr;
  auto const runit = m_runners.find(absDotName.str());
  if (runit == m_runners.end())
  {
    auto insobj = std::make_unique<DotRunner>(absDotName, md5Hash);
    rv = insobj.get();
    m_runners.emplace(absDotName.str(), std::move(insobj));
  }
  else
  {
    // we have a match
    if (md5Hash != runit->second->getMd5Hash())
    {
      err("md5 hash does not match for two different runs of {} !\n", absDotName);
    }
    rv = runit->second.get();
  }
  assert(rv);
  return rv;
}

References err, g_dotManagerMutex, m_runners, and QCString::str().

Referenced by DotGraph::prepareDotFile().

instance()

DotManager * DotManager::instance ( )

static

Definition at line 78 of file dot.cpp.

{
  static DotManager theInstance;
  return &theInstance;
}

References DotManager().

Referenced by DotGraph::generateCode(), generateOutput(), DotGraph::prepareDotFile(), and DotLegendGraph::writeGraph().

run()

bool DotManager::run

(

)

Definition at line 128 of file dot.cpp.

{
  size_t numDotRuns = m_runners.size();
  size_t numFilePatchers = m_filePatchers.size();
  if (numDotRuns+numFilePatchers>1)
  {
    if (Config_getInt(DOT_NUM_THREADS)<=1)
    {
      msg("Generating dot graphs in single threaded mode...\n");
    }
    else
    {
      msg("Generating dot graphs using {:d} parallel threads...\n",Config_getInt(DOT_NUM_THREADS));
    }
  }
  size_t i=1;
 
  bool setPath=FALSE;
  if (Config_getBool(GENERATE_HTML))
  {
    setDotFontPath(Config_getString(HTML_OUTPUT));
    setPath=TRUE;
  }
  else if (Config_getBool(GENERATE_LATEX))
  {
    setDotFontPath(Config_getString(LATEX_OUTPUT));
    setPath=TRUE;
  }
  else if (Config_getBool(GENERATE_RTF))
  {
    setDotFontPath(Config_getString(RTF_OUTPUT));
    setPath=TRUE;
  }
  else if (Config_getBool(GENERATE_DOCBOOK))
  {
    setDotFontPath(Config_getString(DOCBOOK_OUTPUT));
    setPath=TRUE;
  }
  // fill work queue with dot operations
  size_t prev=1;
  if (Config_getInt(DOT_NUM_THREADS)<=1) // no threads to work with
  {
    for (auto & dr : m_runners)
    {
      msg("Running dot for graph {}/{}\n",prev,numDotRuns);
      dr.second->run();
      prev++;
    }
  }
  else // use multiple threads to run instances of dot in parallel
  {
    std::vector< std::future<void> > results;
    for (auto & dr: m_runners)
    {
      DotRunner *runner = dr.second.get();
      auto process = [runner]()
      {
        runner->run();
      };
      results.emplace_back(m_workers.queue(process));
    }
    for (auto &f : results)
    {
      f.get();
      msg("Running dot for graph {}/{}\n",prev,numDotRuns);
      prev++;
    }
  }
  if (setPath)
  {
    unsetDotFontPath();
  }
 
  // patch the output file and insert the maps and figures
  i=1;
  // since patching the svg files may involve patching the header of the SVG
  // (for zoomable SVGs), and patching the .html files requires reading that
  // header after the SVG is patched, we first process the .svg files and
  // then the other files.
  for (auto & fp : m_filePatchers)
  {
    if (fp.second.isSVGFile())
    {
      msg("Patching output file {}/{}\n",i,numFilePatchers);
      if (!fp.second.run()) return FALSE;
      i++;
    }
  }
  for (auto& fp : m_filePatchers)
  {
    if (!fp.second.isSVGFile())
    {
      msg("Patching output file {}/{}\n",i,numFilePatchers);
      if (!fp.second.run()) return FALSE;
      i++;
    }
  }
  return TRUE;
}

References Config_getBool, Config_getInt, Config_getString, FALSE, m_filePatchers, m_runners, m_workers, msg, DotRunner::run(), setDotFontPath(), TRUE, and unsetDotFontPath().

Referenced by generateOutput().

Member Data Documentation

m_filePatchers

std::map<std::string, DotFilePatcher> DotManager::m_filePatchers

private

Definition at line 48 of file dot.h.

Referenced by createFilePatcher(), DotManager(), and run().

m_runners

std::map<std::string, std::unique_ptr<DotRunner> > DotManager::m_runners

private

Definition at line 47 of file dot.h.

Referenced by createRunner(), DotManager(), and run().

m_workers

ThreadPool DotManager::m_workers

private

Definition at line 49 of file dot.h.

Referenced by DotManager(), and run().

---

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

• src/dot.h
• src/dot.cpp