Hi,

What is the SIZE overhead PER active object ? ( executable file (elf) )
What is the BSS overhead PER active object ?
What is the TEXT overhead PER active object ?
What is the DATA overhead PER active object ?
What is the STACK overhead PER active object ?
What is the HEAP overhead PER active object ?
What is the SIZE/BSS/TEXT/DATA/STACK/HEAP overhead FOR THE FRAMEWORK ITSELF ?

All of these are dependent on the op-sys you are targetting.

What is the alternative? If you take the time to study the OXF (there is a model under the C++ oxf directory) you will see that it is the code that you need to provide a 'mailbox' based framework that most of us write anyway. Couple that will autogenerated statechart code and you get a powerful development tool.

Perhaps you don't use statecharts? If not then you are missing the primary reason to use Rhapsody.

Hi,

Thanks for the reply. I am actually well aware of the advantages of using a state-based event-driven framework with an automatic code generation capable modeling tool. Thinking in event-driven way is much different than in traditional sequential way. However, it is important for me to understand how much overhead comes automatically with each active object introduced in the design.

Customizing the OXF capabilities within Rhapsody results in different sized applications and as usual, the smaller it is, the better it is.
Take the Safety Critical (SC) version of OXF. What are those features eliminated so that much more compact code is obtained by using it ?

I wish I had a chance to see some benchmarking figures for different target platforms, anyway.

Regards.

Introducing an active object introduces a new thread that waits on an event queue. The overhead is therefore a context switch when processing events sent across threads and therefore dependent on rtos choice. You don't need any active objects. The main thread is used by default and sometimes a single threaded system is the best choice.

I have the same question as the OP, but for a different reason.

I have a very simple task. It basically sits on a message queue waiting for a command. Only one command will come. This command will block for a while due to IO calls. The command comes from a very high priority task that runs every 5 ms. This fast task is a/has state machine. So basically, the 5 ms task is delegating a job to the task that just waits on a message queue.
It gets complicated because I want the slow task to notify the fast task when it is done. Since the fast task is already reactive, it would be simple codewise, to make the slow task reactive. But the question is, how much overhead does this add? My slow task is about 20 lines of code or so. Does it make sense to make it reactive? This is for Integrity OS. How can I accurately measure the overhead?