SObjectizer / News: Recent posts

A new version of SObjectizer is available:

https://github.com/Stiffstream/sobjectizer/releases/tag/v.5.8.2

This release add a couple of new small features and fixes. More details about this release can be found here: https://github.com/Stiffstream/sobjectizer/wiki/v.5.8.2

There is no update for so5extra, the current version of so5extra should work fine with SO-5.8.2.

PS. The new version is already available via vcpkg.

New versions of SObjectizer and so5extra are available:

https://github.com/Stiffstream/sobjectizer/releases/tag/v.5.8.1
https://github.com/Stiffstream/so5extra/releases/tag/v.1.6.1

The SObjectizer-5.8.1 introduces a couple of new features and fixes several issues. More information about this version can be found here:

https://github.com/Stiffstream/sobjectizer/wiki/v.5.8.1

The so5extra-1.6.1 contains adaptation to SObjectizer-5.8.1. Please note that due to changes inside the SObjectizer Core the previous versions of so5extra may not work with v.5.8.1 properly. If you upgrade to SO-5.8.1 you have to upgrade to so5extra-1.6.1 too.... read more

New versions of SObjectizer and its companion project so5extra are available:

https://github.com/Stiffstream/sobjectizer/releases/tag/v.5.8.0
https://github.com/Stiffstream/so5extra/releases/tag/v.1.6.0

This is a major release of SObjectizer that breaks compatibility with previous 5.7 branch. The list of changes can be found in the project's Wiki:

https://github.com/Stiffstream/sobjectizer/wiki/v.5.8.0
https://github.com/Stiffstream/so5extra/wiki/v.1.6.0... read more

New versions of SObjectizer and its companion project so5extra are available:

https://github.com/Stiffstream/sobjectizer/releases/tag/v.5.7.4
https://github.com/Stiffstream/so5extra/releases/tag/v.1.5.1

There are just two new minor features, but I like that we found time and resources to implement them.

It means that SObjectizer is still alive and evolving. After 20 years of evolution.

Yes, the very first working version of SObjectizer (it was SO-4.0) was created in April 2002. And it was used in an actual project just after that, in May 2002.... read more

New versions of SObjectizer and its companion project so5extra are available:

https://github.com/Stiffstream/sobjectizer/releases/tag/v.5.7.3
https://github.com/Stiffstream/so5extra/releases/tag/v.1.5.0

There are not many new features, but those that were added are consequences of our experience and asks from users. For example:

• there is a possibility to create your own thread factory and pass that factory to a SObjectizer's dispatcher or to SObjectizer Environment. That factory will be used for the creation and releasing of worker thread instead of the use of std::thread. It allows using of custom threads with standard SObjectizer dispatchers. More information can be found here.
• there is a new method so_5::agent_t::so_deactivate_agent() that switches an agent to a special state and drops all agent's subscriptions. It can be useful when it's necessary to deactivate some agent after an error until the agent's cooperation will be deregistered;
• a new type of mbox is added to so5extra: unique-subscribers. That mbox is similar to Multi-Producer/Multi-Consumer mboxes and allows several agents to be subscribed at the same time. But it's a Multi-Producer/Single-Consumer mbox and mutable messages can be sent into it.... read more

The Actor Model is one of the time-proven approaches for simplification of multithreading programming. But if one wants to find real-world examples of using the Actor Model in C++, it could be a rather complex task.

We have known that very well because we maintain one of the C++ actor frameworks but have almost no chances to show the real use cases because most of the uses of our tool are in proprietary closed-source projects.... read more

We did several talks about SObjectizer in Belarus and Russia in the past. But all of them were in Russian.

A couple of days ago the first talk about SObjectizer was made on Italian C++ Community virtual meetup. This is our first SObjectizer-related talk in English and now it's available on YouTube, the slides can be found here.... read more

The first commit of SObjectizer-5 project was made in Oct 2010. Soon after that SObjectizer-5 started working and we consider the end of 2010 as a SObjectizer-5's date of birth. And now, at the end of 2020 we can celebrate the 10th anniversary of SObjectizer-5.

Note. If you didn't hear about SObjectizer earlier then this overview can give you some insight about the project itself and niches where it was or can be used.... read more

SObjectizer-5.7.1 introduces a couple of new features and also contains a few fixes.

One of the new features is default (or generic) message limits:
```cpp
class demo final : public so_5::agent_t
{
public:
demo(context_t ctx)
: so_5::agent_t{ctx
+ limit_then_drop<msg_a>(100u)
+ limit_then_abort<msg_b>(10u)
// That limit will be used for all other messages.
+ limit_then_drop<any_unspecified_message>(50u)
}
{}... read more</any_unspecified_message></msg_b></msg_a>

New versions of SObjectizer and its companion project so5extra are released.

TL;DR:

• SObjectizer-5.7 now supports the send_case in select() function. It makes SObjectizer's select() much more similar to Golang's select statement. But it breaks the compatibility with v.5.6 because old case_ function is now renamed to receive_case;
• v.5.7 of SObjectizer fixes a flaw in enveloped message delivery mechanism with respect to transfer_to_state() and suppress() functionality;
• so5extra is now relicensed and distributed under BSD-3-CLAUSE license. Previous versions of so5extra were distributed under GNU Affero GPL v.3 and commercial licenses;
• so5extra-1.4 now implements fixed-capacity message chains that capacity is known at the compile-time.... read more

A small update for SObjectizer-5.6 and a big shift in the further SObjectizer's development: since Aug 2019 the development of SObjectizer moved to GitHub. New versions of SObjectizer will be developed on GitHub, SourceForge will be used as a mirror for tarballs.

The actual project's Wiki is now also on GitHub.... read more

Yet another "actor framework" is available for C++ developers: "rotor". The main rotor's goal is to reuse existing event-loop implementations (like event-loops inside wxWidgets or Boost.Asio). And I like to mention that rotor-framework was inspired by SObjectizer.

The project lives on GitHub: https://github.com/basiliscos/cpp-rotor

And it's documentation is available here: https://basiliscos.github.io/cpp-rotor-docs/index.html

What if you already have actors and want to build data-processing pipeline on top of them (e.g., building something similar to reactive- or data-flow programming)? Someting like:

validate | convert | archive | distribute

It could be rather easy, and C++ templates can help to catch some errors at compile-time.

There is a new article about an experiment of building such pipeline DSL on the top of SObjectizer and so5extra: A declarative data-processing pipeline on top of actors? Why not?

We've added some new sections in SObjectizer-5.6 docs in the project's Wiki:

• an explanation of some SObjectizer's internals: "Let's look under the SObjectizer's hood";
• a couple of new articles in "In-depth" serie: "Send Functions" and "Environment Infrastructures";
• a new tutorial "Writing own tricky thread-pool dispatcher" (this is a translation of an article in Russian with adaptation to SO-5.6 specific changes).... read more

New versions of SObjectizer and its companion project, so5extra, are available now.

The SObjectizer-5.5 branch has been in the development since 2014. We supported compatibility between versions in 5.5-branch on a very high level. In most cases, a simple recompilation was necessary during switching from an old SObjectizer-5.5 version to a new one.

In more than four years of evolution, 5.5-branch incorporated a lot of new features, most of those were not planned from the beginning. That has a negative impact on SObjectizer's code complexity and the price of further development. We also were oriented on compilers with limited support of C++11, but it isn't actual anymore.... read more

We know that SObjectizer is used in various projects outside our small company. But most of SObjectizer's customers just use it and do not provide any publicly available information about SObjectizer's usage. That is why we are so excited to see a big article from a developer of an automated control system for ruling a theatre's scenery: If your project is «Theatre» then use actors... read more

We're glad to announce the availability of the first beta-versions of SObjectizer-5.6 and so5extra-1.3!

It's the result of several months of deep refactoring and modernization of SObjectizer Core and companion so5extra project. There are still more to do like additional testing on some platforms and compilers. Also, yet more work to do with the adaptation of the documentation for the new versions. But we hope that the final release of new SObjectizer will be somewhere in the mid of May 2019.... read more

According to the preliminary plan the first beta-version of v.5.6.0 was expected at the end of March 2019. It is obvious now that it won't happen. Because of that, there is a sense to speak about what was done and what has to be done.

There are the changes which already implemented in SObjectizer-5.6:

• only send-functions can be used for message sending. There is no access to deliver_message from a mbox anymore;
• every mbox now has a reference to environment_t. This leads to the same format of all send_delayed() and send_periodic() functions. Now send_delayed(target_agent, pause, args) looks the same way as send_delayed(target_mbox, pause, args);
• there isn't ad-hoc agents in SObjectizer-5.6;
• there isn't a support for tuple_as_message;
• there isn't methods which accept raw pointers. For example, coop_t::add_agent() and environment_t::register_agent_as_coop() receive unique_ptr now;
• introduce_coop() and introduce_child_coop() functions return a value now. This is a return value from a lambda passed to these functions;
• dispatcher's mechanism was rewritten. There isn't public and private dispatcher now. New dispatchers are very similar to private dispatchers from SObjectizer-5.5: they are created by a user when appropriately and automatically destroyed when no one uses them. Dispatcher's binders are still there. But now shared_ptr is used instead of unique_ptr. It allows to use the same disp_binder for agents from different coops;
• coop's mechanism was significantly redesigned. Coops are still here and coops can be bound in a parent-child relationship. But coops have no names now. The register_coop() function returns a handle for a new coop (an instance of coop_handle_t type). This handle can be used for the creation of a new child coop or for deregistration of an existing coop. The new mechanism is not faster than the old one, but it is much more scalable if several registrations and deregistrations are performed at the same time. For example there is a new benchmark. With parameters roots=3, levels=5, level-size=9 it works on my notebook for 44s for v.5.5.24.3 and for 11s for v.5.6.0.... read more

The development of next major version of SObjectizer was started several days ago. The motivation and goals of v.5.6 were described here (in Russian here).

Now the development is performed in a private Mercurial repository on BitBucket. When all breaking changes will be done a beta version of SObjectizer-5.6 will be published somewhere. We think that the main repo will be Mercurial repository on BitBucket with an official mirror on GitHub. It's hard to say when it happen but we hope that we can publish the first publicity available beta version at the end of February or at the beginning of March 2019.... read more

Some time ago Lucian Radu Teodorescu published an interesting article "Modern dining philosophers" where several solution of that famous problem were shown. Those solutions use task-based approach.

One of SObjectizer's maintainers wrote a follow-up to that article in two parts:

• "Modern" Dining Philosophers in C++ with Actors and CSP (part 1) shows some implementations expressed in terms of Actors;
• "Modern" Dining Philosophers in C++ with Actors and CSP (part 2) shows the same implementations, but expressed in terms of CSP model.... read more

It seems that lifetime of SObjectizer-5.5 is going to the end. We plan to start the development of "the next big" version of SObjectizer in a week or so. There is something like roadmap: On the road to SObjectizer-5.6 with our motivation, goals and most obvious first steps explained. There are also some open questions for those we have to answers yet.... read more

SObjectizer has been updated to version 5.5.24 and so_5_extra has been updated to version 1.2.2.

The main new feature of SObjectizer-5.5.24 is an experimental support of unit-testing of agents.

The checking of agents' correctness was a hard question for a long time. There was no help from SObjectizer and every developer had to find the answer by him/herself. But starting from v.5.5.24 SObjectizer contains tools those allows to write unit-tests for agents.... read more

SObjectizer has been updated to version 5.5.23 and so_5_extra has been updated to version 1.2.0.

There is no too much new changes in SObjectizer-5.5.23, but there is the building block for the more interesting features from so_5_extra-1.2.0. It is enveloped messages feature (see [so-5.5 In-depth - Enveloped Messages] for more details). This feature allows to wrap a message into a special envelope. Such envelope can hold additional information about the message and can perform additional actions upon delivery of the message.... read more

This summer we released Shrimp. It is a demo project for serving images using Actor Model and embeddable HTTP-server. SObjectizer was used in Shrimp as an implementation of Actor Model for C++.

More information about Shrimp, its internals, live demo and references to source code can be found here. Take a look and feel free to ask any question about Shrimp or SObjectizer.

As far as we can see too many novice C++ programmers ask the same questions: "How to manage work threads?" and "How to perform data exchange between work threads?" There are no such questions if you can use some ready to use high-level library or framework. To show how easy this could be we have prepared a small example. This example uses plain threads (std::thread) and CSP-like channels which implemented in SObjectizer as 'mchains'. Here is an explanation of that example: Data exchange between threads without a pain? CSP-channels to rescue