ISO C++ DDS PSM

OpenSplice DDS
Delivering Performance, Openness, and Freedom

Angelo Corsaro, Ph.D.
Chief Technology Officer

ISO C++ DDS PSM
OMG DDS SIG Co-Chair
angelo.corsaro@prismtech.com

OpenSplice DDS

Rationale

ISO C++ PSM Motivations

The “Native C++ Language DDS PSM” (CxxDDS) was motivated by
the following reasons:
‣Provide better integration with the C++ programming language
‣Provide a simpler and safer API to facilitate adoption within and
beyond current user domains
‣Ensure 100% source-code portability across DDS
implementations

© 2010, PrismTech. All Rights Reserved

Integration with C++

The current IDL-derived PSM suffers the following shortcomings:
‣ Limited integration of IDL-derived types with the C++ language
‣e.g. char* vs. std::string, Sequence vs. std::vector, etc.
‣ Limited use of features and idioms universally supported by C++
compilers and widely used by C++ programmers
‣e.g. template and template-meta-programming, iterators, etc.


API Complexity

‣ The current API suffers from accidental complexity mostly induced
by the limited expressiveness of IDL and the dated IDL2C++
mapping


Portability

‣ The current IDL-derived API leaves some types deﬁned as native,
thus allowing different vendors to use different representations
‣e.g. the type of the domainid
‣ The current IDL-derived API does not speciﬁes the DDS interfaces
as local, yet semantically those are local. This has also been source of
portability issues


OpenSplice DDS

Submission Overview
Foundations

CxxDDS API Organization

‣ Different packages are introduced to limit the
dependencies and group together relevant classes
‣ The submission separates clearly those files features
that are specific to publication and subscription so
that application can include only the minimal set of
files
‣ The API is parametrized w.r.t. a DELEGATE layer


Delegation Layer
‣ The delegation layer, is provided by vendors and used to instantiate the CxxDDS API
into a concrete API
‣ This standard provide a reference implementation that shows how that can be done.
‣ Under any circumstances, compliant implementation shall not change the CxxDDS
API, as detailed in Section 8, vendor-specific extensions shall be added only via
DELEGATEs.
‣ The CxxDDS API provides a standard way of accessing vendor specific extensions
‣ Finally, although the specification allows for vendor-specific extensibility, it should be
clear that this specification does not encourage nor recommend their use
Using vendor specific extensions will make application non-source-code-portable to
other CxxDDS compliant implementations and might also adversely impact on-the-
wire interoperability.

Object Model

The Native C++ Language DDS PSM (CxxDDS) is based
on an object model structured in two different kinds of
object types: reference-types and value-types


Reference Types

‣ Reference-types have a shallow
(polymorphic) assignment operator that Ref
simply changes the value of the reference
Impl.
‣ Reference-types are safe. Under no Ref
circumstances a reference can point to an
invalid object. Ref

‣ Memory for reference-types is
CxxDDS Delegate (provided by a
automatically managed by the runtime. speciﬁc vendor
implementation)


Reference Types (cont.)

‣ The semantics for Reference types is deﬁned by the CxxDDS class
dds::core::Reference.

namespace dds { namespace core {
template <typename DELEGATE> class Reference;
}}

‣ The speciﬁcation mandates the semantics implied by the Reference class, yet the
implementation provided as part of this standard is provided to show one possible
way of implementing this semantics


Reference Types


WeakReferences

‣ The CxxDDS also provides safe Weak References implemented by the class
dds::core::WeakReference
‣ Weak References can be constructed only from strong references
‣ Weak References do not expose other method other than checking wether the
reference is valid and getting a strong-reference

namespace dds { namespace core {
template <typename class R <typename D>>
class WeakReference;
}}


Value Types

‣ All objects that have a value-type have a deep-copy assignment semantics.
‣ It should also be pointed out that value-types are not “pure-value-types” in the sense
that they are immutable (as in functional programming languages).
‣ The CxxPSM makes value-types mutable to limit the number of copies as well limit the
time-overhead necessary to change a value-type (note that for immutable value-types
the only form of change is to create a new value-type).
‣ Value-types always inherit from the CxxPSM dds::core::Value
The CxxDDS models all DDS entities as reference-types while QoS and Topic samples
are all modeled as value-types.


API Extensibility

‣ The CxxPSM allows for QoS to be extended, either by new version of the standard or
by vendor speciﬁc extension without any impact on the public API.
‣ The CxxPSM provides this level of extensibility while also enjoying a very compact
representation of a QoS which leverages the combination of a DELEGEATE QoS
implementation along with template getter and setters.


QoS as an Example of Extensibility
Although the CxxPSM
speciﬁes the EntityQoS by
leveraging variadic C++
templates for providing a
constructor taking an
arbitrary number or
arguments, some
implementation might have
to leverage other techniques
for emulating variadic
templates on non-supported
compilers. The standard
technique for doing this is to
deﬁne several template
constructors accepting an
increasing number of
arguments.


Primitive Types Mapping

‣ The CxxDDS API provides its own
interoperable deﬁnition of DDS primitive types
and represents them in terms of standard (and
portable) C/C++ types.


Sequence Mapping

‣ Bounded and Unbounded IDL Sequences for a type T map to
std::vector<T>


Parameters Passing
Constant-size Primitive types
‣ in T => T
‣ out T => T&
‣ inout T => T&

Variable-size Primitive types (e.g string, wsting)
‣ in T => const T&
‣ out T => T&
‣ inout T => T&


Parameters Passing
Value Types
‣ out T => T&
‣ inout T => T&

Reference Types
‣ out T => T&
‣ inout T => T&


Return Parameters
Attribute Accessors for ﬁxed-size primitive types
‣ T => T

Attribute Accessors for any other type
‣ T => const T&

Non-attribute return-values
‣ T => T


OpenSplice DDS

Submission Overview
API Overview

DDS Entities


Entity QoS
template <typename DELEGATE>
class Publisher : public dds::core::Entity<DELEGATE> {
public:
‣ To improve the // -- QoS related methods --
level of compile template <typename POLICY>
void set_policy(const POLICY& p) {
time error impl_->set_policy(p);
detection, the }

current submission template <typename POLICY>
const POLICY& get_policy() const {
separates the return impl_->get_policy();
initialization of }
entity QoS policy dds::PublisherQos get_qos() const {
from the update of return impl_->get_qos();
}
some of its policies. // -- Other Publisher Methods not shown
// for space constraints
};


QoS Extensibility
Vendor-specific DDS Entity QoS (topic in this case)
XYZVendorTopicQoS vtqos = { /* values */ };
dds::Topic<MyType> topic("MyTopic", vtqos);
‣ The current
submission
provides two Vendor-specific QoS Policy (topic in this case)
ways of dds::Topic<MyType> topic("MyTopic");
providing vendor XYZVendorPolicy policy = { /* values */ };
topic.set_policy(policy);
specific QoS


Reading/Taking Data

The new API simplify and extends the ways in which data can be read/taken
by providing:
‣ std::vector based reads/takes
‣ The std::vector API allows for zero copy optimization
‣ Iterators based read/take supporting both:
‣ Forward Iterators
‣ Back Inserting Iterators


std::vector-based read/take
/**
* Reads all new samples from any view state and alive instances. If the provided containers have
* zero-size than the middleware will loan memory to the application to support zero-copy reads.
* The memory will be returned to the middleware when the container is destroyed or by explicitly
* invoking the <code>return_loan</code> method on the data reader.
*/
void
read(std::vector<T>& samples, dds::SampleInfoSeq& infos);
/**
* Reads at most <code>max_samples</code> samples that have not been read yet from all views
* and alive instances.
*/
void
read(std::vector<T>& samples, uint32_t max_samples);
/**
* Most generic <code>read</code> exposing all the knobs provided by
* the OMG DDS API.
*/
void
read(std::vector<T>& samples, dds::SampleInfoSeq& infos,
uint32_t max_samples, dds::SampleStateMask samples_state,
dds::ViewStateMask views_state, dds::InstanceStateMask instances_state);


std::vector-based take
/**
* Reads all new samples from any view state and alive instances. If the provided containers have
* zero-size than the middleware will loan memory to the application to support zero-copy reads.
* The memory will be returned to the middleware when the container is destroyed or by explicitly
* invoking the <code>return_loan</code> method on the data reader.
*/
void
take(std::vector<T>& samples, dds::SampleInfoSeq& infos);
/**
* Reads at most <code>max_samples</code> samples that have not been read yet from all views
* and alive instances.
*/
void
take(std::vector<T>& samples, uint32_t max_samples);
/**
* the OMG DDS API.
*/
void
take(std::vector<T>& samples, dds::SampleInfoSeq& infos,


FWD-Iterator-based read
/**
* Reads new samples from any view state and alive instances.
*/
template <typename SamplesFWIterator, typename InfoFWIterator>
void
read(SamplesIterator sfit, InfoIterator ifit, uint32_t max_samples);
/**
* Reads at most <code>max_samples</code> samples that have not been read yet from all vies and
* alive instances.
*/
template <typename SamplesFWIterator>
void
read(SamplesFWIterator samples, uint32_t max_samples);
/**
* the OMG DDS API.
*/
void
read(SamplesFWIterator sfit, InfoFWIterator ifit,


FWD-Iterator-based take
/**
* Reads new samples from any view state and alive instances.
*/
void
take(SamplesIterator sfit, InfoIterator ifit, uint32_t max_samples);
/**
* Reads at most <code>max_samples</code> samples that have not been read yet from all vies and
* alive instances.
*/
template <typename SamplesFWIterator>
void
take(SamplesFWIterator samples, uint32_t max_samples);
/**
* the OMG DDS API.
*/
void
take(SamplesFWIterator sfit, InfoFWIterator ifit,


BI-Iterator-based read
/**
* Reads all new samples from any view state and alive instances.
*/
template <typename SamplesBIIterator, typename InfoBIIterator>
void
read(SamplesIterator sbit,
InfoIterator ibit);
/**
* Most generic <code>take</code> exposing all the knobs provided by
* the OMG DDS API.
*/
void
read(SamplesBIIterator ifit, InfoBIIterator ifit,
dds::SampleStateMask samples_state,


BI-Iterator-based take
/**
* Reads all new samples from any view state and alive instances.
*/
void
take(SamplesIterator sbit,
InfoIterator ibit);
/**
* Most generic <code>take</code> exposing all the knobs provided by
* the OMG DDS API.
*/
void
take(SamplesBIIterator ifit, InfoBIIterator ifit,
dds::SampleStateMask samples_state,


Conditions


Creating a Condition (ex.)

/**
* Creates an <code>ActiveReadCondition</code> that waits for new samples to
* be arriving in order to notify.
*/
template <typename F>
::dds::Condition
create_readcondition(const F& f);


OpenSplice DDS

Submission Overview
Writing an application

IDL as Usual
enum TemperatureScale {
! CELSIUS,
! KELVIN,
! FAHRENHEIT
};
!
struct TempSensorType {
! short id;
! float temp;
! float hum;
TemperatureScale scale;

};
#pragma keylist TempSensor id


Writer: As simple as it gets
/**********************************************************
* DataWriter
**********************************************************/
dds::Topic<TempSensorType> tsTopic("TempSensorTopic");
// Create a Publisher connected to the proper partition
// Create a DataWriter
dds::DataWriter<TempSensorType> dw(tsTopic);

TempSensorType ts = {1, 26.0F, 70.0F, CELSIUS};
// Write Data
dw.write(ts);


Customizing the Writer QoS
/**********************************************************
* DataWriter
**********************************************************/
dds::DomainParticipant dp(did);
dds::Publisher pub(dp, pqos);
// Create a Publisher connected to the proper partition
// Create a DataWriter
dds::DataWriter<TempSensorType> dw(tsTopic, pub, dwqos);

TempSensorType ts = {1, 26.0F, 70.0F, CELSIUS};
// Write Data
dw.write(ts);


Data Reader
/**********************************************************
* DataReader
**********************************************************/
// Create a DataReader
dds::DataReader<TempSensorType> dr(tsTopic);

// If no initial size is provided than the read will read
// all available samples
std::vector<TempSensorType> data;
SampleInfoSeq info; // This is a std::vector too!

while (true) {
dr.read(data, info);
for (int i = 0; i < data.length(); ++i)
std::cout << data[i] << std::endl;
sleep(1);


Data Reader (with FW Iterators)
/**********************************************************
* DataReader
**********************************************************/


std::vector<TempSensorType> data(length);
SampleInfoSeq info(length); // This is a std::vector too!

while (true) {
dr.read(data.begin(), info.begin(), length);
sleep(1);
}


Data Reader (with BI Iterators)
/**********************************************************
* DataReader
**********************************************************/


std::vector<TempSensorType> data;
SampleInfoSeq info; // This is a std::vector too!
std::back_insert_iterator<std::vector<TempSensorType>> bid(data);
std::back_insert_iterator<SampleInfoSeq> bii(info);
while (true) {
dr.read(bid, bii);
sleep(1);


OpenSplice DDS

Interoperability with
IDL2C++ API and CORBA

C++2IDL and CORBA Interop

‣ The new mapping deﬁnes implicit conversion methods to create the equivalent C+
+2IDL type when needed
‣ This allows to pass a new DDS Type to a CORBA call by leveraging automatically
generated conversions
‣ Conversion can be enabled/disabled via IDL compilers ﬂags


OpenSplice DDS

Résumé & Next Steps

Résumé

‣ The CxxDDS addresses the goals of the RFP by providing a simpler, safer and well
integrated C++ API for DDS
‣ The current submission addresses extensibility and portability
‣ Efﬁciency and determinism is not impacted by the higher level of abstraction


Next Steps

‣ Vote a ﬁnalized version of this submission on June Meeting


Online Resources

http://www.opensplice.com/
http://www.slideshare.net/angelo.corsaro
emailto:opensplicedds@prismtech.com

http://bit.ly/1Sreg http://twitter.com/acorsaro/

http://opensplice.blogspot.com
http://www.youtube.com/OpenSpliceTube


Thank You...


ISO C++ DDS PSM

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a ISO C++ DDS PSM

Semelhante a ISO C++ DDS PSM (20)

Mais de Angelo Corsaro

Mais de Angelo Corsaro (20)

Último

Último (20)

ISO C++ DDS PSM