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 35 of file ProcessorInternalStateBufferManager.hpp.

Constructor & Destructor Documentation

◆ ProcessorInternalStateBufferManager()

template<typename T >

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

Constructor.

Definition at line 117 of file ProcessorInternalStateBufferManager.hpp.

117 {

118 }

◆ ~ProcessorInternalStateBufferManager()

template<typename T >

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

Destructor.

Definition at line 121 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 143 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 240 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 81 of file ProcessorInternalStateBufferManager.hpp.

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

◆ clear() [1/2]

template<typename T >

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

inline

clear all buffers and deallocate memory.

Definition at line 65 of file ProcessorInternalStateBufferManager.hpp.

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

◆ clear() [2/2]

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

inline

Definition at line 206 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); }
    }

◆ 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 126 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 175 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]

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>.

◆ 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 215 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]

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

inline

Definition at line 252 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;
    }

◆ 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 153 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);
    }