[prog.sobjectizer] Непонятный момент с реализацией параллельных состояний

В иерархических конечных автоматах могут быть т.н. композитные состояния. Т.е. состояния, которые содержат в себе несколько подсостояний, включая и другие композитные состояния. Так, в примере ниже композитное состояние s0 включает в себя два композитных подсостояния s1 и s2. В свою очередь композитное подсостояние s2 имеет композитное подсостояние s21:

Если композитное состояние A содержит два композитных подсостояния B и C, то могут быть следующие варианты:

• в конкретный момент времени внутри A активным может быть либо подсостояние B, либо подсостояние C. Можно сказать, что B и C скомбинированы внутри A операцией ИЛИ (OR);
• в конкретный момент времени внутри A активными являются и подостояние B, и подсостояние C. Можно сказать, что B и C скомбинированы внутри A операцией И (AND). Состояния B и C называют параллельными (parallel states) или конкурентными (concurrent states).

На UML-диаграммах параллельные состояния разделяются пунктирными линиями внутри своего объемлющего композитного состояния. Вот хорошая картинка из Интернета, которая наглядно демонстрирует важность параллельных состояний (на примере простенького КА, описывающего поведение стиральной машины):

[prog.c++] В склерозник: С++ инструменты для concurrency

Время от времени приходится в блоге и/или на форумах давать ссылки на инструменты для упрощения разработчики многопоточных приложений на C++. Дабы не приходилось выискивать их каждый раз заново, решил сделать отдельный пост-слерозник с этими самыми ссылками. Пусть лежат в одном месте, проще будет найти.

• Intel Threading Building Blocks. A library that supports scalable parallel programming using standard ISO C++ code. It is designed to promote scalable data parallel programming. Additionally, it fully supports nested parallelism, so you can build larger parallel components from smaller parallel components. To use the library, you specify tasks, not threads, and let the library map tasks onto threads in an efficient manner.
• HPX (High Performance ParalleX). A general purpose C++ runtime system for parallel and distributed applications of any scale. It strives to provide a unified programming model which transparently utilizes the available resources to achieve unprecedented levels of scalability.
• Just::Thread Pro. Provides a framework for creating actors that run on separate threads, and communicate via message passing, as well as jss::synchronized_value for synchronizing access to a single object and jss::concurrent_map, a hash map that is safe for concurrent access from multiple threads.
• CAF (C++ Actor Framework). An open source C++11 actor model implementation featuring lightweight & fast actor implementations, pattern matching for messages, network transparent messaging, and more..
• SObjectizer. A small tool for simplification of development of concurrent and event-driven applications in C++. It allows to build a concurrent application as a set of agent-objects which interact with each other only by means of asynchronous messages. SObjectizer takes responsibility of in-process message dispatching and providing working context for message processing.
• Boost.Fiber. Provides a framework for micro-/userland-threads (fibers) scheduled cooperativly. The API contains classes and functions to manage and synchronize fibers similiar to boost.thread.
• QP. A family of lightweight software frameworks for building responsive and modular real-time embedded applications as systems of cooperating, event-driven active objects (actors). The QP family consists of QP/C, QP/C++, and QP-nano frameworks, which are all strictly quality controlled, thoroughly documented, and commercially licensable.
• FastFlow. A C/C++ programming framework supporting the development of pattern-based parallel programs on multi/many-core and distributed platforms. FastFlow run-time is built upon non-blocking threads and lock-free queues. Thanks to its very efficient CAS-free communication/synchronization support (e.g. few clock cycles core-to-core latency), FastFlow effectively supports the exploitation of fine grain parallelism, e.g. parallel codes managing very high frequency streams on commodity multi-core.

Ну и это не говоря про более низкоуровневые возможности для работы с многопоточностью, которые есть в фреймворках вроде Boost, ACE, POCO, Qt и т.д.

Так же имеет смысл смотреть вот в эту коллекцию ссылок, в раздел Concurrency.

PS. В комментарии можно кидать ссылки на другие инструменты для C++, решающие проблемы многопоточности применительно к concurrency computing. Я буду добавлять их в общий список.

[prog.c++] Реализация иерархических конечных автоматов в SO-5 задышала...

...почти что полной грудью :) Под катом пример описания агента, реализующего конечный автомат из вот этого поста. Только пару недель назад это были первые наметки, а сейчас уже компилирующийся и работающий код. КА даже оказался чуток более навороченным, т.к. пришлось добавить еще парочку состояний, дабы имитация была более правдоподобной.

В принципе, сделал уже почти все, что хотел. Параллельных состояний нет и, вероятно, не будет. Аналогичных результатов можно добиваться и посредством вспомогательных агентов, как это и происходит в данном примере. А вот чего явно пока не хватает, так это автоматической смены состояния после определенного тайм-аута. Как такое сделать, в принципе, понятно. Но это утяжелит объект state_t на пару умных указателей... В общем, нужно подумать, стоит ли оно того...

Ну а вот, собственно, и получившийся код. Глядя на него уже недоумеваешь, а почему мы не сделали иерархические конечные автоматы раньше? Ведь это так классно! Особенно отлаживать ;)

[prog.thoughts] Про ООП: создание инфраструктуры vs использование инфраструктуры

Я, конечно, не знаменитый LOR-овский anonimous, который периодически срывает покровы веселит посетителей LOR-а своими прозрениями и откровениями в отношении ООП... Но об ООП и сам время от времени задумываюсь. В частности о том, почему в последние годы все чаще и чаще слышна как критика, так и, на мой взгляд, пустые наезды на ООП. В особенности от молодых разработчиков. И вот на днях пришла в голову мысль о том, что это связано с тем, как изменилось само программирование за последние 20-25 лет.