In the past few years we have been experiencing an amazing proliferation of mobile and embedded platforms. Contemporary developers are increasingly faced with the challenge of writing applications that can run on desktop, mobile (e.g. Android), and on low-cost embedded platforms (e.g. Raspberry-Pi and Beaglebone). This is causing a rejuvenated interest in the Java platform as the mean to achieve the holy grail of write-once and run-everywhere. With the availability of Java environments supporting almost any kind of device in several different form factors, the missing element to the picture is an effective way of enabling communication between them.
Vortex Café is a pure Java implementation of the OMG Data Distribution Service (DDS) that enables seamless, efficient and timely data sharing across many-core machines, mobile and embedded devices.
This presentation will (1) introduce the main abstractions provided by Vortex Café, (2) provide an overview of its architecture and explain how it exploits Staged Event Driven Architectures to optimize its runtime depending of the target hardware, (3) provide an overview of the typical performance delivered by Vortex Café, and (3) get you started developing distributed Java and Scala applications with Vortex Café.
4. CopyrightPrismTech,2014
One Standard, One set of Tools, One Goal — Ubiquitous Data Sharing
The Vortex Platform
VORTEX
Web
VORTEX
Lite
VORTEX
Gateway
VORTEX
Cloud
Private
Clouds
VORTEX
Tools
• Insight
• Record/Replay
• Tuner
• Tester
• Configurator
OpenSplice
Enterprise
VORTEX
Café
6. CopyrightPrismTech,2014
Pure Java version of Vortex targeting JVM
and embedded JVMs
DDSI Protocol Stack optimised for mobility
and Android OS
Only DDS on the market designed and
Engineered for Android
Vortex Café
J2SE
DDSI$$
(Optimised*for*Mobility)*
DDS$API Java Scala JavaScript
7. CopyrightPrismTech,2014
Vortex Café has a Staged Event Driven Architecture (SEDA) that allows it to be
easily configured to trade off between throughput and latency
A Staged Event Driven Architecture
8. CopyrightPrismTech,2014
Decomposes a complex, event-driven application into a set of stages connected by
queues
Avoids the high overhead associated with thread-based concurrency models, and
decouples event and thread scheduling from application logic.
Through admission control on each event queue, SEDAs can be well-conditioned to
load, preventing resources from being overcommitted when demand exceeds service
capacity
SEDA
[Matt Welsh, David Culler, and Eric Brewer, SEDA:An Architecture for Well-Conditioned, Scalable Internet Services]
9. CopyrightPrismTech,2014
The Vortex Café architecture is organized
around three stages
Packet Processing
Message Processing
Data Processing
The channel that connect each stage can
be configured to be active or passive
Vortex Café Architecture
Packet
Processor
Message
Processor
Data
Processor
Network Packet
DDSI Messages
Cache Changes
10. CopyrightPrismTech,2014
Channels can be active or passive (and zero-copy).
That means that channels can be configured with
threading resources, or not
Messages posted in a passive channel are executed
in the context of the posting thread
This allows to configure Vortex Café to optimize the
use case at hand
Configurability
Processor
Channel
11. CopyrightPrismTech,2014
Single Thread per Message
Sample Configurations
Packet
Processor
Message
Processor
Data
Processor
Network Packet
DDSI Messages
Cache Changes
Fully Asynchronous
Packet
Processor
Message
Processor
Data
Processor
Network Packet
DDSI Messages
Cache Changes
12. CopyrightPrismTech,2014
Vortex Café is SEDA architecture as well as all the protocol parameters can be configured
through configuration file or via command line properties , i.e. providing -D options to the JVM
Configuration parameters are listed on the user manual
Example:
Configuration in Practice
java
-‐server
-‐cp
.:./target/vortex-‐cafe-‐demo-‐assembly-‐2.0.jar
-‐Ddds.listeners.useTransportThread=true
-‐Dddsi.writers.heartbeatPeriod=0.001
-‐Dddsi.writers.nackResponseDelay=0
-‐Dddsi.readers.heartbeatResponseDelay=0
-‐Dddsi.timer.threadPool.size=1
-‐Dddsi.receiver.threadPool.size=0
-‐Dddsi.dataProcessor.threadPool.size=0
-‐Dddsi.acknackProcessor.threadPool.size=0
-‐Dddsi.writers.reliabilityQueue.size=128
com.prismtech.cafe.demo.perf.RoundTripDemoReader
$*
14. CopyrightPrismTech,2014
• DomainParticipant: Provides access to a data cloud -- called a domain in DDS
• Topic: Domain-wide definition of a kind of Information
• Publisher/Subscriber: Provide scope to data sharing through the concept of partitions
• DataReader/DataWriter: Allow to read/write data for a given topic in the partitions their Subscriber/Publisher are
associated with.
DDS Entities
15. CopyrightPrismTech,2014
Brewing Vortex-Cafe
int
domain_id
=
18;
DomainParticipantFactory
dpf
=
DomainParticipantFactory.getInstance(env)
!
DomainParticipant
dp
=
dpf.createParticipant(domainId);
Topic<Post>
topic
=
dp.createTopic(“Post”,
Post.class);
struct
Post
{
string
name;
string
msg;
};
#pragma
keylist
Post
name
Publisher
pub
=
dp.createPublisher();
DataWriter<Post>
dw
=
pub.createDataWriter<Post>(topic);
dw.write(new
Post(“Barman”,
“Would
you
like
an
espresso?”);
Subscriber
sub
=
dp.createSubscriber();
DataReader<Post>
dr
=
sub.createDataReader<Post>(topic);
LoanedSamples<Post>
samples
=
dw.read();
16. CopyrightPrismTech,2014
Escalating Vortex-Cafe
val
topic
=
Topic[Post](“Post”) struct
Post
{
string
name;
string
msg;
};
#pragma
keylist
Post
name
val
dw
=
DataWriter[Post](topic)
dw
write(new
Post(“Barman”,
“Would
you
like
an
espresso?”)
val
dr
=
DataReader[Post](topic)
dr.listen
{
case
DataAvailable(_)
=>
dr.read.foreach(println(_.getData())
}
18. CopyrightPrismTech,2014
Android applications are written in the Java programming language
Support for native code is available, but this often leads to worse performance
(due to the JNI layer) and worse battery utilisation
Thus unless you have very good reasons not to, you are strongly encouraged to
write android applications in Java and to leverage on Java libraries!
Android Fundamentals
19. CopyrightPrismTech,2014
An Android application runs in its own JVM and (by default) on its own linux process
An application may be composed of the following elements:
- Activities: a single screen with a user interface
- Services: a component that runs in the background to perform long-running operations or to
perform work for remote processes.
- Content Providers: a component that manages shared data for a set of applications
- Broadcast Receivers: a component that responds to system-wide broadcast
announcements
Android allows any applications to start any other application component and potentially
consume the data it produces
Android Application in a Nutshell
20. CopyrightPrismTech,2014
Activities, Services and Broadcast Receivers are activated through an asynchronous
message, called Intent
For Activities and Services the intent specifies the action to perform
For Broadcast Receivers it specifies the event being broadcasted, e.g. battery-low
Component Activation
21. CopyrightPrismTech,2014
The manifest is an XML file containing several important information about the
application
Among, other things, the manifest includes the authorization necessary for your
application -- for instance, it is in this file that you have to mention that your
application requires access to the network, etc.
Application Manifest
24. CopyrightPrismTech,2014
Considering the Android application lifecycle, we should ask ourselves a few
questions:
When should we create DDS entities and who should hold a reference to them?
What happens when an application is no more visible?
Can I control when my application exits?
How do I deal with multi-threading?
DDS Considerations for Android
26. CopyrightPrismTech,2014
To learn how to write an Android
Application that uses Vortex Café
we’ll develop a very simple Chat
To keep things simple this chat will
have a single “chat room”
DDS Chat for Android
27. CopyrightPrismTech,2014
Our Chat application will have a very simple architecture with simply one
Activity that will take care of:
- Sending Posts into the ChatRoom
- Displaying Posts in the room since when we joined
In terms of information modelling, we’ll have a single topic representing the user
post
Step 1: Architecture
struct
Post
{
string
name;
string
msg;
};
#pragma
keylist
Post
name
28. CopyrightPrismTech,2014
Creating DDS entities, such as
DomainParticipants, DataReaders and
DataWriters involves network communication,
such as discovery information
In addition when an a DDS entity is destroyed it
looses its state
As such, tying the life-cycle of DDS entities to
activities should be done with great care
Step 2: Lifecycle Management[1/2]
29. CopyrightPrismTech,2014
In general, it is a better idea to tie the life-cycle of
DDS entities to the Application as opposed to
Activities
In some cases, it may make sense to tie the life-
cycle of DataReaders/DataWriters to that of the
activity that relies on them -- Usually this makes
sense for activities that are “one-off”
Step 2: Lifecycle Management[2/2]
30. CopyrightPrismTech,2014
Application
public class ChatApplication extends Application {!
!
DataReader<Post> dr;!
DataWriter <Post> dw;!
DomainParticipant dp;!
!
@Override!
public void onCreate() {!
super.onCreate();!
// This should be defined via a resource -- but for a small!
// demo that’s OK.!
System.setProperty(ServiceEnvironment.IMPLEMENTATION_CLASS_NAME_PROPERTY,!
"com.prismtech.cafe.core.ServiceEnvironmentImpl");!
ServiceEnvironment env = ServiceEnvironment.createInstance(!
ChatApplication.class.getClassLoader());!
DomainParticipantFactory dpf =!
DomainParticipantFactory.getInstance(env);!
!
dp = dpf.createParticipant(0);!
Topic<Post> topic = dp.createTopic("Post",Post.class);!
Publisher pub = dp.createPublisher();!
Subscriber sub = dp.createSubscriber();!
!
dw = pub.createDataWriter(topic);!
dr = sub.createDataReader(topic);!
}!
!
33. CopyrightPrismTech,2014
When using Vortex Café you need to grant the proper permissions for
networking:
More Manifest...
<uses-permission android:name="android.permission.INTERNET"/>!
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>!
<uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE"/>!
36. CopyrightPrismTech,2014
Activity
1 !
2 public class MainActivity extends Activity {!
3 !
4 private static final String TAG = "ChatMainActivity";!
5 private final Handler handler = new Handler();!
6 private ArrayAdapter<String> chatMessages;!
7 !
8 public class ChatMessageListener extends ChatMessageDataListener { !
9 // ...!
10 }!
11 !
12 @Override!
13 protected void onCreate(Bundle savedInstanceState) {!
14 super.onCreate(savedInstanceState);!
15 setContentView(R.layout.activity_main);!
16 chatMessages = new ArrayAdapter<String>(this, R.layout.messages);!
17 chatMessages.add("Welcome to the DDS Chat Room");!
18 ListView mview = (ListView) findViewById(R.id.messageList);!
19 mview.setAdapter(chatMessages);!
20 ChatApplication app = (ChatApplication) getApplication();!
21 !
22 app.reader().setListener(new ChatMessageListener());!
23 !
24 }!
25
37. CopyrightPrismTech,2014
Activity
!
25 !
26 @Override!
27 public boolean onCreateOptionsMenu(Menu menu) {!
28 // Inflate the menu; this adds items to the action bar if it is present.!
29 getMenuInflater().inflate(R.menu.main, menu);!
30 return true;!
31 }!
39. CopyrightPrismTech,2014
Receiving data is a bit trickier since in Android only the thread that runs an
activity has the right to change the UI
This means, that from a DDS listener it is not possible to change an the UI
directly!
The solution is to use an Android Handler
to which we can post Runnable to
be executed by the activity thread
Let’s see how this works...
Receiving Data
40. CopyrightPrismTech,2014
DDS Listener & Android Handler
1 public class ChatMessageListener extends ChatMessageDataListener {!
2 !
3 private DataReader<Post> dr;!
4 !
5 public ChatMessageListener() {!
6 ChatApplication app = (ChatApplication) getApplication();!
7 dr = app.reader();!
8 }!
9 !
41. CopyrightPrismTech,2014
DDS Listener & Android Handler
10 @Override!
11 public void onDataAvailable(DataAvailableEvent<Post> dae) {!
12 final Iterator<Post> i = dr.read();!
13 !
14 Log.i(TAG, ">>> DataReaderListener.onDataAvailable");!
15 if (i.hasNext()) {!
16 Runnable dispatcher = new Runnable() {!
17 public void run() {!
18 while (i.hasNext()) {!
19 Sample<Post> s = i.next();!
20 !
21 if (s.getSampleState() == SampleState.NOT_READ) {!
22 Post cm = s.getData();!
23 chatMessages.add(cm.name + " > " + cm.msg);!
24 }!
25 }!
26 }!
27 };!
28 handler.post(dispatcher);!
29 }!
30 }!
31 }!
43. CopyrightPrismTech,2014
The Raspberry Pi is a low cost, credit-card
sized computer that plugs into a computer
monitor or TV, and uses a standard keyboard
and mouse
Raspberry Pi can interact with the outside
world, and is used in a wide array of digital
maker projects, from music machines and
parent detectors to weather stations and
tweeting birdhouses with infra-red cameras,
etc.
Raspberry Pi
44. CopyrightPrismTech,2014
Several Images are available nowadays, I tend to use Raspbian
To get started get the image from: http://www.raspberrypi.org/downloads/
Then copy the image on an SD card following instruct ructions available at http://
www.raspberrypi.org/documentation/installation/installing-images/
For MacOS X:
-‐ diskutil
list
[to
check
the
SD
card
/dev/diskN]
-‐ diskutil
unmontDisk
/dev/diskN
-‐ sudo
dd
bs=1m
if=2014-‐01-‐07-‐wheezy-‐raspbian.img
of=/dev/diskN
-‐ sudo
diskutil
eject
/dev/diskN
Raspberry Pi Image
45. CopyrightPrismTech,2014
Getting the Java JDK on raspberry is as easy as executing the following
command:
- sudo apt-get update
- sudo apt-get install oracle-java7-jdk [jdk8 is also available]
Getting Java on Raspberry
46. CopyrightPrismTech,2014
You can get Scala and SBT using curl:
- curl -O http://downloads.typesafe.com/scala/2.11.1/scala-2.11.1.tgz
- http://dl.bintray.com/sbt/native-packages/sbt/0.13.5/sbt-0.13.5.tgz
Then simply extract and properly set the PATH environment variable
Getting Scala and SBT
50. CopyrightPrismTech,2014
Vortex enable seamless, ubiquitous, efficient and timely data sharing across
mobile, embedded, desktop, cloud and web applications
It is the first platform to address the data-sharing needs of Business Critical IoT,
and Industrial Internet Systems
Vortex is fully interoperable with DDS compliant implementations
Concluding Remarks
51. CopyrightPrismTech,2014
Vortex v1.0 will be available in June 2014
Starting from May will be providing a series of webcasts to get you
started in building IoT and I2 applications with Vortex
What’s Next?