niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

move util library into ddsrt

Browse source 
As was the plan with the introduction of ddsrt; this includes renaming
the identifiers to match the capitalization style and removes old junk.

Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
Erik Boasson 2019-04-16 10:23:32 +02:00 • committed by eboasson
parent 42500e7fb8
commit 712ca3149f
62 changed files with 1702 additions and 1869 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/core/CMakeLists.txt
View file

@ -50,16 +50,13 @@ endif()
include(ddsi/CMakeLists.txt)
include(ddsc/CMakeLists.txt)
target_link_libraries(ddsc PRIVATE util)
target_link_libraries(ddsc PRIVATE ddsrt)
target_compile_definitions(
ddsc PUBLIC
$<BUILD_INTERFACE:$<TARGET_PROPERTY:ddsrt,INTERFACE_COMPILE_DEFINITIONS>>
$<BUILD_INTERFACE:$<TARGET_PROPERTY:util,INTERFACE_COMPILE_DEFINITIONS>>)
$<BUILD_INTERFACE:$<TARGET_PROPERTY:ddsrt,INTERFACE_COMPILE_DEFINITIONS>>)
target_include_directories(
ddsc PUBLIC
$<BUILD_INTERFACE:$<TARGET_PROPERTY:ddsrt,INTERFACE_INCLUDE_DIRECTORIES>>
$<BUILD_INTERFACE:$<TARGET_PROPERTY:util,INTERFACE_INCLUDE_DIRECTORIES>>)
$<BUILD_INTERFACE:$<TARGET_PROPERTY:ddsrt,INTERFACE_INCLUDE_DIRECTORIES>>)
# SOVERSION should increase on incompatible ABI change
set_target_properties(ddsc PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})

2
src/core/ddsc/src/dds__domain.h
View file

@ -18,7 +18,7 @@
extern "C" {
#endif
extern DDS_EXPORT const ut_avlTreedef_t dds_domaintree_def;
extern DDS_EXPORT const ddsrt_avl_treedef_t dds_domaintree_def;
DDS_EXPORT dds_domain * dds_domain_create (dds_domainid_t id);
DDS_EXPORT void dds_domain_free (dds_domain * domain);

4
src/core/ddsc/src/dds__handles.h
View file

@ -94,9 +94,9 @@ dds_handle_server_fini(void);
* user data.
*
* A kind value != 0 has to be provided, just to make sure that no 0 handles
* will be created. It should also fit the UT_HANDLE_KIND_MASK.
* will be created. It should also fit the DDSRT_HANDLE_KIND_MASK.
* In other words handle creation will fail if
* ((kind & ~UT_HANDLE_KIND_MASK != 0) || (kind & UT_HANDLE_KIND_MASK == 0)).
* ((kind & ~DDSRT_HANDLE_KIND_MASK != 0) || (kind & DDSRT_HANDLE_KIND_MASK == 0)).
*
* It has to do something clever to make sure that a deleted handle is not
* re-issued very quickly after it was deleted.

10
src/core/ddsc/src/dds__types.h
View file

@ -17,7 +17,7 @@
#include "dds/dds.h"
#include "dds/ddsrt/sync.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds__handles.h"
#if defined (__cplusplus)
@ -94,9 +94,9 @@ struct dds_listener {
typedef struct dds_domain
{
ut_avlNode_t m_node;
ddsrt_avl_node_t m_node;
dds_domainid_t m_id;
ut_avlTree_t m_topics;
ddsrt_avl_tree_t m_topics;
uint32_t m_refc;
}
dds_domain;
@ -151,7 +151,7 @@ typedef struct dds_entity
}
dds_entity;
extern const ut_avlTreedef_t dds_topictree_def;
extern const ddsrt_avl_treedef_t dds_topictree_def;
typedef struct dds_subscriber
{
@ -283,7 +283,7 @@ typedef struct dds_globals
int (*m_dur_wait) (struct dds_reader * reader, dds_duration_t timeout);
void (*m_dur_init) (void);
void (*m_dur_fini) (void);
ut_avlTree_t m_domains;
ddsrt_avl_tree_t m_domains;
ddsrt_mutex_t m_mutex;
}
dds_globals;

10
src/core/ddsc/src/dds_domain.c
View file

@ -17,7 +17,7 @@ static int dds_domain_compare (const int32_t * a, const int32_t * b)
return (*a == *b) ? 0 : (*a < *b) ? -1 : 1;
}
const ut_avlTreedef_t dds_domaintree_def = UT_AVL_TREEDEF_INITIALIZER
const ddsrt_avl_treedef_t dds_domaintree_def = DDSRT_AVL_TREEDEF_INITIALIZER
(
offsetof (dds_domain, m_node),
offsetof (dds_domain, m_id),
@ -27,7 +27,7 @@ const ut_avlTreedef_t dds_domaintree_def = UT_AVL_TREEDEF_INITIALIZER
dds_domain * dds_domain_find_locked (dds_domainid_t id)
{
return ut_avlLookup (&dds_domaintree_def, &dds_global.m_domains, &id);
return ddsrt_avl_lookup (&dds_domaintree_def, &dds_global.m_domains, &id);
}
dds_domain * dds_domain_create (dds_domainid_t id)
@ -39,8 +39,8 @@ dds_domain * dds_domain_create (dds_domainid_t id)
{
domain = dds_alloc (sizeof (*domain));
domain->m_id = id;
ut_avlInit (&dds_topictree_def, &domain->m_topics);
ut_avlInsert (&dds_domaintree_def, &dds_global.m_domains, domain);
ddsrt_avl_init (&dds_topictree_def, &domain->m_topics);
ddsrt_avl_insert (&dds_domaintree_def, &dds_global.m_domains, domain);
}
domain->m_refc++;
ddsrt_mutex_unlock (&dds_global.m_mutex);
@ -52,7 +52,7 @@ void dds_domain_free (dds_domain * domain)
ddsrt_mutex_lock (&dds_global.m_mutex);
if (--domain->m_refc == 0)
{
ut_avlDelete (&dds_domaintree_def, &dds_global.m_domains, domain);
ddsrt_avl_delete (&dds_domaintree_def, &dds_global.m_domains, domain);
dds_free (domain);
}
ddsrt_mutex_unlock (&dds_global.m_mutex);

34
src/core/ddsc/src/dds_handles.c
View file

@ -15,7 +15,7 @@
#include "dds/ddsrt/sync.h"
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/random.h"
#include "dds/util/ut_hopscotch.h"
#include "dds/ddsrt/hopscotch.h"
#include "dds/ddsi/q_thread.h"
#include "dds__handles.h"
#include "dds__types.h"
@ -40,9 +40,9 @@
struct dds_handle_server {
#if USE_CHH
struct ut_chh *ht;
struct ddsrt_chh *ht;
#else
struct ut_hh *ht;
struct ddsrt_hh *ht;
#endif
size_t count;
ddsrt_mutex_t lock;
@ -68,9 +68,9 @@ static int handle_equal (const void *va, const void *vb)
dds_return_t dds_handle_server_init (void (*free_via_gc) (void *x))
{
#if USE_CHH
handles.ht = ut_chhNew (128, handle_hash, handle_equal, free_via_gc);
handles.ht = ddsrt_chh_new (128, handle_hash, handle_equal, free_via_gc);
#else
handles.ht = ut_hhNew (128, handle_hash, handle_equal);
handles.ht = ddsrt_hh_new (128, handle_hash, handle_equal);
(void) free_via_gc;
#endif
handles.count = 0;
@ -83,16 +83,16 @@ void dds_handle_server_fini (void)
{
#if USE_CHH
#ifndef NDEBUG
struct ut_chhIter it;
assert (ut_chhIterFirst (handles.ht, &it) == NULL);
struct ddsrt_chh_iter it;
assert (ddsrt_chh_iter_first (handles.ht, &it) == NULL);
#endif
ut_chhFree (handles.ht);
ddsrt_chh_free (handles.ht);
#else /* USE_CHH */
#ifndef NDEBUG
struct ut_hhIter it;
assert (ut_hhIterFirst (handles.ht, &it) == NULL);
struct ddsrt_hh_iter it;
assert (ddsrt_hh_iter_first (handles.ht, &it) == NULL);
#endif
ut_hhFree (handles.ht);
ddsrt_hh_free (handles.ht);
#endif /* USE_CHH */
ddsrt_cond_destroy (&handles.cond);
ddsrt_mutex_destroy (&handles.lock);
@ -100,9 +100,9 @@ void dds_handle_server_fini (void)
}
#if USE_CHH
static bool hhadd (struct ut_chh *ht, void *elem) { return ut_chhAdd (ht, elem); }
static bool hhadd (struct ddsrt_chh *ht, void *elem) { return ddsrt_chh_add (ht, elem); }
#else
static bool hhadd (struct ut_hh *ht, void *elem) { return ut_hhAdd (ht, elem); }
static bool hhadd (struct ddsrt_hh *ht, void *elem) { return ddsrt_hh_add (ht, elem); }
#endif
static dds_handle_t dds_handle_create_int (struct dds_handle_link *link)
{
@ -176,10 +176,10 @@ int32_t dds_handle_delete (struct dds_handle_link *link, dds_duration_t timeout)
}
#if USE_CHH
thread_state_awake (ts1);
int x = ut_chhRemove (handles.ht, link);
int x = ddsrt_chh_remove (handles.ht, link);
thread_state_asleep (ts1);
#else
int x = ut_hhRemove (handles.ht, link);
int x = ddsrt_hh_remove (handles.ht, link);
#endif
assert(x);
(void)x;
@ -209,10 +209,10 @@ int32_t dds_handle_claim (dds_handle_t hdl, struct dds_handle_link **link)
#if USE_CHH
thread_state_awake (ts1);
*link = ut_chhLookup (handles.ht, &dummy);
*link = ddsrt_chh_lookup (handles.ht, &dummy);
#else
ddsrt_mutex_lock (&handles.lock);
*link = ut_hhLookup (handles.ht, &dummy);
*link = ddsrt_hh_lookup (handles.ht, &dummy);
#endif
if (*link == NULL)
rc = DDS_RETCODE_BAD_PARAMETER;

2
src/core/ddsc/src/dds_init.c
View file

@ -123,7 +123,7 @@ dds_init(dds_domainid_t domain)
}
upgrade_main_thread();
ut_avlInit(&dds_domaintree_def, &dds_global.m_domains);
ddsrt_avl_init(&dds_domaintree_def, &dds_global.m_domains);
/* Start monitoring the liveliness of all threads. */
if (!config.liveliness_monitoring)

4
src/core/ddsc/src/dds_reader.c
View file

@ -532,14 +532,14 @@ void dds_reader_ddsi2direct (dds_entity_t entity, ddsi2direct_directread_cb_t cb
rd->ddsi2direct_cb = cb;
rd->ddsi2direct_cbarg = cbarg;
while ((m = ut_avlLookupSuccEq (&rd_writers_treedef, &rd->writers, &pwrguid)) != NULL)
while ((m = ddsrt_avl_lookup_succ_eq (&rd_writers_treedef, &rd->writers, &pwrguid)) != NULL)
{
/* have to be careful walking the tree -- pretty is different, but
I want to check this before I write a lookup_succ function. */
struct rd_pwr_match *m_next;
nn_guid_t pwrguid_next;
pwrguid = m->pwr_guid;
if ((m_next = ut_avlFindSucc (&rd_writers_treedef, &rd->writers, m)) != NULL)
if ((m_next = ddsrt_avl_find_succ (&rd_writers_treedef, &rd->writers, m)) != NULL)
pwrguid_next = m_next->pwr_guid;
else
{

50
src/core/ddsc/src/dds_rhc.c
View file

@ -27,8 +27,8 @@
#include "dds__reader.h"
#include "dds__rhc.h"
#include "dds/ddsi/ddsi_tkmap.h"
#include "dds/util/ut_hopscotch.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/hopscotch.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_xqos.h"
#include "dds/ddsi/q_error.h"
#include "dds/ddsi/q_unused.h"
@ -174,7 +174,7 @@ struct lwreg
struct lwregs
{
struct ut_ehh * regs;
struct ddsrt_ehh * regs;
};
static uint32_t lwreg_hash (const void *vl)
@ -192,36 +192,36 @@ static int lwreg_equals (const void *va, const void *vb)
static void lwregs_init (struct lwregs *rt)
{
rt->regs = ut_ehhNew (sizeof (struct lwreg), 1, lwreg_hash, lwreg_equals);
rt->regs = ddsrt_ehh_new (sizeof (struct lwreg), 1, lwreg_hash, lwreg_equals);
}
static void lwregs_fini (struct lwregs *rt)
{
ut_ehhFree (rt->regs);
ddsrt_ehh_free (rt->regs);
}
static int lwregs_contains (struct lwregs *rt, uint64_t iid, uint64_t wr_iid)
{
struct lwreg dummy = { .iid = iid, .wr_iid = wr_iid };
return ut_ehhLookup (rt->regs, &dummy) != NULL;
return ddsrt_ehh_lookup (rt->regs, &dummy) != NULL;
}
static int lwregs_add (struct lwregs *rt, uint64_t iid, uint64_t wr_iid)
{
struct lwreg dummy = { .iid = iid, .wr_iid = wr_iid };
return ut_ehhAdd (rt->regs, &dummy);
return ddsrt_ehh_add (rt->regs, &dummy);
}
static int lwregs_delete (struct lwregs *rt, uint64_t iid, uint64_t wr_iid)
{
struct lwreg dummy = { .iid = iid, .wr_iid = wr_iid };
return ut_ehhRemove (rt->regs, &dummy);
return ddsrt_ehh_remove (rt->regs, &dummy);
}
void lwregs_dump (struct lwregs *rt)
{
struct ut_ehhIter it;
for (struct lwreg *r = ut_ehhIterFirst(rt->regs, &it); r; r = ut_ehhIterNext(&it))
struct ddsrt_ehh_iter it;
for (struct lwreg *r = ddsrt_ehh_iter_first(rt->regs, &it); r; r = ddsrt_ehh_iter_next(&it))
printf("iid=%"PRIu64" wr_iid=%"PRIu64"\n", r->iid, r->wr_iid);
}
@ -271,7 +271,7 @@ typedef enum rhc_store_result {
} rhc_store_result_t;
struct rhc {
struct ut_hh *instances;
struct ddsrt_hh *instances;
struct rhc_instance *nonempty_instances; /* circular, points to most recently added one, NULL if none */
struct lwregs registrations; /* should be a global one (with lock-free lookups) */
@ -458,7 +458,7 @@ struct rhc * dds_rhc_new (dds_reader * reader, const struct ddsi_sertopic * topi
lwregs_init (&rhc->registrations);
ddsrt_mutex_init (&rhc->lock);
rhc->instances = ut_hhNew (1, instance_iid_hash, instance_iid_eq);
rhc->instances = ddsrt_hh_new (1, instance_iid_hash, instance_iid_eq);
rhc->topic = topic;
rhc->reader = reader;
@ -620,9 +620,9 @@ static void free_instance_rhc_free_wrap (void *vnode, void *varg)
void dds_rhc_free (struct rhc *rhc)
{
assert (rhc_check_counts_locked (rhc, true, true));
ut_hhEnum (rhc->instances, free_instance_rhc_free_wrap, rhc);
ddsrt_hh_enum (rhc->instances, free_instance_rhc_free_wrap, rhc);
assert (rhc->nonempty_instances == NULL);
ut_hhFree (rhc->instances);
ddsrt_hh_free (rhc->instances);
lwregs_fini (&rhc->registrations);
if (rhc->qcond_eval_samplebuf != NULL)
ddsi_sertopic_free_sample (rhc->topic, rhc->qcond_eval_samplebuf, DDS_FREE_ALL);
@ -848,7 +848,7 @@ static void drop_instance_noupdate_no_writers (struct rhc *rhc, struct rhc_insta
rhc->n_instances--;
ret = ut_hhRemove (rhc->instances, inst);
ret = ddsrt_hh_remove (rhc->instances, inst);
assert (ret);
(void) ret;
@ -1198,7 +1198,7 @@ static rhc_store_result_t rhc_store_new_instance (struct rhc_instance **out_inst
}
account_for_empty_to_nonempty_transition (rhc, inst);
ret = ut_hhAdd (rhc->instances, inst);
ret = ddsrt_hh_add (rhc->instances, inst);
assert (ret);
(void) ret;
rhc->n_instances++;
@ -1248,7 +1248,7 @@ bool dds_rhc_store (struct rhc * __restrict rhc, const struct proxy_writer_info
ddsrt_mutex_lock (&rhc->lock);
inst = ut_hhLookup (rhc->instances, &dummy_instance);
inst = ddsrt_hh_lookup (rhc->instances, &dummy_instance);
if (inst == NULL)
{
/* New instance for this reader. If no data content -- not (also)
@ -1492,13 +1492,13 @@ void dds_rhc_unregister_wr (struct rhc * __restrict rhc, const struct proxy_writ
bool trigger_waitsets = false;
bool notify_data_available = false;
struct rhc_instance *inst;
struct ut_hhIter iter;
struct ddsrt_hh_iter iter;
const uint64_t wr_iid = pwr_info->iid;
const int auto_dispose = pwr_info->auto_dispose;
ddsrt_mutex_lock (&rhc->lock);
TRACE ("rhc_unregister_wr_iid(%"PRIx64",%d:\n", wr_iid, auto_dispose);
for (inst = ut_hhIterFirst (rhc->instances, &iter); inst; inst = ut_hhIterNext (&iter))
for (inst = ddsrt_hh_iter_first (rhc->instances, &iter); inst; inst = ddsrt_hh_iter_next (&iter))
{
if ((inst->wr_iid_islive && inst->wr_iid == wr_iid) || lwregs_contains (&rhc->registrations, inst->iid, wr_iid))
{
@ -1558,10 +1558,10 @@ void dds_rhc_unregister_wr (struct rhc * __restrict rhc, const struct proxy_writ
void dds_rhc_relinquish_ownership (struct rhc * __restrict rhc, const uint64_t wr_iid)
{
struct rhc_instance *inst;
struct ut_hhIter iter;
struct ddsrt_hh_iter iter;
ddsrt_mutex_lock (&rhc->lock);
TRACE ("rhc_relinquish_ownership(%"PRIx64":\n", wr_iid);
for (inst = ut_hhIterFirst (rhc->instances, &iter); inst; inst = ut_hhIterNext (&iter))
for (inst = ddsrt_hh_iter_first (rhc->instances, &iter); inst; inst = ddsrt_hh_iter_next (&iter))
{
if (inst->wr_iid_islive && inst->wr_iid == wr_iid)
{
@ -2234,7 +2234,7 @@ bool dds_rhc_add_readcondition (dds_readcond *cond)
between those attached to a waitset or not. */
struct rhc *rhc = cond->m_rhc;
struct ut_hhIter it;
struct ddsrt_hh_iter it;
assert ((dds_entity_kind (&cond->m_entity) == DDS_KIND_COND_READ && cond->m_query.m_filter == 0) ||
(dds_entity_kind (&cond->m_entity) == DDS_KIND_COND_QUERY && cond->m_query.m_filter != 0));
@ -2296,7 +2296,7 @@ bool dds_rhc_add_readcondition (dds_readcond *cond)
samples, except for those that match the predicate. */
const dds_querycond_mask_t qcmask = cond->m_query.m_qcmask;
uint32_t trigger = 0;
for (struct rhc_instance *inst = ut_hhIterFirst (rhc->instances, &it); inst != NULL; inst = ut_hhIterNext (&it))
for (struct rhc_instance *inst = ddsrt_hh_iter_first (rhc->instances, &it); inst != NULL; inst = ddsrt_hh_iter_next (&it))
{
const bool instmatch = eval_predicate_invsample (rhc, inst, cond->m_query.m_filter);;
uint32_t matches = 0;
@ -2612,7 +2612,7 @@ static int rhc_check_counts_locked (struct rhc *rhc, bool check_conds, bool chec
unsigned cond_match_count[CHECK_MAX_CONDS];
dds_querycond_mask_t enabled_qcmask = 0;
struct rhc_instance *inst;
struct ut_hhIter iter;
struct ddsrt_hh_iter iter;
dds_readcond *rciter;
uint32_t i;
@ -2628,7 +2628,7 @@ static int rhc_check_counts_locked (struct rhc *rhc, bool check_conds, bool chec
enabled_qcmask |= rciter->m_query.m_qcmask;
}
for (inst = ut_hhIterFirst (rhc->instances, &iter); inst; inst = ut_hhIterNext (&iter))
for (inst = ddsrt_hh_iter_first (rhc->instances, &iter); inst; inst = ddsrt_hh_iter_next (&iter))
{
unsigned n_vsamples_in_instance = 0, n_read_vsamples_in_instance = 0;
bool a_sample_free = true;

14
src/core/ddsc/src/dds_topic.c
View file

@ -32,7 +32,7 @@ DECL_ENTITY_LOCK_UNLOCK(extern inline, dds_topic)
#define DDS_TOPIC_STATUS_MASK \
DDS_INCONSISTENT_TOPIC_STATUS
const ut_avlTreedef_t dds_topictree_def = UT_AVL_TREEDEF_INITIALIZER_INDKEY
const ddsrt_avl_treedef_t dds_topictree_def = DDSRT_AVL_TREEDEF_INITIALIZER_INDKEY
(
offsetof (struct ddsi_sertopic, avlnode),
offsetof (struct ddsi_sertopic, name_typename),
@ -118,17 +118,17 @@ dds_topic_lookup_locked(
const char *name)
{
struct ddsi_sertopic *st = NULL;
ut_avlIter_t iter;
ddsrt_avl_iter_t iter;
assert (domain);
assert (name);
st = ut_avlIterFirst (&dds_topictree_def, &domain->m_topics, &iter);
st = ddsrt_avl_iter_first (&dds_topictree_def, &domain->m_topics, &iter);
while (st) {
if (strcmp (st->name, name) == 0) {
break;
}
st = ut_avlIterNext (&iter);
st = ddsrt_avl_iter_next (&iter);
}
return st;
}
@ -155,9 +155,9 @@ dds_topic_free(
assert (st);
ddsrt_mutex_lock (&dds_global.m_mutex);
domain = ut_avlLookup (&dds_domaintree_def, &dds_global.m_domains, &domainid);
domain = ddsrt_avl_lookup (&dds_domaintree_def, &dds_global.m_domains, &domainid);
if (domain != NULL) {
ut_avlDelete (&dds_topictree_def, &domain->m_topics, st);
ddsrt_avl_delete (&dds_topictree_def, &domain->m_topics, st);
}
ddsrt_mutex_unlock (&dds_global.m_mutex);
st->status_cb_entity = NULL;
@ -172,7 +172,7 @@ dds_topic_add_locked(
dds_domain * dom;
dom = dds_domain_find_locked (id);
assert (dom);
ut_avlInsert (&dds_topictree_def, &dom->m_topics, st);
ddsrt_avl_insert (&dds_topictree_def, &dom->m_topics, st);
}
DDS_EXPORT dds_entity_t

112
src/core/ddsc/src/dds_whc.c
View file

@ -22,8 +22,8 @@
#include "dds__whc.h"
#include "dds/ddsi/ddsi_tkmap.h"
#include "dds/util/ut_avl.h"
#include "dds/util/ut_hopscotch.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsrt/hopscotch.h"
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_freelist.h"
@ -47,7 +47,7 @@ struct whc_node {
};
struct whc_intvnode {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
seqno_t min;
seqno_t maxp1;
struct whc_node *first; /* linked list of seqs with contiguous sequence numbers [min,maxp1) */
@ -89,12 +89,12 @@ struct whc_impl {
struct whc_node *maxseq_node; /* NULL if empty; if not in open_intv, open_intv is empty */
struct nn_freelist freelist; /* struct whc_node *; linked via whc_node::next_seq */
#if USE_EHH
struct ut_ehh *seq_hash;
struct ddsrt_ehh *seq_hash;
#else
struct ut_hh *seq_hash;
struct ddsrt_hh *seq_hash;
#endif
struct ut_hh *idx_hash;
ut_avlTree_t seq;
struct ddsrt_hh *idx_hash;
ddsrt_avl_tree_t seq;
};
struct whc_sample_iter_impl {
@ -140,8 +140,8 @@ static void whc_default_sample_iter_init (const struct whc *whc, struct whc_samp
static bool whc_default_sample_iter_borrow_next (struct whc_sample_iter *opaque_it, struct whc_borrowed_sample *sample);
static void whc_default_free (struct whc *whc);
static const ut_avlTreedef_t whc_seq_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct whc_intvnode, avlnode), offsetof (struct whc_intvnode, min), compare_seq, 0);
static const ddsrt_avl_treedef_t whc_seq_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct whc_intvnode, avlnode), offsetof (struct whc_intvnode, min), compare_seq, 0);
static const struct whc_ops whc_ops = {
.insert = whc_default_insert,
@ -225,7 +225,7 @@ static struct whc_node *whc_findmax_procedurally (const struct whc_impl *whc)
}
else
{
struct whc_intvnode *intv = ut_avlFindPred (&whc_seq_treedef, &whc->seq, whc->open_intv);
struct whc_intvnode *intv = ddsrt_avl_find_pred (&whc_seq_treedef, &whc->seq, whc->open_intv);
assert (intv && intv->first);
return intv->last;
}
@ -239,8 +239,8 @@ static void check_whc (const struct whc_impl *whc)
contiguous; all samples in seq & in seqhash; tlidx \subseteq seq;
seq-number ordered list correct; &c. */
assert (whc->open_intv != NULL);
assert (whc->open_intv == ut_avlFindMax (&whc_seq_treedef, &whc->seq));
assert (ut_avlFindSucc (&whc_seq_treedef, &whc->seq, whc->open_intv) == NULL);
assert (whc->open_intv == ddsrt_avl_find_max (&whc_seq_treedef, &whc->seq));
assert (ddsrt_avl_find_succ (&whc_seq_treedef, &whc->seq, whc->open_intv) == NULL);
if (whc->maxseq_node)
{
assert (whc->maxseq_node->next_seq == NULL);
@ -264,7 +264,7 @@ static void check_whc (const struct whc_impl *whc)
struct whc_intvnode *firstintv;
struct whc_node *cur;
seqno_t prevseq = 0;
firstintv = ut_avlFindMin (&whc_seq_treedef, &whc->seq);
firstintv = ddsrt_avl_find_min (&whc_seq_treedef, &whc->seq);
assert (firstintv);
cur = firstintv->first;
while (cur)
@ -283,10 +283,10 @@ static void insert_whcn_in_hash (struct whc_impl *whc, struct whc_node *whcn)
/* precondition: whcn is not in hash */
#if USE_EHH
struct whc_seq_entry e = { .seq = whcn->seq, .whcn = whcn };
if (!ut_ehhAdd (whc->seq_hash, &e))
if (!ddsrt_ehh_add (whc->seq_hash, &e))
assert(0);
#else
if (!ut_hhAdd (whc->seq_hash, whcn))
if (!ddsrt_hh_add (whc->seq_hash, whcn))
assert(0);
#endif
}
@ -296,10 +296,10 @@ static void remove_whcn_from_hash (struct whc_impl *whc, struct whc_node *whcn)
/* precondition: whcn is in hash */
#if USE_EHH
struct whc_seq_entry e = { .seq = whcn->seq };
if (!ut_ehhRemove(whc->seq_hash, &e))
if (!ddsrt_ehh_remove(whc->seq_hash, &e))
assert(0);
#else
if (!ut_hhRemove(whc->seq_hash, whcn))
if (!ddsrt_hh_remove(whc->seq_hash, whcn))
assert(0);
#endif
}
@ -308,14 +308,14 @@ static struct whc_node *whc_findseq (const struct whc_impl *whc, seqno_t seq)
{
#if USE_EHH
struct whc_seq_entry e = { .seq = seq }, *r;
if ((r = ut_ehhLookup(whc->seq_hash, &e)) != NULL)
if ((r = ddsrt_ehh_lookup(whc->seq_hash, &e)) != NULL)
return r->whcn;
else
return NULL;
#else
struct whc_node template;
template.seq = seq;
return ut_hhLookup(whc->seq_hash, &template);
return ddsrt_hh_lookup(whc->seq_hash, &template);
#endif
}
@ -328,7 +328,7 @@ static struct whc_node *whc_findkey (const struct whc_impl *whc, const struct dd
struct whc_idxnode *n;
check_whc (whc);
template.idxn.iid = ddsi_tkmap_lookup(gv.m_tkmap, serdata_key);
n = ut_hhLookup (whc->idx_hash, &template.idxn);
n = ddsrt_hh_lookup (whc->idx_hash, &template.idxn);
if (n == NULL)
return NULL;
else
@ -359,22 +359,22 @@ struct whc *whc_new (int is_transient_local, unsigned hdepth, unsigned tldepth)
whc->total_bytes = 0;
whc->sample_overhead = sample_overhead;
#if USE_EHH
whc->seq_hash = ut_ehhNew (sizeof (struct whc_seq_entry), 32, whc_seq_entry_hash, whc_seq_entry_eq);
whc->seq_hash = ddsrt_ehh_new (sizeof (struct whc_seq_entry), 32, whc_seq_entry_hash, whc_seq_entry_eq);
#else
whc->seq_hash = ut_hhNew(32, whc_node_hash, whc_node_eq);
whc->seq_hash = ddsrt_hh_new(32, whc_node_hash, whc_node_eq);
#endif
if (whc->idxdepth > 0)
whc->idx_hash = ut_hhNew(32, whc_idxnode_hash_key, whc_idxnode_eq_key);
whc->idx_hash = ddsrt_hh_new(32, whc_idxnode_hash_key, whc_idxnode_eq_key);
else
whc->idx_hash = NULL;
/* seq interval tree: always has an "open" node */
ut_avlInit (&whc_seq_treedef, &whc->seq);
ddsrt_avl_init (&whc_seq_treedef, &whc->seq);
intv = ddsrt_malloc (sizeof (*intv));
intv->min = intv->maxp1 = 1;
intv->first = intv->last = NULL;
ut_avlInsert (&whc_seq_treedef, &whc->seq, intv);
ddsrt_avl_insert (&whc_seq_treedef, &whc->seq, intv);
whc->open_intv = intv;
whc->maxseq_node = NULL;
@ -402,11 +402,11 @@ void whc_default_free (struct whc *whc_generic)
if (whc->idx_hash)
{
struct ut_hhIter it;
struct ddsrt_hh_iter it;
struct whc_idxnode *n;
for (n = ut_hhIterFirst(whc->idx_hash, &it); n != NULL; n = ut_hhIterNext(&it))
for (n = ddsrt_hh_iter_first(whc->idx_hash, &it); n != NULL; n = ddsrt_hh_iter_next(&it))
ddsrt_free(n);
ut_hhFree(whc->idx_hash);
ddsrt_hh_free(whc->idx_hash);
}
{
@ -423,13 +423,13 @@ DDSRT_WARNING_MSVC_ON(6001);
}
}
ut_avlFree (&whc_seq_treedef, &whc->seq, ddsrt_free);
ddsrt_avl_free (&whc_seq_treedef, &whc->seq, ddsrt_free);
nn_freelist_fini (&whc->freelist, ddsrt_free);
#if USE_EHH
ut_ehhFree (whc->seq_hash);
ddsrt_ehh_free (whc->seq_hash);
#else
ut_hhFree (whc->seq_hash);
ddsrt_hh_free (whc->seq_hash);
#endif
ddsrt_mutex_destroy (&whc->lock);
ddsrt_free (whc);
@ -445,7 +445,7 @@ static void get_state_locked(const struct whc_impl *whc, struct whc_state *st)
else
{
const struct whc_intvnode *intv;
intv = ut_avlFindMin (&whc_seq_treedef, &whc->seq);
intv = ddsrt_avl_find_min (&whc_seq_treedef, &whc->seq);
/* not empty, open node may be anything but is (by definition)
findmax, and whc is claimed to be non-empty, so min interval
can't be empty */
@ -476,12 +476,12 @@ static struct whc_node *find_nextseq_intv (struct whc_intvnode **p_intv, const s
SEQ < Y can't exist */
#ifndef NDEBUG
{
struct whc_intvnode *predintv = ut_avlLookupPredEq (&whc_seq_treedef, &whc->seq, &seq);
struct whc_intvnode *predintv = ddsrt_avl_lookup_pred_eq (&whc_seq_treedef, &whc->seq, &seq);
assert (predintv == NULL || predintv->maxp1 <= seq);
}
#endif
if ((intv = ut_avlLookupSuccEq (&whc_seq_treedef, &whc->seq, &seq)) == NULL) {
assert (ut_avlLookupPredEq (&whc_seq_treedef, &whc->seq, &seq) == whc->open_intv);
if ((intv = ddsrt_avl_lookup_succ_eq (&whc_seq_treedef, &whc->seq, &seq)) == NULL) {
assert (ddsrt_avl_lookup_pred_eq (&whc_seq_treedef, &whc->seq, &seq) == whc->open_intv);
return NULL;
} else if (intv->min < intv->maxp1) { /* only if not empty interval */
assert (intv->min > seq);
@ -502,7 +502,7 @@ static struct whc_node *find_nextseq_intv (struct whc_intvnode **p_intv, const s
assert (whc->maxseq_node != NULL);
assert (n->seq < whc->maxseq_node->seq);
n = n->next_seq;
*p_intv = ut_avlLookupPredEq (&whc_seq_treedef, &whc->seq, &n->seq);
*p_intv = ddsrt_avl_lookup_pred_eq (&whc_seq_treedef, &whc->seq, &n->seq);
return n;
}
}
@ -538,7 +538,7 @@ static void delete_one_sample_from_idx (struct whc_impl *whc, struct whc_node *w
for (i = 0; i < whc->idxdepth; i++)
assert (i == idxn->headidx || idxn->hist[i] == NULL);
#endif
if (!ut_hhRemove (whc->idx_hash, idxn))
if (!ddsrt_hh_remove (whc->idx_hash, idxn))
assert (0);
ddsi_tkmap_instance_unref(idxn->tk);
ddsrt_free (idxn);
@ -568,7 +568,7 @@ static void free_one_instance_from_idx (struct whc_impl *whc, seqno_t max_drop_s
static void delete_one_instance_from_idx (struct whc_impl *whc, seqno_t max_drop_seq, struct whc_idxnode *idxn)
{
if (!ut_hhRemove (whc->idx_hash, idxn))
if (!ddsrt_hh_remove (whc->idx_hash, idxn))
assert (0);
free_one_instance_from_idx (whc, max_drop_seq, idxn);
}
@ -612,11 +612,11 @@ static unsigned whc_default_downgrade_to_volatile (struct whc *whc_generic, stru
whc->tldepth = 0;
if (whc->hdepth == 0)
{
struct ut_hhIter it;
struct ddsrt_hh_iter it;
struct whc_idxnode *n;
for (n = ut_hhIterFirst(whc->idx_hash, &it); n != NULL; n = ut_hhIterNext(&it))
for (n = ddsrt_hh_iter_first(whc->idx_hash, &it); n != NULL; n = ddsrt_hh_iter_next(&it))
free_one_instance_from_idx (whc, 0, n);
ut_hhFree(whc->idx_hash);
ddsrt_hh_free(whc->idx_hash);
whc->idxdepth = 0;
whc->idx_hash = NULL;
}
@ -680,9 +680,9 @@ static void whc_delete_one_intv (struct whc_impl *whc, struct whc_intvnode **p_i
if (whcn == intv->last && intv != whc->open_intv)
{
struct whc_intvnode *tmp = intv;
*p_intv = ut_avlFindSucc (&whc_seq_treedef, &whc->seq, intv);
*p_intv = ddsrt_avl_find_succ (&whc_seq_treedef, &whc->seq, intv);
/* only sample in interval and not the open interval => delete interval */
ut_avlDelete (&whc_seq_treedef, &whc->seq, tmp);
ddsrt_avl_delete (&whc_seq_treedef, &whc->seq, tmp);
ddsrt_free (tmp);
}
else
@ -703,7 +703,7 @@ static void whc_delete_one_intv (struct whc_impl *whc, struct whc_intvnode **p_i
assert (whcn->prev_seq->seq + 1 == whcn->seq);
intv->last = whcn->prev_seq;
intv->maxp1--;
*p_intv = ut_avlFindSucc (&whc_seq_treedef, &whc->seq, intv);
*p_intv = ddsrt_avl_find_succ (&whc_seq_treedef, &whc->seq, intv);
}
else
{
@ -712,7 +712,7 @@ static void whc_delete_one_intv (struct whc_impl *whc, struct whc_intvnode **p_i
issue only, and so we can (for now) get away with splitting
it greedily */
struct whc_intvnode *new_intv;
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
new_intv = ddsrt_malloc (sizeof (*new_intv));
@ -730,9 +730,9 @@ static void whc_delete_one_intv (struct whc_impl *whc, struct whc_intvnode **p_i
/* insert new node & continue the loop with intv set to the
new interval */
if (ut_avlLookupIPath (&whc_seq_treedef, &whc->seq, &new_intv->min, &path) != NULL)
if (ddsrt_avl_lookup_ipath (&whc_seq_treedef, &whc->seq, &new_intv->min, &path) != NULL)
assert (0);
ut_avlInsertIPath (&whc_seq_treedef, &whc->seq, new_intv, &path);
ddsrt_avl_insert_ipath (&whc_seq_treedef, &whc->seq, new_intv, &path);
if (intv == whc->open_intv)
whc->open_intv = new_intv;
@ -744,7 +744,7 @@ static void whc_delete_one (struct whc_impl *whc, struct whc_node *whcn)
{
struct whc_intvnode *intv;
struct whc_node *whcn_tmp = whcn;
intv = ut_avlLookupPredEq (&whc_seq_treedef, &whc->seq, &whcn->seq);
intv = ddsrt_avl_lookup_pred_eq (&whc_seq_treedef, &whc->seq, &whcn->seq);
assert (intv != NULL);
whc_delete_one_intv (whc, &intv, &whcn);
if (whcn_tmp->prev_seq)
@ -804,7 +804,7 @@ static unsigned whc_default_remove_acked_messages_noidx (struct whc_impl *whc, s
#ifndef NDEBUG
whcn = find_nextseq_intv (&intv, whc, whc->max_drop_seq);
assert (whcn == NULL || whcn->prev_seq == NULL);
assert (ut_avlIsSingleton (&whc->seq));
assert (ddsrt_avl_is_singleton (&whc->seq));
#endif
intv = whc->open_intv;
@ -894,7 +894,7 @@ static unsigned whc_default_remove_acked_messages_full (struct whc_impl *whc, se
}
if (whcn == intv->last)
intv = ut_avlFindSucc (&whc_seq_treedef, &whc->seq, intv);
intv = ddsrt_avl_find_succ (&whc_seq_treedef, &whc->seq, intv);
if (prev_seq)
prev_seq->next_seq = whcn;
whcn->prev_seq = prev_seq;
@ -975,7 +975,7 @@ static unsigned whc_default_remove_acked_messages_full (struct whc_impl *whc, se
DDS_LOG(DDS_LC_WHC, " del %p %"PRId64, (void *) oldn, oldn->seq);
whc_delete_one (whc, oldn);
#ifndef NDEBUG
assert(ut_hhLookup(whc->idx_hash, &template) == idxn);
assert(ddsrt_hh_lookup(whc->idx_hash, &template) == idxn);
ddsi_serdata_unref(whcn_template.serdata);
#endif
}
@ -1069,14 +1069,14 @@ static struct whc_node *whc_default_insert_seq (struct whc_impl *whc, seqno_t ma
{
/* gap => need new open_intv */
struct whc_intvnode *intv1;
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
intv1 = ddsrt_malloc (sizeof (*intv1));
intv1->min = seq;
intv1->maxp1 = seq + 1;
intv1->first = intv1->last = newn;
if (ut_avlLookupIPath (&whc_seq_treedef, &whc->seq, &seq, &path) != NULL)
if (ddsrt_avl_lookup_ipath (&whc_seq_treedef, &whc->seq, &seq, &path) != NULL)
assert (0);
ut_avlInsertIPath (&whc_seq_treedef, &whc->seq, intv1, &path);
ddsrt_avl_insert_ipath (&whc_seq_treedef, &whc->seq, intv1, &path);
whc->open_intv = intv1;
}
@ -1128,7 +1128,7 @@ static int whc_default_insert (struct whc *whc_generic, seqno_t max_drop_seq, se
}
template.idxn.iid = tk->m_iid;
if ((idxn = ut_hhLookup (whc->idx_hash, &template)) != NULL)
if ((idxn = ddsrt_hh_lookup (whc->idx_hash, &template)) != NULL)
{
/* Unregisters cause deleting of index entry, non-unregister of adding/overwriting in history */
DDS_LOG(DDS_LC_WHC, " idxn %p", (void *)idxn);
@ -1203,7 +1203,7 @@ static int whc_default_insert (struct whc *whc_generic, seqno_t max_drop_seq, se
idxn->hist[i] = NULL;
newn->idxnode = idxn;
newn->idxnode_pos = 0;
if (!ut_hhAdd (whc->idx_hash, idxn))
if (!ddsrt_hh_add (whc->idx_hash, idxn))
assert (0);
}
else

4
src/core/ddsc/src/dds_write.c
View file

@ -123,14 +123,14 @@ static dds_return_t deliver_locally (struct writer *wr, struct ddsi_serdata *pay
we fall back to using the GUIDs so that we can deliver all
samples we received from it. As writer being deleted any
reliable samples that are rejected are simply discarded. */
ut_avlIter_t it;
ddsrt_avl_iter_t it;
struct pwr_rd_match *m;
struct proxy_writer_info pwr_info;
dds_duration_t max_block_ms = nn_from_ddsi_duration (wr->xqos->reliability.max_blocking_time);
ddsrt_mutex_unlock (&wr->rdary.rdary_lock);
make_proxy_writer_info (&pwr_info, &wr->e, wr->xqos);
ddsrt_mutex_lock (&wr->e.lock);
for (m = ut_avlIterFirst (&wr_local_readers_treedef, &wr->local_readers, &it); m != NULL; m = ut_avlIterNext (&it))
for (m = ddsrt_avl_iter_first (&wr_local_readers_treedef, &wr->local_readers, &it); m != NULL; m = ddsrt_avl_iter_next (&it))
{
struct reader *rd;
if ((rd = ephash_lookup_reader_guid (&m->rd_guid)) != NULL)

2
src/core/ddsi/include/dds/ddsi/ddsi_serdata_default.h
View file

@ -15,7 +15,7 @@
#include "dds/ddsrt/endian.h"
#include "dds/ddsi/q_plist.h" /* for nn_prismtech_writer_info */
#include "dds/ddsi/q_freelist.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/ddsi_serdata.h"
#include "dds/ddsi/ddsi_sertopic.h"

4
src/core/ddsi/include/dds/ddsi/ddsi_sertopic.h
View file

@ -13,7 +13,7 @@
#define DDSI_SERTOPIC_H
#include "dds/ddsrt/atomics.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsc/dds_public_alloc.h"
struct ddsi_serdata;
@ -25,7 +25,7 @@ typedef void (*topic_cb_t) (struct dds_topic * topic);
struct ddsi_sertopic_ops;
struct ddsi_sertopic {
ut_avlNode_t avlnode; /* index on name_typename */
ddsrt_avl_node_t avlnode; /* index on name_typename */
const struct ddsi_sertopic_ops *ops;
const struct ddsi_serdata_ops *serdata_ops;
uint32_t serdata_basehash;

6
src/core/ddsi/include/dds/ddsi/q_addrset.h
View file

@ -13,7 +13,7 @@
#define NN_ADDRSET_H
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_feature_check.h"
@ -23,14 +23,14 @@ extern "C" {
#endif
typedef struct addrset_node {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_locator_t loc;
} * addrset_node_t;
struct addrset {
ddsrt_mutex_t lock;
ddsrt_atomic_uint32_t refc;
ut_avlCTree_t ucaddrs, mcaddrs;
ddsrt_avl_ctree_t ucaddrs, mcaddrs;
};
typedef void (*addrset_forall_fun_t) (const nn_locator_t *loc, void *arg);

44
src/core/ddsi/include/dds/ddsi/q_entity.h
View file

@ -13,7 +13,7 @@
#define Q_ENTITY_H
#include "dds/ddsrt/atomics.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_lat_estim.h"
@ -54,12 +54,12 @@ status_cb_data_t;
typedef void (*status_cb_t) (void *entity, const status_cb_data_t *data);
struct prd_wr_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t wr_guid;
};
struct rd_pwr_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t pwr_guid;
#ifdef DDSI_INCLUDE_SSM
nn_locator_t ssm_mc_loc;
@ -68,17 +68,17 @@ struct rd_pwr_match {
};
struct wr_rd_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t rd_guid;
};
struct rd_wr_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t wr_guid;
};
struct wr_prd_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t prd_guid; /* guid of the proxy reader */
unsigned assumed_in_sync: 1; /* set to 1 upon receipt of ack not nack'ing msgs */
unsigned has_replied_to_hb: 1; /* we must keep sending HBs until all readers have this set */
@ -105,7 +105,7 @@ enum pwr_rd_match_syncstate {
};
struct pwr_rd_match {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t rd_guid;
nn_mtime_t tcreate;
nn_count_t count; /* most recent acknack sequence number */
@ -247,8 +247,8 @@ struct writer
nn_etime_t t_rexmit_end; /* time of last 1->0 transition of "retransmitting" */
nn_etime_t t_whc_high_upd; /* time "whc_high" was last updated for controlled ramp-up of throughput */
int num_reliable_readers; /* number of matching reliable PROXY readers */
ut_avlTree_t readers; /* all matching PROXY readers, see struct wr_prd_match */
ut_avlTree_t local_readers; /* all matching LOCAL readers, see struct wr_rd_match */
ddsrt_avl_tree_t readers; /* all matching PROXY readers, see struct wr_prd_match */
ddsrt_avl_tree_t local_readers; /* all matching LOCAL readers, see struct wr_rd_match */
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
uint32_t partition_id;
#endif
@ -280,8 +280,8 @@ struct reader
struct addrset *as;
#endif
const struct ddsi_sertopic * topic; /* topic is NULL for built-in readers */
ut_avlTree_t writers; /* all matching PROXY writers, see struct rd_pwr_match */
ut_avlTree_t local_writers; /* all matching LOCAL writers, see struct rd_wr_match */
ddsrt_avl_tree_t writers; /* all matching PROXY writers, see struct rd_pwr_match */
ddsrt_avl_tree_t local_writers; /* all matching LOCAL writers, see struct rd_wr_match */
ddsi2direct_directread_cb_t ddsi2direct_cb;
void *ddsi2direct_cbarg;
};
@ -299,7 +299,7 @@ struct proxy_participant
struct addrset *as_default; /* default address set to use for user data traffic */
struct addrset *as_meta; /* default address set to use for discovery traffic */
struct proxy_endpoint_common *endpoints; /* all proxy endpoints can be reached from here */
ut_avlTree_t groups; /* table of all groups (publisher, subscriber), see struct proxy_group */
ddsrt_avl_tree_t groups; /* table of all groups (publisher, subscriber), see struct proxy_group */
unsigned kernel_sequence_numbers : 1; /* whether this proxy participant generates OSPL kernel sequence numbers */
unsigned implicitly_created : 1; /* participants are implicitly created for Cloud/Fog discovered endpoints */
unsigned is_ddsi2_pp: 1; /* if this is the federation-leader on the remote node */
@ -318,7 +318,7 @@ struct proxy_participant
tables, but "groups" only live in the context of a proxy
participant. */
struct proxy_group {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t guid;
char *name;
struct proxy_participant *proxypp; /* uncounted backref to proxy participant */
@ -340,7 +340,7 @@ struct proxy_endpoint_common
struct proxy_writer {
struct entity_common e;
struct proxy_endpoint_common c;
ut_avlTree_t readers; /* matching LOCAL readers, see pwr_rd_match */
ddsrt_avl_tree_t readers; /* matching LOCAL readers, see pwr_rd_match */
int n_reliable_readers; /* number of those that are reliable */
int n_readers_out_of_sync; /* number of those that require special handling (accepting historical data, waiting for historical data set to become complete) */
seqno_t last_seq; /* highest known seq published by the writer, not last delivered */
@ -373,16 +373,16 @@ struct proxy_reader {
#ifdef DDSI_INCLUDE_SSM
unsigned favours_ssm: 1; /* iff 1, this proxy reader favours SSM when available */
#endif
ut_avlTree_t writers; /* matching LOCAL writers */
ddsrt_avl_tree_t writers; /* matching LOCAL writers */
};
extern const ut_avlTreedef_t wr_readers_treedef;
extern const ut_avlTreedef_t wr_local_readers_treedef;
extern const ut_avlTreedef_t rd_writers_treedef;
extern const ut_avlTreedef_t rd_local_writers_treedef;
extern const ut_avlTreedef_t pwr_readers_treedef;
extern const ut_avlTreedef_t prd_writers_treedef;
extern const ut_avlTreedef_t deleted_participants_treedef;
extern const ddsrt_avl_treedef_t wr_readers_treedef;
extern const ddsrt_avl_treedef_t wr_local_readers_treedef;
extern const ddsrt_avl_treedef_t rd_writers_treedef;
extern const ddsrt_avl_treedef_t rd_local_writers_treedef;
extern const ddsrt_avl_treedef_t pwr_readers_treedef;
extern const ddsrt_avl_treedef_t prd_writers_treedef;
extern const ddsrt_avl_treedef_t deleted_participants_treedef;
#define DPG_LOCAL 1
#define DPG_REMOTE 2

4
src/core/ddsi/include/dds/ddsi/q_ephash.h
View file

@ -12,7 +12,7 @@
#ifndef Q_EPHASH_H
#define Q_EPHASH_H
#include "dds/util/ut_hopscotch.h"
#include "dds/ddsrt/hopscotch.h"
#if defined (__cplusplus)
extern "C" {
@ -39,7 +39,7 @@ struct nn_guid;
struct ephash_enum
{
struct ut_chhIter it;
struct ddsrt_chh_iter it;
enum entity_kind kind;
struct entity_common *cur;
};

8
src/core/ddsi/include/dds/ddsi/q_globals.h
View file

@ -18,7 +18,7 @@
#include "dds/ddsrt/atomics.h"
#include "dds/ddsrt/sockets.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_fibheap.h"
#include "dds/ddsrt/fibheap.h"
#include "dds/ddsi/q_plist.h"
#include "dds/ddsi/q_protocol.h"
@ -47,7 +47,7 @@ struct lease;
struct ddsi_tran_conn;
struct ddsi_tran_listener;
struct ddsi_tran_factory;
struct ut_thread_pool_s;
struct ddsrt_thread_pool_s;
struct debug_monitor;
struct ddsi_tkmap;
@ -110,7 +110,7 @@ struct q_globals {
/* Lease junk */
ddsrt_mutex_t leaseheap_lock;
ddsrt_mutex_t lease_locks[N_LEASE_LOCKS];
ut_fibheap_t leaseheap;
ddsrt_fibheap_t leaseheap;
/* Transport factory */
@ -133,7 +133,7 @@ struct q_globals {
/* Thread pool */
struct ut_thread_pool_s * thread_pool;
struct ddsrt_thread_pool_s * thread_pool;
/* In many sockets mode, the receive threads maintain a local array
with participant GUIDs and sockets, participant_set_generation is

6
src/core/ddsi/include/dds/ddsi/q_inverse_uint32_set.h
View file

@ -12,14 +12,14 @@
#ifndef NN_INVERSE_UINT32_SET_H
#define NN_INVERSE_UINT32_SET_H
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
struct inverse_uint32_set_node {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
uint32_t min, max;
};
struct inverse_uint32_set {
ut_avlTree_t ids;
ddsrt_avl_tree_t ids;
uint32_t cursor;
uint32_t min, max;
};

36
src/core/ddsi/src/ddsi_mcgroup.c
View file

@ -20,10 +20,10 @@
#include "dds/ddsi/ddsi_mcgroup.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
struct nn_group_membership_node {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
ddsi_tran_conn_t conn;
nn_locator_t srcloc;
nn_locator_t mcloc;
@ -32,7 +32,7 @@ struct nn_group_membership_node {
struct nn_group_membership {
ddsrt_mutex_t lock;
ut_avlTree_t mships;
ddsrt_avl_tree_t mships;
};
static int locator_compare_no_port (const nn_locator_t *as, const nn_locator_t *bs)
@ -60,19 +60,19 @@ static int cmp_group_membership (const void *va, const void *vb)
return 0;
}
static ut_avlTreedef_t mship_td = UT_AVL_TREEDEF_INITIALIZER(offsetof (struct nn_group_membership_node, avlnode), 0, cmp_group_membership, 0);
static ddsrt_avl_treedef_t mship_td = DDSRT_AVL_TREEDEF_INITIALIZER(offsetof (struct nn_group_membership_node, avlnode), 0, cmp_group_membership, 0);
struct nn_group_membership *new_group_membership (void)
{
struct nn_group_membership *mship = ddsrt_malloc (sizeof (*mship));
ddsrt_mutex_init (&mship->lock);
ut_avlInit (&mship_td, &mship->mships);
ddsrt_avl_init (&mship_td, &mship->mships);
return mship;
}
void free_group_membership (struct nn_group_membership *mship)
{
ut_avlFree (&mship_td, &mship->mships, ddsrt_free);
ddsrt_avl_free (&mship_td, &mship->mships, ddsrt_free);
ddsrt_mutex_destroy (&mship->lock);
ddsrt_free (mship);
}
@ -80,7 +80,7 @@ void free_group_membership (struct nn_group_membership *mship)
static int reg_group_membership (struct nn_group_membership *mship, ddsi_tran_conn_t conn, const nn_locator_t *srcloc, const nn_locator_t *mcloc)
{
struct nn_group_membership_node key, *n;
ut_avlIPath_t ip;
ddsrt_avl_ipath_t ip;
int isnew;
key.conn = conn;
if (srcloc)
@ -88,7 +88,7 @@ static int reg_group_membership (struct nn_group_membership *mship, ddsi_tran_co
else
memset (&key.srcloc, 0, sizeof (key.srcloc));
key.mcloc = *mcloc;
if ((n = ut_avlLookupIPath (&mship_td, &mship->mships, &key, &ip)) != NULL) {
if ((n = ddsrt_avl_lookup_ipath (&mship_td, &mship->mships, &key, &ip)) != NULL) {
isnew = 0;
n->count++;
} else {
@ -98,7 +98,7 @@ static int reg_group_membership (struct nn_group_membership *mship, ddsi_tran_co
n->srcloc = key.srcloc;
n->mcloc = key.mcloc;
n->count = 1;
ut_avlInsertIPath (&mship_td, &mship->mships, n, &ip);
ddsrt_avl_insert_ipath (&mship_td, &mship->mships, n, &ip);
}
return isnew;
}
@ -106,7 +106,7 @@ static int reg_group_membership (struct nn_group_membership *mship, ddsi_tran_co
static int unreg_group_membership (struct nn_group_membership *mship, ddsi_tran_conn_t conn, const nn_locator_t *srcloc, const nn_locator_t *mcloc)
{
struct nn_group_membership_node key, *n;
ut_avlDPath_t dp;
ddsrt_avl_dpath_t dp;
int mustdel;
key.conn = conn;
if (srcloc)
@ -114,7 +114,7 @@ static int unreg_group_membership (struct nn_group_membership *mship, ddsi_tran_
else
memset (&key.srcloc, 0, sizeof (key.srcloc));
key.mcloc = *mcloc;
n = ut_avlLookupDPath (&mship_td, &mship->mships, &key, &dp);
n = ddsrt_avl_lookup_dpath (&mship_td, &mship->mships, &key, &dp);
assert (n != NULL);
assert (n->count > 0);
if (--n->count > 0)
@ -122,7 +122,7 @@ static int unreg_group_membership (struct nn_group_membership *mship, ddsi_tran_
else
{
mustdel = 1;
ut_avlDeleteDPath (&mship_td, &mship->mships, n, &dp);
ddsrt_avl_delete_dpath (&mship_td, &mship->mships, n, &dp);
ddsrt_free (n);
}
return mustdel;
@ -268,13 +268,13 @@ void ddsi_transfer_group_membership (ddsi_tran_conn_t conn, ddsi_tran_conn_t new
are neither 0 nor maximum representable, min and max define the range of key values that relate to
oldsock */
ddsrt_mutex_lock (&gv.mship->lock);
n = ut_avlLookupSuccEq (&mship_td, &gv.mship->mships, &min);
n = ddsrt_avl_lookup_succ_eq (&mship_td, &gv.mship->mships, &min);
while (n != NULL && cmp_group_membership (n, &max) <= 0)
{
struct nn_group_membership_node * const nn = ut_avlFindSucc (&mship_td, &gv.mship->mships, n);
ut_avlDelete (&mship_td, &gv.mship->mships, n);
struct nn_group_membership_node * const nn = ddsrt_avl_find_succ (&mship_td, &gv.mship->mships, n);
ddsrt_avl_delete (&mship_td, &gv.mship->mships, n);
n->conn = newconn;
ut_avlInsert (&mship_td, &gv.mship->mships, n);
ddsrt_avl_insert (&mship_td, &gv.mship->mships, n);
n = nn;
}
ddsrt_mutex_unlock (&gv.mship->lock);
@ -283,13 +283,13 @@ void ddsi_transfer_group_membership (ddsi_tran_conn_t conn, ddsi_tran_conn_t new
int ddsi_rejoin_transferred_mcgroups (ddsi_tran_conn_t conn)
{
struct nn_group_membership_node *n, min, max;
ut_avlIter_t it;
ddsrt_avl_iter_t it;
int ret = 0;
memset(&min, 0, sizeof(min));
memset(&max, 0xff, sizeof(max));
min.conn = max.conn = conn;
ddsrt_mutex_lock (&gv.mship->lock);
for (n = ut_avlIterSuccEq (&mship_td, &gv.mship->mships, &it, &min); n != NULL && ret >= 0 && cmp_group_membership(n, &max) <= 0; n = ut_avlIterNext (&it))
for (n = ddsrt_avl_iter_succ_eq (&mship_td, &gv.mship->mships, &it, &min); n != NULL && ret >= 0 && cmp_group_membership(n, &max) <= 0; n = ddsrt_avl_iter_next (&it))
{
int have_srcloc = (memcmp(&n->srcloc, &min.srcloc, sizeof(n->srcloc)) != 0);
assert (n->conn == conn);

38
src/core/ddsi/src/ddsi_tcp.c
View file

@ -20,7 +20,7 @@
#include "dds/ddsi/ddsi_tran.h"
#include "dds/ddsi/ddsi_tcp.h"
#include "dds/ddsi/ddsi_ipaddr.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_nwif.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
@ -93,12 +93,12 @@ static int ddsi_tcp_cmp_conn_wrap (const void *a, const void *b)
typedef struct ddsi_tcp_node
{
ut_avlNode_t m_avlnode;
ddsrt_avl_node_t m_avlnode;
ddsi_tcp_conn_t m_conn;
}
* ddsi_tcp_node_t;
static const ut_avlTreedef_t ddsi_tcp_treedef = UT_AVL_TREEDEF_INITIALIZER_INDKEY
static const ddsrt_avl_treedef_t ddsi_tcp_treedef = DDSRT_AVL_TREEDEF_INITIALIZER_INDKEY
(
offsetof (struct ddsi_tcp_node, m_avlnode),
offsetof (struct ddsi_tcp_node, m_conn),
@ -107,7 +107,7 @@ static const ut_avlTreedef_t ddsi_tcp_treedef = UT_AVL_TREEDEF_INITIALIZER_INDKE
);
static ddsrt_mutex_t ddsi_tcp_cache_lock_g;
static ut_avlTree_t ddsi_tcp_cache_g;
static ddsrt_avl_tree_t ddsi_tcp_cache_g;
static struct ddsi_tran_factory ddsi_tcp_factory_g;
static ddsi_tcp_conn_t ddsi_tcp_new_conn (ddsrt_socket_t, bool, struct sockaddr *);
@ -125,11 +125,11 @@ static char *sockaddr_to_string_with_port (char *dst, size_t sizeof_dst, const s
static void ddsi_tcp_cache_dump (void)
{
char buff[64];
ut_avlIter_t iter;
ddsrt_avl_iter_t iter;
ddsi_tcp_node_t n;
unsigned i = 0;
n = ut_avlIterFirst (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, &iter);
n = ddsrt_avl_iter_first (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, &iter);
while (n)
{
os_sockaddrAddressPortToString ((const os_sockaddr *) &n->m_conn->m_peer_addr, buff, sizeof (buff));
@ -140,7 +140,7 @@ static void ddsi_tcp_cache_dump (void)
ddsi_name, i++, n->m_conn->m_base.m_server ? "server" : "client",
n->m_conn->m_sock, n->m_conn->m_base.m_base.m_port, buff
);
n = ut_avlIterNext (&iter);
n = ddsrt_avl_iter_next (&iter);
}
}
*/
@ -242,7 +242,7 @@ static void ddsi_tcp_conn_connect (ddsi_tcp_conn_t conn, const ddsrt_msghdr_t *
}
}
static void ddsi_tcp_cache_add (ddsi_tcp_conn_t conn, ut_avlIPath_t * path)
static void ddsi_tcp_cache_add (ddsi_tcp_conn_t conn, ddsrt_avl_ipath_t * path)
{
const char * action = "added";
ddsi_tcp_node_t node;
@ -255,11 +255,11 @@ static void ddsi_tcp_cache_add (ddsi_tcp_conn_t conn, ut_avlIPath_t * path)
{
node = ddsrt_malloc (sizeof (*node));
node->m_conn = conn;
ut_avlInsertIPath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node, path);
ddsrt_avl_insert_ipath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node, path);
}
else
{
node = ut_avlLookup (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, conn);
node = ddsrt_avl_lookup (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, conn);
if (node)
{
/* Replace connection in cache */
@ -272,7 +272,7 @@ static void ddsi_tcp_cache_add (ddsi_tcp_conn_t conn, ut_avlIPath_t * path)
{
node = ddsrt_malloc (sizeof (*node));
node->m_conn = conn;
ut_avlInsert (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node);
ddsrt_avl_insert (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node);
}
}
@ -284,15 +284,15 @@ static void ddsi_tcp_cache_remove (ddsi_tcp_conn_t conn)
{
char buff[DDSI_LOCSTRLEN];
ddsi_tcp_node_t node;
ut_avlDPath_t path;
ddsrt_avl_dpath_t path;
ddsrt_mutex_lock (&ddsi_tcp_cache_lock_g);
node = ut_avlLookupDPath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, conn, &path);
node = ddsrt_avl_lookup_dpath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, conn, &path);
if (node)
{
sockaddr_to_string_with_port(buff, sizeof(buff), (struct sockaddr *)&conn->m_peer_addr);
DDS_LOG(DDS_LC_TCP, "%s cache removed socket %"PRIdSOCK" to %s\n", ddsi_name, conn->m_sock, buff);
ut_avlDeleteDPath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node, &path);
ddsrt_avl_delete_dpath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node, &path);
ddsi_tcp_node_free (node);
}
ddsrt_mutex_unlock (&ddsi_tcp_cache_lock_g);
@ -305,7 +305,7 @@ static void ddsi_tcp_cache_remove (ddsi_tcp_conn_t conn)
static ddsi_tcp_conn_t ddsi_tcp_cache_find (const ddsrt_msghdr_t * msg)
{
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
ddsi_tcp_node_t node;
struct ddsi_tcp_conn key;
ddsi_tcp_conn_t ret = NULL;
@ -317,12 +317,12 @@ static ddsi_tcp_conn_t ddsi_tcp_cache_find (const ddsrt_msghdr_t * msg)
/* Check cache for existing connection to target */
ddsrt_mutex_lock (&ddsi_tcp_cache_lock_g);
node = ut_avlLookupIPath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, &key, &path);
node = ddsrt_avl_lookup_ipath (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, &key, &path);
if (node)
{
if (node->m_conn->m_base.m_closed)
{
ut_avlDelete (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node);
ddsrt_avl_delete (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, node);
ddsi_tcp_node_free (node);
}
else
@ -1010,7 +1010,7 @@ static void ddsi_tcp_release_listener (ddsi_tran_listener_t listener)
static void ddsi_tcp_release_factory (void)
{
if (ddsrt_atomic_dec32_nv (&ddsi_tcp_init_g) == 0) {
ut_avlFree (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, ddsi_tcp_node_free);
ddsrt_avl_free (&ddsi_tcp_treedef, &ddsi_tcp_cache_g, ddsi_tcp_node_free);
ddsrt_mutex_destroy (&ddsi_tcp_cache_lock_g);
#ifdef DDSI_INCLUDE_SSL
if (ddsi_tcp_ssl_plugin.fini)
@ -1095,7 +1095,7 @@ int ddsi_tcp_init (void)
}
#endif
ut_avlInit (&ddsi_tcp_treedef, &ddsi_tcp_cache_g);
ddsrt_avl_init (&ddsi_tcp_treedef, &ddsi_tcp_cache_g);
ddsrt_mutex_init (&ddsi_tcp_cache_lock_g);
DDS_LOG(DDS_LC_CONFIG, "%s initialized\n", ddsi_name);

24
src/core/ddsi/src/ddsi_tkmap.c
View file

@ -22,7 +22,7 @@
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/ddsi_iid.h"
#include "dds/ddsi/ddsi_tkmap.h"
#include "dds/util/ut_hopscotch.h"
#include "dds/ddsrt/hopscotch.h"
#include "dds__stream.h"
#include "dds/ddsi/ddsi_serdata.h"
@ -31,7 +31,7 @@
struct ddsi_tkmap
{
struct ut_chh * m_hh;
struct ddsrt_chh * m_hh;
ddsrt_mutex_t m_lock;
ddsrt_cond_t m_cond;
};
@ -87,7 +87,7 @@ static int dds_tk_equals_void (const void *a, const void *b)
struct ddsi_tkmap *ddsi_tkmap_new (void)
{
struct ddsi_tkmap *tkmap = dds_alloc (sizeof (*tkmap));
tkmap->m_hh = ut_chhNew (1, dds_tk_hash_void, dds_tk_equals_void, gc_buckets);
tkmap->m_hh = ddsrt_chh_new (1, dds_tk_hash_void, dds_tk_equals_void, gc_buckets);
ddsrt_mutex_init (&tkmap->m_lock);
ddsrt_cond_init (&tkmap->m_cond);
return tkmap;
@ -102,8 +102,8 @@ static void free_tkmap_instance (void *vtk, UNUSED_ARG(void *f_arg))
void ddsi_tkmap_free (struct ddsi_tkmap * map)
{
ut_chhEnumUnsafe (map->m_hh, free_tkmap_instance, NULL);
ut_chhFree (map->m_hh);
ddsrt_chh_enum_unsafe (map->m_hh, free_tkmap_instance, NULL);
ddsrt_chh_free (map->m_hh);
ddsrt_cond_destroy (&map->m_cond);
ddsrt_mutex_destroy (&map->m_lock);
dds_free (map);
@ -115,18 +115,18 @@ uint64_t ddsi_tkmap_lookup (struct ddsi_tkmap * map, const struct ddsi_serdata *
struct ddsi_tkmap_instance * tk;
assert (thread_is_awake ());
dummy.m_sample = (struct ddsi_serdata *) sd;
tk = ut_chhLookup (map->m_hh, &dummy);
tk = ddsrt_chh_lookup (map->m_hh, &dummy);
return (tk) ? tk->m_iid : DDS_HANDLE_NIL;
}
struct ddsi_tkmap_instance *ddsi_tkmap_find_by_id (struct ddsi_tkmap *map, uint64_t iid)
{
/* This is not a function that should be used liberally, as it linearly scans the key-to-iid map. */
struct ut_chhIter it;
struct ddsrt_chh_iter it;
struct ddsi_tkmap_instance *tk;
uint32_t refc;
assert (thread_is_awake ());
for (tk = ut_chhIterFirst (map->m_hh, &it); tk; tk = ut_chhIterNext (&it))
for (tk = ddsrt_chh_iter_first (map->m_hh, &it); tk; tk = ddsrt_chh_iter_next (&it))
if (tk->m_iid == iid)
break;
if (tk == NULL)
@ -165,7 +165,7 @@ ddsi_tkmap_find(
assert (thread_is_awake ());
dummy.m_sample = sd;
retry:
if ((tk = ut_chhLookup(map->m_hh, &dummy)) != NULL)
if ((tk = ddsrt_chh_lookup(map->m_hh, &dummy)) != NULL)
{
uint32_t new;
new = ddsrt_atomic_inc32_nv(&tk->m_refc);
@ -178,7 +178,7 @@ retry:
we can block until someone signals some entry is removed from the map if we take
some lock & wait for some condition */
ddsrt_mutex_lock(&map->m_lock);
while ((tk = ut_chhLookup(map->m_hh, &dummy)) != NULL && (ddsrt_atomic_ld32(&tk->m_refc) & REFC_DELETE))
while ((tk = ddsrt_chh_lookup(map->m_hh, &dummy)) != NULL && (ddsrt_atomic_ld32(&tk->m_refc) & REFC_DELETE))
ddsrt_cond_wait(&map->m_cond, &map->m_lock);
ddsrt_mutex_unlock(&map->m_lock);
goto retry;
@ -192,7 +192,7 @@ retry:
tk->m_sample = ddsi_serdata_to_topicless (sd);
ddsrt_atomic_st32 (&tk->m_refc, 1);
tk->m_iid = ddsi_iid_gen ();
if (!ut_chhAdd (map->m_hh, tk))
if (!ddsrt_chh_add (map->m_hh, tk))
{
/* Lost a race from another thread, retry */
ddsi_serdata_unref (tk->m_sample);
@ -237,7 +237,7 @@ void ddsi_tkmap_instance_unref (struct ddsi_tkmap_instance * tk)
struct ddsi_tkmap *map = gv.m_tkmap;
/* Remove from hash table */
int removed = ut_chhRemove(map->m_hh, tk);
int removed = ddsrt_chh_remove(map->m_hh, tk);
assert (removed);
(void)removed;

108
src/core/ddsi/src/q_addrset.c
View file

@ -17,7 +17,7 @@
#include "dds/ddsrt/log.h"
#include "dds/ddsrt/string.h"
#include "dds/ddsrt/misc.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_config.h"
@ -39,8 +39,8 @@
static int compare_locators_vwrap (const void *va, const void *vb);
static const ut_avlCTreedef_t addrset_treedef =
UT_AVL_CTREEDEF_INITIALIZER (offsetof (struct addrset_node, avlnode), offsetof (struct addrset_node, loc), compare_locators_vwrap, 0);
static const ddsrt_avl_ctreedef_t addrset_treedef =
DDSRT_AVL_CTREEDEF_INITIALIZER (offsetof (struct addrset_node, avlnode), offsetof (struct addrset_node, loc), compare_locators_vwrap, 0);
static int add_addresses_to_addrset_1 (struct addrset *as, const char *ip, int port_mode, const char *msgtag, int req_mc, int mcgen_base, int mcgen_count, int mcgen_idx)
{
@ -203,8 +203,8 @@ struct addrset *new_addrset (void)
struct addrset *as = ddsrt_malloc (sizeof (*as));
ddsrt_atomic_st32 (&as->refc, 1);
ddsrt_mutex_init (&as->lock);
ut_avlCInit (&addrset_treedef, &as->ucaddrs);
ut_avlCInit (&addrset_treedef, &as->mcaddrs);
ddsrt_avl_cinit (&addrset_treedef, &as->ucaddrs);
ddsrt_avl_cinit (&addrset_treedef, &as->mcaddrs);
return as;
}
@ -221,8 +221,8 @@ void unref_addrset (struct addrset *as)
{
if ((as != NULL) && (ddsrt_atomic_dec32_ov (&as->refc) == 1))
{
ut_avlCFree (&addrset_treedef, &as->ucaddrs, ddsrt_free);
ut_avlCFree (&addrset_treedef, &as->mcaddrs, ddsrt_free);
ddsrt_avl_cfree (&addrset_treedef, &as->ucaddrs, ddsrt_free);
ddsrt_avl_cfree (&addrset_treedef, &as->mcaddrs, ddsrt_free);
ddsrt_mutex_destroy (&as->lock);
ddsrt_free (as);
}
@ -247,9 +247,9 @@ int is_unspec_locator (const nn_locator_t *loc)
int addrset_contains_ssm (const struct addrset *as)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (as);
for (n = ut_avlCIterFirst (&addrset_treedef, &as->mcaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &as->mcaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
{
if (ddsi_is_ssm_mcaddr (&n->loc))
{
@ -264,9 +264,9 @@ int addrset_contains_ssm (const struct addrset *as)
int addrset_any_ssm (const struct addrset *as, nn_locator_t *dst)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (as);
for (n = ut_avlCIterFirst (&addrset_treedef, &as->mcaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &as->mcaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
{
if (ddsi_is_ssm_mcaddr (&n->loc))
{
@ -282,9 +282,9 @@ int addrset_any_ssm (const struct addrset *as, nn_locator_t *dst)
int addrset_any_non_ssm_mc (const struct addrset *as, nn_locator_t *dst)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (as);
for (n = ut_avlCIterFirst (&addrset_treedef, &as->mcaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &as->mcaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
{
if (!ddsi_is_ssm_mcaddr (&n->loc))
{
@ -301,8 +301,8 @@ int addrset_any_non_ssm_mc (const struct addrset *as, nn_locator_t *dst)
int addrset_purge (struct addrset *as)
{
LOCK (as);
ut_avlCFree (&addrset_treedef, &as->ucaddrs, ddsrt_free);
ut_avlCFree (&addrset_treedef, &as->mcaddrs, ddsrt_free);
ddsrt_avl_cfree (&addrset_treedef, &as->ucaddrs, ddsrt_free);
ddsrt_avl_cfree (&addrset_treedef, &as->mcaddrs, ddsrt_free);
UNLOCK (as);
return 0;
}
@ -311,14 +311,14 @@ void add_to_addrset (struct addrset *as, const nn_locator_t *loc)
{
if (!is_unspec_locator (loc))
{
ut_avlIPath_t path;
ut_avlCTree_t *tree = ddsi_is_mcaddr (loc) ? &as->mcaddrs : &as->ucaddrs;
ddsrt_avl_ipath_t path;
ddsrt_avl_ctree_t *tree = ddsi_is_mcaddr (loc) ? &as->mcaddrs : &as->ucaddrs;
LOCK (as);
if (ut_avlCLookupIPath (&addrset_treedef, tree, loc, &path) == NULL)
if (ddsrt_avl_clookup_ipath (&addrset_treedef, tree, loc, &path) == NULL)
{
struct addrset_node *n = ddsrt_malloc (sizeof (*n));
n->loc = *loc;
ut_avlCInsertIPath (&addrset_treedef, tree, n, &path);
ddsrt_avl_cinsert_ipath (&addrset_treedef, tree, n, &path);
}
UNLOCK (as);
}
@ -326,13 +326,13 @@ void add_to_addrset (struct addrset *as, const nn_locator_t *loc)
void remove_from_addrset (struct addrset *as, const nn_locator_t *loc)
{
ut_avlDPath_t path;
ut_avlCTree_t *tree = ddsi_is_mcaddr (loc) ? &as->mcaddrs : &as->ucaddrs;
ddsrt_avl_dpath_t path;
ddsrt_avl_ctree_t *tree = ddsi_is_mcaddr (loc) ? &as->mcaddrs : &as->ucaddrs;
struct addrset_node *n;
LOCK (as);
if ((n = ut_avlCLookupDPath (&addrset_treedef, tree, loc, &path)) != NULL)
if ((n = ddsrt_avl_clookup_dpath (&addrset_treedef, tree, loc, &path)) != NULL)
{
ut_avlCDeleteDPath (&addrset_treedef, tree, n, &path);
ddsrt_avl_cdelete_dpath (&addrset_treedef, tree, n, &path);
ddsrt_free (n);
}
UNLOCK (as);
@ -341,9 +341,9 @@ void remove_from_addrset (struct addrset *as, const nn_locator_t *loc)
void copy_addrset_into_addrset_uc (struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (asadd);
for (n = ut_avlCIterFirst (&addrset_treedef, &asadd->ucaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &asadd->ucaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
add_to_addrset (as, &n->loc);
UNLOCK (asadd);
}
@ -351,9 +351,9 @@ void copy_addrset_into_addrset_uc (struct addrset *as, const struct addrset *asa
void copy_addrset_into_addrset_mc (struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (asadd);
for (n = ut_avlCIterFirst (&addrset_treedef, &asadd->mcaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &asadd->mcaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
add_to_addrset (as, &n->loc);
UNLOCK (asadd);
}
@ -368,9 +368,9 @@ void copy_addrset_into_addrset (struct addrset *as, const struct addrset *asadd)
void copy_addrset_into_addrset_no_ssm_mc (struct addrset *as, const struct addrset *asadd)
{
struct addrset_node *n;
ut_avlCIter_t it;
ddsrt_avl_citer_t it;
LOCK (asadd);
for (n = ut_avlCIterFirst (&addrset_treedef, &asadd->mcaddrs, &it); n; n = ut_avlCIterNext (&it))
for (n = ddsrt_avl_citer_first (&addrset_treedef, &asadd->mcaddrs, &it); n; n = ddsrt_avl_citer_next (&it))
{
if (!ddsi_is_ssm_mcaddr (&n->loc))
add_to_addrset (as, &n->loc);
@ -389,14 +389,14 @@ void addrset_purge_ssm (struct addrset *as)
{
struct addrset_node *n;
LOCK (as);
n = ut_avlCFindMin (&addrset_treedef, &as->mcaddrs);
n = ddsrt_avl_cfind_min (&addrset_treedef, &as->mcaddrs);
while (n)
{
struct addrset_node *n1 = n;
n = ut_avlCFindSucc (&addrset_treedef, &as->mcaddrs, n);
n = ddsrt_avl_cfind_succ (&addrset_treedef, &as->mcaddrs, n);
if (ddsi_is_ssm_mcaddr (&n1->loc))
{
ut_avlCDelete (&addrset_treedef, &as->mcaddrs, n1);
ddsrt_avl_cdelete (&addrset_treedef, &as->mcaddrs, n1);
ddsrt_free (n1);
}
}
@ -412,7 +412,7 @@ size_t addrset_count (const struct addrset *as)
{
size_t count;
LOCK (as);
count = ut_avlCCount (&as->ucaddrs) + ut_avlCCount (&as->mcaddrs);
count = ddsrt_avl_ccount (&as->ucaddrs) + ddsrt_avl_ccount (&as->mcaddrs);
UNLOCK (as);
return count;
}
@ -426,7 +426,7 @@ size_t addrset_count_uc (const struct addrset *as)
{
size_t count;
LOCK (as);
count = ut_avlCCount (&as->ucaddrs);
count = ddsrt_avl_ccount (&as->ucaddrs);
UNLOCK (as);
return count;
}
@ -440,7 +440,7 @@ size_t addrset_count_mc (const struct addrset *as)
{
size_t count;
LOCK (as);
count = ut_avlCCount (&as->mcaddrs);
count = ddsrt_avl_ccount (&as->mcaddrs);
UNLOCK (as);
return count;
}
@ -450,7 +450,7 @@ int addrset_empty_uc (const struct addrset *as)
{
int isempty;
LOCK (as);
isempty = ut_avlCIsEmpty (&as->ucaddrs);
isempty = ddsrt_avl_cis_empty (&as->ucaddrs);
UNLOCK (as);
return isempty;
}
@ -459,7 +459,7 @@ int addrset_empty_mc (const struct addrset *as)
{
int isempty;
LOCK (as);
isempty = ut_avlCIsEmpty (&as->mcaddrs);
isempty = ddsrt_avl_cis_empty (&as->mcaddrs);
UNLOCK (as);
return isempty;
}
@ -468,7 +468,7 @@ int addrset_empty (const struct addrset *as)
{
int isempty;
LOCK (as);
isempty = ut_avlCIsEmpty (&as->ucaddrs) && ut_avlCIsEmpty (&as->mcaddrs);
isempty = ddsrt_avl_cis_empty (&as->ucaddrs) && ddsrt_avl_cis_empty (&as->mcaddrs);
UNLOCK (as);
return isempty;
}
@ -476,14 +476,14 @@ int addrset_empty (const struct addrset *as)
int addrset_any_uc (const struct addrset *as, nn_locator_t *dst)
{
LOCK (as);
if (ut_avlCIsEmpty (&as->ucaddrs))
if (ddsrt_avl_cis_empty (&as->ucaddrs))
{
UNLOCK (as);
return 0;
}
else
{
const struct addrset_node *n = ut_avlCRootNonEmpty (&addrset_treedef, &as->ucaddrs);
const struct addrset_node *n = ddsrt_avl_croot_non_empty (&addrset_treedef, &as->ucaddrs);
*dst = n->loc;
UNLOCK (as);
return 1;
@ -493,14 +493,14 @@ int addrset_any_uc (const struct addrset *as, nn_locator_t *dst)
int addrset_any_mc (const struct addrset *as, nn_locator_t *dst)
{
LOCK (as);
if (ut_avlCIsEmpty (&as->mcaddrs))
if (ddsrt_avl_cis_empty (&as->mcaddrs))
{
UNLOCK (as);
return 0;
}
else
{
const struct addrset_node *n = ut_avlCRootNonEmpty (&addrset_treedef, &as->mcaddrs);
const struct addrset_node *n = ddsrt_avl_croot_non_empty (&addrset_treedef, &as->mcaddrs);
*dst = n->loc;
UNLOCK (as);
return 1;
@ -527,9 +527,9 @@ size_t addrset_forall_count (struct addrset *as, addrset_forall_fun_t f, void *a
arg1.f = f;
arg1.arg = arg;
LOCK (as);
ut_avlCWalk (&addrset_treedef, &as->mcaddrs, addrset_forall_helper, &arg1);
ut_avlCWalk (&addrset_treedef, &as->ucaddrs, addrset_forall_helper, &arg1);
count = ut_avlCCount (&as->ucaddrs) + ut_avlCCount (&as->mcaddrs);
ddsrt_avl_cwalk (&addrset_treedef, &as->mcaddrs, addrset_forall_helper, &arg1);
ddsrt_avl_cwalk (&addrset_treedef, &as->ucaddrs, addrset_forall_helper, &arg1);
count = ddsrt_avl_ccount (&as->ucaddrs) + ddsrt_avl_ccount (&as->mcaddrs);
UNLOCK (as);
return count;
}
@ -543,22 +543,22 @@ int addrset_forone (struct addrset *as, addrset_forone_fun_t f, void *arg)
{
unsigned i;
addrset_node_t n;
ut_avlCTree_t *trees[2];
ut_avlCIter_t iter;
ddsrt_avl_ctree_t *trees[2];
ddsrt_avl_citer_t iter;
trees[0] = &as->mcaddrs;
trees[1] = &as->ucaddrs;
for (i = 0; i < 2u; i++)
{
n = (addrset_node_t) ut_avlCIterFirst (&addrset_treedef, trees[i], &iter);
n = (addrset_node_t) ddsrt_avl_citer_first (&addrset_treedef, trees[i], &iter);
while (n)
{
if ((f) (&n->loc, arg) > 0)
{
return 0;
}
n = (addrset_node_t) ut_avlCIterNext (&iter);
n = (addrset_node_t) ddsrt_avl_citer_next (&iter);
}
}
return -1;
@ -588,14 +588,14 @@ void nn_log_addrset (uint32_t tf, const char *prefix, const struct addrset *as)
}
}
static int addrset_eq_onesidederr1 (const ut_avlCTree_t *at, const ut_avlCTree_t *bt)
static int addrset_eq_onesidederr1 (const ddsrt_avl_ctree_t *at, const ddsrt_avl_ctree_t *bt)
{
/* Just checking the root */
if (ut_avlCIsEmpty (at) && ut_avlCIsEmpty (bt)) {
if (ddsrt_avl_cis_empty (at) && ddsrt_avl_cis_empty (bt)) {
return 1;
} else if (ut_avlCIsSingleton (at) && ut_avlCIsSingleton (bt)) {
const struct addrset_node *a = ut_avlCRootNonEmpty (&addrset_treedef, at);
const struct addrset_node *b = ut_avlCRootNonEmpty (&addrset_treedef, bt);
} else if (ddsrt_avl_cis_singleton (at) && ddsrt_avl_cis_singleton (bt)) {
const struct addrset_node *a = ddsrt_avl_croot_non_empty (&addrset_treedef, at);
const struct addrset_node *b = ddsrt_avl_croot_non_empty (&addrset_treedef, bt);
return compare_locators (&a->loc, &b->loc) == 0;
} else {
return 0;

56
src/core/ddsi/src/q_config.c
View file

@ -24,15 +24,15 @@
#include "dds/ddsrt/misc.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_unused.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_nwif.h"
#include "dds/ddsi/q_error.h"
#include "dds/util/ut_xmlparser.h"
#include "dds/util/ut_expand_envvars.h"
#include "dds/ddsrt/xmlparser.h"
#include "dds/ddsrt/expand_envvars.h"
#include "dds/version.h"
@ -77,7 +77,7 @@ struct cfgst_nodekey {
};
struct cfgst_node {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
struct cfgst_nodekey key;
int count;
int failed;
@ -85,7 +85,7 @@ struct cfgst_node {
};
struct cfgst {
ut_avlTree_t found;
ddsrt_avl_tree_t found;
struct config *cfg;
/* error flag set so that we can continue parsing for some errors and still fail properly */
int error;
@ -119,8 +119,8 @@ the configuration, so we update this variable instead. */
static uint32_t enabled_logcats;
static int cfgst_node_cmp(const void *va, const void *vb);
static const ut_avlTreedef_t cfgst_found_treedef =
UT_AVL_TREEDEF_INITIALIZER(offsetof(struct cfgst_node, avlnode), offsetof(struct cfgst_node, key), cfgst_node_cmp, 0);
static const ddsrt_avl_treedef_t cfgst_found_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER(offsetof(struct cfgst_node, avlnode), offsetof(struct cfgst_node, key), cfgst_node_cmp, 0);
#define DU(fname) static int uf_##fname (struct cfgst *cfgst, void *parent, struct cfgelem const * const cfgelem, int first, const char *value)
#define PF(fname) static void pf_##fname (struct cfgst *cfgst, void *parent, struct cfgelem const * const cfgelem, int is_default)
@ -2067,10 +2067,10 @@ static int do_update(struct cfgst *cfgst, update_fun_t upd, void *parent, struct
{
struct cfgst_node *n;
struct cfgst_nodekey key;
ut_avlIPath_t np;
ddsrt_avl_ipath_t np;
int ok;
key.e = cfgelem;
if ( (n = ut_avlLookupIPath(&cfgst_found_treedef, &cfgst->found, &key, &np)) == NULL ) {
if ( (n = ddsrt_avl_lookup_ipath(&cfgst_found_treedef, &cfgst->found, &key, &np)) == NULL ) {
if ( (n = ddsrt_malloc(sizeof(*n))) == NULL )
return cfg_error(cfgst, "out of memory");
@ -2078,7 +2078,7 @@ static int do_update(struct cfgst *cfgst, update_fun_t upd, void *parent, struct
n->count = 0;
n->failed = 0;
n->is_default = is_default;
ut_avlInsertIPath(&cfgst_found_treedef, &cfgst->found, n, &np);
ddsrt_avl_insert_ipath(&cfgst_found_treedef, &cfgst->found, n, &np);
}
if ( cfgelem->multiplicity == 0 || n->count < cfgelem->multiplicity )
ok = upd(cfgst, parent, cfgelem, (n->count == n->failed), value);
@ -2108,7 +2108,7 @@ static int set_defaults(struct cfgst *cfgst, void *parent, int isattr, struct cf
key.e = ce;
cfgst_push(cfgst, isattr, ce, parent);
if ( ce->multiplicity == 1 ) {
if ( ut_avlLookup(&cfgst_found_treedef, &cfgst->found, &key) == NULL ) {
if ( ddsrt_avl_lookup(&cfgst_found_treedef, &cfgst->found, &key) == NULL ) {
if ( ce->update ) {
int ok1;
cfgst_push(cfgst, 0, NULL, NULL);
@ -2117,9 +2117,9 @@ static int set_defaults(struct cfgst *cfgst, void *parent, int isattr, struct cf
ok = ok && ok1;
}
}
if ( (n = ut_avlLookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
if ( (n = ddsrt_avl_lookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
if ( clear_found ) {
ut_avlDelete(&cfgst_found_treedef, &cfgst->found, n);
ddsrt_avl_delete(&cfgst_found_treedef, &cfgst->found, n);
ddsrt_free(n);
}
}
@ -2419,7 +2419,7 @@ static void print_configitems(struct cfgst *cfgst, void *parent, int isattr, str
key.e = ce;
cfgst_push(cfgst, isattr, ce, parent);
if ( ce->multiplicity == 1 ) {
if ( (n = ut_avlLookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
if ( (n = ddsrt_avl_lookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
cfgst_push(cfgst, 0, NULL, NULL);
ce->print(cfgst, parent, ce, n->is_default);
cfgst_pop(cfgst);
@ -2496,7 +2496,7 @@ static void free_configured_elements(struct cfgst *cfgst, void *parent, struct c
if ( ce->name[0] == '>' ) /* moved, so don't care */
continue;
key.e = ce;
if ( (n = ut_avlLookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
if ( (n = ddsrt_avl_lookup(&cfgst_found_treedef, &cfgst->found, &key)) != NULL ) {
if ( ce->free && n->count > n->failed )
ce->free(cfgst, parent, ce);
}
@ -2646,7 +2646,7 @@ static int proc_attr(void *varg, UNUSED_ARG(uintptr_t eleminfo), const char *nam
return cfg_error(cfgst, "%s: unknown attribute", name);
else {
void *parent = cfgst_parent(cfgst);
char *xvalue = ut_expand_envvars(value);
char *xvalue = ddsrt_expand_envvars(value);
int ok;
cfgst_push(cfgst, 1, cfg_attr, parent);
ok = do_update(cfgst, cfg_attr->update, parent, cfg_attr, xvalue, 0);
@ -2666,7 +2666,7 @@ static int proc_elem_data(void *varg, UNUSED_ARG(uintptr_t eleminfo), const char
return cfg_error(cfgst, "%s: no data expected", value);
else {
void *parent = cfgst_parent(cfgst);
char *xvalue = ut_expand_envvars(value);
char *xvalue = ddsrt_expand_envvars(value);
int ok;
cfgst_push(cfgst, 0, NULL, parent);
ok = do_update(cfgst, cfgelem->update, parent, cfgelem, xvalue, 0);
@ -2802,14 +2802,14 @@ struct cfgst * config_init (const char *configfile)
cfgst = ddsrt_malloc(sizeof(*cfgst));
memset(cfgst, 0, sizeof(*cfgst));
ut_avlInit(&cfgst_found_treedef, &cfgst->found);
ddsrt_avl_init(&cfgst_found_treedef, &cfgst->found);
cfgst->cfg = &config;
cfgst->error = 0;
/* configfile == NULL will get you the default configuration */
if (configfile) {
char *copy = ddsrt_strdup(configfile), *cursor = copy;
struct ut_xmlpCallbacks cb;
struct ddsrt_xmlp_callbacks cb;
cb.attr = proc_attr;
cb.elem_close = proc_elem_close;
@ -2818,14 +2818,14 @@ struct cfgst * config_init (const char *configfile)
cb.error = proc_error;
while (ok && cursor && cursor[0]) {
struct ut_xmlpState *qx;
struct ddsrt_xmlp_state *qx;
FILE *fp;
char *tok;
tok = cursor;
if (tok[0] == '<') {
/* Read XML directly from input string */
qx = ut_xmlpNewString (tok, cfgst, &cb);
ut_xmlpSetRequireEOF (qx, 0);
qx = ddsrt_xmlp_new_string (tok, cfgst, &cb);
ddsrt_xmlp_set_requireEOF (qx, 0);
fp = NULL;
} else {
char *comma;
@ -2845,11 +2845,11 @@ struct cfgst * config_init (const char *configfile)
}
}
DDSRT_WARNING_MSVC_ON(4996);
qx = ut_xmlpNewFile(fp, cfgst, &cb);
qx = ddsrt_xmlp_new_file(fp, cfgst, &cb);
}
cfgst_push(cfgst, 0, &root_cfgelem, &config);
ok = (ut_xmlpParse(qx) >= 0) && !cfgst->error;
ok = (ddsrt_xmlp_parse(qx) >= 0) && !cfgst->error;
/* Pop until stack empty: error handling is rather brutal */
assert(!ok || cfgst->path_depth == 1);
while (cfgst->path_depth > 0) {
@ -2858,9 +2858,9 @@ struct cfgst * config_init (const char *configfile)
if (fp) {
fclose(fp);
} else if (ok) {
cursor = tok + ut_xmlpGetBufpos (qx);
cursor = tok + ddsrt_xmlp_get_bufpos (qx);
}
ut_xmlpFree(qx);
ddsrt_xmlp_free(qx);
while (cursor && cursor[0] == ',') {
cursor++;
}
@ -3019,7 +3019,7 @@ struct cfgst * config_init (const char *configfile)
config.valid = 1;
return cfgst;
} else {
ut_avlFree(&cfgst_found_treedef, &cfgst->found, ddsrt_free);
ddsrt_avl_free(&cfgst_found_treedef, &cfgst->found, ddsrt_free);
ddsrt_free(cfgst);
return NULL;
}
@ -3047,7 +3047,7 @@ void config_fini(struct cfgst *cfgst)
memset(&config, 0, sizeof(config));
config.valid = 0;
ut_avlFree(&cfgst_found_treedef, &cfgst->found, ddsrt_free);
ddsrt_avl_free(&cfgst_found_treedef, &cfgst->found, ddsrt_free);
ddsrt_free(cfgst);
}

4
src/core/ddsi/src/q_ddsi_discovery.c
View file

@ -20,7 +20,7 @@
#include "dds/ddsrt/log.h"
#include "dds/ddsrt/md5.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_misc.h"
@ -1767,7 +1767,7 @@ int builtins_dqueue_handler (const struct nn_rsample_info *sampleinfo, const str
statusinfo = (qos.present & PP_STATUSINFO) ? qos.statusinfo : 0;
}
if (pwr && ut_avlIsEmpty (&pwr->readers))
if (pwr && ddsrt_avl_is_empty (&pwr->readers))
{
/* Wasn't empty when enqueued, but needn't still be; SPDP has no
proxy writer, and is always accepted */

18
src/core/ddsi/src/q_debmon.c
View file

@ -18,7 +18,7 @@
#include "dds/ddsrt/sync.h"
#include "dds/ddsrt/misc.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_config.h"
@ -161,7 +161,7 @@ static int print_participants (struct thread_state1 * const ts1, ddsi_tran_conn_
ephash_enum_reader_init (&er);
while ((r = ephash_enum_reader_next (&er)) != NULL)
{
ut_avlIter_t writ;
ddsrt_avl_iter_t writ;
struct rd_pwr_match *m;
if (r->c.pp != p)
continue;
@ -170,7 +170,7 @@ static int print_participants (struct thread_state1 * const ts1, ddsi_tran_conn_
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
x += print_addrset_if_notempty (conn, " as", r->as, "\n");
#endif
for (m = ut_avlIterFirst (&rd_writers_treedef, &r->writers, &writ); m; m = ut_avlIterNext (&writ))
for (m = ddsrt_avl_iter_first (&rd_writers_treedef, &r->writers, &writ); m; m = ddsrt_avl_iter_next (&writ))
x += cpf (conn, " pwr %x:%x:%x:%x\n", PGUID (m->pwr_guid));
ddsrt_mutex_unlock (&r->e.lock);
}
@ -183,7 +183,7 @@ static int print_participants (struct thread_state1 * const ts1, ddsi_tran_conn_
ephash_enum_writer_init (&ew);
while ((w = ephash_enum_writer_next (&ew)) != NULL)
{
ut_avlIter_t rdit;
ddsrt_avl_iter_t rdit;
struct wr_prd_match *m;
struct whc_state whcst;
if (w->c.pp != p)
@ -207,7 +207,7 @@ static int print_participants (struct thread_state1 * const ts1, ddsi_tran_conn_
x += cpf (conn, " max-drop-seq %lld\n", writer_max_drop_seq (w));
}
x += print_addrset_if_notempty (conn, " as", w->as, "\n");
for (m = ut_avlIterFirst (&wr_readers_treedef, &w->readers, &rdit); m; m = ut_avlIterNext (&rdit))
for (m = ddsrt_avl_iter_first (&wr_readers_treedef, &w->readers, &rdit); m; m = ddsrt_avl_iter_next (&rdit))
{
char wr_prd_flags[4];
wr_prd_flags[0] = m->is_reliable ? 'R' : 'U';
@ -248,13 +248,13 @@ static int print_proxy_participants (struct thread_state1 * const ts1, ddsi_tran
ephash_enum_proxy_reader_init (&er);
while ((r = ephash_enum_proxy_reader_next (&er)) != NULL)
{
ut_avlIter_t writ;
ddsrt_avl_iter_t writ;
struct prd_wr_match *m;
if (r->c.proxypp != p)
continue;
ddsrt_mutex_lock (&r->e.lock);
print_proxy_endpoint_common (conn, "prd", &r->e, &r->c);
for (m = ut_avlIterFirst (&rd_writers_treedef, &r->writers, &writ); m; m = ut_avlIterNext (&writ))
for (m = ddsrt_avl_iter_first (&rd_writers_treedef, &r->writers, &writ); m; m = ddsrt_avl_iter_next (&writ))
x += cpf (conn, " wr %x:%x:%x:%x\n", PGUID (m->wr_guid));
ddsrt_mutex_unlock (&r->e.lock);
}
@ -267,14 +267,14 @@ static int print_proxy_participants (struct thread_state1 * const ts1, ddsi_tran
ephash_enum_proxy_writer_init (&ew);
while ((w = ephash_enum_proxy_writer_next (&ew)) != NULL)
{
ut_avlIter_t rdit;
ddsrt_avl_iter_t rdit;
struct pwr_rd_match *m;
if (w->c.proxypp != p)
continue;
ddsrt_mutex_lock (&w->e.lock);
print_proxy_endpoint_common (conn, "pwr", &w->e, &w->c);
x += cpf (conn, " last_seq %lld last_fragnum %u\n", w->last_seq, w->last_fragnum);
for (m = ut_avlIterFirst (&wr_readers_treedef, &w->readers, &rdit); m; m = ut_avlIterNext (&rdit))
for (m = ddsrt_avl_iter_first (&wr_readers_treedef, &w->readers, &rdit); m; m = ddsrt_avl_iter_next (&rdit))
{
x += cpf (conn, " rd %x:%x:%x:%x (nack %lld %lld)\n",
PGUID (m->rd_guid), m->seq_last_nack, m->t_last_nack);

220
src/core/ddsi/src/q_entity.c
View file

@ -25,7 +25,7 @@
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_misc.h"
#include "dds/ddsi/q_log.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_plist.h"
#include "dds/ddsi/q_lease.h"
#include "dds/ddsi/q_qosmatch.h"
@ -49,34 +49,34 @@
#include "dds/ddsi/ddsi_tkmap.h"
struct deleted_participant {
ut_avlNode_t avlnode;
ddsrt_avl_node_t avlnode;
nn_guid_t guid;
unsigned for_what;
nn_mtime_t t_prune;
};
static ddsrt_mutex_t deleted_participants_lock;
static ut_avlTree_t deleted_participants;
static ddsrt_avl_tree_t deleted_participants;
static int compare_guid (const void *va, const void *vb);
static void augment_wr_prd_match (void *vnode, const void *vleft, const void *vright);
const ut_avlTreedef_t wr_readers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct wr_prd_match, avlnode), offsetof (struct wr_prd_match, prd_guid), compare_guid, augment_wr_prd_match);
const ut_avlTreedef_t wr_local_readers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct wr_rd_match, avlnode), offsetof (struct wr_rd_match, rd_guid), compare_guid, 0);
const ut_avlTreedef_t rd_writers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct rd_pwr_match, avlnode), offsetof (struct rd_pwr_match, pwr_guid), compare_guid, 0);
const ut_avlTreedef_t rd_local_writers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct rd_wr_match, avlnode), offsetof (struct rd_wr_match, wr_guid), compare_guid, 0);
const ut_avlTreedef_t pwr_readers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct pwr_rd_match, avlnode), offsetof (struct pwr_rd_match, rd_guid), compare_guid, 0);
const ut_avlTreedef_t prd_writers_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct prd_wr_match, avlnode), offsetof (struct prd_wr_match, wr_guid), compare_guid, 0);
const ut_avlTreedef_t deleted_participants_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct deleted_participant, avlnode), offsetof (struct deleted_participant, guid), compare_guid, 0);
const ut_avlTreedef_t proxypp_groups_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct proxy_group, avlnode), offsetof (struct proxy_group, guid), compare_guid, 0);
const ddsrt_avl_treedef_t wr_readers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct wr_prd_match, avlnode), offsetof (struct wr_prd_match, prd_guid), compare_guid, augment_wr_prd_match);
const ddsrt_avl_treedef_t wr_local_readers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct wr_rd_match, avlnode), offsetof (struct wr_rd_match, rd_guid), compare_guid, 0);
const ddsrt_avl_treedef_t rd_writers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct rd_pwr_match, avlnode), offsetof (struct rd_pwr_match, pwr_guid), compare_guid, 0);
const ddsrt_avl_treedef_t rd_local_writers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct rd_wr_match, avlnode), offsetof (struct rd_wr_match, wr_guid), compare_guid, 0);
const ddsrt_avl_treedef_t pwr_readers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct pwr_rd_match, avlnode), offsetof (struct pwr_rd_match, rd_guid), compare_guid, 0);
const ddsrt_avl_treedef_t prd_writers_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct prd_wr_match, avlnode), offsetof (struct prd_wr_match, wr_guid), compare_guid, 0);
const ddsrt_avl_treedef_t deleted_participants_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct deleted_participant, avlnode), offsetof (struct deleted_participant, guid), compare_guid, 0);
const ddsrt_avl_treedef_t proxypp_groups_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct proxy_group, avlnode), offsetof (struct proxy_group, guid), compare_guid, 0);
static const unsigned builtin_writers_besmask =
NN_DISC_BUILTIN_ENDPOINT_PARTICIPANT_ANNOUNCER |
@ -267,13 +267,13 @@ nn_vendorid_t get_entity_vendorid (const struct entity_common *e)
int deleted_participants_admin_init (void)
{
ddsrt_mutex_init (&deleted_participants_lock);
ut_avlInit (&deleted_participants_treedef, &deleted_participants);
ddsrt_avl_init (&deleted_participants_treedef, &deleted_participants);
return 0;
}
void deleted_participants_admin_fini (void)
{
ut_avlFree (&deleted_participants_treedef, &deleted_participants, ddsrt_free);
ddsrt_avl_free (&deleted_participants_treedef, &deleted_participants, ddsrt_free);
ddsrt_mutex_destroy (&deleted_participants_lock);
}
@ -283,13 +283,13 @@ static void prune_deleted_participant_guids_unlocked (nn_mtime_t tnow)
all circumstances, but I expect the tree to be very small at all
times, so a full scan is fine, too ... */
struct deleted_participant *dpp;
dpp = ut_avlFindMin (&deleted_participants_treedef, &deleted_participants);
dpp = ddsrt_avl_find_min (&deleted_participants_treedef, &deleted_participants);
while (dpp)
{
struct deleted_participant *dpp1 = ut_avlFindSucc (&deleted_participants_treedef, &deleted_participants, dpp);
struct deleted_participant *dpp1 = ddsrt_avl_find_succ (&deleted_participants_treedef, &deleted_participants, dpp);
if (dpp->t_prune.v < tnow.v)
{
ut_avlDelete (&deleted_participants_treedef, &deleted_participants, dpp);
ddsrt_avl_delete (&deleted_participants_treedef, &deleted_participants, dpp);
ddsrt_free (dpp);
}
dpp = dpp1;
@ -306,16 +306,16 @@ static void prune_deleted_participant_guids (nn_mtime_t tnow)
static void remember_deleted_participant_guid (const struct nn_guid *guid)
{
struct deleted_participant *n;
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
ddsrt_mutex_lock (&deleted_participants_lock);
if (ut_avlLookupIPath (&deleted_participants_treedef, &deleted_participants, guid, &path) == NULL)
if (ddsrt_avl_lookup_ipath (&deleted_participants_treedef, &deleted_participants, guid, &path) == NULL)
{
if ((n = ddsrt_malloc (sizeof (*n))) != NULL)
{
n->guid = *guid;
n->t_prune.v = T_NEVER;
n->for_what = DPG_LOCAL | DPG_REMOTE;
ut_avlInsertIPath (&deleted_participants_treedef, &deleted_participants, n, &path);
ddsrt_avl_insert_ipath (&deleted_participants_treedef, &deleted_participants, n, &path);
}
}
ddsrt_mutex_unlock (&deleted_participants_lock);
@ -327,7 +327,7 @@ int is_deleted_participant_guid (const struct nn_guid *guid, unsigned for_what)
int known;
ddsrt_mutex_lock (&deleted_participants_lock);
prune_deleted_participant_guids_unlocked (now_mt());
if ((n = ut_avlLookup (&deleted_participants_treedef, &deleted_participants, guid)) == NULL)
if ((n = ddsrt_avl_lookup (&deleted_participants_treedef, &deleted_participants, guid)) == NULL)
known = 0;
else
known = ((n->for_what & for_what) != 0);
@ -340,7 +340,7 @@ static void remove_deleted_participant_guid (const struct nn_guid *guid, unsigne
struct deleted_participant *n;
DDS_LOG(DDS_LC_DISCOVERY, "remove_deleted_participant_guid(%x:%x:%x:%x for_what=%x)\n", PGUID (*guid), for_what);
ddsrt_mutex_lock (&deleted_participants_lock);
if ((n = ut_avlLookup (&deleted_participants_treedef, &deleted_participants, guid)) != NULL)
if ((n = ddsrt_avl_lookup (&deleted_participants_treedef, &deleted_participants, guid)) != NULL)
{
if (config.prune_deleted_ppant.enforce_delay)
{
@ -357,7 +357,7 @@ static void remove_deleted_participant_guid (const struct nn_guid *guid, unsigne
}
else
{
ut_avlDelete (&deleted_participants_treedef, &deleted_participants, n);
ddsrt_avl_delete (&deleted_participants_treedef, &deleted_participants, n);
ddsrt_free (n);
}
}
@ -971,13 +971,13 @@ static struct addrset *rebuild_make_all_addrs (int *nreaders, struct writer *wr)
{
struct addrset *all_addrs = new_addrset();
struct wr_prd_match *m;
ut_avlIter_t it;
ddsrt_avl_iter_t it;
#ifdef DDSI_INCLUDE_SSM
if (wr->supports_ssm && wr->ssm_as)
copy_addrset_into_addrset_mc (all_addrs, wr->ssm_as);
#endif
*nreaders = 0;
for (m = ut_avlIterFirst (&wr_readers_treedef, &wr->readers, &it); m; m = ut_avlIterNext (&it))
for (m = ddsrt_avl_iter_first (&wr_readers_treedef, &wr->readers, &it); m; m = ddsrt_avl_iter_next (&it))
{
struct proxy_reader *prd;
if ((prd = ephash_lookup_proxy_reader_guid (&m->prd_guid)) == NULL)
@ -1030,7 +1030,7 @@ static void rebuild_make_covered(int8_t **covered, const struct writer *wr, int
{
struct rebuild_flatten_locs_arg flarg;
struct wr_prd_match *m;
ut_avlIter_t it;
ddsrt_avl_iter_t it;
int rdidx, i, j;
int8_t *cov = ddsrt_malloc((size_t) *nreaders * (size_t) nlocs * sizeof (*cov));
for (i = 0; i < *nreaders * nlocs; i++)
@ -1040,7 +1040,7 @@ static void rebuild_make_covered(int8_t **covered, const struct writer *wr, int
#ifndef NDEBUG
flarg.size = nlocs;
#endif
for (m = ut_avlIterFirst (&wr_readers_treedef, &wr->readers, &it); m; m = ut_avlIterNext (&it))
for (m = ddsrt_avl_iter_first (&wr_readers_treedef, &wr->readers, &it); m; m = ddsrt_avl_iter_next (&it))
{
struct proxy_reader *prd;
struct addrset *ass[] = { NULL, NULL, NULL };
@ -1337,10 +1337,10 @@ static void writer_drop_connection (const struct nn_guid * wr_guid, const struct
struct whc_node *deferred_free_list = NULL;
struct wr_prd_match *m;
ddsrt_mutex_lock (&wr->e.lock);
if ((m = ut_avlLookup (&wr_readers_treedef, &wr->readers, &prd->e.guid)) != NULL)
if ((m = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &prd->e.guid)) != NULL)
{
struct whc_state whcst;
ut_avlDelete (&wr_readers_treedef, &wr->readers, m);
ddsrt_avl_delete (&wr_readers_treedef, &wr->readers, m);
rebuild_writer_addrset (wr);
remove_acked_messages (wr, &whcst, &deferred_free_list);
wr->num_reliable_readers -= m->is_reliable;
@ -1368,9 +1368,9 @@ static void writer_drop_local_connection (const struct nn_guid *wr_guid, struct
struct wr_rd_match *m;
ddsrt_mutex_lock (&wr->e.lock);
if ((m = ut_avlLookup (&wr_local_readers_treedef, &wr->local_readers, &rd->e.guid)) != NULL)
if ((m = ddsrt_avl_lookup (&wr_local_readers_treedef, &wr->local_readers, &rd->e.guid)) != NULL)
{
ut_avlDelete (&wr_local_readers_treedef, &wr->local_readers, m);
ddsrt_avl_delete (&wr_local_readers_treedef, &wr->local_readers, m);
local_reader_ary_remove (&wr->rdary, rd);
}
ddsrt_mutex_unlock (&wr->e.lock);
@ -1393,8 +1393,8 @@ static void reader_drop_connection (const struct nn_guid *rd_guid, const struct
{
struct rd_pwr_match *m;
ddsrt_mutex_lock (&rd->e.lock);
if ((m = ut_avlLookup (&rd_writers_treedef, &rd->writers, &pwr->e.guid)) != NULL)
ut_avlDelete (&rd_writers_treedef, &rd->writers, m);
if ((m = ddsrt_avl_lookup (&rd_writers_treedef, &rd->writers, &pwr->e.guid)) != NULL)
ddsrt_avl_delete (&rd_writers_treedef, &rd->writers, m);
ddsrt_mutex_unlock (&rd->e.lock);
free_rd_pwr_match (m);
@ -1427,8 +1427,8 @@ static void reader_drop_local_connection (const struct nn_guid *rd_guid, const s
{
struct rd_wr_match *m;
ddsrt_mutex_lock (&rd->e.lock);
if ((m = ut_avlLookup (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid)) != NULL)
ut_avlDelete (&rd_local_writers_treedef, &rd->local_writers, m);
if ((m = ddsrt_avl_lookup (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid)) != NULL)
ddsrt_avl_delete (&rd_local_writers_treedef, &rd->local_writers, m);
ddsrt_mutex_unlock (&rd->e.lock);
free_rd_wr_match (m);
@ -1486,9 +1486,9 @@ static void proxy_writer_drop_connection (const struct nn_guid *pwr_guid, struct
struct pwr_rd_match *m;
ddsrt_mutex_lock (&pwr->e.lock);
if ((m = ut_avlLookup (&pwr_readers_treedef, &pwr->readers, &rd->e.guid)) != NULL)
if ((m = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, &rd->e.guid)) != NULL)
{
ut_avlDelete (&pwr_readers_treedef, &pwr->readers, m);
ddsrt_avl_delete (&pwr_readers_treedef, &pwr->readers, m);
if (m->in_sync != PRMSS_SYNC)
pwr->n_readers_out_of_sync--;
if (rd->reliable)
@ -1512,10 +1512,10 @@ static void proxy_reader_drop_connection
{
struct prd_wr_match *m;
ddsrt_mutex_lock (&prd->e.lock);
m = ut_avlLookup (&prd_writers_treedef, &prd->writers, &wr->e.guid);
m = ddsrt_avl_lookup (&prd_writers_treedef, &prd->writers, &wr->e.guid);
if (m)
{
ut_avlDelete (&prd_writers_treedef, &prd->writers, m);
ddsrt_avl_delete (&prd_writers_treedef, &prd->writers, m);
}
ddsrt_mutex_unlock (&prd->e.lock);
free_prd_wr_match (m);
@ -1525,7 +1525,7 @@ static void proxy_reader_drop_connection
static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
{
struct wr_prd_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
int pretend_everything_acked;
m->prd_guid = prd->e.guid;
m->is_reliable = (prd->c.xqos->reliability.kind > NN_BEST_EFFORT_RELIABILITY_QOS);
@ -1564,7 +1564,7 @@ static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
m->seq = MAX_SEQ_NUMBER;
else
m->seq = wr->seq;
if (ut_avlLookupIPath (&wr_readers_treedef, &wr->readers, &prd->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&wr_readers_treedef, &wr->readers, &prd->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (prd->e.guid));
ddsrt_mutex_unlock (&wr->e.lock);
@ -1574,7 +1574,7 @@ static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
else
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - ack seq %"PRId64"\n", PGUID (wr->e.guid), PGUID (prd->e.guid), m->seq);
ut_avlInsertIPath (&wr_readers_treedef, &wr->readers, m, &path);
ddsrt_avl_insert_ipath (&wr_readers_treedef, &wr->readers, m, &path);
rebuild_writer_addrset (wr);
wr->num_reliable_readers += m->is_reliable;
ddsrt_mutex_unlock (&wr->e.lock);
@ -1618,10 +1618,10 @@ static void writer_add_connection (struct writer *wr, struct proxy_reader *prd)
static void writer_add_local_connection (struct writer *wr, struct reader *rd)
{
struct wr_rd_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
ddsrt_mutex_lock (&wr->e.lock);
if (ut_avlLookupIPath (&wr_local_readers_treedef, &wr->local_readers, &rd->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&wr_local_readers_treedef, &wr->local_readers, &rd->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&wr->e.lock);
@ -1631,7 +1631,7 @@ static void writer_add_local_connection (struct writer *wr, struct reader *rd)
DDS_LOG(DDS_LC_DISCOVERY, " writer_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x)", PGUID (wr->e.guid), PGUID (rd->e.guid));
m->rd_guid = rd->e.guid;
ut_avlInsertIPath (&wr_local_readers_treedef, &wr->local_readers, m, &path);
ddsrt_avl_insert_ipath (&wr_local_readers_treedef, &wr->local_readers, m, &path);
local_reader_ary_insert (&wr->rdary, rd);
/* Store available data into the late joining reader when it is reliable (we don't do
@ -1672,7 +1672,7 @@ static void writer_add_local_connection (struct writer *wr, struct reader *rd)
static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr, nn_count_t *init_count)
{
struct rd_pwr_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
m->pwr_guid = pwr->e.guid;
@ -1687,7 +1687,7 @@ static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr,
DDS_LOG(DDS_LC_DISCOVERY, " reader %x:%x:%x:%x init_acknack_count = %d\n", PGUID (rd->e.guid), rd->init_acknack_count);
*init_count = rd->init_acknack_count;
if (ut_avlLookupIPath (&rd_writers_treedef, &rd->writers, &pwr->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&rd_writers_treedef, &rd->writers, &pwr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
@ -1698,7 +1698,7 @@ static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr,
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_connection(pwr %x:%x:%x:%x rd %x:%x:%x:%x)\n",
PGUID (pwr->e.guid), PGUID (rd->e.guid));
ut_avlInsertIPath (&rd_writers_treedef, &rd->writers, m, &path);
ddsrt_avl_insert_ipath (&rd_writers_treedef, &rd->writers, m, &path);
ddsrt_mutex_unlock (&rd->e.lock);
#ifdef DDSI_INCLUDE_SSM
@ -1736,13 +1736,13 @@ static void reader_add_connection (struct reader *rd, struct proxy_writer *pwr,
static void reader_add_local_connection (struct reader *rd, struct writer *wr)
{
struct rd_wr_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
m->wr_guid = wr->e.guid;
ddsrt_mutex_lock (&rd->e.lock);
if (ut_avlLookupIPath (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&rd_local_writers_treedef, &rd->local_writers, &wr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x) - already connected\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ddsrt_mutex_unlock (&rd->e.lock);
@ -1751,7 +1751,7 @@ static void reader_add_local_connection (struct reader *rd, struct writer *wr)
else
{
DDS_LOG(DDS_LC_DISCOVERY, " reader_add_local_connection(wr %x:%x:%x:%x rd %x:%x:%x:%x)\n", PGUID (wr->e.guid), PGUID (rd->e.guid));
ut_avlInsertIPath (&rd_local_writers_treedef, &rd->local_writers, m, &path);
ddsrt_avl_insert_ipath (&rd_local_writers_treedef, &rd->local_writers, m, &path);
ddsrt_mutex_unlock (&rd->e.lock);
if (rd->status_cb)
@ -1772,11 +1772,11 @@ static void reader_add_local_connection (struct reader *rd, struct writer *wr)
static void proxy_writer_add_connection (struct proxy_writer *pwr, struct reader *rd, nn_mtime_t tnow, nn_count_t init_count)
{
struct pwr_rd_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
seqno_t last_deliv_seq;
ddsrt_mutex_lock (&pwr->e.lock);
if (ut_avlLookupIPath (&pwr_readers_treedef, &pwr->readers, &rd->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&pwr_readers_treedef, &pwr->readers, &rd->e.guid, &path))
goto already_matched;
if (pwr->c.topic == NULL && rd->topic)
@ -1816,7 +1816,7 @@ static void proxy_writer_add_connection (struct proxy_writer *pwr, struct reader
{
m->in_sync = PRMSS_SYNC;
}
else if (!config.conservative_builtin_reader_startup && is_builtin_entityid (rd->e.guid.entityid, NN_VENDORID_ECLIPSE) && !ut_avlIsEmpty (&pwr->readers))
else if (!config.conservative_builtin_reader_startup && is_builtin_entityid (rd->e.guid.entityid, NN_VENDORID_ECLIPSE) && !ddsrt_avl_is_empty (&pwr->readers))
{
/* builtins really don't care about multiple copies */
m->in_sync = PRMSS_SYNC;
@ -1860,7 +1860,7 @@ static void proxy_writer_add_connection (struct proxy_writer *pwr, struct reader
nn_reorder_new (NN_REORDER_MODE_MONOTONICALLY_INCREASING, config.secondary_reorder_maxsamples);
}
ut_avlInsertIPath (&pwr_readers_treedef, &pwr->readers, m, &path);
ddsrt_avl_insert_ipath (&pwr_readers_treedef, &pwr->readers, m, &path);
local_reader_ary_insert(&pwr->rdary, rd);
ddsrt_mutex_unlock (&pwr->e.lock);
qxev_pwr_entityid (pwr, &rd->e.guid.prefix);
@ -1890,13 +1890,13 @@ already_matched:
static void proxy_reader_add_connection (struct proxy_reader *prd, struct writer *wr)
{
struct prd_wr_match *m = ddsrt_malloc (sizeof (*m));
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
m->wr_guid = wr->e.guid;
ddsrt_mutex_lock (&prd->e.lock);
if (prd->c.topic == NULL)
prd->c.topic = ddsi_sertopic_ref (wr->topic);
if (ut_avlLookupIPath (&prd_writers_treedef, &prd->writers, &wr->e.guid, &path))
if (ddsrt_avl_lookup_ipath (&prd_writers_treedef, &prd->writers, &wr->e.guid, &path))
{
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x) - already connected\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
@ -1907,7 +1907,7 @@ static void proxy_reader_add_connection (struct proxy_reader *prd, struct writer
{
DDS_LOG(DDS_LC_DISCOVERY, " proxy_reader_add_connection(wr %x:%x:%x:%x prd %x:%x:%x:%x)\n",
PGUID (wr->e.guid), PGUID (prd->e.guid));
ut_avlInsertIPath (&prd_writers_treedef, &prd->writers, m, &path);
ddsrt_avl_insert_ipath (&prd_writers_treedef, &prd->writers, m, &path);
ddsrt_mutex_unlock (&prd->e.lock);
qxev_prd_entityid (prd, &wr->e.guid.prefix);
}
@ -2539,15 +2539,15 @@ static void augment_wr_prd_match (void *vnode, const void *vleft, const void *vr
seqno_t writer_max_drop_seq (const struct writer *wr)
{
const struct wr_prd_match *n;
if (ut_avlIsEmpty (&wr->readers))
if (ddsrt_avl_is_empty (&wr->readers))
return wr->seq;
n = ut_avlRootNonEmpty (&wr_readers_treedef, &wr->readers);
n = ddsrt_avl_root_non_empty (&wr_readers_treedef, &wr->readers);
return (n->min_seq == MAX_SEQ_NUMBER) ? wr->seq : n->min_seq;
}
int writer_must_have_hb_scheduled (const struct writer *wr, const struct whc_state *whcst)
{
if (ut_avlIsEmpty (&wr->readers) || whcst->max_seq < 0)
if (ddsrt_avl_is_empty (&wr->readers) || whcst->max_seq < 0)
{
/* Can't transmit a valid heartbeat if there is no data; and it
wouldn't actually be sent anywhere if there are no readers, so
@ -2558,7 +2558,7 @@ int writer_must_have_hb_scheduled (const struct writer *wr, const struct whc_sta
a heartbeat if no data is available. */
return 0;
}
else if (!((const struct wr_prd_match *) ut_avlRootNonEmpty (&wr_readers_treedef, &wr->readers))->all_have_replied_to_hb)
else if (!((const struct wr_prd_match *) ddsrt_avl_root_non_empty (&wr_readers_treedef, &wr->readers))->all_have_replied_to_hb)
{
/* Labouring under the belief that heartbeats must be sent
regardless of ack state */
@ -2800,8 +2800,8 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
assert (!is_builtin_entityid(wr->e.guid.entityid, NN_VENDORID_ECLIPSE) || (wr->whc_low == wr->whc_high && wr->whc_low == INT32_MAX));
/* Connection admin */
ut_avlInit (&wr_readers_treedef, &wr->readers);
ut_avlInit (&wr_local_readers_treedef, &wr->local_readers);
ddsrt_avl_init (&wr_readers_treedef, &wr->readers);
ddsrt_avl_init (&wr_local_readers_treedef, &wr->local_readers);
local_reader_ary_init (&wr->rdary);
}
@ -2917,17 +2917,17 @@ static void gc_delete_writer (struct gcreq *gcreq)
us now, because we can't be found via guid_hash anymore. We
therefore need not take lock. */
while (!ut_avlIsEmpty (&wr->readers))
while (!ddsrt_avl_is_empty (&wr->readers))
{
struct wr_prd_match *m = ut_avlRootNonEmpty (&wr_readers_treedef, &wr->readers);
ut_avlDelete (&wr_readers_treedef, &wr->readers, m);
struct wr_prd_match *m = ddsrt_avl_root_non_empty (&wr_readers_treedef, &wr->readers);
ddsrt_avl_delete (&wr_readers_treedef, &wr->readers, m);
proxy_reader_drop_connection (&m->prd_guid, wr);
free_wr_prd_match (m);
}
while (!ut_avlIsEmpty (&wr->local_readers))
while (!ddsrt_avl_is_empty (&wr->local_readers))
{
struct wr_rd_match *m = ut_avlRootNonEmpty (&wr_local_readers_treedef, &wr->local_readers);
ut_avlDelete (&wr_local_readers_treedef, &wr->local_readers, m);
struct wr_rd_match *m = ddsrt_avl_root_non_empty (&wr_local_readers_treedef, &wr->local_readers);
ddsrt_avl_delete (&wr_local_readers_treedef, &wr->local_readers, m);
reader_drop_local_connection (&m->rd_guid, wr);
free_wr_rd_match (m);
}
@ -3324,8 +3324,8 @@ static dds_retcode_t new_reader_guid
#endif
#endif
ut_avlInit (&rd_writers_treedef, &rd->writers);
ut_avlInit (&rd_local_writers_treedef, &rd->local_writers);
ddsrt_avl_init (&rd_writers_treedef, &rd->writers);
ddsrt_avl_init (&rd_local_writers_treedef, &rd->local_writers);
ddsrt_mutex_lock (&rd->e.lock);
ephash_insert_reader_guid (rd);
@ -3371,17 +3371,17 @@ static void gc_delete_reader (struct gcreq *gcreq)
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_reader(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (rd->e.guid));
gcreq_free (gcreq);
while (!ut_avlIsEmpty (&rd->writers))
while (!ddsrt_avl_is_empty (&rd->writers))
{
struct rd_pwr_match *m = ut_avlRootNonEmpty (&rd_writers_treedef, &rd->writers);
ut_avlDelete (&rd_writers_treedef, &rd->writers, m);
struct rd_pwr_match *m = ddsrt_avl_root_non_empty (&rd_writers_treedef, &rd->writers);
ddsrt_avl_delete (&rd_writers_treedef, &rd->writers, m);
proxy_writer_drop_connection (&m->pwr_guid, rd);
free_rd_pwr_match (m);
}
while (!ut_avlIsEmpty (&rd->local_writers))
while (!ddsrt_avl_is_empty (&rd->local_writers))
{
struct rd_wr_match *m = ut_avlRootNonEmpty (&rd_local_writers_treedef, &rd->local_writers);
ut_avlDelete (&rd_local_writers_treedef, &rd->local_writers, m);
struct rd_wr_match *m = ddsrt_avl_root_non_empty (&rd_local_writers_treedef, &rd->local_writers);
ddsrt_avl_delete (&rd_local_writers_treedef, &rd->local_writers, m);
writer_drop_local_connection (&m->wr_guid, rd);
free_rd_wr_match (m);
}
@ -3552,7 +3552,7 @@ void new_proxy_participant
proxypp->as_meta = as_meta;
proxypp->endpoints = NULL;
proxypp->plist = nn_plist_dup (plist);
ut_avlInit (&proxypp_groups_treedef, &proxypp->groups);
ddsrt_avl_init (&proxypp_groups_treedef, &proxypp->groups);
if (custom_flags & CF_INC_KERNEL_SEQUENCE_NUMBERS)
@ -3851,8 +3851,8 @@ static void delete_ppt (struct proxy_participant * proxypp, nn_wctime_t timestam
proxypp->lease_expired = 1;
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt(%x:%x:%x:%x) - deleting groups\n", PGUID (proxypp->e.guid));
while (!ut_avlIsEmpty (&proxypp->groups))
delete_proxy_group_locked (ut_avlRoot (&proxypp_groups_treedef, &proxypp->groups), timestamp, isimplicit);
while (!ddsrt_avl_is_empty (&proxypp->groups))
delete_proxy_group_locked (ddsrt_avl_root (&proxypp_groups_treedef, &proxypp->groups), timestamp, isimplicit);
DDS_LOG(DDS_LC_DISCOVERY, "delete_ppt(%x:%x:%x:%x) - deleting endpoints\n", PGUID (proxypp->e.guid));
c = proxypp->endpoints;
@ -3965,7 +3965,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
else
{
struct proxy_group *pgroup;
ut_avlIPath_t ipath;
ddsrt_avl_ipath_t ipath;
int is_sub;
switch (guid->entityid.u & (NN_ENTITYID_SOURCE_MASK | NN_ENTITYID_KIND_MASK))
{
@ -3980,7 +3980,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
return Q_ERR_INVALID_DATA;
}
ddsrt_mutex_lock (&proxypp->e.lock);
if ((pgroup = ut_avlLookupIPath (&proxypp_groups_treedef, &proxypp->groups, guid, &ipath)) != NULL)
if ((pgroup = ddsrt_avl_lookup_ipath (&proxypp_groups_treedef, &proxypp->groups, guid, &ipath)) != NULL)
{
/* Complete proxy group definition if it was a partial
definition made by creating a proxy reader or writer,
@ -3997,7 +3997,7 @@ int new_proxy_group (const struct nn_guid *guid, const char *name, const struct
pgroup->proxypp = proxypp;
pgroup->name = NULL;
pgroup->xqos = NULL;
ut_avlInsertIPath (&proxypp_groups_treedef, &proxypp->groups, pgroup, &ipath);
ddsrt_avl_insert_ipath (&proxypp_groups_treedef, &proxypp->groups, pgroup, &ipath);
}
if (name)
{
@ -4021,7 +4021,7 @@ static void delete_proxy_group_locked (struct proxy_group *pgroup, nn_wctime_t t
(void)isimplicit;
assert ((pgroup->xqos != NULL) == (pgroup->name != NULL));
DDS_LOG(DDS_LC_DISCOVERY, "delete_proxy_group_locked %x:%x:%x:%x\n", PGUID (pgroup->guid));
ut_avlDelete (&proxypp_groups_treedef, &proxypp->groups, pgroup);
ddsrt_avl_delete (&proxypp_groups_treedef, &proxypp->groups, pgroup);
/* Publish corresponding built-in topic only if it is not a place
holder: in that case we haven't announced its presence and
therefore don't need to dispose it, and this saves us from having
@ -4046,7 +4046,7 @@ void delete_proxy_group (const nn_guid_t *guid, nn_wctime_t timestamp, int isimp
{
struct proxy_group *pgroup;
ddsrt_mutex_lock (&proxypp->e.lock);
if ((pgroup = ut_avlLookup (&proxypp_groups_treedef, &proxypp->groups, guid)) != NULL)
if ((pgroup = ddsrt_avl_lookup (&proxypp_groups_treedef, &proxypp->groups, guid)) != NULL)
delete_proxy_group_locked (pgroup, timestamp, isimplicit);
ddsrt_mutex_unlock (&proxypp->e.lock);
}
@ -4112,7 +4112,7 @@ int new_proxy_writer (const struct nn_guid *ppguid, const struct nn_guid *guid,
pwr = ddsrt_malloc (sizeof (*pwr));
proxy_endpoint_common_init (&pwr->e, &pwr->c, EK_PROXY_WRITER, guid, timestamp, proxypp, as, plist);
ut_avlInit (&pwr_readers_treedef, &pwr->readers);
ddsrt_avl_init (&pwr_readers_treedef, &pwr->readers);
pwr->n_reliable_readers = 0;
pwr->n_readers_out_of_sync = 0;
pwr->last_seq = 0;
@ -4195,7 +4195,7 @@ void update_proxy_writer (struct proxy_writer * pwr, struct addrset * as)
{
struct reader * rd;
struct pwr_rd_match * m;
ut_avlIter_t iter;
ddsrt_avl_iter_t iter;
/* Update proxy writer endpoints (from SEDP alive) */
@ -4208,7 +4208,7 @@ void update_proxy_writer (struct proxy_writer * pwr, struct addrset * as)
unref_addrset (pwr->c.as);
ref_addrset (as);
pwr->c.as = as;
m = ut_avlIterFirst (&pwr_readers_treedef, &pwr->readers, &iter);
m = ddsrt_avl_iter_first (&pwr_readers_treedef, &pwr->readers, &iter);
while (m)
{
rd = ephash_lookup_reader_guid (&m->rd_guid);
@ -4216,7 +4216,7 @@ void update_proxy_writer (struct proxy_writer * pwr, struct addrset * as)
{
qxev_pwr_entityid (pwr, &rd->e.guid.prefix);
}
m = ut_avlIterNext (&iter);
m = ddsrt_avl_iter_next (&iter);
}
}
ddsrt_mutex_unlock (&pwr->e.lock);
@ -4240,14 +4240,14 @@ void update_proxy_reader (struct proxy_reader * prd, struct addrset * as)
/* Rebuild writer endpoints */
while ((m = ut_avlLookupSuccEq (&prd_writers_treedef, &prd->writers, &wrguid)) != NULL)
while ((m = ddsrt_avl_lookup_succ_eq (&prd_writers_treedef, &prd->writers, &wrguid)) != NULL)
{
struct prd_wr_match *next;
nn_guid_t guid_next;
struct writer * wr;
wrguid = m->wr_guid;
next = ut_avlFindSucc (&prd_writers_treedef, &prd->writers, m);
next = ddsrt_avl_find_succ (&prd_writers_treedef, &prd->writers, m);
if (next)
{
guid_next = next->wr_guid;
@ -4280,10 +4280,10 @@ static void gc_delete_proxy_writer (struct gcreq *gcreq)
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_writer(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (pwr->e.guid));
gcreq_free (gcreq);
while (!ut_avlIsEmpty (&pwr->readers))
while (!ddsrt_avl_is_empty (&pwr->readers))
{
struct pwr_rd_match *m = ut_avlRootNonEmpty (&pwr_readers_treedef, &pwr->readers);
ut_avlDelete (&pwr_readers_treedef, &pwr->readers, m);
struct pwr_rd_match *m = ddsrt_avl_root_non_empty (&pwr_readers_treedef, &pwr->readers);
ddsrt_avl_delete (&pwr_readers_treedef, &pwr->readers, m);
reader_drop_connection (&m->rd_guid, pwr);
update_reader_init_acknack_count (&m->rd_guid, m->count);
free_pwr_rd_match (m);
@ -4353,7 +4353,7 @@ int new_proxy_reader (const struct nn_guid *ppguid, const struct nn_guid *guid,
"real" participant, rather than the thing we use for endpoints discovered via the DS */
prd->assert_pp_lease = (unsigned) !!config.arrival_of_data_asserts_pp_and_ep_liveliness;
ut_avlInit (&prd_writers_treedef, &prd->writers);
ddsrt_avl_init (&prd_writers_treedef, &prd->writers);
/* locking the entity prevents matching while the built-in topic hasn't been published yet */
ddsrt_mutex_lock (&prd->e.lock);
@ -4374,14 +4374,14 @@ static void proxy_reader_set_delete_and_ack_all_messages (struct proxy_reader *p
memset (&wrguid, 0, sizeof (wrguid));
ddsrt_mutex_lock (&prd->e.lock);
prd->deleting = 1;
while ((m = ut_avlLookupSuccEq (&prd_writers_treedef, &prd->writers, &wrguid)) != NULL)
while ((m = ddsrt_avl_lookup_succ_eq (&prd_writers_treedef, &prd->writers, &wrguid)) != NULL)
{
/* have to be careful walking the tree -- pretty is different, but
I want to check this before I write a lookup_succ function. */
struct prd_wr_match *m_a_next;
nn_guid_t wrguid_next;
wrguid = m->wr_guid;
if ((m_a_next = ut_avlFindSucc (&prd_writers_treedef, &prd->writers, m)) != NULL)
if ((m_a_next = ddsrt_avl_find_succ (&prd_writers_treedef, &prd->writers, m)) != NULL)
wrguid_next = m_a_next->wr_guid;
else
{
@ -4395,11 +4395,11 @@ static void proxy_reader_set_delete_and_ack_all_messages (struct proxy_reader *p
struct whc_node *deferred_free_list = NULL;
struct wr_prd_match *m_wr;
ddsrt_mutex_lock (&wr->e.lock);
if ((m_wr = ut_avlLookup (&wr_readers_treedef, &wr->readers, &prd->e.guid)) != NULL)
if ((m_wr = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &prd->e.guid)) != NULL)
{
struct whc_state whcst;
m_wr->seq = MAX_SEQ_NUMBER;
ut_avlAugmentUpdate (&wr_readers_treedef, m_wr);
ddsrt_avl_augment_update (&wr_readers_treedef, m_wr);
(void)remove_acked_messages (wr, &whcst, &deferred_free_list);
writer_clear_retransmitting (wr);
}
@ -4419,10 +4419,10 @@ static void gc_delete_proxy_reader (struct gcreq *gcreq)
DDS_LOG(DDS_LC_DISCOVERY, "gc_delete_proxy_reader(%p, %x:%x:%x:%x)\n", (void *) gcreq, PGUID (prd->e.guid));
gcreq_free (gcreq);
while (!ut_avlIsEmpty (&prd->writers))
while (!ddsrt_avl_is_empty (&prd->writers))
{
struct prd_wr_match *m = ut_avlRootNonEmpty (&prd_writers_treedef, &prd->writers);
ut_avlDelete (&prd_writers_treedef, &prd->writers, m);
struct prd_wr_match *m = ddsrt_avl_root_non_empty (&prd_writers_treedef, &prd->writers);
ddsrt_avl_delete (&prd_writers_treedef, &prd->writers, m);
writer_drop_connection (&m->wr_guid, prd);
free_prd_wr_match (m);
}

22
src/core/ddsi/src/q_ephash.c
View file

@ -15,7 +15,7 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/misc.h"
#include "dds/util/ut_hopscotch.h"
#include "dds/ddsrt/hopscotch.h"
#include "dds/ddsi/q_ephash.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_globals.h"
@ -25,7 +25,7 @@
#include "dds/ddsi/q_thread.h" /* for assert(thread is awake) */
struct ephash {
struct ut_chh *hash;
struct ddsrt_chh *hash;
};
static const uint64_t unihashconsts[] = {
@ -80,7 +80,7 @@ struct ephash *ephash_new (void)
{
struct ephash *ephash;
ephash = ddsrt_malloc (sizeof (*ephash));
ephash->hash = ut_chhNew (32, hash_entity_guid_wrapper, entity_guid_eq_wrapper, gc_buckets);
ephash->hash = ddsrt_chh_new (32, hash_entity_guid_wrapper, entity_guid_eq_wrapper, gc_buckets);
if (ephash->hash == NULL) {
ddsrt_free (ephash);
return NULL;
@ -91,7 +91,7 @@ struct ephash *ephash_new (void)
void ephash_free (struct ephash *ephash)
{
ut_chhFree (ephash->hash);
ddsrt_chh_free (ephash->hash);
ephash->hash = NULL;
ddsrt_free (ephash);
}
@ -101,7 +101,7 @@ static void ephash_guid_insert (struct entity_common *e)
int x;
assert(gv.guid_hash);
assert(gv.guid_hash->hash);
x = ut_chhAdd (gv.guid_hash->hash, e);
x = ddsrt_chh_add (gv.guid_hash->hash, e);
(void)x;
assert (x);
}
@ -111,7 +111,7 @@ static void ephash_guid_remove (struct entity_common *e)
int x;
assert(gv.guid_hash);
assert(gv.guid_hash->hash);
x = ut_chhRemove (gv.guid_hash->hash, e);
x = ddsrt_chh_remove (gv.guid_hash->hash, e);
(void)x;
assert (x);
}
@ -121,7 +121,7 @@ void *ephash_lookup_guid_untyped (const struct nn_guid *guid)
/* FIXME: could (now) require guid to be first in entity_common; entity_common already is first in entity */
struct entity_common e;
e.guid = *guid;
return ut_chhLookup (gv.guid_hash->hash, &e);
return ddsrt_chh_lookup (gv.guid_hash->hash, &e);
}
static void *ephash_lookup_guid_int (const struct ephash *ephash, const struct nn_guid *guid, enum entity_kind kind)
@ -246,9 +246,9 @@ struct proxy_reader *ephash_lookup_proxy_reader_guid (const struct nn_guid *guid
static void ephash_enum_init_int (struct ephash_enum *st, struct ephash *ephash, enum entity_kind kind)
{
st->kind = kind;
st->cur = ut_chhIterFirst (ephash->hash, &st->it);
st->cur = ddsrt_chh_iter_first (ephash->hash, &st->it);
while (st->cur && st->cur->kind != st->kind)
st->cur = ut_chhIterNext (&st->it);
st->cur = ddsrt_chh_iter_next (&st->it);
}
void ephash_enum_init (struct ephash_enum *st, enum entity_kind kind)
@ -291,9 +291,9 @@ void *ephash_enum_next (struct ephash_enum *st)
void *res = st->cur;
if (st->cur)
{
st->cur = ut_chhIterNext (&st->it);
st->cur = ddsrt_chh_iter_next (&st->it);
while (st->cur && st->cur->kind != st->kind)
st->cur = ut_chhIterNext (&st->it);
st->cur = ddsrt_chh_iter_next (&st->it);
}
return res;
}

10
src/core/ddsi/src/q_init.c
View file

@ -19,8 +19,8 @@
#include "dds/ddsrt/string.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_avl.h"
#include "dds/util/ut_thread_pool.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsrt/thread_pool.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_rtps.h"
@ -895,7 +895,7 @@ int rtps_init (void)
if (config.tp_enable)
{
gv.thread_pool = ut_thread_pool_new
gv.thread_pool = ddsrt_thread_pool_new
(config.tp_threads, config.tp_max_threads, 0, NULL);
}
@ -1357,7 +1357,7 @@ err_find_own_ip:
ddsi_tran_factories_fini ();
err_udp_tcp_init:
if (config.tp_enable)
ut_thread_pool_free (gv.thread_pool);
ddsrt_thread_pool_free (gv.thread_pool);
return -1;
}
@ -1609,7 +1609,7 @@ void rtps_fini (void)
}
#endif
ut_thread_pool_free (gv.thread_pool);
ddsrt_thread_pool_free (gv.thread_pool);
(void) joinleave_spdp_defmcip (0);

38
src/core/ddsi/src/q_inverse_uint32_set.c
View file

@ -12,14 +12,14 @@
#include <assert.h>
#include <stddef.h>
#include "dds/ddsrt/heap.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_config.h"
#include "dds/ddsi/q_log.h"
#include "dds/ddsi/q_inverse_uint32_set.h"
static int uint32_t_cmp(const void *va, const void *vb);
static ut_avlTreedef_t inverse_uint32_set_td = UT_AVL_TREEDEF_INITIALIZER(offsetof(struct inverse_uint32_set_node, avlnode), offsetof(struct inverse_uint32_set_node, min), uint32_t_cmp, 0);
static ddsrt_avl_treedef_t inverse_uint32_set_td = DDSRT_AVL_TREEDEF_INITIALIZER(offsetof(struct inverse_uint32_set_node, avlnode), offsetof(struct inverse_uint32_set_node, min), uint32_t_cmp, 0);
static int uint32_t_cmp(const void *va, const void *vb)
{
@ -31,12 +31,12 @@ static int uint32_t_cmp(const void *va, const void *vb)
static void check(const struct inverse_uint32_set *set)
{
#ifndef NDEBUG
ut_avlIter_t it;
ddsrt_avl_iter_t it;
struct inverse_uint32_set_node *pn = NULL, *n;
assert(set->min <= set->max);
assert(set->cursor >= set->min);
assert(set->cursor <= set->max);
for (n = ut_avlIterFirst(&inverse_uint32_set_td, &set->ids, &it); n; pn = n, n = ut_avlIterNext(&it))
for (n = ddsrt_avl_iter_first(&inverse_uint32_set_td, &set->ids, &it); n; pn = n, n = ddsrt_avl_iter_next(&it))
{
assert(n->min <= n->max);
assert(n->min >= set->min);
@ -51,20 +51,20 @@ static void check(const struct inverse_uint32_set *set)
void inverse_uint32_set_init(struct inverse_uint32_set *set, uint32_t min, uint32_t max)
{
struct inverse_uint32_set_node *n;
ut_avlInit(&inverse_uint32_set_td, &set->ids);
ddsrt_avl_init(&inverse_uint32_set_td, &set->ids);
set->cursor = min;
set->min = min;
set->max = max;
n = ddsrt_malloc(sizeof(*n));
n->min = min;
n->max = max;
ut_avlInsert(&inverse_uint32_set_td, &set->ids, n);
ddsrt_avl_insert(&inverse_uint32_set_td, &set->ids, n);
check(set);
}
void inverse_uint32_set_fini(struct inverse_uint32_set *set)
{
ut_avlFree(&inverse_uint32_set_td, &set->ids, ddsrt_free);
ddsrt_avl_free(&inverse_uint32_set_td, &set->ids, ddsrt_free);
}
static uint32_t inverse_uint32_set_alloc_use_min(struct inverse_uint32_set *set, struct inverse_uint32_set_node *n)
@ -72,7 +72,7 @@ static uint32_t inverse_uint32_set_alloc_use_min(struct inverse_uint32_set *set,
const uint32_t id = n->min;
if (n->min == n->max)
{
ut_avlDelete(&inverse_uint32_set_td, &set->ids, n);
ddsrt_avl_delete(&inverse_uint32_set_td, &set->ids, n);
ddsrt_free(n);
}
else
@ -86,7 +86,7 @@ static uint32_t inverse_uint32_set_alloc_use_min(struct inverse_uint32_set *set,
int inverse_uint32_set_alloc(uint32_t * const id, struct inverse_uint32_set *set)
{
struct inverse_uint32_set_node *n;
if ((n = ut_avlLookupPredEq(&inverse_uint32_set_td, &set->ids, &set->cursor)) != NULL && set->cursor <= n->max) {
if ((n = ddsrt_avl_lookup_pred_eq(&inverse_uint32_set_td, &set->ids, &set->cursor)) != NULL && set->cursor <= n->max) {
/* n is [a,b] s.t. a <= C <= b, so C is available */
*id = set->cursor;
if (n->min == set->cursor)
@ -105,15 +105,15 @@ int inverse_uint32_set_alloc(uint32_t * const id, struct inverse_uint32_set *set
n1->min = set->cursor + 1;
n1->max = n->max;
n->max = set->cursor - 1;
ut_avlInsert(&inverse_uint32_set_td, &set->ids, n1);
ddsrt_avl_insert(&inverse_uint32_set_td, &set->ids, n1);
}
}
else if ((n = ut_avlLookupSucc(&inverse_uint32_set_td, &set->ids, &set->cursor)) != NULL)
else if ((n = ddsrt_avl_lookup_succ(&inverse_uint32_set_td, &set->ids, &set->cursor)) != NULL)
{
/* n is [a,b] s.t. a > C and all intervals [a',b'] in tree have a' <= C */
*id = inverse_uint32_set_alloc_use_min(set, n);
}
else if ((n = ut_avlFindMin(&inverse_uint32_set_td, &set->ids)) != NULL)
else if ((n = ddsrt_avl_find_min(&inverse_uint32_set_td, &set->ids)) != NULL)
{
/* no available ids >= cursor: wrap around and use the first available */
assert(n->max < set->cursor);
@ -133,8 +133,8 @@ void inverse_uint32_set_free(struct inverse_uint32_set *set, uint32_t id)
{
struct inverse_uint32_set_node *n;
const uint32_t idp1 = id + 1;
ut_avlIPath_t ip;
if ((n = ut_avlLookupPredEq(&inverse_uint32_set_td, &set->ids, &id)) != NULL && id <= n->max + 1) {
ddsrt_avl_ipath_t ip;
if ((n = ddsrt_avl_lookup_pred_eq(&inverse_uint32_set_td, &set->ids, &id)) != NULL && id <= n->max + 1) {
if (id <= n->max)
{
/* n is [a,b] s.t. a <= I <= b: so it is already in the set */
@ -143,18 +143,18 @@ void inverse_uint32_set_free(struct inverse_uint32_set *set, uint32_t id)
else
{
struct inverse_uint32_set_node *n1;
ut_avlDPath_t dp;
ddsrt_avl_dpath_t dp;
/* grow the interval, possibly coalesce with next */
if ((n1 = ut_avlLookupDPath(&inverse_uint32_set_td, &set->ids, &idp1, &dp)) == NULL) {
if ((n1 = ddsrt_avl_lookup_dpath(&inverse_uint32_set_td, &set->ids, &idp1, &dp)) == NULL) {
n->max = id;
} else {
n->max = n1->max;
ut_avlDeleteDPath(&inverse_uint32_set_td, &set->ids, n1, &dp);
ddsrt_avl_delete_dpath(&inverse_uint32_set_td, &set->ids, n1, &dp);
ddsrt_free(n1);
}
}
}
else if ((n = ut_avlLookupIPath(&inverse_uint32_set_td, &set->ids, &idp1, &ip)) != NULL) {
else if ((n = ddsrt_avl_lookup_ipath(&inverse_uint32_set_td, &set->ids, &idp1, &ip)) != NULL) {
/* changing the key in-place here: the key value may be changing, but the structure of the tree is not or the previous case would have applied */
n->min = id;
}
@ -163,7 +163,7 @@ void inverse_uint32_set_free(struct inverse_uint32_set *set, uint32_t id)
/* no adjacent interval */
n = ddsrt_malloc(sizeof(*n));
n->min = n->max = id;
ut_avlInsertIPath(&inverse_uint32_set_td, &set->ids, n, &ip);
ddsrt_avl_insert_ipath(&inverse_uint32_set_td, &set->ids, n, &ip);
}
check(set);
}

26
src/core/ddsi/src/q_lease.c
View file

@ -16,7 +16,7 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_fibheap.h"
#include "dds/ddsrt/fibheap.h"
#include "dds/ddsi/ddsi_serdata_default.h"
#include "dds/ddsi/q_protocol.h"
@ -44,7 +44,7 @@
#define TSCHED_NOT_ON_HEAP INT64_MIN
struct lease {
ut_fibheapNode_t heapnode;
ddsrt_fibheap_node_t heapnode;
nn_etime_t tsched; /* access guarded by leaseheap_lock */
nn_etime_t tend; /* access guarded by lock_lease/unlock_lease */
int64_t tdur; /* constant (renew depends on it) */
@ -53,7 +53,7 @@ struct lease {
static int compare_lease_tsched (const void *va, const void *vb);
static const ut_fibheapDef_t lease_fhdef = UT_FIBHEAPDEF_INITIALIZER(offsetof (struct lease, heapnode), compare_lease_tsched);
static const ddsrt_fibheap_def_t lease_fhdef = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct lease, heapnode), compare_lease_tsched);
static void force_lease_check (void)
{
@ -73,13 +73,13 @@ void lease_management_init (void)
ddsrt_mutex_init (&gv.leaseheap_lock);
for (i = 0; i < N_LEASE_LOCKS; i++)
ddsrt_mutex_init (&gv.lease_locks[i]);
ut_fibheapInit (&lease_fhdef, &gv.leaseheap);
ddsrt_fibheap_init (&lease_fhdef, &gv.leaseheap);
}
void lease_management_term (void)
{
int i;
assert (ut_fibheapMin (&lease_fhdef, &gv.leaseheap) == NULL);
assert (ddsrt_fibheap_min (&lease_fhdef, &gv.leaseheap) == NULL);
for (i = 0; i < N_LEASE_LOCKS; i++)
ddsrt_mutex_destroy (&gv.lease_locks[i]);
ddsrt_mutex_destroy (&gv.leaseheap_lock);
@ -125,7 +125,7 @@ void lease_register (struct lease *l)
if (l->tend.v != T_NEVER)
{
l->tsched = l->tend;
ut_fibheapInsert (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_insert (&lease_fhdef, &gv.leaseheap, l);
}
unlock_lease (l);
ddsrt_mutex_unlock (&gv.leaseheap_lock);
@ -139,7 +139,7 @@ void lease_free (struct lease *l)
DDS_TRACE("lease_free(l %p guid %x:%x:%x:%x)\n", (void *) l, PGUID (l->entity->guid));
ddsrt_mutex_lock (&gv.leaseheap_lock);
if (l->tsched.v != TSCHED_NOT_ON_HEAP)
ut_fibheapDelete (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_delete (&lease_fhdef, &gv.leaseheap, l);
ddsrt_mutex_unlock (&gv.leaseheap_lock);
ddsrt_free (l);
@ -187,14 +187,14 @@ void lease_set_expiry (struct lease *l, nn_etime_t when)
/* moved forward and currently scheduled (by virtue of
TSCHED_NOT_ON_HEAP == INT64_MIN) */
l->tsched = l->tend;
ut_fibheapDecreaseKey (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_decrease_key (&lease_fhdef, &gv.leaseheap, l);
trigger = true;
}
else if (l->tsched.v == TSCHED_NOT_ON_HEAP && l->tend.v < T_NEVER)
{
/* not currently scheduled, with a finite new expiry time */
l->tsched = l->tend;
ut_fibheapInsert (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_insert (&lease_fhdef, &gv.leaseheap, l);
trigger = true;
}
unlock_lease (l);
@ -210,13 +210,13 @@ int64_t check_and_handle_lease_expiration (nn_etime_t tnowE)
struct lease *l;
int64_t delay;
ddsrt_mutex_lock (&gv.leaseheap_lock);
while ((l = ut_fibheapMin (&lease_fhdef, &gv.leaseheap)) != NULL && l->tsched.v <= tnowE.v)
while ((l = ddsrt_fibheap_min (&lease_fhdef, &gv.leaseheap)) != NULL && l->tsched.v <= tnowE.v)
{
nn_guid_t g = l->entity->guid;
enum entity_kind k = l->entity->kind;
assert (l->tsched.v != TSCHED_NOT_ON_HEAP);
ut_fibheapExtractMin (&lease_fhdef, &gv.leaseheap);
ddsrt_fibheap_extract_min (&lease_fhdef, &gv.leaseheap);
lock_lease (l);
if (tnowE.v < l->tend.v)
@ -228,7 +228,7 @@ int64_t check_and_handle_lease_expiration (nn_etime_t tnowE)
} else {
l->tsched = l->tend;
unlock_lease (l);
ut_fibheapInsert (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_insert (&lease_fhdef, &gv.leaseheap, l);
}
continue;
}
@ -270,7 +270,7 @@ int64_t check_and_handle_lease_expiration (nn_etime_t tnowE)
PGUID (proxypp->privileged_pp_guid));
l->tsched = l->tend = add_duration_to_etime (tnowE, 200 * T_MILLISECOND);
unlock_lease (l);
ut_fibheapInsert (&lease_fhdef, &gv.leaseheap, l);
ddsrt_fibheap_insert (&lease_fhdef, &gv.leaseheap, l);
continue;
}
}

2
src/core/ddsi/src/q_nwif.c
View file

@ -31,7 +31,7 @@
#include "dds/ddsi/q_addrset.h" /* unspec locator */
#include "dds/ddsi/q_feature_check.h"
#include "dds/ddsi/ddsi_ipaddr.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
static void print_sockerror (const char *msg)
{

2
src/core/ddsi/src/q_plist.c
View file

@ -32,7 +32,7 @@
#include "dds/ddsi/q_radmin.h" /* for nn_plist_quickscan */
#include "dds/ddsi/q_static_assert.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_misc.h" /* for vendor_is_... */
/* These are internal to the parameter list processing. We never

172
src/core/ddsi/src/q_radmin.c
View file

@ -28,7 +28,7 @@
#include "dds/ddsrt/string.h"
#include "dds/ddsrt/log.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_rtps.h"
#include "dds/ddsi/q_misc.h"
@ -812,7 +812,7 @@ static void nn_rdata_unref (struct nn_rdata *rdata)
anyway). */
struct nn_defrag_iv {
ut_avlNode_t avlnode; /* for nn_rsample.defrag::fragtree */
ddsrt_avl_node_t avlnode; /* for nn_rsample.defrag::fragtree */
uint32_t min, maxp1;
struct nn_rdata *first;
struct nn_rdata *last;
@ -821,14 +821,14 @@ struct nn_defrag_iv {
struct nn_rsample {
union {
struct nn_rsample_defrag {
ut_avlNode_t avlnode; /* for nn_defrag::sampletree */
ut_avlTree_t fragtree;
ddsrt_avl_node_t avlnode; /* for nn_defrag::sampletree */
ddsrt_avl_tree_t fragtree;
struct nn_defrag_iv *lastfrag;
struct nn_rsample_info *sampleinfo;
seqno_t seq;
} defrag;
struct nn_rsample_reorder {
ut_avlNode_t avlnode; /* for nn_reorder::sampleivtree, if head of a chain */
ddsrt_avl_node_t avlnode; /* for nn_reorder::sampleivtree, if head of a chain */
struct nn_rsample_chain sc; /* this interval's samples, covering ... */
seqno_t min, maxp1; /* ... seq nos: [min,maxp1), but possibly with holes in it */
uint32_t n_samples; /* so this is the actual length of the chain */
@ -837,7 +837,7 @@ struct nn_rsample {
};
struct nn_defrag {
ut_avlTree_t sampletree;
ddsrt_avl_tree_t sampletree;
struct nn_rsample *max_sample; /* = max(sampletree) */
uint32_t n_samples;
uint32_t max_samples;
@ -847,8 +847,8 @@ struct nn_defrag {
static int compare_uint32 (const void *va, const void *vb);
static int compare_seqno (const void *va, const void *vb);
static const ut_avlTreedef_t defrag_sampletree_treedef = UT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_rsample, u.defrag.avlnode), offsetof (struct nn_rsample, u.defrag.seq), compare_seqno, 0);
static const ut_avlTreedef_t rsample_defrag_fragtree_treedef = UT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_defrag_iv, avlnode), offsetof (struct nn_defrag_iv, min), compare_uint32, 0);
static const ddsrt_avl_treedef_t defrag_sampletree_treedef = DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_rsample, u.defrag.avlnode), offsetof (struct nn_rsample, u.defrag.seq), compare_seqno, 0);
static const ddsrt_avl_treedef_t rsample_defrag_fragtree_treedef = DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_defrag_iv, avlnode), offsetof (struct nn_defrag_iv, min), compare_uint32, 0);
static int compare_uint32 (const void *va, const void *vb)
{
@ -870,7 +870,7 @@ struct nn_defrag *nn_defrag_new (enum nn_defrag_drop_mode drop_mode, uint32_t ma
assert (max_samples >= 1);
if ((d = ddsrt_malloc (sizeof (*d))) == NULL)
return NULL;
ut_avlInit (&defrag_sampletree_treedef, &d->sampletree);
ddsrt_avl_init (&defrag_sampletree_treedef, &d->sampletree);
d->drop_mode = drop_mode;
d->max_samples = max_samples;
d->n_samples = 0;
@ -903,25 +903,25 @@ static void defrag_rsample_drop (struct nn_defrag *defrag, struct nn_rsample *rs
So we need to walk the fragments while guaranteeing strict
"forward progress" in the memory accesses, which this particular
inorder treewalk does provide. */
ut_avlIter_t iter;
ddsrt_avl_iter_t iter;
struct nn_defrag_iv *iv;
DDS_LOG(DDS_LC_RADMIN, " defrag_rsample_drop (%p, %p)\n", (void *) defrag, (void *) rsample);
ut_avlDelete (&defrag_sampletree_treedef, &defrag->sampletree, rsample);
ddsrt_avl_delete (&defrag_sampletree_treedef, &defrag->sampletree, rsample);
assert (defrag->n_samples > 0);
defrag->n_samples--;
for (iv = ut_avlIterFirst (&rsample_defrag_fragtree_treedef, &rsample->u.defrag.fragtree, &iter); iv; iv = ut_avlIterNext (&iter))
for (iv = ddsrt_avl_iter_first (&rsample_defrag_fragtree_treedef, &rsample->u.defrag.fragtree, &iter); iv; iv = ddsrt_avl_iter_next (&iter))
nn_fragchain_rmbias (iv->first);
}
void nn_defrag_free (struct nn_defrag *defrag)
{
struct nn_rsample *s;
s = ut_avlFindMin (&defrag_sampletree_treedef, &defrag->sampletree);
s = ddsrt_avl_find_min (&defrag_sampletree_treedef, &defrag->sampletree);
while (s)
{
DDS_LOG(DDS_LC_RADMIN, "defrag_free(%p, sample %p seq %"PRId64")\n", (void *) defrag, (void *) s, s->u.defrag.seq);
defrag_rsample_drop (defrag, s);
s = ut_avlFindMin (&defrag_sampletree_treedef, &defrag->sampletree);
s = ddsrt_avl_find_min (&defrag_sampletree_treedef, &defrag->sampletree);
}
assert (defrag->n_samples == 0);
ddsrt_free (defrag);
@ -940,7 +940,7 @@ static int defrag_try_merge_with_succ (struct nn_rsample_defrag *sample, struct
return 0;
}
succ = ut_avlFindSucc (&rsample_defrag_fragtree_treedef, &sample->fragtree, node);
succ = ddsrt_avl_find_succ (&rsample_defrag_fragtree_treedef, &sample->fragtree, node);
assert (succ != NULL);
DDS_LOG(DDS_LC_RADMIN, " succ is %p [%u..%u)\n", (void *) succ, succ->min, succ->maxp1);
if (succ->min > node->maxp1)
@ -955,7 +955,7 @@ static int defrag_try_merge_with_succ (struct nn_rsample_defrag *sample, struct
/* no longer a gap between node & succ => succ will be removed
from the interval tree and therefore node will become the
last interval if succ currently is */
ut_avlDelete (&rsample_defrag_fragtree_treedef, &sample->fragtree, succ);
ddsrt_avl_delete (&rsample_defrag_fragtree_treedef, &sample->fragtree, succ);
if (sample->lastfrag == succ)
{
DDS_LOG(DDS_LC_RADMIN, " succ is lastfrag\n");
@ -987,7 +987,7 @@ static int defrag_try_merge_with_succ (struct nn_rsample_defrag *sample, struct
}
}
static void defrag_rsample_addiv (struct nn_rsample_defrag *sample, struct nn_rdata *rdata, ut_avlIPath_t *path)
static void defrag_rsample_addiv (struct nn_rsample_defrag *sample, struct nn_rdata *rdata, ddsrt_avl_ipath_t *path)
{
struct nn_defrag_iv *newiv;
if ((newiv = nn_rmsg_alloc (rdata->rmsg, sizeof (*newiv))) == NULL)
@ -997,7 +997,7 @@ static void defrag_rsample_addiv (struct nn_rsample_defrag *sample, struct nn_rd
newiv->min = rdata->min;
newiv->maxp1 = rdata->maxp1;
nn_rdata_addbias (rdata);
ut_avlInsertIPath (&rsample_defrag_fragtree_treedef, &sample->fragtree, newiv, path);
ddsrt_avl_insert_ipath (&rsample_defrag_fragtree_treedef, &sample->fragtree, newiv, path);
if (sample->lastfrag == NULL || rdata->min > sample->lastfrag->min)
sample->lastfrag = newiv;
}
@ -1010,7 +1010,7 @@ static struct nn_rsample *defrag_rsample_new (struct nn_rdata *rdata, const stru
{
struct nn_rsample *rsample;
struct nn_rsample_defrag *dfsample;
ut_avlIPath_t ivpath;
ddsrt_avl_ipath_t ivpath;
if ((rsample = nn_rmsg_alloc (rdata->rmsg, sizeof (*rsample))) == NULL)
return NULL;
@ -1022,7 +1022,7 @@ static struct nn_rsample *defrag_rsample_new (struct nn_rdata *rdata, const stru
return NULL;
*dfsample->sampleinfo = *sampleinfo;
ut_avlInit (&rsample_defrag_fragtree_treedef, &dfsample->fragtree);
ddsrt_avl_init (&rsample_defrag_fragtree_treedef, &dfsample->fragtree);
/* add sentinel if rdata is not the first fragment of the message */
if (rdata->min > 0)
@ -1032,12 +1032,12 @@ static struct nn_rsample *defrag_rsample_new (struct nn_rdata *rdata, const stru
return NULL;
sentinel->first = sentinel->last = NULL;
sentinel->min = sentinel->maxp1 = 0;
ut_avlLookupIPath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &sentinel->min, &ivpath);
ut_avlInsertIPath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, sentinel, &ivpath);
ddsrt_avl_lookup_ipath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &sentinel->min, &ivpath);
ddsrt_avl_insert_ipath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, sentinel, &ivpath);
}
/* add an interval for the first received fragment */
ut_avlLookupIPath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &rdata->min, &ivpath);
ddsrt_avl_lookup_ipath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &rdata->min, &ivpath);
defrag_rsample_addiv (dfsample, rdata, &ivpath);
return rsample;
}
@ -1084,7 +1084,7 @@ static int is_complete (const struct nn_rsample_defrag *sample)
one interval covering all bytes. One interval because of the
greedy coalescing in add_fragment(). There is at least one
interval if we get here. */
const struct nn_defrag_iv *iv = ut_avlRoot (&rsample_defrag_fragtree_treedef, &sample->fragtree);
const struct nn_defrag_iv *iv = ddsrt_avl_root (&rsample_defrag_fragtree_treedef, &sample->fragtree);
assert (iv != NULL);
if (iv->min == 0 && iv->maxp1 >= sample->sampleinfo->size)
{
@ -1094,7 +1094,7 @@ static int is_complete (const struct nn_rsample_defrag *sample)
samples that will never be completed; dropping them in the
defragmenter would be feasible by discarding all fragments of
that sample collected so far. */
assert (ut_avlIsSingleton (&sample->fragtree));
assert (ddsrt_avl_is_singleton (&sample->fragtree));
return 1;
}
else
@ -1111,14 +1111,14 @@ static void rsample_convert_defrag_to_reorder (struct nn_rsample *sample)
self-respecting compiler will optimise them away, and any
self-respecting CPU would need to copy them via registers anyway
because it uses a load-store architecture. */
struct nn_defrag_iv *iv = ut_avlRootNonEmpty (&rsample_defrag_fragtree_treedef, &sample->u.defrag.fragtree);
struct nn_defrag_iv *iv = ddsrt_avl_root_non_empty (&rsample_defrag_fragtree_treedef, &sample->u.defrag.fragtree);
struct nn_rdata *fragchain = iv->first;
struct nn_rsample_info *sampleinfo = sample->u.defrag.sampleinfo;
struct nn_rsample_chain_elem *sce;
seqno_t seq = sample->u.defrag.seq;
/* re-use memory fragment interval node for sample chain */
sce = (struct nn_rsample_chain_elem *) ut_avlRootNonEmpty (&rsample_defrag_fragtree_treedef, &sample->u.defrag.fragtree);
sce = (struct nn_rsample_chain_elem *) ddsrt_avl_root_non_empty (&rsample_defrag_fragtree_treedef, &sample->u.defrag.fragtree);
sce->fragchain = fragchain;
sce->next = NULL;
sce->sampleinfo = sampleinfo;
@ -1145,7 +1145,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
/* there must be a last fragment */
assert (dfsample->lastfrag);
/* relatively expensive test: lastfrag, tree must be consistent */
assert (dfsample->lastfrag == ut_avlFindMax (&rsample_defrag_fragtree_treedef, &dfsample->fragtree));
assert (dfsample->lastfrag == ddsrt_avl_find_max (&rsample_defrag_fragtree_treedef, &dfsample->fragtree));
DDS_LOG(DDS_LC_RADMIN, " lastfrag %p [%u..%u)\n",
(void *) dfsample->lastfrag,
@ -1162,7 +1162,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
else
{
/* Slow path: find preceding fragment by tree search */
predeq = ut_avlLookupPredEq (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &min);
predeq = ddsrt_avl_lookup_pred_eq (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &min);
assert (predeq);
DDS_LOG(DDS_LC_RADMIN, " slow path: predeq = lookup %u => %p [%u..%u)\n",
min, (void *) predeq, predeq->min, predeq->maxp1);
@ -1206,7 +1206,7 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
return is_complete (dfsample) ? sample : NULL;
}
else if (predeq != dfsample->lastfrag && /* if predeq is last frag, there is no succ */
(succ = ut_avlFindSucc (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, predeq)) != NULL &&
(succ = ddsrt_avl_find_succ (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, predeq)) != NULL &&
succ->min <= maxp1)
{
/* extends succ (at the low end; no guarantee each individual
@ -1236,9 +1236,9 @@ static struct nn_rsample *defrag_add_fragment (struct nn_rsample *sample, struct
{
/* doesn't extend either predeq at the end or succ at the head =>
new interval; rdata did not cause completion of sample */
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
DDS_LOG(DDS_LC_RADMIN, " new interval\n");
if (ut_avlLookupIPath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &min, &path))
if (ddsrt_avl_lookup_ipath (&rsample_defrag_fragtree_treedef, &dfsample->fragtree, &min, &path))
assert (0);
defrag_rsample_addiv (dfsample, rdata, &path);
return NULL;
@ -1274,7 +1274,7 @@ static int defrag_limit_samples (struct nn_defrag *defrag, seqno_t seq, seqno_t
break;
case NN_DEFRAG_DROP_OLDEST:
DDS_LOG(DDS_LC_RADMIN, " drop mode = DROP_OLDEST\n");
sample_to_drop = ut_avlFindMin (&defrag_sampletree_treedef, &defrag->sampletree);
sample_to_drop = ddsrt_avl_find_min (&defrag_sampletree_treedef, &defrag->sampletree);
assert (sample_to_drop);
if (seq < sample_to_drop->u.defrag.seq)
{
@ -1287,7 +1287,7 @@ static int defrag_limit_samples (struct nn_defrag *defrag, seqno_t seq, seqno_t
defrag_rsample_drop (defrag, sample_to_drop);
if (sample_to_drop == defrag->max_sample)
{
defrag->max_sample = ut_avlFindMax (&defrag_sampletree_treedef, &defrag->sampletree);
defrag->max_sample = ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree);
*max_seq = defrag->max_sample ? defrag->max_sample->u.defrag.seq : 0;
DDS_LOG(DDS_LC_RADMIN, " updating max_sample: now %p %"PRId64"\n",
(void *) defrag->max_sample,
@ -1322,7 +1322,7 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
by adding BIAS to the refcount. */
struct nn_rsample *sample, *result;
seqno_t max_seq;
ut_avlIPath_t path;
ddsrt_avl_ipath_t path;
assert (defrag->n_samples <= defrag->max_samples);
@ -1334,7 +1334,7 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
/* max_seq is used for the fast path, and is 0 when there is no
last message in 'defrag'. max_seq and max_sample must be
consistent. Max_sample must be consistent with tree */
assert (defrag->max_sample == ut_avlFindMax (&defrag_sampletree_treedef, &defrag->sampletree));
assert (defrag->max_sample == ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree));
max_seq = defrag->max_sample ? defrag->max_sample->u.defrag.seq : 0;
DDS_LOG(DDS_LC_RADMIN, "defrag_rsample(%p, %p [%u..%u) msg %p, %p seq %"PRId64" size %u) max_seq %p %"PRId64":\n",
(void *) defrag, (void *) rdata, rdata->min, rdata->maxp1, (void *) rdata->rmsg,
@ -1358,22 +1358,22 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
child of the old maximum node */
/* FIXME: MERGE THIS ONE WITH THE NEXT */
DDS_LOG(DDS_LC_RADMIN, " new max sample\n");
ut_avlLookupIPath (&defrag_sampletree_treedef, &defrag->sampletree, &sampleinfo->seq, &path);
ddsrt_avl_lookup_ipath (&defrag_sampletree_treedef, &defrag->sampletree, &sampleinfo->seq, &path);
if ((sample = defrag_rsample_new (rdata, sampleinfo)) == NULL)
return NULL;
ut_avlInsertIPath (&defrag_sampletree_treedef, &defrag->sampletree, sample, &path);
ddsrt_avl_insert_ipath (&defrag_sampletree_treedef, &defrag->sampletree, sample, &path);
defrag->max_sample = sample;
defrag->n_samples++;
result = NULL;
}
else if ((sample = ut_avlLookupIPath (&defrag_sampletree_treedef, &defrag->sampletree, &sampleinfo->seq, &path)) == NULL)
else if ((sample = ddsrt_avl_lookup_ipath (&defrag_sampletree_treedef, &defrag->sampletree, &sampleinfo->seq, &path)) == NULL)
{
/* a new sequence number, but smaller than the maximum */
DDS_LOG(DDS_LC_RADMIN, " new sample less than max\n");
assert (sampleinfo->seq < max_seq);
if ((sample = defrag_rsample_new (rdata, sampleinfo)) == NULL)
return NULL;
ut_avlInsertIPath (&defrag_sampletree_treedef, &defrag->sampletree, sample, &path);
ddsrt_avl_insert_ipath (&defrag_sampletree_treedef, &defrag->sampletree, sample, &path);
defrag->n_samples++;
result = NULL;
}
@ -1390,12 +1390,12 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
reorder format. If it is the sample with the maximum sequence in
the tree, an update of max_sample is required. */
DDS_LOG(DDS_LC_RADMIN, " complete\n");
ut_avlDelete (&defrag_sampletree_treedef, &defrag->sampletree, result);
ddsrt_avl_delete (&defrag_sampletree_treedef, &defrag->sampletree, result);
assert (defrag->n_samples > 0);
defrag->n_samples--;
if (result == defrag->max_sample)
{
defrag->max_sample = ut_avlFindMax (&defrag_sampletree_treedef, &defrag->sampletree);
defrag->max_sample = ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree);
DDS_LOG(DDS_LC_RADMIN, " updating max_sample: now %p %"PRId64"\n",
(void *) defrag->max_sample,
defrag->max_sample ? defrag->max_sample->u.defrag.seq : 0);
@ -1403,7 +1403,7 @@ struct nn_rsample *nn_defrag_rsample (struct nn_defrag *defrag, struct nn_rdata
rsample_convert_defrag_to_reorder (result);
}
assert (defrag->max_sample == ut_avlFindMax (&defrag_sampletree_treedef, &defrag->sampletree));
assert (defrag->max_sample == ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree));
return result;
}
@ -1412,14 +1412,14 @@ void nn_defrag_notegap (struct nn_defrag *defrag, seqno_t min, seqno_t maxp1)
/* All sequence numbers in [min,maxp1) are unavailable so any
fragments in that range must be discarded. Used both for
Hearbeats (by setting min=1) and for Gaps. */
struct nn_rsample *s = ut_avlLookupSuccEq (&defrag_sampletree_treedef, &defrag->sampletree, &min);
struct nn_rsample *s = ddsrt_avl_lookup_succ_eq (&defrag_sampletree_treedef, &defrag->sampletree, &min);
while (s && s->u.defrag.seq < maxp1)
{
struct nn_rsample *s1 = ut_avlFindSucc (&defrag_sampletree_treedef, &defrag->sampletree, s);
struct nn_rsample *s1 = ddsrt_avl_find_succ (&defrag_sampletree_treedef, &defrag->sampletree, s);
defrag_rsample_drop (defrag, s);
s = s1;
}
defrag->max_sample = ut_avlFindMax (&defrag_sampletree_treedef, &defrag->sampletree);
defrag->max_sample = ddsrt_avl_find_max (&defrag_sampletree_treedef, &defrag->sampletree);
}
int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnum, struct nn_fragment_number_set *map, uint32_t maxsz)
@ -1428,7 +1428,7 @@ int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnu
struct nn_defrag_iv *iv;
uint32_t i, fragsz, nfrags;
assert (maxsz <= 256);
s = ut_avlLookup (&defrag_sampletree_treedef, &defrag->sampletree, &seq);
s = ddsrt_avl_lookup (&defrag_sampletree_treedef, &defrag->sampletree, &seq);
if (s == NULL)
{
if (maxfragnum == UINT32_MAX)
@ -1465,7 +1465,7 @@ int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnu
are missing the first fragment. */
struct nn_defrag_iv *liv = s->u.defrag.lastfrag;
nn_fragment_number_t map_end;
iv = ut_avlFindMin (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree);
iv = ddsrt_avl_find_min (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree);
assert (iv != NULL);
/* iv is first interval, iv->maxp1 is first byte beyond that =>
divide by fragsz to get first missing fragment */
@ -1485,7 +1485,7 @@ int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnu
map->bitmap_base, but there is nothing to request in that
case. */
map->numbits = (map_end < map->bitmap_base) ? 0 : map_end - map->bitmap_base + 1;
iv = ut_avlFindSucc (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree, iv);
iv = ddsrt_avl_find_succ (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree, iv);
}
/* Clear bitmap, then set bits for gaps in available fragments */
@ -1515,7 +1515,7 @@ int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnu
at fragment containing maxp1 (because we don't have that byte
yet), and runs until the next interval begins */
i = iv->maxp1 / fragsz;
iv = ut_avlFindSucc (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree, iv);
iv = ddsrt_avl_find_succ (&rsample_defrag_fragtree_treedef, &s->u.defrag.fragtree, iv);
}
/* and set bits for missing fragments beyond the highest interval */
for (; i < map->bitmap_base + map->numbits; i++)
@ -1603,7 +1603,7 @@ int nn_defrag_nackmap (struct nn_defrag *defrag, seqno_t seq, uint32_t maxfragnu
in the overview comment at the top of this file. */
struct nn_reorder {
ut_avlTree_t sampleivtree;
ddsrt_avl_tree_t sampleivtree;
struct nn_rsample *max_sampleiv; /* = max(sampleivtree) */
seqno_t next_seq;
enum nn_reorder_mode mode;
@ -1611,15 +1611,15 @@ struct nn_reorder {
uint32_t n_samples;
};
static const ut_avlTreedef_t reorder_sampleivtree_treedef =
UT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_rsample, u.reorder.avlnode), offsetof (struct nn_rsample, u.reorder.min), compare_seqno, 0);
static const ddsrt_avl_treedef_t reorder_sampleivtree_treedef =
DDSRT_AVL_TREEDEF_INITIALIZER (offsetof (struct nn_rsample, u.reorder.avlnode), offsetof (struct nn_rsample, u.reorder.min), compare_seqno, 0);
struct nn_reorder *nn_reorder_new (enum nn_reorder_mode mode, uint32_t max_samples)
{
struct nn_reorder *r;
if ((r = ddsrt_malloc (sizeof (*r))) == NULL)
return NULL;
ut_avlInit (&reorder_sampleivtree_treedef, &r->sampleivtree);
ddsrt_avl_init (&reorder_sampleivtree_treedef, &r->sampleivtree);
r->max_sampleiv = NULL;
r->next_seq = 1;
r->mode = mode;
@ -1644,10 +1644,10 @@ void nn_reorder_free (struct nn_reorder *r)
struct nn_rsample *iv;
struct nn_rsample_chain_elem *sce;
/* FXIME: instead of findmin/delete, a treewalk can be used. */
iv = ut_avlFindMin (&reorder_sampleivtree_treedef, &r->sampleivtree);
iv = ddsrt_avl_find_min (&reorder_sampleivtree_treedef, &r->sampleivtree);
while (iv)
{
ut_avlDelete (&reorder_sampleivtree_treedef, &r->sampleivtree, iv);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &r->sampleivtree, iv);
sce = iv->u.reorder.sc.first;
while (sce)
{
@ -1655,17 +1655,17 @@ void nn_reorder_free (struct nn_reorder *r)
nn_fragchain_unref (sce->fragchain);
sce = sce1;
}
iv = ut_avlFindMin (&reorder_sampleivtree_treedef, &r->sampleivtree);
iv = ddsrt_avl_find_min (&reorder_sampleivtree_treedef, &r->sampleivtree);
}
ddsrt_free (r);
}
static void reorder_add_rsampleiv (struct nn_reorder *reorder, struct nn_rsample *rsample)
{
ut_avlIPath_t path;
if (ut_avlLookupIPath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &rsample->u.reorder.min, &path) != NULL)
ddsrt_avl_ipath_t path;
if (ddsrt_avl_lookup_ipath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &rsample->u.reorder.min, &path) != NULL)
assert (0);
ut_avlInsertIPath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, rsample, &path);
ddsrt_avl_insert_ipath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, rsample, &path);
}
#ifndef NDEBUG
@ -1713,7 +1713,7 @@ static int reorder_try_append_and_discard (struct nn_reorder *reorder, struct nn
appendto->u.reorder.min, appendto->u.reorder.maxp1, (void *) appendto,
todiscard->u.reorder.min, todiscard->u.reorder.maxp1, (void *) todiscard);
assert (todiscard->u.reorder.min == appendto->u.reorder.maxp1);
ut_avlDelete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, todiscard);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, todiscard);
append_rsample_interval (appendto, todiscard);
DDS_LOG(DDS_LC_RADMIN, " try_append_and_discard: max_sampleiv needs update? %s\n",
(todiscard == reorder->max_sampleiv) ? "yes" : "no");
@ -1793,8 +1793,8 @@ static void delete_last_sample (struct nn_reorder *reorder)
recalc max_sampleiv. */
DDS_LOG(DDS_LC_RADMIN, " delete_last_sample: in singleton interval\n");
fragchain = last->sc.first->fragchain;
ut_avlDelete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, reorder->max_sampleiv);
reorder->max_sampleiv = ut_avlFindMax (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, reorder->max_sampleiv);
reorder->max_sampleiv = ddsrt_avl_find_max (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
/* No harm done if it the sampleivtree is empty, except that we
chose not to allow it */
assert (reorder->max_sampleiv != NULL);
@ -1847,7 +1847,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
seq; max must be set iff the reorder is non-empty. */
#ifndef NDEBUG
{
struct nn_rsample *min = ut_avlFindMin (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
struct nn_rsample *min = ddsrt_avl_find_min (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
if (min)
DDS_LOG(DDS_LC_RADMIN, " min = %"PRId64" @ %p\n", min->u.reorder.min, (void *) min);
assert (min == NULL || reorder->next_seq < min->u.reorder.min);
@ -1855,8 +1855,8 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
(reorder->max_sampleiv != NULL && min != NULL));
}
#endif
assert ((!!ut_avlIsEmpty (&reorder->sampleivtree)) == (reorder->max_sampleiv == NULL));
assert (reorder->max_sampleiv == NULL || reorder->max_sampleiv == ut_avlFindMax (&reorder_sampleivtree_treedef, &reorder->sampleivtree));
assert ((!!ddsrt_avl_is_empty (&reorder->sampleivtree)) == (reorder->max_sampleiv == NULL));
assert (reorder->max_sampleiv == NULL || reorder->max_sampleiv == ddsrt_avl_find_max (&reorder_sampleivtree_treedef, &reorder->sampleivtree));
assert (reorder->n_samples <= reorder->max_samples);
if (reorder->max_sampleiv)
DDS_LOG(DDS_LC_RADMIN, " max = [%"PRId64",%"PRId64") @ %p\n", reorder->max_sampleiv->u.reorder.min, reorder->max_sampleiv->u.reorder.maxp1, (void *) reorder->max_sampleiv);
@ -1883,7 +1883,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
out-of-order either ends up here or in discard.) */
if (reorder->max_sampleiv != NULL)
{
struct nn_rsample *min = ut_avlFindMin (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
struct nn_rsample *min = ddsrt_avl_find_min (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
DDS_LOG(DDS_LC_RADMIN, " try append_and_discard\n");
if (reorder_try_append_and_discard (reorder, rsampleiv, min))
reorder->max_sampleiv = NULL;
@ -1908,7 +1908,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
DDS_LOG(DDS_LC_RADMIN, " discard: too old\n");
return NN_REORDER_TOO_OLD; /* don't want refcount increment */
}
else if (ut_avlIsEmpty (&reorder->sampleivtree))
else if (ddsrt_avl_is_empty (&reorder->sampleivtree))
{
/* else, if nothing's stored simply add this one, max_samples = 0
is technically allowed, and potentially useful, so check for
@ -1989,7 +1989,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
return NN_REORDER_REJECT;
}
predeq = ut_avlLookupPredEq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &s->min);
predeq = ddsrt_avl_lookup_pred_eq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &s->min);
if (predeq)
DDS_LOG(DDS_LC_RADMIN, " predeq = [%"PRId64",%"PRId64") @ %p\n",
predeq->u.reorder.min, predeq->u.reorder.maxp1, (void *) predeq);
@ -2002,7 +2002,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
return NN_REORDER_REJECT;
}
immsucc = ut_avlLookup (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &s->maxp1);
immsucc = ddsrt_avl_lookup (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &s->maxp1);
if (immsucc)
DDS_LOG(DDS_LC_RADMIN, " immsucc = [%"PRId64",%"PRId64") @ %p\n",
immsucc->u.reorder.min, immsucc->u.reorder.maxp1, (void *) immsucc);
@ -2040,7 +2040,7 @@ nn_reorder_result_t nn_reorder_rsample (struct nn_rsample_chain *sc, struct nn_r
Therefore, we can swap rsampleiv in for immsucc and avoid the
case above. */
rsampleiv->u.reorder = immsucc->u.reorder;
ut_avlSwapNode (&reorder_sampleivtree_treedef, &reorder->sampleivtree, immsucc, rsampleiv);
ddsrt_avl_swap_node (&reorder_sampleivtree_treedef, &reorder->sampleivtree, immsucc, rsampleiv);
if (immsucc == reorder->max_sampleiv)
reorder->max_sampleiv = rsampleiv;
}
@ -2072,12 +2072,12 @@ static struct nn_rsample *coalesce_intervals_touching_range (struct nn_reorder *
struct nn_rsample *s, *t;
*valuable = 0;
/* Find first (lowest m) interval [m,n) s.t. n >= min && m <= maxp1 */
s = ut_avlLookupPredEq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &min);
s = ddsrt_avl_lookup_pred_eq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &min);
if (s && s->u.reorder.maxp1 >= min)
{
/* m <= min && n >= min (note: pred of s [m',n') necessarily has n' < m) */
#ifndef NDEBUG
struct nn_rsample *q = ut_avlFindPred (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s);
struct nn_rsample *q = ddsrt_avl_find_pred (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s);
assert (q == NULL || q->u.reorder.maxp1 < min);
#endif
}
@ -2086,15 +2086,15 @@ static struct nn_rsample *coalesce_intervals_touching_range (struct nn_reorder *
/* No good, but the first (if s = NULL) or the next one (if s !=
NULL) may still have m <= maxp1 (m > min is implied now). If
not, no such interval. */
s = ut_avlFindSucc (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s);
s = ddsrt_avl_find_succ (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s);
if (!(s && s->u.reorder.min <= maxp1))
return NULL;
}
/* Append successors [m',n') s.t. m' <= maxp1 to s */
assert (s->u.reorder.min + s->u.reorder.n_samples <= s->u.reorder.maxp1);
while ((t = ut_avlFindSucc (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s)) != NULL && t->u.reorder.min <= maxp1)
while ((t = ddsrt_avl_find_succ (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s)) != NULL && t->u.reorder.min <= maxp1)
{
ut_avlDelete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, t);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, t);
assert (t->u.reorder.min + t->u.reorder.n_samples <= t->u.reorder.maxp1);
append_rsample_interval (s, t);
*valuable = 1;
@ -2126,8 +2126,8 @@ static int reorder_insert_gap (struct nn_reorder *reorder, struct nn_rdata *rdat
{
struct nn_rsample_chain_elem *sce;
struct nn_rsample *s;
ut_avlIPath_t path;
if (ut_avlLookupIPath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &min, &path) != NULL)
ddsrt_avl_ipath_t path;
if (ddsrt_avl_lookup_ipath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &min, &path) != NULL)
assert (0);
if ((sce = nn_rmsg_alloc (rdata->rmsg, sizeof (*sce))) == NULL)
return 0;
@ -2140,7 +2140,7 @@ static int reorder_insert_gap (struct nn_reorder *reorder, struct nn_rdata *rdat
s->u.reorder.min = min;
s->u.reorder.maxp1 = maxp1;
s->u.reorder.n_samples = 1;
ut_avlInsertIPath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s, &path);
ddsrt_avl_insert_ipath (&reorder_sampleivtree_treedef, &reorder->sampleivtree, s, &path);
return 1;
}
@ -2225,7 +2225,7 @@ nn_reorder_result_t nn_reorder_gap (struct nn_rsample_chain *sc, struct nn_reord
delete_last_sample (reorder);
(*refcount_adjust)++;
}
reorder->max_sampleiv = ut_avlFindMax (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
reorder->max_sampleiv = ddsrt_avl_find_max (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
return res;
}
else if (coalesced->u.reorder.min <= reorder->next_seq)
@ -2233,11 +2233,11 @@ nn_reorder_result_t nn_reorder_gap (struct nn_rsample_chain *sc, struct nn_reord
DDS_LOG(DDS_LC_RADMIN, " coalesced = [%"PRId64",%"PRId64") @ %p containing %d samples\n",
coalesced->u.reorder.min, coalesced->u.reorder.maxp1,
(void *) coalesced, coalesced->u.reorder.n_samples);
ut_avlDelete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, coalesced);
ddsrt_avl_delete (&reorder_sampleivtree_treedef, &reorder->sampleivtree, coalesced);
if (coalesced->u.reorder.min <= reorder->next_seq)
assert (min <= reorder->next_seq);
reorder->next_seq = coalesced->u.reorder.maxp1;
reorder->max_sampleiv = ut_avlFindMax (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
reorder->max_sampleiv = ddsrt_avl_find_max (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
DDS_LOG(DDS_LC_RADMIN, " next expected: %"PRId64"\n", reorder->next_seq);
*sc = coalesced->u.reorder.sc;
@ -2251,7 +2251,7 @@ nn_reorder_result_t nn_reorder_gap (struct nn_rsample_chain *sc, struct nn_reord
{
DDS_LOG(DDS_LC_RADMIN, " coalesced = [%"PRId64",%"PRId64") @ %p - that is all\n",
coalesced->u.reorder.min, coalesced->u.reorder.maxp1, (void *) coalesced);
reorder->max_sampleiv = ut_avlFindMax (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
reorder->max_sampleiv = ddsrt_avl_find_max (&reorder_sampleivtree_treedef, &reorder->sampleivtree);
return valuable ? NN_REORDER_ACCEPT : NN_REORDER_REJECT;
}
}
@ -2264,7 +2264,7 @@ int nn_reorder_wantsample (struct nn_reorder *reorder, seqno_t seq)
return 0;
/* Find interval that contains seq, if we know seq. We are
interested if seq is outside this interval (if any). */
s = ut_avlLookupPredEq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &seq);
s = ddsrt_avl_lookup_pred_eq (&reorder_sampleivtree_treedef, &reorder->sampleivtree, &seq);
return (s == NULL || s->u.reorder.maxp1 <= seq);
}
@ -2307,7 +2307,7 @@ unsigned nn_reorder_nackmap (struct nn_reorder *reorder, seqno_t base, seqno_t m
map->numbits = (uint32_t) (maxseq + 1 - base);
nn_bitset_zero (map->numbits, map->bits);
if ((iv = ut_avlFindMin (&reorder_sampleivtree_treedef, &reorder->sampleivtree)) != NULL)
if ((iv = ddsrt_avl_find_min (&reorder_sampleivtree_treedef, &reorder->sampleivtree)) != NULL)
assert (iv->u.reorder.min > base);
i = base;
while (iv && i < base + map->numbits)
@ -2318,7 +2318,7 @@ unsigned nn_reorder_nackmap (struct nn_reorder *reorder, seqno_t base, seqno_t m
nn_bitset_set (map->numbits, map->bits, x);
}
i = iv->u.reorder.maxp1;
iv = ut_avlFindSucc (&reorder_sampleivtree_treedef, &reorder->sampleivtree, iv);
iv = ddsrt_avl_find_succ (&reorder_sampleivtree_treedef, &reorder->sampleivtree, iv);
}
if (notail && i < base + map->numbits)
map->numbits = (unsigned) (i - base);

56
src/core/ddsi/src/q_receive.c
View file

@ -20,7 +20,7 @@
#include "dds/ddsrt/sync.h"
#include "dds/ddsrt/string.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds__stream.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_rtps.h"
@ -767,7 +767,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
}
ddsrt_mutex_lock (&wr->e.lock);
if ((rn = ut_avlLookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
if ((rn = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a connection)", PGUID (src), PGUID (dst));
goto out;
@ -823,7 +823,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
that rn->seq <= wr->seq) */
rn->seq = wr->seq;
}
ut_avlAugmentUpdate (&wr_readers_treedef, rn);
ddsrt_avl_augment_update (&wr_readers_treedef, rn);
n = remove_acked_messages (wr, &whcst, &deferred_free_list);
DDS_TRACE(" ACK%"PRId64" RM%u", n_ack, n);
}
@ -850,7 +850,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
that rn->seq <= wr->seq) */
rn->seq = wr->seq;
}
ut_avlAugmentUpdate (&wr_readers_treedef, rn);
ddsrt_avl_augment_update (&wr_readers_treedef, rn);
DDS_LOG(DDS_LC_THROTTLE, "writer %x:%x:%x:%x considering reader %x:%x:%x:%x responsive again\n", PGUID (wr->e.guid), PGUID (rn->prd_guid));
}
@ -867,7 +867,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
rn->has_replied_to_hb = 1;
/* walk the whole tree to ensure all proxy readers for this writer
have their unack'ed info updated */
ut_avlAugmentUpdate (&wr_readers_treedef, rn);
ddsrt_avl_augment_update (&wr_readers_treedef, rn);
}
if (is_preemptive_ack)
{
@ -1075,7 +1075,7 @@ static int handle_AckNack (struct receiver_state *rst, nn_etime_t tnow, const Ac
return 1;
}
static void handle_forall_destinations (const nn_guid_t *dst, struct proxy_writer *pwr, ut_avlWalk_t fun, void *arg)
static void handle_forall_destinations (const nn_guid_t *dst, struct proxy_writer *pwr, ddsrt_avl_walk_t fun, void *arg)
{
/* prefix: id: to:
0 0 all matched readers
@ -1093,12 +1093,12 @@ static void handle_forall_destinations (const nn_guid_t *dst, struct proxy_write
switch ((haveprefix << 1) | haveid)
{
case (0 << 1) | 0: /* all: full treewalk */
ut_avlWalk (&pwr_readers_treedef, &pwr->readers, fun, arg);
ddsrt_avl_walk (&pwr_readers_treedef, &pwr->readers, fun, arg);
break;
case (0 << 1) | 1: /* all with correct entityid: special filtering treewalk */
{
struct pwr_rd_match *wn;
for (wn = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers); wn; wn = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, wn))
for (wn = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers); wn; wn = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, wn))
{
if (wn->rd_guid.entityid.u == dst->entityid.u)
fun (wn, arg);
@ -1110,13 +1110,13 @@ static void handle_forall_destinations (const nn_guid_t *dst, struct proxy_write
nn_guid_t a, b;
a = *dst; a.entityid.u = 0;
b = *dst; b.entityid.u = ~0u;
ut_avlWalkRange (&pwr_readers_treedef, &pwr->readers, &a, &b, fun, arg);
ddsrt_avl_walk_range (&pwr_readers_treedef, &pwr->readers, &a, &b, fun, arg);
}
break;
case (1 << 1) | 1: /* fully addressed: dst should exist (but for removal) */
{
struct pwr_rd_match *wn;
if ((wn = ut_avlLookup (&pwr_readers_treedef, &pwr->readers, dst)) != NULL)
if ((wn = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, dst)) != NULL)
fun (wn, arg);
}
break;
@ -1289,7 +1289,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
else
nn_dqueue_enqueue (pwr->dqueue, &sc, res);
}
for (wn = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers); wn; wn = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, wn))
for (wn = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers); wn; wn = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, wn))
if (wn->in_sync != PRMSS_SYNC)
{
seqno_t last_deliv_seq = 0;
@ -1324,7 +1324,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
arg.timestamp = timestamp;
arg.tnow = tnow;
arg.tnow_mt = now_mt ();
handle_forall_destinations (&dst, pwr, (ut_avlWalk_t) handle_Heartbeat_helper, &arg);
handle_forall_destinations (&dst, pwr, (ddsrt_avl_walk_t) handle_Heartbeat_helper, &arg);
DDS_TRACE(")");
ddsrt_mutex_unlock (&pwr->e.lock);
@ -1380,7 +1380,7 @@ static int handle_HeartbeatFrag (struct receiver_state *rst, UNUSED_ARG(nn_etime
discover a missing fragment, which differs significantly from
handle_Heartbeat's scheduling of an AckNack event when it must
respond. Why? Just because. */
if (ut_avlIsEmpty (&pwr->readers) || pwr->local_matching_inprogress)
if (ddsrt_avl_is_empty (&pwr->readers) || pwr->local_matching_inprogress)
DDS_TRACE(" no readers");
else
{
@ -1392,19 +1392,19 @@ static int handle_HeartbeatFrag (struct receiver_state *rst, UNUSED_ARG(nn_etime
assuming a reliable writer -> unreliable reader is rare, and
so scanning the readers is acceptable if the first guess
fails */
m = ut_avlRootNonEmpty (&pwr_readers_treedef, &pwr->readers);
m = ddsrt_avl_root_non_empty (&pwr_readers_treedef, &pwr->readers);
if (m->acknack_xevent == NULL)
{
m = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers);
m = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers);
while (m && m->acknack_xevent == NULL)
m = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, m);
m = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, m);
}
}
else if (seq < nn_reorder_next_seq (pwr->reorder))
{
/* Check out-of-sync readers -- should add a bit to cheaply test
whether there are any (usually there aren't) */
m = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers);
m = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers);
while (m)
{
if ((m->in_sync == PRMSS_OUT_OF_SYNC) && m->acknack_xevent != NULL && nn_reorder_wantsample (m->u.not_in_sync.reorder, seq))
@ -1414,7 +1414,7 @@ static int handle_HeartbeatFrag (struct receiver_state *rst, UNUSED_ARG(nn_etime
reader to decide which fragments to nack */
break;
}
m = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, m);
m = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, m);
}
}
@ -1495,7 +1495,7 @@ static int handle_NackFrag (struct receiver_state *rst, nn_etime_t tnow, const N
}
ddsrt_mutex_lock (&wr->e.lock);
if ((rn = ut_avlLookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
if ((rn = ddsrt_avl_lookup (&wr_readers_treedef, &wr->readers, &src)) == NULL)
{
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x not a connection", PGUID (src), PGUID (dst));
goto out;
@ -1737,7 +1737,7 @@ static int handle_Gap (struct receiver_state *rst, nn_etime_t tnow, struct nn_rm
lease_renew (ddsrt_atomic_ldvoidp (&pwr->c.proxypp->lease), tnow);
ddsrt_mutex_lock (&pwr->e.lock);
if ((wn = ut_avlLookup (&pwr_readers_treedef, &pwr->readers, &dst)) == NULL)
if ((wn = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, &dst)) == NULL)
{
DDS_TRACE("%x:%x:%x:%x -> %x:%x:%x:%x not a connection)", PGUID (src), PGUID (dst));
ddsrt_mutex_unlock (&pwr->e.lock);
@ -2069,11 +2069,11 @@ retry:
we fall back to using the GUIDs so that we can deliver all
samples we received from it. As writer being deleted any
reliable samples that are rejected are simply discarded. */
ut_avlIter_t it;
ddsrt_avl_iter_t it;
struct pwr_rd_match *m;
ddsrt_mutex_unlock (&pwr->rdary.rdary_lock);
if (!pwr_locked) ddsrt_mutex_lock (&pwr->e.lock);
for (m = ut_avlIterFirst (&pwr_readers_treedef, &pwr->readers, &it); m != NULL; m = ut_avlIterNext (&it))
for (m = ddsrt_avl_iter_first (&pwr_readers_treedef, &pwr->readers, &it); m != NULL; m = ddsrt_avl_iter_next (&it))
{
struct reader *rd;
if ((rd = ephash_lookup_reader_guid (&m->rd_guid)) != NULL)
@ -2138,7 +2138,7 @@ static void clean_defrag (struct proxy_writer *pwr)
if (pwr->n_readers_out_of_sync > 0)
{
struct pwr_rd_match *wn;
for (wn = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers); wn != NULL; wn = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, wn))
for (wn = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers); wn != NULL; wn = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, wn))
{
if (wn->in_sync == PRMSS_OUT_OF_SYNC)
{
@ -2199,7 +2199,7 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
return;
}
if (ut_avlIsEmpty (&pwr->readers) || pwr->local_matching_inprogress)
if (ddsrt_avl_is_empty (&pwr->readers) || pwr->local_matching_inprogress)
{
ddsrt_mutex_unlock (&pwr->e.lock);
DDS_TRACE(" %x:%x:%x:%x -> %x:%x:%x:%x: no readers", PGUID (pwr->e.guid), PGUID (dst));
@ -2274,9 +2274,9 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
writer may have become in sync with the proxy writer and the
writer; those catching up with TL all by themselves go through
the "TOO_OLD" path below. */
ut_avlIter_t it;
ddsrt_avl_iter_t it;
struct pwr_rd_match *wn;
for (wn = ut_avlIterFirst (&pwr_readers_treedef, &pwr->readers, &it); wn != NULL; wn = ut_avlIterNext (&it))
for (wn = ddsrt_avl_iter_first (&pwr_readers_treedef, &pwr->readers, &it); wn != NULL; wn = ddsrt_avl_iter_next (&it))
if (wn->in_sync == PRMSS_TLCATCHUP)
maybe_set_reader_in_sync (pwr, wn, sampleinfo->seq);
}
@ -2286,7 +2286,7 @@ static void handle_regular (struct receiver_state *rst, nn_etime_t tnow, struct
struct pwr_rd_match *wn;
struct nn_rsample *rsample_dup = NULL;
int reuse_rsample_dup = 0;
for (wn = ut_avlFindMin (&pwr_readers_treedef, &pwr->readers); wn != NULL; wn = ut_avlFindSucc (&pwr_readers_treedef, &pwr->readers, wn))
for (wn = ddsrt_avl_find_min (&pwr_readers_treedef, &pwr->readers); wn != NULL; wn = ddsrt_avl_find_succ (&pwr_readers_treedef, &pwr->readers, wn))
{
nn_reorder_result_t rres2;
if (wn->in_sync != PRMSS_OUT_OF_SYNC || sampleinfo->seq > wn->u.not_in_sync.end_of_out_of_sync_seq)
@ -2380,7 +2380,7 @@ static void drop_oversize (struct receiver_state *rst, struct nn_rmsg *rmsg, con
dst.entityid = msg->readerId;
ddsrt_mutex_lock (&pwr->e.lock);
wn = ut_avlLookup (&pwr_readers_treedef, &pwr->readers, &dst);
wn = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, &dst);
gap_was_valuable = handle_one_gap (pwr, wn, sampleinfo->seq, sampleinfo->seq+1, gap, &refc_adjust);
nn_fragchain_adjust_refcount (gap, refc_adjust);
ddsrt_mutex_unlock (&pwr->e.lock);

16
src/core/ddsi/src/q_transmit.c
View file

@ -15,7 +15,7 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_avl.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsi/q_entity.h"
#include "dds/ddsi/q_addrset.h"
#include "dds/ddsi/q_xmsg.h"
@ -51,12 +51,12 @@
static const struct wr_prd_match *root_rdmatch (const struct writer *wr)
{
return ut_avlRoot (&wr_readers_treedef, &wr->readers);
return ddsrt_avl_root (&wr_readers_treedef, &wr->readers);
}
static int have_reliable_subs (const struct writer *wr)
{
if (ut_avlIsEmpty (&wr->readers) || root_rdmatch (wr)->min_seq == MAX_SEQ_NUMBER)
if (ddsrt_avl_is_empty (&wr->readers) || root_rdmatch (wr)->min_seq == MAX_SEQ_NUMBER)
return 0;
else
return 1;
@ -152,7 +152,7 @@ struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const stru
/* out of memory at worst slows down traffic */
return NULL;
if (ut_avlIsEmpty (&wr->readers) || wr->num_reliable_readers == 0)
if (ddsrt_avl_is_empty (&wr->readers) || wr->num_reliable_readers == 0)
{
/* Not really supposed to come here, at least not for the first
case. Secondly, there really seems to be little use for
@ -192,9 +192,9 @@ struct nn_xmsg *writer_hbcontrol_create_heartbeat (struct writer *wr, const stru
DDS_TRACE("unicasting to prd %x:%x:%x:%x ", PGUID (*prd_guid));
DDS_TRACE("(rel-prd %d seq-eq-max %d seq %"PRId64" maxseq %"PRId64")\n",
wr->num_reliable_readers,
ut_avlIsEmpty (&wr->readers) ? -1 : root_rdmatch (wr)->num_reliable_readers_where_seq_equals_max,
ddsrt_avl_is_empty (&wr->readers) ? -1 : root_rdmatch (wr)->num_reliable_readers_where_seq_equals_max,
wr->seq,
ut_avlIsEmpty (&wr->readers) ? (seqno_t) -1 : root_rdmatch (wr)->max_seq);
ddsrt_avl_is_empty (&wr->readers) ? (seqno_t) -1 : root_rdmatch (wr)->max_seq);
if (prd_guid == NULL)
{
@ -312,8 +312,8 @@ struct nn_xmsg *writer_hbcontrol_piggyback (struct writer *wr, const struct whc_
PGUID (wr->e.guid),
*hbansreq ? "" : " final",
(hbc->tsched.v == T_NEVER) ? POS_INFINITY_DOUBLE : (double) (hbc->tsched.v - tnow.v) / 1e9,
ut_avlIsEmpty (&wr->readers) ? -1 : root_rdmatch (wr)->min_seq,
ut_avlIsEmpty (&wr->readers) || root_rdmatch (wr)->all_have_replied_to_hb ? "" : "!",
ddsrt_avl_is_empty (&wr->readers) ? -1 : root_rdmatch (wr)->min_seq,
ddsrt_avl_is_empty (&wr->readers) || root_rdmatch (wr)->all_have_replied_to_hb ? "" : "!",
whcst->max_seq, READ_SEQ_XMIT(wr));
}

52
src/core/ddsi/src/q_xevent.c
View file

@ -16,8 +16,8 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/sync.h"
#include "dds/util/ut_avl.h"
#include "dds/util/ut_fibheap.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsrt/fibheap.h"
#include "dds/ddsi/q_time.h"
#include "dds/ddsi/q_log.h"
@ -70,7 +70,7 @@ enum xeventkind
struct xevent
{
ut_fibheapNode_t heapnode;
ddsrt_fibheap_node_t heapnode;
struct xeventq *evq;
nn_mtime_t tsched;
enum xeventkind kind;
@ -133,7 +133,7 @@ struct xevent_nt
/* xmsg is self-contained / relies on reference counts */
struct nn_xmsg *msg;
size_t queued_rexmit_bytes;
ut_avlNode_t msg_avlnode;
ddsrt_avl_node_t msg_avlnode;
} msg_rexmit;
struct {
/* xmsg is self-contained / relies on reference counts */
@ -143,8 +143,8 @@ struct xevent_nt
};
struct xeventq {
ut_fibheap_t xevents;
ut_avlTree_t msg_xevents;
ddsrt_fibheap_t xevents;
ddsrt_avl_tree_t msg_xevents;
struct xevent_nt *non_timed_xmit_list_oldest;
struct xevent_nt *non_timed_xmit_list_newest; /* undefined if ..._oldest == NULL */
size_t queued_rexmit_bytes;
@ -164,9 +164,9 @@ static nn_mtime_t earliest_in_xeventq (struct xeventq *evq);
static int msg_xevents_cmp (const void *a, const void *b);
static int compare_xevent_tsched (const void *va, const void *vb);
static const ut_avlTreedef_t msg_xevents_treedef = UT_AVL_TREEDEF_INITIALIZER_INDKEY (offsetof (struct xevent_nt, u.msg_rexmit.msg_avlnode), offsetof (struct xevent_nt, u.msg_rexmit.msg), msg_xevents_cmp, 0);
static const ddsrt_avl_treedef_t msg_xevents_treedef = DDSRT_AVL_TREEDEF_INITIALIZER_INDKEY (offsetof (struct xevent_nt, u.msg_rexmit.msg_avlnode), offsetof (struct xevent_nt, u.msg_rexmit.msg), msg_xevents_cmp, 0);
static const ut_fibheapDef_t evq_xevents_fhdef = UT_FIBHEAPDEF_INITIALIZER(offsetof (struct xevent, heapnode), compare_xevent_tsched);
static const ddsrt_fibheap_def_t evq_xevents_fhdef = DDSRT_FIBHEAPDEF_INITIALIZER(offsetof (struct xevent, heapnode), compare_xevent_tsched);
static int compare_xevent_tsched (const void *va, const void *vb)
{
@ -209,21 +209,21 @@ static struct xevent_nt *lookup_msg (struct xeventq *evq, struct nn_xmsg *msg)
{
assert (nn_xmsg_kind (msg) == NN_XMSG_KIND_DATA_REXMIT);
trace_msg ("lookup-msg", msg);
return ut_avlLookup (&msg_xevents_treedef, &evq->msg_xevents, msg);
return ddsrt_avl_lookup (&msg_xevents_treedef, &evq->msg_xevents, msg);
}
static void remember_msg (struct xeventq *evq, struct xevent_nt *ev)
{
assert (ev->kind == XEVK_MSG_REXMIT);
trace_msg ("remember-msg", ev->u.msg_rexmit.msg);
ut_avlInsert (&msg_xevents_treedef, &evq->msg_xevents, ev);
ddsrt_avl_insert (&msg_xevents_treedef, &evq->msg_xevents, ev);
}
static void forget_msg (struct xeventq *evq, struct xevent_nt *ev)
{
assert (ev->kind == XEVK_MSG_REXMIT);
trace_msg ("forget-msg", ev->u.msg_rexmit.msg);
ut_avlDelete (&msg_xevents_treedef, &evq->msg_xevents, ev);
ddsrt_avl_delete (&msg_xevents_treedef, &evq->msg_xevents, ev);
}
static void add_to_non_timed_xmit_list (struct xeventq *evq, struct xevent_nt *ev)
@ -330,7 +330,7 @@ static void free_xevent_nt (struct xeventq *evq, struct xevent_nt *ev)
nn_xmsg_free (ev->u.msg.msg);
break;
case XEVK_MSG_REXMIT:
assert (ut_avlLookup (&msg_xevents_treedef, &evq->msg_xevents, ev->u.msg_rexmit.msg) == NULL);
assert (ddsrt_avl_lookup (&msg_xevents_treedef, &evq->msg_xevents, ev->u.msg_rexmit.msg) == NULL);
update_rexmit_counts (evq, ev);
nn_xmsg_free (ev->u.msg_rexmit.msg);
break;
@ -351,12 +351,12 @@ void delete_xevent (struct xevent *ev)
if (ev->tsched.v != T_NEVER)
{
ev->tsched.v = TSCHED_DELETE;
ut_fibheapDecreaseKey (&evq_xevents_fhdef, &evq->xevents, ev);
ddsrt_fibheap_decrease_key (&evq_xevents_fhdef, &evq->xevents, ev);
}
else
{
ev->tsched.v = TSCHED_DELETE;
ut_fibheapInsert (&evq_xevents_fhdef, &evq->xevents, ev);
ddsrt_fibheap_insert (&evq_xevents_fhdef, &evq->xevents, ev);
}
/* TSCHED_DELETE is absolute minimum time, so chances are we need to
wake up the thread. The superfluous signal is harmless. */
@ -384,12 +384,12 @@ int resched_xevent_if_earlier (struct xevent *ev, nn_mtime_t tsched)
if (ev->tsched.v != T_NEVER)
{
ev->tsched = tsched;
ut_fibheapDecreaseKey (&evq_xevents_fhdef, &evq->xevents, ev);
ddsrt_fibheap_decrease_key (&evq_xevents_fhdef, &evq->xevents, ev);
}
else
{
ev->tsched = tsched;
ut_fibheapInsert (&evq_xevents_fhdef, &evq->xevents, ev);
ddsrt_fibheap_insert (&evq_xevents_fhdef, &evq->xevents, ev);
}
is_resched = 1;
if (tsched.v < tbefore.v)
@ -435,7 +435,7 @@ static nn_mtime_t earliest_in_xeventq (struct xeventq *evq)
{
struct xevent *min;
ASSERT_MUTEX_HELD (&evq->lock);
if ((min = ut_fibheapMin (&evq_xevents_fhdef, &evq->xevents)) != NULL)
if ((min = ddsrt_fibheap_min (&evq_xevents_fhdef, &evq->xevents)) != NULL)
return min->tsched;
else
{
@ -453,7 +453,7 @@ static void qxev_insert (struct xevent *ev)
if (ev->tsched.v != T_NEVER)
{
nn_mtime_t tbefore = earliest_in_xeventq (evq);
ut_fibheapInsert (&evq_xevents_fhdef, &evq->xevents, ev);
ddsrt_fibheap_insert (&evq_xevents_fhdef, &evq->xevents, ev);
if (ev->tsched.v < tbefore.v)
ddsrt_cond_signal (&evq->cond);
}
@ -485,8 +485,8 @@ struct xeventq * xeventq_new
/* limit to 2GB to prevent overflow (4GB - 64kB should be ok, too) */
if (max_queued_rexmit_bytes > 2147483648u)
max_queued_rexmit_bytes = 2147483648u;
ut_fibheapInit (&evq_xevents_fhdef, &evq->xevents);
ut_avlInit (&msg_xevents_treedef, &evq->msg_xevents);
ddsrt_fibheap_init (&evq_xevents_fhdef, &evq->xevents);
ddsrt_avl_init (&msg_xevents_treedef, &evq->msg_xevents);
evq->non_timed_xmit_list_oldest = NULL;
evq->non_timed_xmit_list_newest = NULL;
evq->terminate = 0;
@ -540,7 +540,7 @@ void xeventq_free (struct xeventq *evq)
{
struct xevent *ev;
assert (evq->ts == NULL);
while ((ev = ut_fibheapExtractMin (&evq_xevents_fhdef, &evq->xevents)) != NULL)
while ((ev = ddsrt_fibheap_extract_min (&evq_xevents_fhdef, &evq->xevents)) != NULL)
{
if (ev->tsched.v == TSCHED_DELETE || ev->kind != XEVK_CALLBACK)
free_xevent (evq, ev);
@ -559,7 +559,7 @@ void xeventq_free (struct xeventq *evq)
}
while (!non_timed_xmit_list_is_empty(evq))
free_xevent_nt (evq, getnext_from_non_timed_xmit_list (evq));
assert (ut_avlIsEmpty (&evq->msg_xevents));
assert (ddsrt_avl_is_empty (&evq->msg_xevents));
ddsrt_cond_destroy (&evq->cond);
ddsrt_mutex_destroy (&evq->lock);
ddsrt_free (evq);
@ -636,8 +636,8 @@ static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mt
hbansreq ? "" : " final",
msg ? "sent" : "suppressed",
(t_next.v == T_NEVER) ? POS_INFINITY_DOUBLE : (double)(t_next.v - tnow.v) / 1e9,
ut_avlIsEmpty (&wr->readers) ? (seqno_t) -1 : ((struct wr_prd_match *) ut_avlRootNonEmpty (&wr_readers_treedef, &wr->readers))->min_seq,
ut_avlIsEmpty (&wr->readers) || ((struct wr_prd_match *) ut_avlRootNonEmpty (&wr_readers_treedef, &wr->readers))->all_have_replied_to_hb ? "" : "!",
ddsrt_avl_is_empty (&wr->readers) ? (seqno_t) -1 : ((struct wr_prd_match *) ddsrt_avl_root_non_empty (&wr_readers_treedef, &wr->readers))->min_seq,
ddsrt_avl_is_empty (&wr->readers) || ((struct wr_prd_match *) ddsrt_avl_root_non_empty (&wr_readers_treedef, &wr->readers))->all_have_replied_to_hb ? "" : "!",
whcst.max_seq, READ_SEQ_XMIT(wr));
resched_xevent_if_earlier (ev, t_next);
wr->hbcontrol.tsched = t_next;
@ -888,7 +888,7 @@ static void handle_xevk_acknack (UNUSED_ARG (struct nn_xpack *xp), struct xevent
}
ddsrt_mutex_lock (&pwr->e.lock);
if ((rwn = ut_avlLookup (&pwr_readers_treedef, &pwr->readers, &ev->u.acknack.rd_guid)) == NULL)
if ((rwn = ddsrt_avl_lookup (&pwr_readers_treedef, &pwr->readers, &ev->u.acknack.rd_guid)) == NULL)
{
ddsrt_mutex_unlock (&pwr->e.lock);
return;
@ -1322,7 +1322,7 @@ static void handle_xevents (struct thread_state1 * const ts1, struct xeventq *xe
{
while (earliest_in_xeventq(xevq).v <= tnow.v)
{
struct xevent *xev = ut_fibheapExtractMin (&evq_xevents_fhdef, &xevq->xevents);
struct xevent *xev = ddsrt_fibheap_extract_min (&evq_xevents_fhdef, &xevq->xevents);
if (xev->tsched.v == TSCHED_DELETE)
{
free_xevent (xevq, xev);

6
src/core/ddsi/src/q_xmsg.c
View file

@ -23,8 +23,8 @@
#include "dds/ddsrt/heap.h"
#include "dds/ddsrt/random.h"
#include "dds/util/ut_avl.h"
#include "dds/util/ut_thread_pool.h"
#include "dds/ddsrt/avl.h"
#include "dds/ddsrt/thread_pool.h"
#include "dds/ddsi/q_protocol.h"
#include "dds/ddsi/q_xqos.h"
@ -1340,7 +1340,7 @@ static void nn_xpack_send1_threaded (const nn_locator_t *loc, void * varg)
arg->xp = (struct nn_xpack *) varg;
arg->loc = loc;
ddsrt_atomic_inc32 (&arg->xp->calls);
ut_thread_pool_submit (gv.thread_pool, nn_xpack_send1_thread, arg);
ddsrt_thread_pool_submit (gv.thread_pool, nn_xpack_send1_thread, arg);
}
static void nn_xpack_send_real (struct nn_xpack * xp)

2
src/core/xtests/CMakeLists.txt
View file

@ -18,7 +18,7 @@ target_include_directories(
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../ddsc/src>"
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../ddsi/include>")
target_link_libraries(rhc_torture RhcTypes ddsc util)
target_link_libraries(rhc_torture RhcTypes ddsc)
add_test(
NAME rhc_torture