//================================ DMS L0 shared-mem vs heap-mem read latency benchmark ==========================//
        /* Measures are limited to the first 1000 DMS frames to avoid log flooding.
         * Both paths use a volatile byte-by-byte loop so the compiler cannot elide
         * the reads as dead code.  The XOR accumulator (u8Sink) is also volatile so
         * each load must be committed.  clock_gettime(CLOCK_MONOTONIC) gives
         * sub-microsecond resolution, far better than gettimeofday truncated to ms. */
#if 1
        {
            static uint32_t s_l0BenchCount = 0U;
            s_l0BenchCount++;
            if ( s_l0BenchCount <= 1000U )
            {
                /* Shared-memory base pointer for DMS L0 */
                const volatile uint8_t* const shmPtr =
                    static_cast<const volatile uint8_t*>(
                        static_cast<const void*>(
                            static_cast<const char*>( localBuffAddr )
                            + ( frameData[FrameIdxInfo.QueueCnt].l0_Frame_Addr - DMR5_START_ADDR ) ) );

                /* Heap pointer — slot.l0 was just populated from shared mem above */
                const volatile uint8_t* const heapPtr =
                    static_cast<const volatile uint8_t*>( static_cast<const void*>( slot.l0 ) );

                volatile uint8_t u8Sink = 0U; /* Accumulator prevents dead-code elimination */
                struct timespec tsStart, tsEnd;
                int64_t elapsedNs;

                /* --- Shared memory sequential read --- */
                ( void )clock_gettime( CLOCK_MONOTONIC, &tsStart );
                for ( uint32_t i = 0U; i < DMS_L0_size; i++ )
                {
                    u8Sink = static_cast<uint8_t>( shmPtr[i] );
                }
                ( void )clock_gettime( CLOCK_MONOTONIC, &tsEnd );
                elapsedNs = ( static_cast<int64_t>( tsEnd.tv_sec - tsStart.tv_sec ) * 1000000000LL )
                          + ( static_cast<int64_t>( tsEnd.tv_nsec ) - static_cast<int64_t>( tsStart.tv_nsec ) );
                const int64_t shmReadUs = elapsedNs / 1000LL;

                /* --- Heap memory sequential read --- */
                ( void )clock_gettime( CLOCK_MONOTONIC, &tsStart );
                for ( uint32_t i = 0U; i < DMS_L0_size; i++ )
                {
                    u8Sink = static_cast<uint8_t>( heapPtr[i] );
                }
                ( void )clock_gettime( CLOCK_MONOTONIC, &tsEnd );
                elapsedNs = ( static_cast<int64_t>( tsEnd.tv_sec - tsStart.tv_sec ) * 1000000000LL )
                          + ( static_cast<int64_t>( tsEnd.tv_nsec ) - static_cast<int64_t>( tsStart.tv_nsec ) );
                const int64_t heapReadUs = elapsedNs / 1000LL;

                printf( "[L0 ReadBench #%u] DMS_L0 (%u bytes): ShmRead=%lld us  HeapRead=%lld us  Diff(shm-heap)=%lld us\n",
                        s_l0BenchCount,
                        DMS_L0_size,
                        static_cast<long long>( shmReadUs ),
                        static_cast<long long>( heapReadUs ),
                        static_cast<long long>( shmReadUs - heapReadUs ) );
            }
        }
#endif
        //==========================================================================================================//