Manages the internal state storage buffers for a processor. More...

#include <ProcessorInternalStateBufferManager.hpp>

Collaboration diagram for tpglibs::ProcessorInternalStateBufferManager< T >:

Public Types
using	signal_t = T
	Signal type to use. Generally __m256i or std::array<int16_t, 16>;.

Public Member Functions
	ProcessorInternalStateBufferManager ()
	Constructor.
	~ProcessorInternalStateBufferManager ()
	Destructor.
void	write_to_active_buffer ()
	Write to the active buffer.
ProcessorMetricArray< signal_t >	switch_buffer_and_read ()
	Read from the inactive buffer.
ProcessorMetricArray< std::array< int16_t, 16 > >	switch_buffer_and_read_casted ()
	Read from the inactive buffer and cast to std::array<int16_t, 16>.
void	configure_from_registry (ProcessorInternalStateNameRegistry< signal_t > *registry)
	Configure and allocate correct buffer storage given the configuration string.
void	clear ()
	clear all buffers and deallocate memory.
void	clear ()
ProcessorMetricArray< std::array< int16_t, 16 > >	switch_buffer_and_read_casted ()
ProcessorMetricArray< std::array< int16_t, 16 > >	switch_buffer_and_read_casted ()

Protected Member Functions
void	allocate_buffers (size_t buffer_size)
	Allocate the correct size for the double buffer read and write buffers.
void	allocate_cast_buffers (size_t)
	Allocate the correct size for the double buffer read and write buffers for the casted data.
void	switch_active_buffer ()
	Switch the active buffer.
void	allocate_cast_buffers (size_t n)

Private Attributes
std::vector< std::shared_ptr< signal_t > >	m_internal_state_item_ptrs
	The vector of pointers to the internal state items.
ProcessorMetricArray< signal_t >	m_store_buffers [2] {}
	The double buffers for storing the internal state data.
ProcessorMetricArray< std::array< int16_t, 16 > >	m_cast_store_buffers [2] {}
	The double buffers for storing the internal state data casted to std::array<int16_t, 16>.
std::atomic< ProcessorMetricArray< std::array< int16_t, 16 > > * >	m_cast_active_buffer { &m_cast_store_buffers[0] }
	The active buffer for the casted data.
std::atomic< ProcessorMetricArray< signal_t > * >	m_write_buffer = &m_store_buffers[0]
	The write buffer pointer (buffer writer currently uses).
std::atomic< ProcessorMetricArray< signal_t > * >	m_read_buffer = &m_store_buffers[0]
	The read buffer pointer (buffer reader currently uses).
std::atomic< uint16_t >	m_write_seq { 0 }
	The sequence number for writes (odd=writing, even=complete).
std::atomic< uint16_t >	m_last_read_seq { 0 }
	The last sequence number that was read.
size_t	m_buffer_size
	size of each buffer.

Detailed Description

template<typename T>
class tpglibs::ProcessorInternalStateBufferManager< T >

Manages the internal state storage buffers for a processor.

Definition at line 32 of file ProcessorInternalStateBufferManager.hpp.

Member Typedef Documentation

◆ signal_t

template<typename T>

using tpglibs::ProcessorInternalStateBufferManager< T >::signal_t = T

Signal type to use. Generally __m256i or std::array<int16_t, 16>;.

Definition at line 36 of file ProcessorInternalStateBufferManager.hpp.

Constructor & Destructor Documentation

◆ ProcessorInternalStateBufferManager()

template<typename T>

tpglibs::ProcessorInternalStateBufferManager< T >::ProcessorInternalStateBufferManager ( )

Constructor.

Definition at line 120 of file ProcessorInternalStateBufferManager.hpp.

121{

122}

◆ ~ProcessorInternalStateBufferManager()

template<typename T>

tpglibs::ProcessorInternalStateBufferManager< T >::~ProcessorInternalStateBufferManager ( )

Destructor.

Definition at line 125 of file ProcessorInternalStateBufferManager.hpp.

{
  clear();
}

Member Function Documentation

◆ allocate_buffers()

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::allocate_buffers ( size_t buffer_size )

protected

Allocate the correct size for the double buffer read and write buffers.

Parameters

buffer_size The size of the buffer.

Definition at line 151 of file ProcessorInternalStateBufferManager.hpp.

{
  for (auto& buf : m_store_buffers) {
    buf.m_size = buffer_size;
    buf.m_data = static_cast<T*>(_mm_malloc(buf.m_size * sizeof(T), alignof(T)));
  }
}

◆ allocate_cast_buffers() [1/2]

void tpglibs::ProcessorInternalStateBufferManager< __m256i >::allocate_cast_buffers ( size_t n )

inlineprotected

Definition at line 257 of file ProcessorInternalStateBufferManager.hpp.

{
  for (auto& buf : m_cast_store_buffers) {
    buf.m_size = n;
    buf.m_data = static_cast<std::array<int16_t, 16>*>(_mm_malloc(n * sizeof(std::array<int16_t, 16>), 32));
  }
  m_cast_active_buffer.store(&m_cast_store_buffers[0], std::memory_order_release);
}

◆ allocate_cast_buffers() [2/2]

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::allocate_cast_buffers ( size_t )

inlineprotected

Allocate the correct size for the double buffer read and write buffers for the casted data.

Parameters

buffer_size The size of the buffer.

Definition at line 84 of file ProcessorInternalStateBufferManager.hpp.

84{}; // Do nothing for the generic template

◆ clear() [1/2]

void tpglibs::ProcessorInternalStateBufferManager< __m256i >::clear ( )

inline

Definition at line 218 of file ProcessorInternalStateBufferManager.hpp.

{
  // free double buffer for temp values
  for (auto& buf : m_store_buffers) {
    _mm_free(buf.m_data);
  }
  // free double buffer for casted values
  for (auto& buf : m_cast_store_buffers) {
    _mm_free(buf.m_data);
  }
}

◆ clear() [2/2]

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::clear ( )

inline

clear all buffers and deallocate memory.

Definition at line 66 of file ProcessorInternalStateBufferManager.hpp.

  {
    for (auto& buf : m_store_buffers) {
      _mm_free(buf.m_data);
    }
  }

◆ configure_from_registry()

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::configure_from_registry ( ProcessorInternalStateNameRegistry< signal_t > * registry )

Configure and allocate correct buffer storage given the configuration string.

Parameters

registry The registry object of internal state names.

Definition at line 132 of file ProcessorInternalStateBufferManager.hpp.

{
  // obtain the number of internal state items
  auto num_items = registry->get_number_of_requested_internal_states();
  allocate_buffers(num_items);
  allocate_cast_buffers(num_items);
  // Writer starts with buffer 0, reader starts with buffer 1 (they must be different!)
  m_write_buffer.store(&m_store_buffers[0], std::memory_order_release);
  m_read_buffer.store(&m_store_buffers[1], std::memory_order_release);
  m_cast_active_buffer.store(&m_cast_store_buffers[0], std::memory_order_release);
  // reset sequence counters
  m_write_seq.store(0, std::memory_order_release);
  m_last_read_seq.store(0, std::memory_order_release);
  // obtain the pointers to the internal state items
  m_internal_state_item_ptrs = registry->get_all_requested_internal_state_item_ptrs();
}

◆ switch_active_buffer()

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::switch_active_buffer ( )

protected

Switch the active buffer.

◆ switch_buffer_and_read()

template<typename T>

ProcessorMetricArray< typename ProcessorInternalStateBufferManager< T >::signal_t > tpglibs::ProcessorInternalStateBufferManager< T >::switch_buffer_and_read ( )

Read from the inactive buffer.

Returns: The data read from the inactive buffer.

Definition at line 185 of file ProcessorInternalStateBufferManager.hpp.

{
  // Wait until no write is in progress
  uint16_t current_write_seq;
  do {
    current_write_seq = m_write_seq.load(std::memory_order_acquire);
  } while (current_write_seq & 1); // spin if writer is mid-write (odd seq number)
 
  // Check if there's new data since last read
  uint16_t last_read = m_last_read_seq.load(std::memory_order_acquire);
 
  if (current_write_seq != last_read && current_write_seq > 0) {
    // New data available - swap the buffers between reader and writer
    auto current_read = m_read_buffer.load(std::memory_order_acquire);
    auto current_write = m_write_buffer.load(std::memory_order_acquire);
 
    // Swap: reader gets what writer just finished, writer gets what reader was using
    m_read_buffer.store(current_write, std::memory_order_release);
    m_write_buffer.store(current_read, std::memory_order_release);
 
    // Update last read sequence
    m_last_read_seq.store(current_write_seq, std::memory_order_release);
  }
 
  // Return data from read buffer
  auto read_ptr = m_read_buffer.load(std::memory_order_acquire);
  return *read_ptr;
}

◆ switch_buffer_and_read_casted() [1/3]

ProcessorMetricArray< std::array< int16_t, 16 > > tpglibs::ProcessorInternalStateBufferManager< std::array< int16_t, 16 > >::switch_buffer_and_read_casted ( )

inline

Definition at line 269 of file ProcessorInternalStateBufferManager.hpp.

{
  // First, get the raw data using switch_buffer_and_read
  auto raw_data = switch_buffer_and_read();
 
  // For std::array<int16_t, 16>, the cast is trivial - just return the data as-is
  return raw_data;
}

◆ switch_buffer_and_read_casted() [2/3]

ProcessorMetricArray< std::array< int16_t, 16 > > tpglibs::ProcessorInternalStateBufferManager< __m256i >::switch_buffer_and_read_casted ( )

inline

Definition at line 233 of file ProcessorInternalStateBufferManager.hpp.

{
  // First, get the raw data using switch_buffer_and_read
  auto raw_data = switch_buffer_and_read();
 
  auto* cast_free = m_cast_active_buffer.load(std::memory_order_acquire);
 
  // Cast each __m256i to std::array<int16_t, 16>
  for (size_t i = 0; i < raw_data.m_size; ++i) {
    // Cast and save to cast buffer
    _mm256_store_si256(reinterpret_cast<__m256i*>(cast_free->m_data[i].data()), raw_data.m_data[i]);
  }
 
  // Flip the active cast buffer
 
  auto* next = (cast_free == &m_cast_store_buffers[0]) ? &m_cast_store_buffers[1] : &m_cast_store_buffers[0];
  m_cast_active_buffer.store(next, std::memory_order_release);
 
  return *cast_free;
}

◆ switch_buffer_and_read_casted() [3/3]

template<typename T>

ProcessorMetricArray< std::array< int16_t, 16 > > tpglibs::ProcessorInternalStateBufferManager< T >::switch_buffer_and_read_casted ( )

Read from the inactive buffer and cast to std::array<int16_t, 16>.

◆ write_to_active_buffer()

template<typename T>

void tpglibs::ProcessorInternalStateBufferManager< T >::write_to_active_buffer ( )

Write to the active buffer.

Parameters

data	The data to write.

Definition at line 161 of file ProcessorInternalStateBufferManager.hpp.

{
  // Increment seq to indicate write start (becomes odd)
  m_write_seq.fetch_add(1, std::memory_order_release);
 
  auto write_ptr = m_write_buffer.load(std::memory_order_acquire);
 
  // Write to write buffer
  for (size_t i = 0; i < m_internal_state_item_ptrs.size(); i++) {
    // Check for nullptr before dereferencing (handles invalid state names)
    if (m_internal_state_item_ptrs[i] != nullptr) {
      write_ptr->m_data[i] = *m_internal_state_item_ptrs[i];
    } else {
      // If pointer is null, write a zeroed value
      write_ptr->m_data[i] = T{};
    }
  }
 
  // Increment seq to indicate write complete (becomes even)
  m_write_seq.fetch_add(1, std::memory_order_release);
}