embedlets-developer

[Embedlets-dev] More benchmarks....

[Andrzej J. T. <an...@ch...>]

I added an optimization, since if you are using Sync events, the component 
(Embedlet) knows upon return of the send() method, all consumers have 
received the event, and so it's now possible to flag a sync event instance as 
non-recycleable, and thus the component can create one event and keep reusing 
it for all future sends (since the container won't try to recycle it).

In the benchmark example, this means the ProducerEmbedlet just creates a 
single event and then sends it 1000 times in the non-recycled case. 

Assuming fairly accurate processor clocks, here were the results, comparing async and sync event
propagation (all values in events/second)

PLATFORM                           ASYNC           SYNC (Recycled)    SYNC (Non-Recycled)

PC/Windows (400 mhz):          2800                      16.7K                        50K

SaJe (aJile aJ-100):                 3940                      10.7K                      43.5K

JStamp( aJile aJ-80):                652                       2000                        7350

TINI:                                           8                         13                           143

What the non-recycled case does is eliminate some setter methods on the 
event, along with elimination of the hashtable lookup of the event type (in 
string form, eg "event.producer") into an internal event typeID (long).  I'll 
bet that the hashtable implementations coupled with the string compares they 
do (eg. str1.equals( str2 ) ) are taking a lot of processor time, and are 
especially inefficient on the TINI.

This points to some potential optimizations that can be done down the road 
that will speed the Async and recycled Sync event propagation paths.

However, I think I'm gonna leave that till later, since I want to work on 
some other things before we start getting too tied up in low level 
optimizations.
Andrzej Jan Taramina
Chaeron Corporation: Enterprise System Solutions
http://www.chaeron.com

RE: [Embedlets-dev] More benchmarks....

[Christopher S. <cs...@oo...>]

>
> Topic tags:[ARCH][JAPL][WIRING][DOCS][MGMT][STRATEGY][NEWBIE]
> _______________________________________________
>
> I added an optimization, since if you are using Sync events, the
> component
> (Embedlet) knows upon return of the send() method, all consumers have
> received the event, and so it's now possible to flag a sync event
> instance as
> non-recycleable, and thus the component can create one event and
> keep reusing
> it for all future sends (since the container won't try to recycle it).

This makes the most sense in core Embedlet communication. This makes the
'wires' a solid connection between produce and consumers and ensures prompt
processing of events. Async events will be very important as well to off
load communication between more loosely coupled processes to lower priority
services.

We should probably put together a 'When to use Sync/Async events' document
based on this discussion thread.

>
> In the benchmark example, this means the ProducerEmbedlet just creates a
> single event and then sends it 1000 times in the non-recycled case.
>
> Assuming fairly accurate processor clocks, here were the results,
> comparing async and sync event
> propagation (all values in events/second)
>
> PLATFORM                           ASYNC           SYNC
> (Recycled)    SYNC (Non-Recycled)
>
> PC/Windows (400 mhz):          2800                      16.7K
>                     50K
>
> SaJe (aJile aJ-100):                 3940
> 10.7K                      43.5K
>
> JStamp( aJile aJ-80):                652
> 2000                        7350
>
> TINI:                                           8
>         13                           143
>
> What the non-recycled case does is eliminate some setter methods on the
> event, along with elimination of the hashtable lookup of the
> event type (in
> string form, eg "event.producer") into an internal event typeID
> (long).  I'll
> bet that the hashtable implementations coupled with the string
> compares they
> do (eg. str1.equals( str2 ) ) are taking a lot of processor time, and are
> especially inefficient on the TINI.
>
> This points to some potential optimizations that can be done down
> the road
> that will speed the Async and recycled Sync event propagation paths.
>
> However, I think I'm gonna leave that till later, since I want to work on
> some other things before we start getting too tied up in low level
> optimizations.
> Andrzej Jan Taramina
> Chaeron Corporation: Enterprise System Solutions
> http://www.chaeron.com
>
>

I think that it is certainly good enough to release for version 0.0.3 :-)

Very impressive indeed!


>
> -------------------------------------------------------
> This SF.net email is sponsored by: Etnus, makers of TotalView,
> The debugger
> for complex code. Debugging C/C++ programs can leave you feeling lost and
> disoriented. TotalView can help you find your way. Available on
> major UNIX
> and Linux platforms. Try it free. www.etnus.com
> _______________________________________________
> Embedlets-developer mailing list
> Emb...@li...
> https://lists.sourceforge.net/lists/listinfo/embedlets-developer
>