Merge pull request #55 from art-daq/eflumerf/ClangFormat

Apply clang-format to all source files

artdaq-core/Core/SharedMemoryManager.cc

@@ -315,7 +315,7 @@ int artdaq::SharedMemoryManager::GetBufferForReading()
 		{
 			buffer_num = (ii + rp) % shm_ptr_->buffer_count;
 
-			//TLOG(TLVL_GETBUFFER + 1) << "Checking if buffer " << buffer_num << " is stale. Shm destructive_read_mode=" << shm_ptr_->destructive_read_mode;
+			// TLOG(TLVL_GETBUFFER + 1) << "Checking if buffer " << buffer_num << " is stale. Shm destructive_read_mode=" << shm_ptr_->destructive_read_mode;
 			ResetBuffer(buffer_num);
 
 			auto buf = getBufferInfo_(buffer_num);
@@ -331,7 +331,7 @@ int artdaq::SharedMemoryManager::GetBufferForReading()
 			{
 				TLOG(TLVL_GETBUFFER + 1) << "ID " << manager_id_ << " Buffer " << buffer_num << ": sem=" << FlagToString(semaphore.flags)
 				                         << " (looking for " << FlagToString(BufferSemaphoreFlags::Full) << "), sem_id=" << semaphore.id << ", seq_id=" << sequence_id << ", last_seen_id_=" << last_seen_id_;
-                // Claim the buffer if it is in my sequence, I haven't claimed buffers before, or if we are in Broadcast mode
+				// Claim the buffer if it is in my sequence, I haven't claimed buffers before, or if we are in Broadcast mode
 				if (last_seen_id_ == 0 || !shm_ptr_->destructive_read_mode || sequence_id % reader_count == last_seen_id_ % reader_count || sequence_id + reader_count < last_seen_id_)
 				{
 					buffer_ptr = buf;
@@ -356,11 +356,11 @@ int artdaq::SharedMemoryManager::GetBufferForReading()
 
 					TLOG(TLVL_GETBUFFER) << "Returning " << buffer_num;
 					return buffer_num;
-                }
+				}
 			}
 		}
 
-        if (buffer_ptr == nullptr)
+		if (buffer_ptr == nullptr)
 		{
 			continue;
 		}
@@ -681,18 +681,18 @@ std::deque<int> artdaq::SharedMemoryManager::GetBuffersOwnedByManager()
 		return output;
 	}
 	TLOG(TLVL_BUFFER) << "GetBuffersOwnedByManager BEGIN";
-		for (size_t ii = 0; ii < buffer_count; ++ii)
+	for (size_t ii = 0; ii < buffer_count; ++ii)
+	{
+		auto buf = getBufferInfo_(ii);
+		if (buf == nullptr)
 		{
-			auto buf = getBufferInfo_(ii);
-			if (buf == nullptr)
-			{
-				continue;
-			}
-			if (buf->semaphore.load().id == manager_id_)
-			{
-				output.push_back(ii);
-			}
+			continue;
 		}
+		if (buf->semaphore.load().id == manager_id_)
+		{
+			output.push_back(ii);
+		}
+	}
 
 	TLOG(TLVL_BUFFER) << "GetBuffersOwnedByManager: own " << output.size() << " / " << buffer_count << " buffers.";
 	return output;

artdaq-core/Core/SharedMemoryManager.hh

@@ -327,11 +327,11 @@ public:
 	 */
 	size_t GetBufferCount() const { return IsValid() ? shm_ptr_->next_sequence_id : 0; }
 
-    /**
-     * \brief Get the number of reader instances connected to the Shared Memory
-     * \return The number of attached readers, as reported by the readers
-     */
-    int GetReaderCount() { return IsValid() ? shm_ptr_->reader_count.load() : 0; }
+	/**
+	 * \brief Get the number of reader instances connected to the Shared Memory
+	 * \return The number of attached readers, as reported by the readers
+	 */
+	int GetReaderCount() { return IsValid() ? shm_ptr_->reader_count.load() : 0; }
 	/**
 	 * \brief Gets the highest buffer number either written or read by this SharedMemoryManager
 	 * \return The highest buffer id written or read by this SharedMemoryManager
@@ -398,16 +398,16 @@ private:
 	SharedMemoryManager& operator=(SharedMemoryManager const&) = delete;
 	SharedMemoryManager& operator=(SharedMemoryManager&&) = delete;
 
-    struct ShmBufferSem
-    {
+	struct ShmBufferSem
+	{
 		BufferSemaphoreFlags flags;
 		int id;
 
-        ShmBufferSem()
-		    : flags(BufferSemaphoreFlags::Empty), id(-1){}
-        ShmBufferSem(BufferSemaphoreFlags f, int i)
+		ShmBufferSem()
+		    : flags(BufferSemaphoreFlags::Empty), id(-1) {}
+		ShmBufferSem(BufferSemaphoreFlags f, int i)
 		    : flags(f), id(i) {}
-    };
+	};
 
 	struct ShmBuffer
 	{

artdaq-core/Data/ArtdaqMetadata.hh

@@ -14,7 +14,7 @@ struct ArtdaqMetadata;
  */
 struct artdaq::ArtdaqMetadata
 {
-	int rank{-1};                     ///< Rank of the producing artdaq process
+	int rank{-1};                          ///< Rank of the producing artdaq process
 	std::vector<uint16_t> fragment_ids{};  ///< Fragment IDs of the generating process (if any)
 	std::string metadata_tag{};            ///< User-defined tag, to help decoding the metadata_string
 	std::string metadata_string{};         ///< Unstructured string data

artdaq-core/Data/ContainerFragmentLoader.hh

@@ -194,7 +194,6 @@ inline void artdaq::ContainerFragmentLoader::addFragment(artdaq::Fragment& frag,
 	reset_index_ptr_();
 }
 
-
 inline void artdaq::ContainerFragmentLoader::addFragments(artdaq::Fragments& frags, bool allowDifferentTypes)
 {
 	TLOG(TLVL_DEBUG + 33, "ContainerFragmentLoader") << "addFragments: Adding " << frags.size() << " Fragments to Container";

artdaq-core/Data/MetadataFragment.cc

@@ -5,13 +5,13 @@ artdaq::ArtdaqMetadata artdaq::MetadataFragment::get_metadata()
 	ArtdaqMetadata output;
 
 	auto ptr = reinterpret_cast<uint8_t const*>(artdaq_fragment_.dataBeginBytes());
-	
+
 	size_t element_size = *reinterpret_cast<size_t const*>(ptr);
 	ptr += sizeof(size_t);
 	assert(element_size == sizeof(output.rank));
 	output.rank = *reinterpret_cast<int const*>(ptr);
 	ptr += element_size;
-	
+
 	element_size = *reinterpret_cast<size_t const*>(ptr);
 	ptr += sizeof(size_t);
 	assert(element_size % sizeof(uint16_t) == 0);

artdaq-core/Data/MetadataFragment.hh

@@ -1,8 +1,8 @@
 #ifndef artdaq_core_Data_MetadataFragment_hh
 #define artdaq_core_Data_MetadataFragment_hh
 
-#include "artdaq-core/Data/Fragment.hh"
 #include "artdaq-core/Data/ArtdaqMetadata.hh"
+#include "artdaq-core/Data/Fragment.hh"
 
 namespace artdaq {
 class MetadataFragment;
@@ -12,7 +12,7 @@ class artdaq::MetadataFragment
 {
 public:
 	explicit MetadataFragment(artdaq::Fragment const& frag)
-	    : artdaq_fragment_(frag){}
+	    : artdaq_fragment_(frag) {}
 
 	ArtdaqMetadata get_metadata();
 

artdaq-core/Data/classes.h

@@ -1,8 +1,8 @@
 #include <vector>
 #include "artdaq-core/Core/QuickVec.hh"
+#include "artdaq-core/Data/ArtdaqMetadata.hh"
 #include "artdaq-core/Data/Fragment.hh"
 #include "artdaq-core/Data/PackageBuildInfo.hh"
 #include "artdaq-core/Data/RawEvent.hh"
 #include "artdaq-core/Data/detail/ParentageMap.hh"
-#include "artdaq-core/Data/ArtdaqMetadata.hh"
 #include "canvas/Persistency/Common/Wrapper.h"

artdaq-core/Plugins/FragmentNameHelper.hh

@@ -169,7 +169,8 @@ public:
 		else
 		{
 			auto systemTypes = artdaq::Fragment::MakeVerboseSystemTypeMap();
-			if (systemTypes.count(fragment.type())) {
+			if (systemTypes.count(fragment.type()))
+			{
 				TLOG(TLVL_DEBUG + 33) << "Matched fragment type " << static_cast<int>(fragment.type()) << " to extended system type " << systemTypes.at(fragment.type());
 				instance_name = systemTypes.at(fragment.type());
 			}

artdaq-core/Utilities/configureMessageFacility.cc

@@ -33,7 +33,7 @@ std::string artdaq::generateMessageFacilityConfiguration(char const* progname, b
 	char* logFhiclCode = getenv("ARTDAQ_LOG_FHICL");
 	char* artdaqMfextensionsDir = getenv("ARTDAQ_MFEXTENSIONS_DIR");
 	char* useMFExtensionsS = getenv("ARTDAQ_MFEXTENSIONS_ENABLED");
-	char* run_number            = getenv("ARTDAQ_RUN_NUMBER");
+	char* run_number = getenv("ARTDAQ_RUN_NUMBER");
 	bool useMFExtensions = false;
 	if (useMFExtensionsS != nullptr && !(strncmp(useMFExtensionsS, "0", 1) == 0))
 	{
@@ -109,20 +109,24 @@ std::string artdaq::generateMessageFacilityConfiguration(char const* progname, b
 	{
 		ss << " file: {";
 		ss << R"( type: "GenFile" threshold: "DEBUG" seperator: "-")";
-    //  ss << " pattern: \"" << progname << fileExtraName << "-%?H%t-%p.log"
-    //     << "\"";
-    if (run_number == nullptr) {
-      ss << " pattern: \"" << progname << fileExtraName << "-%?H%t-%p.log" << "\"";
-    }
-    else {
-//-----------------------------------------------------------------------------
-// Mu2e case: run number is defined
-//-----------------------------------------------------------------------------
-      char c[10];
-      sprintf(c,"%06i",std::stoi(run_number));
-      ss << " pattern: \"" << progname << "-" << c << fileExtraName << "-%?H%t-%p.log" << "\"";
-    }
-
+		//  ss << " pattern: \"" << progname << fileExtraName << "-%?H%t-%p.log"
+		//     << "\"";
+		if (run_number == nullptr)
+		{
+			ss << " pattern: \"" << progname << fileExtraName << "-%?H%t-%p.log"
+			   << "\"";
+		}
+		else
+		{
+			//-----------------------------------------------------------------------------
+			// Mu2e case: run number is defined
+			//-----------------------------------------------------------------------------
+			char c[10];
+			sprintf(c, "%06i", std::stoi(run_number));
+			ss << " pattern: \"" << progname << "-" << c << fileExtraName << "-%?H%t-%p.log"
+			   << "\"";
+		}
+
 		ss << " timestamp_pattern: \"%Y%m%d%H%M%S\"";
 		ss << " directory: \"" << logfileDir << "\"";
 		ss << " append : false";

test/Core/SharedMemoryManager_t.cc

@@ -360,7 +360,7 @@ BOOST_AUTO_TEST_CASE(RoundRobin)
 	uint8_t data[0x1000];
 	std::generate_n(data, 0x1000, [&]() { return ++n; });
 
-    const int reader_count = 10;
+	const int reader_count = 10;
 	const size_t n_writes = 1'000'000;
 
 	auto reader_proc = [key, reader_count]() {
@@ -371,11 +371,12 @@ BOOST_AUTO_TEST_CASE(RoundRobin)
 		artdaq::SharedMemoryManager reader_man(key);
 		auto my_id = static_cast<size_t>(reader_man.GetMyId() - 1);
 
-        TLOG(TLVL_INFO) << "Reader " << my_id << " waiting for other readers..." << reader_man.GetReaderCount();
-        while (reader_man.GetReaderCount() < reader_count) {
+		TLOG(TLVL_INFO) << "Reader " << my_id << " waiting for other readers..." << reader_man.GetReaderCount();
+		while (reader_man.GetReaderCount() < reader_count)
+		{
 			reader_man.ReadyForRead();
 			std::this_thread::yield();
-        }
+		}
 
 		TLOG(TLVL_INFO) << "Reader " << my_id << " starting";
 		while (!reader_man.IsEndOfData())
@@ -403,21 +404,23 @@ BOOST_AUTO_TEST_CASE(RoundRobin)
 		TLOG(TLVL_INFO) << "Reader " << my_id << " read " << counter << " buffers, " << ooo_counter << " of them were out of round-robin order, and " << misses_after_start << " times there was no data available";
 	};
 
-    auto writer_proc = [&man, n_writes]() {
+	auto writer_proc = [&man, n_writes]() {
 		TLOG(TLVL_INFO) << "Writer Starting";
 		size_t write_counter = 0;
 		auto current_oom = 1;
 		auto start_time = std::chrono::steady_clock::now();
-		while (write_counter < n_writes) {
+		while (write_counter < n_writes)
+		{
 			if (man.ReadyForWrite(false))
 			{
-                if (write_counter % current_oom == 0) {
+				if (write_counter % current_oom == 0)
+				{
 					TLOG(TLVL_INFO) << "Writing buffer " << write_counter;
 					if (write_counter >= static_cast<size_t>((10 * current_oom) - 1))
 					{
 						current_oom *= 10;
-                    }
-                }
+					}
+				}
 				int buf = man.GetBufferForWriting(false);
 				man.MarkBufferFull(buf);
 				write_counter++;
@@ -430,18 +433,20 @@ BOOST_AUTO_TEST_CASE(RoundRobin)
 		TLOG(TLVL_INFO) << "Writer proc END";
 	};
 
-    TLOG(TLVL_INFO) << "Starting threads";
-    std::vector<std::jthread> threads;
-    for (int ii = 0; ii < reader_count; ++ii) {
+	TLOG(TLVL_INFO) << "Starting threads";
+	std::vector<std::jthread> threads;
+	for (int ii = 0; ii < reader_count; ++ii)
+	{
 		threads.emplace_back(reader_proc);
-    }
+	}
 	threads.emplace_back(writer_proc);
 
-    TLOG(TLVL_INFO) << "Joining threads";
-    threads[threads.size() - 1].join();
-    for (auto& thread : threads) {
-		if(thread.joinable()) thread.join();
-    }
+	TLOG(TLVL_INFO) << "Joining threads";
+	threads[threads.size() - 1].join();
+	for (auto& thread : threads)
+	{
+		if (thread.joinable()) thread.join();
+	}
 
 	TLOG(TLVL_DEBUG) << "END TEST RoundRobin";
 }