Improve sub frame decode performance

CMakeLists.txt

@@ -207,6 +207,7 @@ set(Z_FEATURE_TCP_NODELAY 1 CACHE STRING "Toggle TCP_NODELAY")
 set(Z_FEATURE_LOCAL_SUBSCRIBER 0 CACHE STRING "Toggle local subscriptions")
 set(Z_FEATURE_PUBLISHER_SESSION_CHECK 1 CACHE STRING "Toggle publisher session check")
 set(Z_FEATURE_BATCHING 1 CACHE STRING "Toggle batching")
+set(Z_FEATURE_RX_CACHE 0 CACHE STRING "Toggle RX_CACHE")
 
 add_compile_definitions("Z_BUILD_DEBUG=$<CONFIG:Debug>")
 message(STATUS "Building with feature confing:\n\

include/zenoh-pico/collections/bytes.h

@@ -27,11 +27,8 @@ inline size_t _z_arc_slice_size(const _z_arc_slice_t *s) {
     (void)s;
     return sizeof(_z_arc_slice_t);
 }
-static inline void _z_arc_slice_elem_move(void *dst, void *src) {
-    _z_arc_slice_move((_z_arc_slice_t *)dst, (_z_arc_slice_t *)src);
-}
-_Z_ELEM_DEFINE(_z_arc_slice, _z_arc_slice_t, _z_arc_slice_size, _z_arc_slice_drop, _z_arc_slice_copy)
-_Z_SVEC_DEFINE(_z_arc_slice, _z_arc_slice_t)
+_Z_ELEM_DEFINE(_z_arc_slice, _z_arc_slice_t, _z_arc_slice_size, _z_arc_slice_drop, _z_arc_slice_copy, _z_arc_slice_move)
+_Z_SVEC_DEFINE(_z_arc_slice, _z_arc_slice_t, true)
 
 /*-------- Bytes --------*/
 /**

include/zenoh-pico/collections/element.h

@@ -30,7 +30,7 @@ typedef void (*z_element_move_f)(void *dst, void *src);
 typedef void *(*z_element_clone_f)(const void *e);
 typedef bool (*z_element_eq_f)(const void *left, const void *right);
 
-#define _Z_ELEM_DEFINE(name, type, elem_size_f, elem_clear_f, elem_copy_f)                                     \
+#define _Z_ELEM_DEFINE(name, type, elem_size_f, elem_clear_f, elem_copy_f, elem_move_f)                        \
     typedef bool (*name##_eq_f)(const type *left, const type *right);                                          \
     static inline void name##_elem_clear(void *e) { elem_clear_f((type *)e); }                                 \
     static inline void name##_elem_free(void **e) {                                                            \
@@ -41,6 +41,7 @@ typedef bool (*z_element_eq_f)(const void *left, const void *right);
             *e = NULL;                                                                                         \
         }                                                                                                      \
     }                                                                                                          \
+    static inline void name##_elem_move(void *dst, void *src) { elem_move_f((type *)dst, (type *)src); }       \
     static inline void name##_elem_copy(void *dst, const void *src) { elem_copy_f((type *)dst, (type *)src); } \
     static inline void *name##_elem_clone(const void *src) {                                                   \
         type *dst = (type *)z_malloc(elem_size_f((type *)src));                                                \
@@ -72,6 +73,6 @@ static inline void _z_noop_move(void *dst, void *src) {
     _ZP_UNUSED(src);
 }
 
-_Z_ELEM_DEFINE(_z_noop, _z_noop_t, _z_noop_size, _z_noop_clear, _z_noop_copy)
+_Z_ELEM_DEFINE(_z_noop, _z_noop_t, _z_noop_size, _z_noop_clear, _z_noop_copy, _z_noop_move)
 
 #endif /* ZENOH_PICO_COLLECTIONS_ELEMENT_H */

include/zenoh-pico/collections/string.h

@@ -33,7 +33,7 @@ bool _z_str_eq(const char *left, const char *right);
 size_t _z_str_size(const char *src);
 void _z_str_copy(char *dst, const char *src);
 void _z_str_n_copy(char *dst, const char *src, size_t size);
-_Z_ELEM_DEFINE(_z_str, char, _z_str_size, _z_noop_clear, _z_str_copy)
+_Z_ELEM_DEFINE(_z_str, char, _z_str_size, _z_noop_clear, _z_str_copy, _z_noop_move)
 
 _Z_VEC_DEFINE(_z_str, char)
 _Z_LIST_DEFINE(_z_str, char)
@@ -97,10 +97,8 @@ bool _z_string_equals(const _z_string_t *left, const _z_string_t *right);
 _z_string_t _z_string_convert_bytes(const _z_slice_t *bs);
 _z_string_t _z_string_preallocate(const size_t len);
 
-_Z_ELEM_DEFINE(_z_string, _z_string_t, _z_string_len, _z_string_clear, _z_string_copy)
-
-static inline void _z_string_elem_move(void *dst, void *src) { _z_string_move((_z_string_t *)dst, (_z_string_t *)src); }
-_Z_SVEC_DEFINE(_z_string, _z_string_t)
+_Z_ELEM_DEFINE(_z_string, _z_string_t, _z_string_len, _z_string_clear, _z_string_copy, _z_string_move)
+_Z_SVEC_DEFINE(_z_string, _z_string_t, true)
 _Z_LIST_DEFINE(_z_string, _z_string_t)
 _Z_INT_MAP_DEFINE(_z_string, _z_string_t)
 

include/zenoh-pico/collections/vec.h

@@ -30,9 +30,10 @@ typedef struct {
 } _z_vec_t;
 
 static inline _z_vec_t _z_vec_null(void) { return (_z_vec_t){0}; }
+static inline _z_vec_t _z_vec_alias(const _z_vec_t *src) { return *src; }
 _z_vec_t _z_vec_make(size_t capacity);
 void _z_vec_copy(_z_vec_t *dst, const _z_vec_t *src, z_element_clone_f f);
-void _z_vec_steal(_z_vec_t *dst, _z_vec_t *src);
+void _z_vec_move(_z_vec_t *dst, _z_vec_t *src);
 
 size_t _z_vec_len(const _z_vec_t *v);
 bool _z_vec_is_empty(const _z_vec_t *v);
@@ -61,7 +62,8 @@ void _z_vec_release(_z_vec_t *v);
     static inline void name##_vec_copy(name##_vec_t *dst, const name##_vec_t *src) {                               \
         _z_vec_copy(dst, src, name##_elem_clone);                                                                  \
     }                                                                                                              \
-    static inline void name##_vec_steal(name##_vec_t *dst, name##_vec_t *src) { _z_vec_steal(dst, src); }          \
+    static inline name##_vec_t name##_vec_alias(const name##_vec_t *v) { return _z_vec_alias(v); }                 \
+    static inline void name##_vec_move(name##_vec_t *dst, name##_vec_t *src) { _z_vec_move(dst, src); }            \
     static inline void name##_vec_reset(name##_vec_t *v) { _z_vec_reset(v, name##_elem_free); }                    \
     static inline void name##_vec_clear(name##_vec_t *v) { _z_vec_clear(v, name##_elem_free); }                    \
     static inline void name##_vec_free(name##_vec_t **v) { _z_vec_free(v, name##_elem_free); }                     \
@@ -77,44 +79,63 @@ typedef struct {
     void *_val;
 } _z_svec_t;
 
+static inline _z_svec_t _z_svec_null(void) { return (_z_svec_t){0}; }
+static inline _z_svec_t _z_svec_alias(const _z_svec_t *src) { return *src; }
+void _z_svec_init(_z_svec_t *dst, size_t element_size);
 _z_svec_t _z_svec_make(size_t capacity, size_t element_size);
-bool _z_svec_copy(_z_svec_t *dst, const _z_svec_t *src, z_element_copy_f copy, size_t element_size);
+z_result_t _z_svec_copy(_z_svec_t *dst, const _z_svec_t *src, z_element_copy_f copy, size_t element_size,
+                        bool use_elem_f);
+void _z_svec_move(_z_svec_t *dst, _z_svec_t *src);
 
 size_t _z_svec_len(const _z_svec_t *v);
 bool _z_svec_is_empty(const _z_svec_t *v);
 
-bool _z_svec_append(_z_svec_t *v, const void *e, z_element_move_f m, size_t element_size);
+z_result_t _z_svec_expand(_z_svec_t *v, z_element_move_f move, size_t element_size, bool use_elem_f);
+z_result_t _z_svec_append(_z_svec_t *v, const void *e, z_element_move_f m, size_t element_size, bool use_elem_f);
 void *_z_svec_get(const _z_svec_t *v, size_t pos, size_t element_size);
+void *_z_svec_get_mut(_z_svec_t *v, size_t i, size_t element_size);
 void _z_svec_set(_z_svec_t *sv, size_t pos, void *e, z_element_clear_f f, size_t element_size);
-void _z_svec_remove(_z_svec_t *sv, size_t pos, z_element_clear_f f, z_element_move_f m, size_t element_size);
+void _z_svec_remove(_z_svec_t *sv, size_t pos, z_element_clear_f f, z_element_move_f m, size_t element_size,
+                    bool use_elem_f);
 
 void _z_svec_reset(_z_svec_t *v, z_element_clear_f f, size_t element_size);
 void _z_svec_clear(_z_svec_t *v, z_element_clear_f f, size_t element_size);
 void _z_svec_free(_z_svec_t **v, z_element_clear_f f, size_t element_size);
 void _z_svec_release(_z_svec_t *v);
 
-#define _Z_SVEC_DEFINE(name, type)                                                                                 \
+#define _Z_SVEC_DEFINE(name, type, use_elem_f)                                                                     \
     typedef _z_svec_t name##_svec_t;                                                                               \
+    static inline name##_svec_t name##_svec_null(void) { return _z_svec_null(); }                                  \
     static inline name##_svec_t name##_svec_make(size_t capacity) { return _z_svec_make(capacity, sizeof(type)); } \
+    static inline void name##_svec_init(name##_svec_t *v) { _z_svec_init(v, sizeof(type)); }                       \
     static inline size_t name##_svec_len(const name##_svec_t *v) { return _z_svec_len(v); }                        \
     static inline bool name##_svec_is_empty(const name##_svec_t *v) { return _z_svec_is_empty(v); }                \
-    static inline bool name##_svec_append(name##_svec_t *v, type *e) {                                             \
-        return _z_svec_append(v, e, name##_elem_move, sizeof(type));                                               \
+    static inline z_result_t name##_svec_expand(name##_svec_t *v) {                                                \
+        return _z_svec_expand(v, name##_elem_move, sizeof(type), use_elem_f);                                      \
+    }                                                                                                              \
+    static inline z_result_t name##_svec_append(name##_svec_t *v, const type *e) {                                 \
+        return _z_svec_append(v, e, name##_elem_move, sizeof(type), use_elem_f);                                   \
     }                                                                                                              \
     static inline type *name##_svec_get(const name##_svec_t *v, size_t pos) {                                      \
         return (type *)_z_svec_get(v, pos, sizeof(type));                                                          \
     }                                                                                                              \
+    static inline type *name##_svec_get_mut(name##_svec_t *v, size_t pos) {                                        \
+        return (type *)_z_svec_get_mut(v, pos, sizeof(type));                                                      \
+    }                                                                                                              \
     static inline void name##_svec_set(name##_svec_t *v, size_t pos, type *e) {                                    \
         _z_svec_set(v, pos, e, name##_elem_clear, sizeof(type));                                                   \
     }                                                                                                              \
     static inline void name##_svec_remove(name##_svec_t *v, size_t pos) {                                          \
-        _z_svec_remove(v, pos, name##_elem_clear, name##_elem_move, sizeof(type));                                 \
+        _z_svec_remove(v, pos, name##_elem_clear, name##_elem_move, sizeof(type), use_elem_f);                     \
     }                                                                                                              \
-    static inline bool name##_svec_copy(name##_svec_t *dst, const name##_svec_t *src) {                            \
-        return _z_svec_copy(dst, src, name##_elem_copy, sizeof(type));                                             \
+    static inline z_result_t name##_svec_copy(name##_svec_t *dst, const name##_svec_t *src) {                      \
+        return _z_svec_copy(dst, src, name##_elem_copy, sizeof(type), use_elem_f);                                 \
     }                                                                                                              \
+    static inline name##_svec_t name##_svec_alias(const name##_svec_t *v) { return _z_svec_alias(v); }             \
+    static inline void name##_svec_move(name##_svec_t *dst, name##_svec_t *src) { _z_svec_move(dst, src); }        \
     static inline void name##_svec_reset(name##_svec_t *v) { _z_svec_reset(v, name##_elem_clear, sizeof(type)); }  \
     static inline void name##_svec_clear(name##_svec_t *v) { _z_svec_clear(v, name##_elem_clear, sizeof(type)); }  \
+    static inline void name##_svec_release(name##_svec_t *v) { _z_svec_release(v); }                               \
     static inline void name##_svec_free(name##_svec_t **v) { _z_svec_free(v, name##_elem_clear, sizeof(type)); }
 
 #endif /* ZENOH_PICO_COLLECTIONS_VECTOR_H */

include/zenoh-pico/config.h

@@ -45,6 +45,7 @@
 #define Z_FEATURE_LOCAL_SUBSCRIBER 0
 #define Z_FEATURE_PUBLISHER_SESSION_CHECK 1
 #define Z_FEATURE_BATCHING 1
+#define Z_FEATURE_RX_CACHE 0
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/
@@ -176,6 +177,11 @@
  */
 #define Z_GET_TIMEOUT_DEFAULT 10000
 
+/**
+ * Average size of a frame message (bytes). Used to evaluate initial decoding frame size.
+ */
+#define Z_CONFIG_FRAME_AVG_MSG_SIZE 32
+
 /**
  * Default "nop" instruction
  */

include/zenoh-pico/config.h.in

@@ -45,6 +45,7 @@
 #define Z_FEATURE_LOCAL_SUBSCRIBER @Z_FEATURE_LOCAL_SUBSCRIBER@
 #define Z_FEATURE_PUBLISHER_SESSION_CHECK @Z_FEATURE_PUBLISHER_SESSION_CHECK@
 #define Z_FEATURE_BATCHING @Z_FEATURE_BATCHING@
+#define Z_FEATURE_RX_CACHE @Z_FEATURE_RX_CACHE@
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/
@@ -176,6 +177,11 @@
  */
 #define Z_GET_TIMEOUT_DEFAULT 10000
 
+/**
+ * Average size of a frame message (bytes). Used to evaluate initial decoding frame size.
+ */
+#define Z_CONFIG_FRAME_AVG_MSG_SIZE 32
+
 /**
  * Default "nop" instruction
  */

include/zenoh-pico/link/endpoint.h

@@ -54,7 +54,7 @@ z_result_t _z_locator_from_string(_z_locator_t *lc, _z_string_t *s);
 
 size_t _z_locator_size(_z_locator_t *lc);
 void _z_locator_clear(_z_locator_t *lc);
-_Z_ELEM_DEFINE(_z_locator, _z_locator_t, _z_locator_size, _z_locator_clear, _z_noop_copy)
+_Z_ELEM_DEFINE(_z_locator, _z_locator_t, _z_locator_size, _z_locator_clear, _z_noop_copy, _z_noop_move)
 
 /*------------------ Locator array ------------------*/
 _Z_ARRAY_DEFINE(_z_locator, _z_locator_t)

include/zenoh-pico/net/reply.h

@@ -67,7 +67,7 @@ static inline _z_reply_data_t _z_reply_data_init(void) {
 void _z_reply_data_clear(_z_reply_data_t *rd);
 z_result_t _z_reply_data_copy(_z_reply_data_t *dst, const _z_reply_data_t *src);
 
-_Z_ELEM_DEFINE(_z_reply_data, _z_reply_data_t, _z_noop_size, _z_reply_data_clear, _z_noop_copy)
+_Z_ELEM_DEFINE(_z_reply_data, _z_reply_data_t, _z_noop_size, _z_reply_data_clear, _z_noop_copy, _z_noop_move)
 _Z_LIST_DEFINE(_z_reply_data, _z_reply_data_t)
 
 /**
@@ -102,7 +102,7 @@ typedef struct _z_pending_reply_t {
 bool _z_pending_reply_eq(const _z_pending_reply_t *one, const _z_pending_reply_t *two);
 void _z_pending_reply_clear(_z_pending_reply_t *res);
 
-_Z_ELEM_DEFINE(_z_pending_reply, _z_pending_reply_t, _z_noop_size, _z_pending_reply_clear, _z_noop_copy)
+_Z_ELEM_DEFINE(_z_pending_reply, _z_pending_reply_t, _z_noop_size, _z_pending_reply_clear, _z_noop_copy, _z_noop_move)
 _Z_LIST_DEFINE(_z_pending_reply, _z_pending_reply_t)
 
 #endif /* ZENOH_PICO_REPLY_NETAPI_H */

include/zenoh-pico/net/sample.h

@@ -59,8 +59,8 @@ void _z_sample_free(_z_sample_t **sample);
 z_result_t _z_sample_copy(_z_sample_t *dst, const _z_sample_t *src);
 _z_sample_t _z_sample_duplicate(const _z_sample_t *src);
 
-_z_sample_t _z_sample_create(_z_keyexpr_t *key, const _z_bytes_t *payload, const _z_timestamp_t *timestamp,
-                             _z_encoding_t *encoding, const z_sample_kind_t kind, const _z_qos_t qos,
-                             const _z_bytes_t *attachment, z_reliability_t reliability);
+void _z_sample_create(_z_sample_t *s, _z_keyexpr_t *key, _z_bytes_t *payload, const _z_timestamp_t *timestamp,
+                      _z_encoding_t *encoding, const z_sample_kind_t kind, const _z_qos_t qos, _z_bytes_t *attachment,
+                      z_reliability_t reliability);
 
 #endif /* ZENOH_PICO_SAMPLE_NETAPI_H */

include/zenoh-pico/net/session.h

@@ -22,6 +22,7 @@
 #include "zenoh-pico/config.h"
 #include "zenoh-pico/protocol/core.h"
 #include "zenoh-pico/session/session.h"
+#include "zenoh-pico/session/subscription.h"
 #include "zenoh-pico/utils/config.h"
 
 /**
@@ -52,6 +53,9 @@ typedef struct _z_session_t {
 #if Z_FEATURE_SUBSCRIPTION == 1
     _z_subscription_rc_list_t *_local_subscriptions;
     _z_subscription_rc_list_t *_remote_subscriptions;
+#if Z_FEATURE_RX_CACHE == 1
+    _z_subscription_cache_t _subscription_cache;
+#endif
 #endif
 
     // Session queryables

include/zenoh-pico/protocol/codec/transport.h

@@ -17,7 +17,6 @@
 
 #include "zenoh-pico/protocol/definitions/transport.h"
 #include "zenoh-pico/protocol/iobuf.h"
-#define _ZENOH_PICO_FRAME_MESSAGES_VEC_SIZE 32
 
 z_result_t _z_scouting_message_encode(_z_wbuf_t *buf, const _z_scouting_message_t *msg);
 z_result_t _z_scouting_message_decode(_z_scouting_message_t *msg, _z_zbuf_t *buf);

include/zenoh-pico/protocol/core.h

@@ -199,7 +199,7 @@ z_result_t _z_hello_copy(_z_hello_t *dst, const _z_hello_t *src);
 
 bool _z_hello_check(const _z_hello_t *hello);
 
-_Z_ELEM_DEFINE(_z_hello, _z_hello_t, _z_noop_size, _z_hello_clear, _z_noop_copy)
+_Z_ELEM_DEFINE(_z_hello, _z_hello_t, _z_noop_size, _z_hello_clear, _z_noop_copy, _z_noop_move)
 _Z_LIST_DEFINE(_z_hello, _z_hello_t)
 
 typedef struct {

include/zenoh-pico/protocol/definitions/network.h

@@ -289,8 +289,8 @@ void _z_n_msg_clear(_z_network_message_t *m);
 void _z_n_msg_free(_z_network_message_t **m);
 inline static void _z_msg_clear(_z_zenoh_message_t *msg) { _z_n_msg_clear(msg); }
 inline static void _z_msg_free(_z_zenoh_message_t **msg) { _z_n_msg_free(msg); }
-_Z_ELEM_DEFINE(_z_network_message, _z_network_message_t, _z_noop_size, _z_n_msg_clear, _z_noop_copy)
-_Z_VEC_DEFINE(_z_network_message, _z_network_message_t)
+_Z_ELEM_DEFINE(_z_network_message, _z_network_message_t, _z_noop_size, _z_n_msg_clear, _z_noop_copy, _z_noop_move)
+_Z_SVEC_DEFINE(_z_network_message, _z_network_message_t, false)
 
 void _z_msg_fix_mapping(_z_zenoh_message_t *msg, uint16_t mapping);
 _z_network_message_t _z_msg_make_query(_Z_MOVE(_z_keyexpr_t) key, _Z_MOVE(_z_slice_t) parameters, _z_zint_t qid,

include/zenoh-pico/protocol/definitions/transport.h

@@ -444,7 +444,7 @@ void _z_t_msg_keep_alive_clear(_z_t_msg_keep_alive_t *msg);
 // - if R==1 then the FRAME is sent on the reliable channel, best-effort otherwise.
 //
 typedef struct {
-    _z_network_message_vec_t _messages;
+    _z_network_message_svec_t _messages;
     _z_zint_t _sn;
 } _z_t_msg_frame_t;
 void _z_t_msg_frame_clear(_z_t_msg_frame_t *msg);
@@ -507,7 +507,7 @@ _z_transport_message_t _z_t_msg_make_open_syn(_z_zint_t lease, _z_zint_t initial
 _z_transport_message_t _z_t_msg_make_open_ack(_z_zint_t lease, _z_zint_t initial_sn);
 _z_transport_message_t _z_t_msg_make_close(uint8_t reason, bool link_only);
 _z_transport_message_t _z_t_msg_make_keep_alive(void);
-_z_transport_message_t _z_t_msg_make_frame(_z_zint_t sn, _z_network_message_vec_t messages,
+_z_transport_message_t _z_t_msg_make_frame(_z_zint_t sn, _z_network_message_svec_t messages,
                                            z_reliability_t reliability);
 _z_transport_message_t _z_t_msg_make_frame_header(_z_zint_t sn, z_reliability_t reliability);
 _z_transport_message_t _z_t_msg_make_fragment_header(_z_zint_t sn, z_reliability_t reliability, bool is_last);

include/zenoh-pico/protocol/ext.h

@@ -96,7 +96,7 @@ void _z_msg_ext_copy_unit(_z_msg_ext_unit_t *clone, const _z_msg_ext_unit_t *ext
 void _z_msg_ext_copy_zint(_z_msg_ext_zint_t *clone, const _z_msg_ext_zint_t *ext);
 void _z_msg_ext_copy_zbuf(_z_msg_ext_zbuf_t *clone, const _z_msg_ext_zbuf_t *ext);
 
-_Z_ELEM_DEFINE(_z_msg_ext, _z_msg_ext_t, _z_noop_size, _z_msg_ext_clear, _z_msg_ext_copy)
+_Z_ELEM_DEFINE(_z_msg_ext, _z_msg_ext_t, _z_noop_size, _z_msg_ext_clear, _z_msg_ext_copy, _z_noop_move)
 _Z_VEC_DEFINE(_z_msg_ext, _z_msg_ext_t)
 
 #endif /* ZENOH_PICO_PROTOCOL_EXTENSION_H */

include/zenoh-pico/protocol/iobuf.h

@@ -60,7 +60,7 @@ void _z_iosli_free(_z_iosli_t **ios);
 void _z_iosli_copy(_z_iosli_t *dst, const _z_iosli_t *src);
 _z_iosli_t *_z_iosli_clone(const _z_iosli_t *src);
 
-_Z_ELEM_DEFINE(_z_iosli, _z_iosli_t, _z_iosli_size, _z_iosli_clear, _z_iosli_copy)
+_Z_ELEM_DEFINE(_z_iosli, _z_iosli_t, _z_iosli_size, _z_iosli_clear, _z_iosli_copy, _z_noop_move)
 _Z_VEC_DEFINE(_z_iosli, _z_iosli_t)
 
 /*------------------ ZBuf ------------------*/