ProcessHistoryRegistry_t.cc File Reference

#include "boost/test/unit_test.hpp"
#include "art/Persistency/Provenance/ProcessHistoryRegistry.h"
#include "art/Version/GetReleaseVersion.h"
#include "canvas/Persistency/Provenance/ProcessHistory.h"
#include "cetlib/container_algorithms.h"
#include "fhiclcpp/ParameterSet.h"
#include "hep_concurrency/simultaneous_function_spawner.h"
#include <string>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   (ProcessHistoryRegistry_t)

Functions
	BOOST_AUTO_TEST_CASE (concurrent_insertion_reading)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (ProcessHistoryRegistry_t)

Definition at line 1 of file ProcessHistoryRegistry_t.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

concurrent_insertion_reading

)

Definition at line 37 of file ProcessHistoryRegistry_t.cc.

{
  std::vector<ProcessConfiguration> pcs;
  pcs.push_back(makeProcessConfiguration("p1", "m1"));
  pcs.push_back(makeProcessConfiguration("p2", "m2"));
  pcs.push_back(makeProcessConfiguration("pA", "mA"));
  pcs.push_back(makeProcessConfiguration("pB", "mB"));

  auto makeProcessHistory = [&pcs](std::size_t const first,
                                   std::size_t const last) {
    ProcessHistory ph;
    ph.push_back(pcs.at(first));
    ph.push_back(pcs.at(last));
    return ph;
  };

  std::vector<ProcessHistory> histories;
  histories.push_back(makeProcessHistory(0, 1));
  histories.push_back(makeProcessHistory(0, 3));
  histories.push_back(makeProcessHistory(2, 1));
  histories.push_back(makeProcessHistory(2, 3));

  // Insert histories in parallel
  {
    std::vector<std::function<void()>> tasks;
    cet::transform_all(histories, std::back_inserter(tasks), [](auto const& h) {
      return [&h] { ProcessHistoryRegistry::emplace(h.id(), h); };
    });
    hep::concurrency::simultaneous_function_spawner sfs{tasks};
  }

  BOOST_TEST_REQUIRE(ProcessHistoryRegistry::get().size() == histories.size());

  // Retrieve histories in parallel
  {
    std::vector<ProcessHistory> retrievedHistories(histories.size());
    std::vector<std::function<void()>> tasks;
    cet::for_all_with_index(
      histories,
      [&retrievedHistories, &tasks](std::size_t const i, auto const& h) {
        auto& entry = retrievedHistories[i];
        tasks.push_back([&h, &entry] {
          ProcessHistory retrievedHistory;
          ProcessHistoryRegistry::get(h.id(), retrievedHistory);
          entry = std::move(retrievedHistory);
        });
      });
    hep::concurrency::simultaneous_function_spawner sfs{tasks};
    BOOST_TEST(histories == retrievedHistories);
  }
}