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

Replace T_NEVER by DDS_NEVER, DDS_INFINITY

Browse source 
Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
Erik Boasson 2020-03-09 14:02:30 +01:00 • committed by eboasson
parent 39c7997c67
commit 763ed67958
15 changed files with 76 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/core/ddsi/include/dds/ddsi/ddsi_deadline.h
View file

@ -48,30 +48,30 @@ DDS_EXPORT void deadline_renew_instance_real (struct deadline_adm *deadline_adm,
inline void deadline_register_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem, nn_mtime_t tnow)
{
if (deadline_adm->dur != T_NEVER)
if (deadline_adm->dur != DDS_INFINITY)
deadline_register_instance_real (deadline_adm, elem, tnow, tnow);
}
inline void deadline_reregister_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem, nn_mtime_t tnow)
{
if (deadline_adm->dur != T_NEVER)
if (deadline_adm->dur != DDS_INFINITY)
deadline_register_instance_real (deadline_adm, elem, elem->t_deadline, tnow);
}
inline void deadline_unregister_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem)
{
if (deadline_adm->dur != T_NEVER)
if (deadline_adm->dur != DDS_INFINITY)
{
assert (elem->t_deadline.v != T_NEVER);
assert (elem->t_deadline.v != DDS_NEVER);
deadline_unregister_instance_real (deadline_adm, elem);
}
}
inline void deadline_renew_instance_locked (struct deadline_adm *deadline_adm, struct deadline_elem *elem)
{
if (deadline_adm->dur != T_NEVER)
if (deadline_adm->dur != DDS_INFINITY)
{
assert (elem->t_deadline.v != T_NEVER);
assert (elem->t_deadline.v != DDS_NEVER);
deadline_renew_instance_real (deadline_adm, elem);
}
}

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

@ -43,13 +43,13 @@ DDS_EXPORT void lifespan_unregister_sample_real (struct lifespan_adm *lifespan_a
inline void lifespan_register_sample_locked (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node)
{
if (node->t_expire.v != T_NEVER)
if (node->t_expire.v != DDS_NEVER)
lifespan_register_sample_real (lifespan_adm, node);
}
inline void lifespan_unregister_sample_locked (struct lifespan_adm *lifespan_adm, struct lifespan_fhnode *node)
{
if (node->t_expire.v != T_NEVER)
if (node->t_expire.v != DDS_NEVER)
lifespan_unregister_sample_real (lifespan_adm, node);
}

7
src/core/ddsi/include/dds/ddsi/q_time.h
View file

@ -20,7 +20,6 @@
extern "C" {
#endif
#define T_NEVER 0x7fffffffffffffffll
#define T_MILLISECOND 1000000ll
#define T_SECOND (1000 * T_MILLISECOND)
#define T_MICROSECOND (T_MILLISECOND/1000)
@ -46,9 +45,9 @@ typedef struct {
int64_t v;
} nn_etime_t;
#define NN_MTIME_NEVER ((nn_mtime_t) { T_NEVER })
#define NN_WCTIME_NEVER ((nn_wctime_t) { T_NEVER })
#define NN_ETIME_NEVER ((nn_etime_t) { T_NEVER })
#define NN_MTIME_NEVER ((nn_mtime_t) { DDS_NEVER })
#define NN_WCTIME_NEVER ((nn_wctime_t) { DDS_NEVER })
#define NN_ETIME_NEVER ((nn_etime_t) { DDS_NEVER })
#define NN_WCTIME_INVALID ((nn_wctime_t) { INT64_MIN })
int valid_ddsi_timestamp (ddsi_time_t t);

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

@ -43,7 +43,7 @@ struct xeventq *xeventq_new
uint32_t auxiliary_bandwidth_limit
);
/* xeventq_free calls callback handlers with t = T_NEVER, at which point they are required to free
/* xeventq_free calls callback handlers with t = NEVER, at which point they are required to free
whatever memory is claimed for the argument and call delete_xevent. */
DDS_EXPORT void xeventq_free (struct xeventq *evq);
DDS_EXPORT dds_return_t xeventq_start (struct xeventq *evq, const char *name); /* <0 => error, =0 => ok */
@ -68,7 +68,7 @@ DDS_EXPORT struct xevent *qxev_spdp (struct xeventq *evq, nn_mtime_t tsched, con
DDS_EXPORT struct xevent *qxev_pmd_update (struct xeventq *evq, nn_mtime_t tsched, const ddsi_guid_t *pp_guid);
DDS_EXPORT struct xevent *qxev_delete_writer (struct xeventq *evq, nn_mtime_t tsched, const ddsi_guid_t *guid);
/* cb will be called with now = T_NEVER if the event is still enqueued when when xeventq_free starts cleaning up */
/* cb will be called with now = NEVER if the event is still enqueued when when xeventq_free starts cleaning up */
DDS_EXPORT struct xevent *qxev_callback (struct xeventq *evq, nn_mtime_t tsched, void (*cb) (struct xevent *xev, void *arg, nn_mtime_t now), void *arg);
#if defined (__cplusplus)

14
src/core/ddsi/src/ddsi_plist.c
View file

@ -2803,14 +2803,14 @@ static void xqos_init_default_common (dds_qos_t *xqos)
xqos->durability.kind = DDS_DURABILITY_VOLATILE;
xqos->present |= QP_DEADLINE;
xqos->deadline.deadline = T_NEVER;
xqos->deadline.deadline = DDS_INFINITY;
xqos->present |= QP_LATENCY_BUDGET;
xqos->latency_budget.duration = 0;
xqos->present |= QP_LIVELINESS;
xqos->liveliness.kind = DDS_LIVELINESS_AUTOMATIC;
xqos->liveliness.lease_duration = T_NEVER;
xqos->liveliness.lease_duration = DDS_INFINITY;
xqos->present |= QP_DESTINATION_ORDER;
xqos->destination_order.kind = DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP;
@ -2866,12 +2866,12 @@ void ddsi_xqos_init_default_reader (dds_qos_t *xqos)
xqos->time_based_filter.minimum_separation = 0;
xqos->present |= QP_PRISMTECH_READER_DATA_LIFECYCLE;
xqos->reader_data_lifecycle.autopurge_nowriter_samples_delay = T_NEVER;
xqos->reader_data_lifecycle.autopurge_disposed_samples_delay = T_NEVER;
xqos->reader_data_lifecycle.autopurge_nowriter_samples_delay = DDS_INFINITY;
xqos->reader_data_lifecycle.autopurge_disposed_samples_delay = DDS_INFINITY;
xqos->present |= QP_PRISMTECH_READER_LIFESPAN;
xqos->reader_lifespan.use_lifespan = 0;
xqos->reader_lifespan.duration = T_NEVER;
xqos->reader_lifespan.duration = DDS_INFINITY;
xqos->present |= QP_PRISMTECH_SUBSCRIPTION_KEYS;
xqos->subscription_keys.use_key_list = 0;
@ -2902,7 +2902,7 @@ void ddsi_xqos_init_default_writer (dds_qos_t *xqos)
xqos->transport_priority.value = 0;
xqos->present |= QP_LIFESPAN;
xqos->lifespan.duration = T_NEVER;
xqos->lifespan.duration = DDS_INFINITY;
xqos->present |= QP_PRISMTECH_WRITER_DATA_LIFECYCLE;
xqos->writer_data_lifecycle.autodispose_unregistered_instances = 1;
@ -2934,7 +2934,7 @@ void ddsi_xqos_init_default_topic (dds_qos_t *xqos)
xqos->transport_priority.value = 0;
xqos->present |= QP_LIFESPAN;
xqos->lifespan.duration = T_NEVER;
xqos->lifespan.duration = DDS_INFINITY;
xqos->present |= QP_PRISMTECH_SUBSCRIPTION_KEYS;
xqos->subscription_keys.use_key_list = 0;

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

@ -1910,10 +1910,10 @@ static enum update_result uf_duration_inf (struct cfgst *cfgst, void *parent, st
{
if (ddsrt_strcasecmp (value, "inf") == 0) {
int64_t * const elem = cfg_address (cfgst, parent, cfgelem);
*elem = T_NEVER;
*elem = DDS_INFINITY;
return URES_SUCCESS;
} else {
return uf_duration_gen (cfgst, parent, cfgelem, value, 0, 0, T_NEVER - 1);
return uf_duration_gen (cfgst, parent, cfgelem, value, 0, 0, DDS_INFINITY - 1);
}
}
@ -1940,7 +1940,7 @@ static enum update_result uf_duration_100ms_1hr (struct cfgst *cfgst, void *pare
static void pf_duration (struct cfgst *cfgst, void *parent, struct cfgelem const * const cfgelem, uint32_t sources)
{
int64_t const * const elem = cfg_address (cfgst, parent, cfgelem);
if (*elem == T_NEVER)
if (*elem == DDS_INFINITY)
cfg_logelem (cfgst, sources, "inf");
else
pf_int64_unit (cfgst, *elem, sources, unittab_duration, "s");

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

@ -662,7 +662,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
GVLOGDISC (" (depends on "PGUIDFMT")", PGUID (privileged_pp_guid));
/* never expire lease for this proxy: it won't actually expire
until the "privileged" one expires anyway */
lease_duration = T_NEVER;
lease_duration = DDS_INFINITY;
}
else if (vendor_is_eclipse_or_opensplice (rst->vendor) && !(custom_flags & CF_PARTICIPANT_IS_DDSI2))
{
@ -674,7 +674,7 @@ static int handle_SPDP_alive (const struct receiver_state *rst, seqno_t seq, nn_
else
{
privileged_pp_guid.prefix = ddsi2->e.guid.prefix;
lease_duration = T_NEVER;
lease_duration = DDS_INFINITY;
GVLOGDISC (" (depends on "PGUIDFMT")", PGUID (privileged_pp_guid));
}
}
@ -1086,7 +1086,7 @@ static struct proxy_participant *implicitly_create_proxypp (struct ddsi_domaingv
doing anything about (1). That means we fall back to the legacy mode of locally generating
GIDs but leaving the system id unchanged if the remote is OSPL. */
actual_vendorid = (datap->present & PP_VENDORID) ? datap->vendorid : vendorid;
new_proxy_participant(gv, ppguid, 0, &privguid, new_addrset(), new_addrset(), &pp_plist, T_NEVER, actual_vendorid, CF_IMPLICITLY_CREATED_PROXYPP, timestamp, seq);
new_proxy_participant(gv, ppguid, 0, &privguid, new_addrset(), new_addrset(), &pp_plist, DDS_INFINITY, actual_vendorid, CF_IMPLICITLY_CREATED_PROXYPP, timestamp, seq);
}
else if (ppguid->prefix.u[0] == src_guid_prefix->u[0] && vendor_is_eclipse_or_opensplice (vendorid))
{
@ -1120,7 +1120,7 @@ static struct proxy_participant *implicitly_create_proxypp (struct ddsi_domaingv
ddsrt_mutex_unlock (&privpp->e.lock);
pp_plist.prismtech_participant_version_info.flags &= ~NN_PRISMTECH_FL_PARTICIPANT_IS_DDSI2;
new_proxy_participant (gv, ppguid, 0, &privguid, as_default, as_meta, &pp_plist, T_NEVER, vendorid, CF_IMPLICITLY_CREATED_PROXYPP | CF_PROXYPP_NO_SPDP, timestamp, seq);
new_proxy_participant (gv, ppguid, 0, &privguid, as_default, as_meta, &pp_plist, DDS_INFINITY, vendorid, CF_IMPLICITLY_CREATED_PROXYPP | CF_PROXYPP_NO_SPDP, timestamp, seq);
}
}

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

@ -417,7 +417,7 @@ static void remember_deleted_participant_guid (struct deleted_participants_admin
if ((n = ddsrt_malloc (sizeof (*n))) != NULL)
{
n->guid = *guid;
n->t_prune.v = T_NEVER;
n->t_prune = NN_MTIME_NEVER;
n->for_what = DPG_LOCAL | DPG_REMOTE;
ddsrt_avl_insert_ipath (&deleted_participants_treedef, &admin->deleted_participants, n, &path);
}
@ -811,7 +811,7 @@ dds_return_t new_participant_guid (const ddsi_guid_t *ppguid, struct ddsi_domain
{
nn_mtime_t tsched;
tsched.v = (pp->lease_duration == T_NEVER) ? T_NEVER : 0;
tsched = (pp->lease_duration == DDS_INFINITY) ? NN_MTIME_NEVER : (nn_mtime_t){0};
pp->pmd_update_xevent = qxev_pmd_update (gv->xevents, tsched, &pp->e.guid);
}
return 0;
@ -1089,7 +1089,7 @@ dds_duration_t pp_get_pmd_interval (struct participant *pp)
dds_duration_t intv;
ddsrt_mutex_lock (&pp->e.lock);
ldur_node = ddsrt_fibheap_min (&ldur_fhdef, &pp->ldur_auto_wr);
intv = (ldur_node != NULL) ? ldur_node->ldur : T_NEVER;
intv = (ldur_node != NULL) ? ldur_node->ldur : DDS_INFINITY;
if (pp->lease_duration < intv)
intv = pp->lease_duration;
ddsrt_mutex_unlock (&pp->e.lock);
@ -2920,7 +2920,7 @@ void writer_set_alive_may_unlock (struct writer *wr, bool notify)
ddsrt_mutex_lock (&wr->c.pp->e.lock);
wr->alive = true;
wr->alive_vclock++;
if (wr->xqos->liveliness.lease_duration != T_NEVER)
if (wr->xqos->liveliness.lease_duration != DDS_INFINITY)
{
if (wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
participant_add_wr_lease_locked (wr->c.pp, wr);
@ -2943,7 +2943,7 @@ static int writer_set_notalive_locked (struct writer *wr, bool notify)
ddsrt_mutex_lock (&wr->c.pp->e.lock);
wr->alive = false;
wr->alive_vclock++;
if (wr->xqos->liveliness.lease_duration != T_NEVER && wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
if (wr->xqos->liveliness.lease_duration != DDS_INFINITY && wr->xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_PARTICIPANT)
participant_remove_wr_lease_locked (wr->c.pp, wr);
ddsrt_mutex_unlock (&wr->c.pp->e.lock);
@ -3089,22 +3089,16 @@ static void new_writer_guid_common_init (struct writer *wr, const struct ddsi_se
}
/* heartbeat event will be deleted when the handler can't find a
writer for it in the hash table. T_NEVER => won't ever be
writer for it in the hash table. NEVER => won't ever be
scheduled, and this can only change by writing data, which won't
happen until after it becomes visible. */
if (wr->reliable)
{
nn_mtime_t tsched;
tsched.v = T_NEVER;
wr->heartbeat_xevent = qxev_heartbeat (wr->evq, tsched, &wr->e.guid);
}
wr->heartbeat_xevent = qxev_heartbeat (wr->evq, NN_MTIME_NEVER, &wr->e.guid);
else
{
wr->heartbeat_xevent = NULL;
}
assert (wr->xqos->present & QP_LIVELINESS);
if (wr->xqos->liveliness.lease_duration != T_NEVER)
if (wr->xqos->liveliness.lease_duration != DDS_INFINITY)
{
wr->lease_duration = ddsrt_malloc (sizeof(*wr->lease_duration));
wr->lease_duration->ldur = wr->xqos->liveliness.lease_duration;
@ -3181,7 +3175,7 @@ static dds_return_t new_writer_guid (struct writer **wr_out, const struct ddsi_g
if (wr->lease_duration != NULL)
{
assert (wr->lease_duration->ldur != T_NEVER);
assert (wr->lease_duration->ldur != DDS_INFINITY);
assert (!is_builtin_entityid (wr->e.guid.entityid, NN_VENDORID_ECLIPSE));
if (wr->xqos->liveliness.kind == DDS_LIVELINESS_AUTOMATIC)
{
@ -3278,7 +3272,7 @@ static void gc_delete_writer (struct gcreq *gcreq)
if (wr->heartbeat_xevent)
{
wr->hbcontrol.tsched.v = T_NEVER;
wr->hbcontrol.tsched = NN_MTIME_NEVER;
delete_xevent (wr->heartbeat_xevent);
}
@ -4026,7 +4020,7 @@ void new_proxy_participant (struct ddsi_domaingv *gv, const struct ddsi_guid *pp
lease that doesn't expire now and that has a "reasonable" lease duration. That way the lease renewal in
the data path is fine, and we only need to do something special in SEDP handling. */
nn_etime_t texp = add_duration_to_etime (now_et(), tlease_dur);
dds_duration_t dur = (tlease_dur == T_NEVER) ? gv->config.lease_duration : tlease_dur;
dds_duration_t dur = (tlease_dur == DDS_INFINITY) ? gv->config.lease_duration : tlease_dur;
proxypp->lease = lease_new (texp, dur, &proxypp->e);
proxypp->owns_lease = 1;
@ -4529,7 +4523,7 @@ int new_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *ppguid,
#endif
assert (pwr->c.xqos->present & QP_LIVELINESS);
if (pwr->c.xqos->liveliness.lease_duration != T_NEVER)
if (pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY)
{
nn_etime_t texpire = add_duration_to_etime (now_et (), pwr->c.xqos->liveliness.lease_duration);
pwr->lease = lease_new (texpire, pwr->c.xqos->liveliness.lease_duration, &pwr->e);
@ -4689,7 +4683,7 @@ static void gc_delete_proxy_writer (struct gcreq *gcreq)
free_pwr_rd_match (m);
}
local_reader_ary_fini (&pwr->rdary);
if (pwr->c.xqos->liveliness.lease_duration != T_NEVER)
if (pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY)
lease_free (pwr->lease);
proxy_endpoint_common_fini (&pwr->e, &pwr->c);
nn_defrag_free (pwr->defrag);
@ -4722,7 +4716,7 @@ int delete_proxy_writer (struct ddsi_domaingv *gv, const struct ddsi_guid *guid,
builtintopic_write (gv->builtin_topic_interface, &pwr->e, timestamp, false);
entidx_remove_proxy_writer_guid (gv->entity_index, pwr);
ddsrt_mutex_unlock (&gv->lock);
if (pwr->c.xqos->liveliness.lease_duration != T_NEVER &&
if (pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY &&
pwr->c.xqos->liveliness.kind == DDS_LIVELINESS_MANUAL_BY_TOPIC)
lease_unregister (pwr->lease);
if (proxy_writer_set_notalive (pwr, false) != DDS_RETCODE_OK)
@ -4768,7 +4762,7 @@ void proxy_writer_set_alive_may_unlock (struct proxy_writer *pwr, bool notify)
ddsrt_mutex_lock (&pwr->c.proxypp->e.lock);
pwr->alive = true;
pwr->alive_vclock++;
if (pwr->c.xqos->liveliness.lease_duration != T_NEVER)
if (pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY)
{
if (pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_MANUAL_BY_TOPIC)
proxy_participant_add_pwr_lease_locked (pwr->c.proxypp, pwr);
@ -4795,7 +4789,7 @@ int proxy_writer_set_notalive (struct proxy_writer *pwr, bool notify)
ddsrt_mutex_lock (&pwr->c.proxypp->e.lock);
pwr->alive = false;
pwr->alive_vclock++;
if (pwr->c.xqos->liveliness.lease_duration != T_NEVER && pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_MANUAL_BY_TOPIC)
if (pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY && pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_MANUAL_BY_TOPIC)
proxy_participant_remove_pwr_lease_locked (pwr->c.proxypp, pwr);
ddsrt_mutex_unlock (&pwr->c.proxypp->e.lock);

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

@ -952,7 +952,7 @@ int rtps_init (struct ddsi_domaingv *gv)
uint32_t port_disc_uc = 0;
uint32_t port_data_uc = 0;
bool mc_available = true;
nn_mtime_t reset_deaf_mute_time = { T_NEVER };
nn_mtime_t reset_deaf_mute_time = NN_MTIME_NEVER;
gv->tstart = now (); /* wall clock time, used in logs */
@ -1429,7 +1429,7 @@ int rtps_init (struct ddsi_domaingv *gv)
gv->user_dqueue = nn_dqueue_new ("user", gv, gv->config.delivery_queue_maxsamples, user_dqueue_handler, NULL);
#endif
if (reset_deaf_mute_time.v < T_NEVER)
if (reset_deaf_mute_time.v < DDS_NEVER)
qxev_callback (gv->xevents, reset_deaf_mute_time, reset_deaf_mute, gv);
return 0;

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

@ -110,7 +110,7 @@ void lease_register (struct lease *l) /* FIXME: make lease admin struct */
ddsrt_mutex_lock (&gv->leaseheap_lock);
assert (l->tsched.v == TSCHED_NOT_ON_HEAP);
int64_t tend = (int64_t) ddsrt_atomic_ld64 (&l->tend);
if (tend != T_NEVER)
if (tend != DDS_NEVER)
{
l->tsched.v = tend;
ddsrt_fibheap_insert (&lease_fhdef, &gv->leaseheap, l);
@ -175,7 +175,7 @@ void lease_renew (struct lease *l, nn_etime_t tnowE)
/* Only at this point we can assume that gv can be recovered from the entity in the
* lease (i.e. the entity still exists). In cases where dereferencing l->entity->gv
* is not safe (e.g. the deletion of entities), the early out in the loop above
* will be the case because tend is set to T_NEVER. */
* will be the case because tend is set to DDS_NEVER. */
trace_lease_renew (l, "", tend_new);
}
@ -197,7 +197,7 @@ void lease_set_expiry (struct lease *l, nn_etime_t when)
trace_lease_renew (l, "earlier ", when);
trigger = true;
}
else if (l->tsched.v == TSCHED_NOT_ON_HEAP && when.v < T_NEVER)
else if (l->tsched.v == TSCHED_NOT_ON_HEAP && when.v < DDS_NEVER)
{
/* not currently scheduled, with a finite new expiry time */
l->tsched = when;
@ -229,7 +229,7 @@ int64_t check_and_handle_lease_expiration (struct ddsi_domaingv *gv, nn_etime_t
int64_t tend = (int64_t) ddsrt_atomic_ld64 (&l->tend);
if (tnowE.v < tend)
{
if (tend == T_NEVER) {
if (tend == DDS_NEVER) {
/* don't reinsert if it won't expire */
l->tsched.v = TSCHED_NOT_ON_HEAP;
} else {
@ -302,7 +302,7 @@ int64_t check_and_handle_lease_expiration (struct ddsi_domaingv *gv, nn_etime_t
ddsrt_mutex_lock (&gv->leaseheap_lock);
}
delay = (l == NULL) ? T_NEVER : (l->tsched.v - tnowE.v);
delay = (l == NULL) ? DDS_INFINITY : (l->tsched.v - tnowE.v);
ddsrt_mutex_unlock (&gv->leaseheap_lock);
return delay;
}

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

@ -1072,8 +1072,7 @@ static void handle_Heartbeat_helper (struct pwr_rd_match * const wn, struct hand
once, regardless of which readers care about it. */
if (wn->acknack_xevent)
{
nn_mtime_t tsched;
tsched.v = T_NEVER;
nn_mtime_t tsched = NN_MTIME_NEVER;
if (pwr->last_seq > refseq)
{
RSTTRACE ("/NAK");
@ -1142,7 +1141,7 @@ static int handle_Heartbeat (struct receiver_state *rst, nn_etime_t tnow, struct
ddsrt_mutex_lock (&pwr->e.lock);
if (msg->smhdr.flags & HEARTBEAT_FLAG_LIVELINESS &&
pwr->c.xqos->liveliness.kind != DDS_LIVELINESS_AUTOMATIC &&
pwr->c.xqos->liveliness.lease_duration != T_NEVER)
pwr->c.xqos->liveliness.lease_duration != DDS_INFINITY)
{
if ((lease = ddsrt_atomic_ldvoidp (&pwr->c.proxypp->minl_man)) != NULL)
lease_renew (lease, tnow);

14
src/core/ddsi/src/q_time.c
View file

@ -75,7 +75,7 @@ nn_mtime_t mtime_round_up (nn_mtime_t t, int64_t round)
t is nanoseconds, round is milliseconds. Avoid functions from
maths libraries to keep code portable */
assert (t.v >= 0 && round >= 0);
if (round == 0 || t.v == T_NEVER)
if (round == 0 || t.v == DDS_INFINITY)
{
return t;
}
@ -100,12 +100,12 @@ static int64_t add_duration_to_time (int64_t t, int64_t d)
uint64_t sum;
assert (t >= 0 && d >= 0);
sum = (uint64_t)t + (uint64_t)d;
return sum >= T_NEVER ? T_NEVER : (int64_t)sum;
return sum >= DDS_NEVER ? DDS_NEVER : (int64_t)sum;
}
nn_mtime_t add_duration_to_mtime (nn_mtime_t t, int64_t d)
{
/* assumed T_NEVER <=> MAX_INT64 */
/* assumed DDS_NEVER <=> MAX_INT64 */
nn_mtime_t u;
u.v = add_duration_to_time (t.v, d);
return u;
@ -113,7 +113,7 @@ nn_mtime_t add_duration_to_mtime (nn_mtime_t t, int64_t d)
nn_wctime_t add_duration_to_wctime (nn_wctime_t t, int64_t d)
{
/* assumed T_NEVER <=> MAX_INT64 */
/* assumed DDS_NEVER <=> MAX_INT64 */
nn_wctime_t u;
u.v = add_duration_to_time (t.v, d);
return u;
@ -121,7 +121,7 @@ nn_wctime_t add_duration_to_wctime (nn_wctime_t t, int64_t d)
nn_etime_t add_duration_to_etime (nn_etime_t t, int64_t d)
{
/* assumed T_NEVER <=> MAX_INT64 */
/* assumed DDS_NEVER <=> MAX_INT64 */
nn_etime_t u;
u.v = add_duration_to_time (t.v, d);
return u;
@ -134,7 +134,7 @@ int valid_ddsi_timestamp (ddsi_time_t t)
static ddsi_time_t nn_to_ddsi_time (int64_t t)
{
if (t == T_NEVER)
if (t == DDS_NEVER)
return DDSI_TIME_INFINITE;
else
{
@ -157,7 +157,7 @@ ddsi_time_t nn_wctime_to_ddsi_time (nn_wctime_t t)
static int64_t nn_from_ddsi_time (ddsi_time_t x)
{
if (x.seconds == DDSI_TIME_INFINITE.seconds && x.fraction == DDSI_TIME_INFINITE.fraction)
return T_NEVER;
return DDS_NEVER;
else
{
/* Round-to-nearest conversion of DDSI time fraction to nanoseconds */

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

@ -58,7 +58,7 @@ void writer_hbcontrol_init (struct hbcontrol *hbc)
hbc->t_of_last_write.v = 0;
hbc->t_of_last_hb.v = 0;
hbc->t_of_last_ackhb.v = 0;
hbc->tsched.v = T_NEVER;
hbc->tsched = NN_MTIME_NEVER;
hbc->hbs_since_last_write = 0;
hbc->last_packetid = 0;
}
@ -306,7 +306,7 @@ struct nn_xmsg *writer_hbcontrol_piggyback (struct writer *wr, const struct whc_
ETRACE (wr, "heartbeat(wr "PGUIDFMT"%s) piggybacked, resched in %g s (min-ack %"PRId64"%s, avail-seq %"PRId64", xmit %"PRId64")\n",
PGUID (wr->e.guid),
*hbansreq ? "" : " final",
(hbc->tsched.v == T_NEVER) ? INFINITY : (double) (hbc->tsched.v - tnow.v) / 1e9,
(hbc->tsched.v == DDS_NEVER) ? INFINITY : (double) (hbc->tsched.v - tnow.v) / 1e9,
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, writer_read_seq_xmit (wr));

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

@ -321,7 +321,7 @@ void delete_xevent (struct xevent *ev)
/* Can delete it only once, no matter how we implement it internally */
assert (ev->tsched.v != TSCHED_DELETE);
assert (TSCHED_DELETE < ev->tsched.v);
if (ev->tsched.v != T_NEVER)
if (ev->tsched.v != DDS_NEVER)
{
ev->tsched.v = TSCHED_DELETE;
ddsrt_fibheap_decrease_key (&evq_xevents_fhdef, &evq->xevents, ev);
@ -343,13 +343,13 @@ void delete_xevent_callback (struct xevent *ev)
assert (ev->kind == XEVK_CALLBACK);
ddsrt_mutex_lock (&evq->lock);
/* wait until neither scheduled nor executing; loop in case the callback reschedules the event */
while (ev->tsched.v != T_NEVER || ev->u.callback.executing)
while (ev->tsched.v != DDS_NEVER || ev->u.callback.executing)
{
if (ev->tsched.v != T_NEVER)
if (ev->tsched.v != DDS_NEVER)
{
assert (ev->tsched.v != TSCHED_DELETE);
ddsrt_fibheap_delete (&evq_xevents_fhdef, &evq->xevents, ev);
ev->tsched.v = T_NEVER;
ev->tsched.v = DDS_NEVER;
}
if (ev->u.callback.executing)
{
@ -364,7 +364,7 @@ int resched_xevent_if_earlier (struct xevent *ev, nn_mtime_t tsched)
{
struct xeventq *evq = ev->evq;
int is_resched;
if (tsched.v == T_NEVER)
if (tsched.v == DDS_NEVER)
return 0;
ddsrt_mutex_lock (&evq->lock);
/* If you want to delete it, you to say so by calling the right
@ -377,7 +377,7 @@ int resched_xevent_if_earlier (struct xevent *ev, nn_mtime_t tsched)
else
{
nn_mtime_t tbefore = earliest_in_xeventq (evq);
if (ev->tsched.v != T_NEVER)
if (ev->tsched.v != DDS_NEVER)
{
ev->tsched = tsched;
ddsrt_fibheap_decrease_key (&evq_xevents_fhdef, &evq->xevents, ev);
@ -405,7 +405,7 @@ static struct xevent *qxev_common (struct xeventq *evq, nn_mtime_t tsched, enum
ASSERT_MUTEX_HELD (&evq->lock);
/* round up the scheduled time if required */
if (tsched.v != T_NEVER && evq->gv->config.schedule_time_rounding != 0)
if (tsched.v != DDS_NEVER && evq->gv->config.schedule_time_rounding != 0)
{
nn_mtime_t tsched_rounded = mtime_round_up (tsched, evq->gv->config.schedule_time_rounding);
EVQTRACE ("rounded event scheduled for %"PRId64" to %"PRId64"\n", tsched.v, tsched_rounded.v);
@ -440,7 +440,7 @@ static void qxev_insert (struct xevent *ev)
event administration. */
struct xeventq *evq = ev->evq;
ASSERT_MUTEX_HELD (&evq->lock);
if (ev->tsched.v != T_NEVER)
if (ev->tsched.v != DDS_NEVER)
{
nn_mtime_t tbefore = earliest_in_xeventq (evq);
ddsrt_fibheap_insert (&evq_xevents_fhdef, &evq->xevents, ev);
@ -606,7 +606,7 @@ static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mt
{
hbansreq = 1; /* just for trace */
msg = NULL; /* Need not send it now, and no need to schedule it for the future */
t_next.v = T_NEVER;
t_next.v = DDS_NEVER;
}
else if (!writer_hbcontrol_must_send (wr, &whcst, tnow))
{
@ -625,7 +625,7 @@ static void handle_xevk_heartbeat (struct nn_xpack *xp, struct xevent *ev, nn_mt
PGUID (wr->e.guid),
hbansreq ? "" : " final",
msg ? "sent" : "suppressed",
(t_next.v == T_NEVER) ? INFINITY : (double)(t_next.v - tnow.v) / 1e9,
(t_next.v == DDS_NEVER) ? INFINITY : (double)(t_next.v - tnow.v) / 1e9,
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, writer_read_seq_xmit (wr));
@ -1111,9 +1111,9 @@ static void handle_xevk_pmd_update (struct thread_state1 * const ts1, struct nn_
write_pmd_message (ts1, xp, pp, PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE);
intv = pp_get_pmd_interval (pp);
if (intv == T_NEVER)
if (intv == DDS_INFINITY)
{
tnext.v = T_NEVER;
tnext.v = DDS_NEVER;
GVTRACE ("resched pmd("PGUIDFMT"): never\n", PGUID (pp->e.guid));
}
else
@ -1258,7 +1258,7 @@ static void handle_xevents (struct thread_state1 * const ts1, struct xeventq *xe
determine whether it is currently on the heap or not (i.e.,
scheduled or not), so set to TSCHED_NEVER to indicate it
currently isn't. */
xev->tsched.v = T_NEVER;
xev->tsched.v = DDS_NEVER;
thread_state_awake_to_awake_no_nest (ts1);
handle_timed_xevent (ts1, xev, xp, tnow);
}
@ -1314,7 +1314,7 @@ static uint32_t xevent_thread (struct xeventq * xevq)
else
{
nn_mtime_t twakeup = earliest_in_xeventq (xevq);
if (twakeup.v == T_NEVER)
if (twakeup.v == DDS_NEVER)
{
/* no scheduled events nor any non-timed events */
ddsrt_cond_wait (&xevq->cond, &xevq->lock);

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

@ -952,7 +952,7 @@ static void nn_xpack_reinit (struct nn_xpack *xp)
xp->call_flags = 0;
xp->msg_len.length = 0;
xp->included_msgs.latest = NULL;
xp->maxdelay = T_NEVER;
xp->maxdelay = DDS_INFINITY;
#ifdef DDSI_INCLUDE_NETWORK_PARTITIONS
xp->encoderId = 0;
#endif