Fix read_last could read unpublished data; Added shm init handshake; bump version number to 1.4.0

Author: kzhdev

.github/workflows/release.yml

@@ -28,7 +28,7 @@ jobs:
             # Escape dots in version for regex
             VERSION_ESCAPED=$(echo "$VERSION" | sed 's/\./\\./g')
             # Use awk to extract content: start at version header, stop at next ## header
-            CHANGES=$(awk "BEGIN{p=0} /^# $VERSION_ESCAPED/{p=1;next} /^# /{p=0} p" CHANGELOG | sed '/^$/d')
+            CHANGES=$(awk "BEGIN{p=0} /^# $VERSION_ESCAPED( |$)/{p=1;next} /^# /{p=0} p" CHANGELOG | sed '/^$/d')
 
             if [ -z "$CHANGES" ]; then
               echo "CHANGELOG_CONTENT=No changelog entry found for this version." >> $GITHUB_OUTPUT

CHANGELOG

@@ -1,3 +1,12 @@
+# v1.4.0 - 2026-02-04
+- **BREAKING CHANGE**: Added last_published_index and header magic in shared memory header
+  - Fixed shared-memory attach race by adding an init-state handshake with readiness wait and legacy fallback
+  - Added last-published tracking so `read_last()` only returns published data; added a regression test
+  - Changed read_last() return signature to std::pair<T*, uint32_t>
+- Updated `read_last()` documentation for legacy shared-memory segments
+- Relaxed memory ordering in the shared atomic cursor path for lower overhead
+- Fixed release workflow changelog extraction to match version headers with trailing dates
+
 # v1.3.0 - 2026-01-30
 - **BREAKING CHANGE**: Replaced platform-specific shared memory implementation with slick-shm library
   - Removed all Windows-specific code (CreateFileMapping, MapViewOfFile, etc.)

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 
 project(slick-queue
-        VERSION 1.3.0
+        VERSION 1.4.0
         DESCRIPTION "A C++ Lock-Free MPMC queue"
         LANGUAGES CXX)
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020-2026 Slick Quant LLC.
+Copyright (c) 2020-2026 Slick Quant LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -212,7 +212,7 @@ SlickQueue(const char* shm_name);                  // Reader/Attacher
 - `void publish(uint64_t slot, uint32_t n = 1)` - Publish `n` written items to consumers
 - `std::pair<T*, uint32_t> read(uint64_t& cursor)` - Read next available item (independent cursor)
 - `std::pair<T*, uint32_t> read(std::atomic<uint64_t>& cursor)` - Read next available item (shared atomic cursor for work-stealing)
-- `T* read_last()` - Read the most recently published item without a cursor
+- `std::pair<T*, uint32_t> read_last()` - Read the most recently published item without a cursor
 - `uint32_t size()` - Get queue capacity
 - `uint64_t loss_count() const` - Get count of skipped items due to overwrite (debug-only if enabled)
 - `void reset()` - Reset the queue, invalidating all existing data
@@ -227,10 +227,10 @@ SlickQueue(const char* shm_name);                  // Reader/Attacher
 
 **CPU Relax Backoff**: Define `SLICK_QUEUE_ENABLE_CPU_RELAX=0` to disable the pause/yield backoff used on contended CAS loops (default is enabled). Disabling may reduce latency in very short contention bursts but can increase CPU usage under load.
 
-**⚠️ Reserve Size Limitation**: When using `read_last()`, the number of slots in any `reserve(n)` call **must not exceed 65,535** (2^16 - 1). This is because the size is stored in 16 bits within the packed atomic.
+**⚠️ Reserve Size Limitation (legacy shared memory)**: Older shared-memory segments used the 16-bit size stored in the packed reservation atomic to compute `read_last()`. New segments track the last published index separately, so this limit no longer applies in normal use.
 
+- If you attach to a shared-memory segment created by older versions, keep `reserve(n) <= 65,535` when using `read_last()`
 - For typical use cases with `reserve()` or `reserve(1)`, this limit is not a concern
-- If you need to reserve more than 65,535 slots at once, do not use `read_last()`
 - The 48-bit index supports up to 2^48 (281 trillion) iterations, sufficient for any practical application
 
 ## Performance Characteristics

include/slick/queue.h

@@ -13,6 +13,9 @@ if(NOT GTest_FOUND)
 endif()
 
 add_executable(slick-queue-tests tests.cpp shm_tests.cpp)
+if(MSVC)
+  add_compile_options(/wd4996)
+endif()
 
 target_link_libraries(slick-queue-tests PRIVATE slick::queue GTest::gtest_main)
 

tests/CMakeLists.txt

@@ -202,3 +202,84 @@ TEST(ShmTests, SizeMismatch) {
     }
   }, std::runtime_error);
 }
+
+TEST(ShmTests, ReadLastUsesLatestReserveSize) {
+  SlickQueue<int> queue(8, "sq_read_last");
+  SlickQueue<int> reader_queue(8, "sq_read_last");
+
+  auto first = queue.reserve(2);
+  *queue[first] = 1;
+  *queue[first + 1] = 2;
+  queue.publish(first, 2);
+
+  auto last = queue.reserve(1);
+  *queue[last] = 3;
+  queue.publish(last, 1);
+
+  auto [latest, size] = reader_queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  EXPECT_EQ(*latest, 3);
+  EXPECT_EQ(size, 1);
+}
+
+TEST(ShmTests, ReadLastIgnoresUnpublishedReservation) {
+  SlickQueue<int> queue(8, "sq_read_last2");
+  SlickQueue<int> reader_queue(8, "sq_read_last2");
+
+  auto first = queue.reserve(2);
+  *queue[first] = 1;
+  *queue[first + 1] = 2;
+  queue.publish(first, 2);
+
+  auto last = queue.reserve(1);
+  *queue[last] = 3;
+
+  auto [latest, size] = reader_queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  EXPECT_EQ(*latest, 1);
+  EXPECT_EQ(size, 2);
+}
+
+TEST(ShmTests, ReadLastUsesLatestReserveSizeMultiple) {
+  SlickQueue<char> queue(256, "sq_read_last_multi");
+  SlickQueue<char> reader_queue(256, "sq_read_last_multi");
+
+  const char* first_str = "One";
+  uint32_t length = static_cast<uint32_t>(std::strlen(first_str) + 1);
+  auto first = queue.reserve(length);
+  std::strcpy(queue[first], first_str);
+  queue.publish(first, length);
+
+  const char* last_str = "Four";
+  length = static_cast<uint32_t>(strlen(first_str) + 1);
+  auto last = queue.reserve(length);
+  std::strcpy(queue[last], last_str);
+  queue.publish(last, length);
+
+  auto [latest, size] = reader_queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  std::string s(latest, size);
+  EXPECT_EQ(strncmp(latest, last_str, size), 0);
+}
+
+TEST(ShmTests, ReadLastIgnoresUnpublishedReservationMultiple) {
+  SlickQueue<char> queue(256, "sq_read_last_multi2");
+  SlickQueue<char> reader_queue(256, "sq_read_last_multi2");
+
+  const char* first_str = "One";
+  uint32_t length = static_cast<uint32_t>(std::strlen(first_str) + 1);
+  auto first = queue.reserve(length);
+  std::strcpy(queue[first], first_str);
+  queue.publish(first, length);
+
+  const char* last_str = "Four";
+  length = static_cast<uint32_t>(strlen(first_str) + 1);
+  auto last = queue.reserve(length);
+  std::strcpy(queue[last], last_str);
+
+  auto [latest, size] = reader_queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  std::string s(latest, size);
+  EXPECT_EQ(strncmp(latest, first_str, size), 0);
+}
+

tests/shm_tests.cpp

@@ -137,9 +137,68 @@ TEST(SlickQueueTests, ReadLastUsesLatestReserveSize) {
   *queue[last] = 3;
   queue.publish(last, 1);
 
-  auto latest = queue.read_last();
+  auto [latest, size] = queue.read_last();
   ASSERT_NE(latest, nullptr);
   EXPECT_EQ(*latest, 3);
+  EXPECT_EQ(size, 1);
+}
+
+TEST(SlickQueueTests, ReadLastIgnoresUnpublishedReservation) {
+  SlickQueue<int> queue(8);
+
+  auto first = queue.reserve(2);
+  *queue[first] = 1;
+  *queue[first + 1] = 2;
+  queue.publish(first, 2);
+
+  auto last = queue.reserve(1);
+  *queue[last] = 3;
+
+  auto [latest, size] = queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  EXPECT_EQ(*latest, 1);
+  EXPECT_EQ(size, 2);
+}
+
+TEST(SlickQueueTests, ReadLastUsesLatestReserveSizeMultiple) {
+  SlickQueue<char> queue(256);
+
+  const char* first_str = "One";
+  uint32_t length = static_cast<uint32_t>(std::strlen(first_str) + 1);
+  auto first = queue.reserve(length);
+  std::strcpy(queue[first], first_str);
+  queue.publish(first, length);
+
+  const char* last_str = "Four";
+  length = static_cast<uint32_t>(strlen(first_str) + 1);
+  auto last = queue.reserve(length);
+  std::strcpy(queue[last], last_str);
+  queue.publish(last, length);
+
+  auto [latest, size] = queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  std::string s(latest, size);
+  EXPECT_EQ(strncmp(latest, last_str, size), 0);
+}
+
+TEST(SlickQueueTests, ReadLastIgnoresUnpublishedReservationMultiple) {
+  SlickQueue<char> queue(256);
+
+  const char* first_str = "One";
+  uint32_t length = static_cast<uint32_t>(std::strlen(first_str) + 1);
+  auto first = queue.reserve(length);
+  std::strcpy(queue[first], first_str);
+  queue.publish(first, length);
+
+  const char* last_str = "Four";
+  length = static_cast<uint32_t>(strlen(first_str) + 1);
+  auto last = queue.reserve(length);
+  std::strcpy(queue[last], last_str);
+
+  auto [latest, size] = queue.read_last();
+  ASSERT_NE(latest, nullptr);
+  std::string s(latest, size);
+  EXPECT_EQ(strncmp(latest, first_str, size), 0);
 }
 
 TEST(SlickQueueTests, LossyOverwriteSkipsOldData) {