lib: os: spsc_pbuf: Add option to get maximum utilization

Add option to track maximum utilization of the packet buffer.

Signed-off-by: Krzysztof Chruscinski <[email protected]>

Author: nordic-krch

include/zephyr/sys/spsc_pbuf.h

@@ -24,6 +24,12 @@ extern "C" {
 /** @brief Flag indicating that cache shall be handled. */
 #define SPSC_PBUF_CACHE BIT(0)
 
+/** @brief Size of the field which stores maximum utilization. */
+#define SPSC_PBUF_UTILIZATION_BITS 24
+
+/** @brief Offset of the field which stores maximum utilization. */
+#define SPSC_PBUF_UTILIZATION_OFFSET 8
+
 /**@} */
 
 #ifndef CONFIG_SPSC_PBUF_CACHE_LINE
@@ -223,6 +229,18 @@ uint16_t spsc_pbuf_claim(struct spsc_pbuf *pb, char **buf);
  */
 void spsc_pbuf_free(struct spsc_pbuf *pb, uint16_t len);
 
+/**
+ * @brief Get maximum utilization of the packet buffer.
+ *
+ * Function can be used to tune the buffer size. Feature is enabled by
+ * CONFIG_SPSC_PBUF_UTILIZATION. Utilization is updated by the consumer.
+ *
+ * @param pb	A packet buffer.
+ *
+ * @retval -ENOTSUP	Feature not enabled.
+ * @retval non-negative	Maximum utilization.
+ */
+int spsc_pbuf_get_utilization(struct spsc_pbuf *pb);
 /**
  * @}
  */

lib/os/Kconfig

@@ -89,6 +89,12 @@ config SPSC_PBUF_CACHE_LINE
 
 endif # SPSC_PBUF_CACHE_FLAG || SPSC_PBUF_CACHE_ALWAYS
 
+config SPSC_PBUF_UTILIZATION
+	bool "Track maximum utilization"
+	help
+	  When enabled, maximum utilization is tracked which can be used to
+	  determine the size of the packet buffer.
+
 endif # SPSC_PBUF
 
 config SHARED_MULTI_HEAP

lib/os/spsc_pbuf.c

@@ -14,6 +14,14 @@
 #define LEN_SZ sizeof(uint32_t)
 #define PADDING_MARK 0xFF
 
+#define GET_UTILIZATION(flags) \
+	(((flags) >> SPSC_PBUF_UTILIZATION_OFFSET) & BIT_MASK(SPSC_PBUF_UTILIZATION_BITS))
+
+#define SET_UTILIZATION(flags, val) \
+	((flags & ~(BIT_MASK(SPSC_PBUF_UTILIZATION_BITS) << \
+			     SPSC_PBUF_UTILIZATION_OFFSET)) | \
+			((val) << SPSC_PBUF_UTILIZATION_OFFSET))
+
 /*
  * In order to allow allocation of continuous buffers (in zero copy manner) buffer
  * is handling wrapping. When it is detected that request space cannot be allocated
@@ -254,6 +262,17 @@ uint16_t spsc_pbuf_claim(struct spsc_pbuf *pb, char **buf)
 
 	uint32_t bytes_stored = idx_occupied(pblen, wr_idx, rd_idx);
 
+	/* Utilization is calculated at claiming to handle cache case when flags
+	 * and rd_idx is in the same cache line thus it should be modified only
+	 * by the consumer.
+	 */
+	if (IS_ENABLED(CONFIG_SPSC_PBUF_UTILIZATION) && (bytes_stored > GET_UTILIZATION(flags))) {
+		__ASSERT_NO_MSG(bytes_stored <= BIT_MASK(SPSC_PBUF_UTILIZATION_BITS));
+		pb->common.flags = SET_UTILIZATION(flags, bytes_stored);
+		__sync_synchronize();
+		cache_wb(&pb->common.flags, sizeof(pb->common.flags), flags);
+	}
+
 	/* Read message len. */
 	uint16_t len;
 
@@ -326,3 +345,15 @@ int spsc_pbuf_read(struct spsc_pbuf *pb, char *buf, uint16_t len)
 
 	return plen;
 }
+
+int spsc_pbuf_get_utilization(struct spsc_pbuf *pb)
+{
+	if (!IS_ENABLED(CONFIG_SPSC_PBUF_UTILIZATION)) {
+		return -ENOTSUP;
+	}
+
+	cache_inv(&pb->common.flags, sizeof(pb->common.flags), pb->common.flags);
+	__sync_synchronize();
+
+	return GET_UTILIZATION(pb->common.flags);
+}