Improve throughput performance (trigger local subscriber focus) (#730)

* feat: switch null functions to static inline

* feat: switch check fct to static inline

* feat: check if there are subs to trigger

* feat: pass by ref with keyexpr alias and duplicate

* feat: switch null fct to return {0}

* feat: add local sub config token

* feat: simplify slice_init / string_preallocate

* feat: add expanded key case

* feat: make _alias fct static inline

* doc: fix typo

* fix: add local subscriber token to config.h

* doc: add warning on null functions

* feat: add reply_data_init function

CMakeLists.txt

@@ -204,6 +204,7 @@ set(Z_FEATURE_MULTICAST_TRANSPORT 1 CACHE STRING "Toggle multicast transport")
 set(Z_FEATURE_UNICAST_TRANSPORT 1 CACHE STRING "Toggle unicast transport")
 set(Z_FEATURE_RAWETH_TRANSPORT 0 CACHE STRING "Toggle raw ethernet transport")
 set(Z_FEATURE_TCP_NODELAY 1 CACHE STRING "Toggle TCP_NODELAY")
+set(Z_FEATURE_LOCAL_SUBSCRIBER 0 CACHE STRING "Toggle local subscriptions")
 
 add_compile_definitions("Z_BUILD_DEBUG=$<CONFIG:Debug>")
 message(STATUS "Building with feature confing:\n\

include/zenoh-pico/collections/bytes.h

@@ -45,8 +45,9 @@ typedef struct {
     _z_arc_slice_svec_t _slices;
 } _z_bytes_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_bytes_t _z_bytes_null(void) { return (_z_bytes_t){0}; }
 bool _z_bytes_check(const _z_bytes_t *bytes);
-_z_bytes_t _z_bytes_null(void);
 z_result_t _z_bytes_append_bytes(_z_bytes_t *dst, _z_bytes_t *src);
 z_result_t _z_bytes_append_slice(_z_bytes_t *dst, _z_arc_slice_t *s);
 z_result_t _z_bytes_copy(_z_bytes_t *dst, const _z_bytes_t *src);

include/zenoh-pico/collections/slice.h

@@ -26,9 +26,13 @@ typedef struct {
     void *context;
 } _z_delete_context_t;
 
-_z_delete_context_t _z_delete_context_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_delete_context_t _z_delete_context_null(void) { return (_z_delete_context_t){0}; }
+
+static inline _z_delete_context_t _z_delete_context_create(void (*deleter)(void *context, void *data), void *context) {
+    return (_z_delete_context_t){.deleter = deleter, .context = context};
+}
 bool _z_delete_context_is_null(const _z_delete_context_t *c);
-_z_delete_context_t _z_delete_context_create(void (*deleter)(void *context, void *data), void *context);
 _z_delete_context_t _z_delete_context_default(void);
 void _z_delete_context_delete(_z_delete_context_t *c, void *data);
 
@@ -47,21 +51,23 @@ typedef struct {
     _z_delete_context_t _delete_context;
 } _z_slice_t;
 
-_z_slice_t _z_slice_empty(void);
-inline static bool _z_slice_check(const _z_slice_t *slice) { return slice->start != NULL; }
+static inline _z_slice_t _z_slice_empty(void) { return (_z_slice_t){0}; }
+static inline bool _z_slice_is_empty(const _z_slice_t *bs) { return bs->len == 0; }
+static inline bool _z_slice_check(const _z_slice_t *slice) { return slice->start != NULL; }
+static inline _z_slice_t _z_slice_alias(const _z_slice_t bs) {
+    return (_z_slice_t){.len = bs.len, .start = bs.start, ._delete_context = _z_delete_context_null()};
+}
 z_result_t _z_slice_init(_z_slice_t *bs, size_t capacity);
 _z_slice_t _z_slice_make(size_t capacity);
 _z_slice_t _z_slice_alias_buf(const uint8_t *bs, size_t len);
 _z_slice_t _z_slice_from_buf_custom_deleter(const uint8_t *p, size_t len, _z_delete_context_t dc);
 _z_slice_t _z_slice_copy_from_buf(const uint8_t *bs, size_t len);
 _z_slice_t _z_slice_steal(_z_slice_t *b);
-_z_slice_t _z_slice_alias(const _z_slice_t *bs);
 z_result_t _z_slice_copy(_z_slice_t *dst, const _z_slice_t *src);
 z_result_t _z_slice_n_copy(_z_slice_t *dst, const _z_slice_t *src, size_t offset, size_t len);
 _z_slice_t _z_slice_duplicate(const _z_slice_t *src);
 void _z_slice_move(_z_slice_t *dst, _z_slice_t *src);
 void _z_slice_reset(_z_slice_t *bs);
-bool _z_slice_is_empty(const _z_slice_t *bs);
 bool _z_slice_eq(const _z_slice_t *left, const _z_slice_t *right);
 void _z_slice_clear(_z_slice_t *bs);
 void _z_slice_free(_z_slice_t **bs);

include/zenoh-pico/collections/string.h

@@ -66,8 +66,13 @@ typedef struct {
     _z_slice_t _slice;
 } _z_string_t;
 
-_z_string_t _z_string_null(void);
-bool _z_string_check(const _z_string_t *value);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_string_t _z_string_null(void) { return (_z_string_t){0}; }
+static inline bool _z_string_check(const _z_string_t *value) { return !_z_slice_is_empty(&value->_slice); }
+static inline _z_string_t _z_string_alias(const _z_string_t str) {
+    return (_z_string_t){._slice = _z_slice_alias(str._slice)};
+}
+
 _z_string_t _z_string_copy_from_str(const char *value);
 _z_string_t _z_string_copy_from_substr(const char *value, size_t len);
 _z_string_t *_z_string_copy_from_str_as_ptr(const char *value);
@@ -84,7 +89,6 @@ z_result_t _z_string_copy(_z_string_t *dst, const _z_string_t *src);
 z_result_t _z_string_copy_substring(_z_string_t *dst, const _z_string_t *src, size_t offset, size_t len);
 void _z_string_move(_z_string_t *dst, _z_string_t *src);
 _z_string_t _z_string_steal(_z_string_t *str);
-_z_string_t _z_string_alias(const _z_string_t *str);
 void _z_string_move_str(_z_string_t *dst, char *src);
 void _z_string_clear(_z_string_t *s);
 void _z_string_free(_z_string_t **s);

include/zenoh-pico/config.h

@@ -42,6 +42,7 @@
 #define Z_FEATURE_FRAGMENTATION 1
 #define Z_FEATURE_ENCODING_VALUES 1
 #define Z_FEATURE_TCP_NODELAY 1
+#define Z_FEATURE_LOCAL_SUBSCRIBER 0
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/

include/zenoh-pico/config.h.in

@@ -42,6 +42,7 @@
 #define Z_FEATURE_FRAGMENTATION @Z_FEATURE_FRAGMENTATION@
 #define Z_FEATURE_ENCODING_VALUES @Z_FEATURE_ENCODING_VALUES@
 #define Z_FEATURE_TCP_NODELAY @Z_FEATURE_TCP_NODELAY@
+#define Z_FEATURE_LOCAL_SUBSCRIBER @Z_FEATURE_LOCAL_SUBSCRIBER@
 // End of CMake generation
 
 /*------------------ Runtime configuration properties ------------------*/

include/zenoh-pico/net/encoding.h

@@ -27,11 +27,14 @@ typedef struct _z_encoding_t {
     uint16_t id;
 } _z_encoding_t;
 
-z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *schema, size_t len);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_encoding_t _z_encoding_null(void) { return (_z_encoding_t){0}; }
+static inline bool _z_encoding_check(const _z_encoding_t *encoding) {
+    return ((encoding->id != _Z_ENCODING_ID_DEFAULT) || _z_string_check(&encoding->schema));
+}
 _z_encoding_t _z_encoding_wrap(uint16_t id, const char *schema);
-_z_encoding_t _z_encoding_null(void);
+z_result_t _z_encoding_make(_z_encoding_t *encoding, uint16_t id, const char *schema, size_t len);
 void _z_encoding_clear(_z_encoding_t *encoding);
-bool _z_encoding_check(const _z_encoding_t *encoding);
 z_result_t _z_encoding_copy(_z_encoding_t *dst, const _z_encoding_t *src);
 void _z_encoding_move(_z_encoding_t *dst, _z_encoding_t *src);
 _z_encoding_t _z_encoding_steal(_z_encoding_t *val);

include/zenoh-pico/net/publish.h

@@ -37,10 +37,11 @@ typedef struct _z_publisher_t {
 } _z_publisher_t;
 
 #if Z_FEATURE_PUBLICATION == 1
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_publisher_t _z_publisher_null(void) { return (_z_publisher_t){0}; }
+static inline bool _z_publisher_check(const _z_publisher_t *publisher) { return !_Z_RC_IS_NULL(&publisher->_zn); }
 void _z_publisher_clear(_z_publisher_t *pub);
 void _z_publisher_free(_z_publisher_t **pub);
-bool _z_publisher_check(const _z_publisher_t *publisher);
-_z_publisher_t _z_publisher_null(void);
 #endif
 
 #endif /* INCLUDE_ZENOH_PICO_NET_PUBLISH_H */

include/zenoh-pico/net/query.h

@@ -34,7 +34,8 @@ typedef struct _z_query_t {
     bool _anyke;
 } _z_query_t;
 
-_z_query_t _z_query_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_query_t _z_query_null(void) { return (_z_query_t){0}; }
 void _z_query_clear(_z_query_t *q);
 z_result_t _z_query_copy(_z_query_t *dst, const _z_query_t *src);
 void _z_query_free(_z_query_t **query);
@@ -50,12 +51,14 @@ typedef struct {
 } _z_queryable_t;
 
 #if Z_FEATURE_QUERYABLE == 1
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_queryable_t _z_queryable_null(void) { return (_z_queryable_t){0}; }
+static inline bool _z_queryable_check(const _z_queryable_t *queryable) { return !_Z_RC_IS_NULL(&queryable->_zn); }
 _z_query_t _z_query_create(_z_value_t *value, _z_keyexpr_t *key, const _z_slice_t *parameters, _z_session_rc_t *zn,
                            uint32_t request_id, const _z_bytes_t attachment);
 void _z_queryable_clear(_z_queryable_t *qbl);
 void _z_queryable_free(_z_queryable_t **qbl);
-_z_queryable_t _z_queryable_null(void);
-bool _z_queryable_check(const _z_queryable_t *queryable);
+
 #endif
 
 #endif /* ZENOH_PICO_QUERY_NETAPI_H */

include/zenoh-pico/net/reply.h

@@ -57,6 +57,13 @@ typedef struct _z_reply_data_t {
     _z_reply_tag_t _tag;
 } _z_reply_data_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_reply_data_t _z_reply_data_null(void) { return (_z_reply_data_t){0}; }
+static inline _z_reply_data_t _z_reply_data_init(void) {
+    _z_reply_data_t reply_data = _z_reply_data_null();
+    reply_data._tag = _Z_REPLY_TAG_NONE;
+    return reply_data;
+}
 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);
 
@@ -76,9 +83,9 @@ typedef struct _z_reply_t {
     _z_reply_data_t data;
 } _z_reply_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_reply_t _z_reply_null(void) { return (_z_reply_t){0}; }
 _z_reply_t _z_reply_move(_z_reply_t *src_reply);
-
-_z_reply_t _z_reply_null(void);
 void _z_reply_clear(_z_reply_t *src);
 void _z_reply_free(_z_reply_t **hello);
 z_result_t _z_reply_copy(_z_reply_t *dst, const _z_reply_t *src);

include/zenoh-pico/net/sample.h

@@ -40,8 +40,12 @@ typedef struct _z_sample_t {
 } _z_sample_t;
 void _z_sample_clear(_z_sample_t *sample);
 
-_z_sample_t _z_sample_null(void);
-bool _z_sample_check(const _z_sample_t *sample);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_sample_t _z_sample_null(void) { return (_z_sample_t){0}; }
+static inline bool _z_sample_check(const _z_sample_t *sample) {
+    return _z_keyexpr_check(&sample->keyexpr) || _z_encoding_check(&sample->encoding) ||
+           _z_bytes_check(&sample->payload) || _z_bytes_check(&sample->attachment);
+}
 void _z_sample_move(_z_sample_t *dst, _z_sample_t *src);
 
 /**

include/zenoh-pico/net/subscribe.h

@@ -29,11 +29,12 @@ typedef struct {
 } _z_subscriber_t;
 
 #if Z_FEATURE_SUBSCRIPTION == 1
-
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_subscriber_t _z_subscriber_null(void) { return (_z_subscriber_t){0}; }
+static inline bool _z_subscriber_check(const _z_subscriber_t *subscriber) { return !_Z_RC_IS_NULL(&subscriber->_zn); }
 void _z_subscriber_clear(_z_subscriber_t *sub);
 void _z_subscriber_free(_z_subscriber_t **sub);
-bool _z_subscriber_check(const _z_subscriber_t *subscriber);
-_z_subscriber_t _z_subscriber_null(void);
+
 #endif
 
 #endif /* ZENOH_PICO_SUBSCRIBE_NETAPI_H */

include/zenoh-pico/protocol/core.h

@@ -66,8 +66,9 @@ typedef struct {
     uint64_t time;
 } _z_timestamp_t;
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_timestamp_t _z_timestamp_null(void) { return (_z_timestamp_t){0}; }
 _z_timestamp_t _z_timestamp_duplicate(const _z_timestamp_t *tstamp);
-_z_timestamp_t _z_timestamp_null(void);
 void _z_timestamp_clear(_z_timestamp_t *tstamp);
 bool _z_timestamp_check(const _z_timestamp_t *stamp);
 uint64_t _z_timestamp_ntp64_from_time(uint32_t seconds, uint32_t nanos);
@@ -163,7 +164,9 @@ typedef struct {
     _z_bytes_t payload;
     _z_encoding_t encoding;
 } _z_value_t;
-_z_value_t _z_value_null(void);
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_value_t _z_value_null(void) { return (_z_value_t){0}; }
 _z_value_t _z_value_steal(_z_value_t *value);
 z_result_t _z_value_copy(_z_value_t *dst, const _z_value_t *src);
 void _z_value_move(_z_value_t *dst, _z_value_t *src);
@@ -184,10 +187,13 @@ typedef struct {
     z_whatami_t _whatami;
     uint8_t _version;
 } _z_hello_t;
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_hello_t _z_hello_null(void) { return (_z_hello_t){0}; }
 void _z_hello_clear(_z_hello_t *src);
 void _z_hello_free(_z_hello_t **hello);
 z_result_t _z_hello_copy(_z_hello_t *dst, const _z_hello_t *src);
-_z_hello_t _z_hello_null(void);
+
 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)
@@ -202,7 +208,9 @@ typedef struct {
     uint32_t _entity_id;
     uint32_t _source_sn;
 } _z_source_info_t;
-_z_source_info_t _z_source_info_null(void);
+
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_source_info_t _z_source_info_null(void) { return (_z_source_info_t){0}; }
 
 typedef struct {
     uint32_t _request_id;

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

@@ -24,22 +24,26 @@ typedef struct {
     uint16_t _id;
     _z_keyexpr_t _keyexpr;
 } _z_decl_kexpr_t;
-_z_decl_kexpr_t _z_decl_kexpr_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_kexpr_t _z_decl_kexpr_null(void) { return (_z_decl_kexpr_t){0}; }
 typedef struct {
     uint16_t _id;
 } _z_undecl_kexpr_t;
-_z_undecl_kexpr_t _z_undecl_kexpr_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_kexpr_t _z_undecl_kexpr_null(void) { return (_z_undecl_kexpr_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
     uint32_t _id;
 } _z_decl_subscriber_t;
-_z_decl_subscriber_t _z_decl_subscriber_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_subscriber_t _z_decl_subscriber_null(void) { return (_z_decl_subscriber_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_subscriber_t;
-_z_undecl_subscriber_t _z_undecl_subscriber_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_subscriber_t _z_undecl_subscriber_null(void) { return (_z_undecl_subscriber_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
@@ -49,28 +53,33 @@ typedef struct {
         uint16_t _distance;
     } _ext_queryable_info;
 } _z_decl_queryable_t;
-_z_decl_queryable_t _z_decl_queryable_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_queryable_t _z_decl_queryable_null(void) { return (_z_decl_queryable_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_queryable_t;
-_z_undecl_queryable_t _z_undecl_queryable_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_queryable_t _z_undecl_queryable_null(void) { return (_z_undecl_queryable_t){0}; }
 
 typedef struct {
     _z_keyexpr_t _keyexpr;
     uint32_t _id;
 } _z_decl_token_t;
-_z_decl_token_t _z_decl_token_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_token_t _z_decl_token_null(void) { return (_z_decl_token_t){0}; }
 typedef struct {
     uint32_t _id;
     _z_keyexpr_t _ext_keyexpr;
 } _z_undecl_token_t;
-_z_undecl_token_t _z_undecl_token_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_undecl_token_t _z_undecl_token_null(void) { return (_z_undecl_token_t){0}; }
 
 typedef struct {
     bool _placeholder;  // In case we add extensions
 } _z_decl_final_t;
-_z_decl_final_t _z_decl_final_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_decl_final_t _z_decl_final_null(void) { return (_z_decl_final_t){0}; }
 
 typedef struct {
     enum {

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

@@ -36,10 +36,10 @@ typedef struct {
     uint32_t _id;
     uint8_t flags;
 } _z_interest_t;
-_z_interest_t _z_interest_null(void);
 
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_interest_t _z_interest_null(void) { return (_z_interest_t){0}; }
 void _z_interest_clear(_z_interest_t* decl);
-
 _z_interest_t _z_make_interest(_Z_MOVE(_z_keyexpr_t) key, uint32_t id, uint8_t flags);
 _z_interest_t _z_make_interest_final(uint32_t id);
 

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

@@ -149,7 +149,9 @@ _z_n_msg_request_exts_t _z_n_msg_request_needed_exts(const _z_n_msg_request_t *m
 void _z_n_msg_request_clear(_z_n_msg_request_t *msg);
 
 typedef _z_reply_body_t _z_push_body_t;
-_z_push_body_t _z_push_body_null(void);
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_push_body_t _z_push_body_null(void) { return (_z_push_body_t){0}; }
+
 _z_push_body_t _z_push_body_steal(_z_push_body_t *msg);
 void _z_push_body_clear(_z_push_body_t *msg);
 

include/zenoh-pico/protocol/keyexpr.h

@@ -26,20 +26,25 @@ bool _z_keyexpr_suffix_intersects(const _z_keyexpr_t *left, const _z_keyexpr_t *
 bool _z_keyexpr_suffix_equals(const _z_keyexpr_t *left, const _z_keyexpr_t *right);
 
 /*------------------ clone/Copy/Free helpers ------------------*/
+// Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
+static inline _z_keyexpr_t _z_keyexpr_null(void) { return (_z_keyexpr_t){0}; }
+static inline _z_keyexpr_t _z_keyexpr_alias(const _z_keyexpr_t src) {
+    return (_z_keyexpr_t){
+        ._id = src._id,
+        ._mapping = src._mapping,
+        ._suffix = _z_string_alias(src._suffix),
+    };
+}
+
 _z_keyexpr_t _z_keyexpr_from_string(uint16_t rid, _z_string_t *str);
 _z_keyexpr_t _z_keyexpr_from_substr(uint16_t rid, const char *str, size_t len);
 z_result_t _z_keyexpr_copy(_z_keyexpr_t *dst, const _z_keyexpr_t *src);
-_z_keyexpr_t _z_keyexpr_duplicate(_z_keyexpr_t src);
-_z_keyexpr_t _z_keyexpr_alias(_z_keyexpr_t src);
+_z_keyexpr_t _z_keyexpr_duplicate(const _z_keyexpr_t *src);
 /// Returns either keyexpr defined by id + mapping with null suffix if try_declared is true and id is non-zero,
 /// or keyexpr defined by its suffix only, with 0 id and no mapping. This is to be used only when forwarding
 /// keyexpr in user api to properly separate declared keyexpr from its suffix.
 _z_keyexpr_t _z_keyexpr_alias_from_user_defined(_z_keyexpr_t src, bool try_declared);
 _z_keyexpr_t _z_keyexpr_steal(_Z_MOVE(_z_keyexpr_t) src);
-static inline _z_keyexpr_t _z_keyexpr_null(void) {
-    _z_keyexpr_t keyexpr = {0, {0}, _z_string_null()};
-    return keyexpr;
-}
 bool _z_keyexpr_equals(const _z_keyexpr_t *left, const _z_keyexpr_t *right);
 void _z_keyexpr_move(_z_keyexpr_t *dst, _z_keyexpr_t *src);
 void _z_keyexpr_clear(_z_keyexpr_t *rk);