Показаны сообщения с ярлыком Concurrency. Показать все сообщения
Показаны сообщения с ярлыком Concurrency. Показать все сообщения

понедельник, 11 сентября 2023 г.

[prog.c++] В склерозник: статья "What every systems programmer should know about concurrency"

Хорошая статья для тех, кто хотел бы в общих чертах понять что такое атомарные операции и с чем их едят: "What every systems programmer should know about concurrency".

Просто зафиксирую ссылку на нее в блоге, чтобы проще было найти при необходимости.

PS. Для хардкорных системщиков статья может показаться набором тривиальной банальщины, но для тех, кто атомики никогда не использовал это вполне себе нормальная точка для старта, благо там в конце перечисленны ресурсы для более глубокого погружения.

понедельник, 12 октября 2020 г.

[prog.c++] The follow-up for "What's new in rotor v0.09" article

There is a new article "What's new in rotor v0.09" that tells several things about yet another C++ actor framework named "rotor". As for me it's a good example of how different implementations of Actor Model could be. And it's a good reason to write some words about SObjectizer's features to show how the same things were addressed a long time ago.

Before I start, it's necessary to note that some of the decisions described below are rather philosophical than technical ones. It also means that some decisions taken from philosophical standpoints had a significant impact on technical aspects of SObjectizer's internals and API, and on applications built on top of the SObjectizer.

суббота, 28 марта 2020 г.

[prog.actors] Почему я не считаю упомянутых в статье на Хабре акторов настоящими акторами

Давеча не удержался и влез в комментарии к статье "Линеаризуем асинхронный код с помощью корутин" на Хабре. Не удержался потому, что автор взялся за интересную и актуальную тему, но не смог ее толком раскрыть потому, что, как мне показалось, от всех его примеров и принятых проектных решений сильно попахивало какой-то искусственной сложностью.

К сожалению, получилось как в анекдоте: "Вот нутром чую, что 0.5 плюс 0.5 будет литр, а математически выразить не могу". Т.е. ощущение "должно было быть попроще" присутствует, но вот чтобы выяснить, что именно и как можно (и нужно бы) упростить... На это не хватает времени и терпения.

Это вообще достаточно сложная проблема, с которой я регулярно сталкивался будучи тимлидом. Делаешь code review подчиненного и явно ощущаешь, что реализация переусложнена, что можно проще. Говоришь "здесь что-то слишком сложно, должно быть проще", а на встречный вопрос "А как проще?" сходу ответ дать не можешь. Потому что для того, чтобы дать такой ответ, нужно самому сесть и плотно поработать над этой задачей. А это значит, что ты мало того, что будешь вынужден переделать работу, которую должен сделать твой подчиненный, но еще и не успеешь сделать что-то другое, что ты никому не можешь делегировать.

Поэтому критика по типу "что-то здесь все слишком сложно" она такая... Двоякая. Потому что бывает, что она оправдана. Но вот чтобы ее аргументировать нужно приложить столько же усилий, сколько автор потратил на написание статьи.

Но данный пост я решил написать на другую тему, связанную с этой же статьей.

Дело в том, что в статье автор повсюду упоминает акторов и, как мне показалось, пребывает в уверенности, что использует "акторный подход". Хотя я (пока еще) убежден, что это не так. И в данном посте попробую объяснить, почему мне кажется, что использованные в статье "акторы" на самом деле "акторами" не являются.

вторник, 28 января 2020 г.

[prog.c++] Перевел демо-проект so5-dining-philosophers на свежие версии SObjectizer, so5extra, fmtlib

Год назад на Хабре была опубликована большая статья "«Современные» обедающие философы на C++ посредством акторов и CSP", в которой рассматривалось несколько реализаций решения задачи "Обедающих философов" на SObjectizer (как на базе агентов, так и на базе голых нитей с mchain-ами).

За прошедшее время многое поменялось: вышли новые версии SObjectizer-а (5.6 и 5.7) несовместимые с SO-5.5, на котором были написаны примеры для статьи. А Atlassian принял решение удалить в 2020-ом году с BitBucket-а все Mercurial репозитории. Эта участь ожидает и исходный репозиторий, в котором были собраны примеры кода для статьи.

Так что этот демо-проект подвергся модернизации. Во-первых, он переехал на GitHub: so5-dining-philosophers. Во-вторых, код был переведен на свежие версии зависимостей: SObjectizer-5.7.0, so5extra-1.4.0 и fmtlib-6.1.2.

Поэтому теперь для so5-dining-philosophers нужен C++17. Старая версия под C++14 и SO-5.5 доступа под тегом 20190129.

Несколько слов про адаптацию старых решений под новый SObjectizer:

  • потребовалось исправить сигнатуру метода state_watcher_t::changed. Этот метод в SO-5.6/5.7 должен быть noexcept. В данном демо-примере noexcept означает не то, что changed() не будет бросать исключений, а то, что нет возможности продолжить работу, если исключение все-таки выскочило, поэтому нужно грохнуть все через std::terminate;
  • потребовалось исправить сигнатуру метода do_deliver_message в собственном типе mbox-а. В SO-5.6/5.7 этот метод уже не помечен как const, а в SO-5.5 эта отметка долго сохранялась по соображениям совместимости;
  • пришлось изменить подписку у некоторых агентов. Ранее использовалась нотация state.event<Signal>([]{...}), теперь она не поддерживается и нужно использовать унифицированный вариант: state.event([](mhood_t<Signal>){...}). Это было одним из ломающих совместимость изменений в SO-5.6;
  • в нескольких вызовах receive для чтения входящих сообщений из mchain-ов потребовалось указать handle_all(), поскольку SO-5.6/5.7 требуют, чтобы для receive/select было указано количество обрабатываемых сообщений (т.е. нужно вызывать handle_n/handle_all/extract_n явным образом). Контролируется это во время компиляции. О том, как этого удалось достичь была отдельная статья на Habr-е;
  • потребовалось поменять создание диспетчеров. Вместо вызовов вида create_private_disp(env)->binder() начиная с SO-5.6 нужно писать make_dispatcher(env).binder(). Собственно, это одно из принципиальных отличий SO-5.6 от SO-5.5.

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

Но важность сохранения совместимости все равно осознал. Постараюсь больше ломающих нововведений в SObjectizer не вносить и держать совместимость в рамках SO-5.7 как можно дольше.

суббота, 4 января 2020 г.

[prog.c++] В SObjectizer-овском select() появляется send_case()

В черновой ветке SObjectizer-а появилась возможность делать select() не только для чтения входящих сообщений из нескольких каналов, но и для отсылки сообщений в канал. Так что совсем скоро SObjectizer-овский select() станет еще более близок к Go-шному. Естественно, с поправкой на то, что в SObjectizer-е все это сделано средствами библиотеки, а не вшито в язык намертво с оптимально причесанным под это дело синтаксисом.

Под катом традиционный для демонстрации Go-шного select-а пример: вычисление чисел Фибоначчи в отдельном потоке и отсылка их в канал. Отсылка автоматически приостанавливается, если в канале нет места. Так же вычисление прекращается, если из второго канала вычитали сообщение на завершение работы. Или если какой-то из каналов принудительно закрыли.

Примечательна история появления send_case для SObjectizer-овского select-а.

Сам select() в SObjectizer-е появился чуть менее четырех лет назад, в марте 2016-го. После чего я пытался сделать несколько подходов к реализации в select-е не только receive_case, но и send_case. Но каждый раз эти подходы завершались неудачей из-за отсутствия хороших идей по интеграции send_case в уже имеющуюся реализацию select-а.

За пару недель перед Новым Годом начался очередной, можно сказать, дежурный подход, в начале которого было полторы или две недели безрезультатного выкуривания бамбука. Пока, наконец, не пришло некоторое понимание и того, что хочется вложить в send_case, и того, как это поместить в уже имеющуюся схему работы select-а. После чего потребовалось буквально пара дней, чтобы реализовать это все. Тот самый случай, когда идея реально должна была вызреть и, кроме того, должны были сойтись звезды, чтобы появилась возможность качественно "подойти к снаряду".

Плохо то, что пришлось поломать API select-а, поэтому версия SObjectizer-а будет увеличена до 5.7.0. На подготовку новой версии к релизу потребуется какое-то время, так что доступно все это будет где-то через пару недель.

суббота, 20 июля 2019 г.

[prog.c++] Идея развития темы, начатой в статье "A declarative data-processing pipeline on top of actors? Why not?"

Давеча опубликовал на Хабре большую статью на английском языке "A declarative data-processing pipeline on top of actors? Why not?", в которой описал старый, но доведенный "до ума" пример make_pipeline из состава SObjectizer-а. К самой статье Григорий Демченко задал интересные вопросы в комментарии. Плюс на Reddit-е подсунули ссылку на (как мне показалось) недоделанную и полузаброшенную библиотеку RaftLib.

В общем, появилось навязчивое желание сделать продолжение этой темы.

По сути, тема создания пайплайнов (или графов в общем случае) обработки данных на C++ состоит из двух частей. Можно сказать, что есть верхняя и нижняя части проблемы.

Нижняя часть -- это то, как работа распределяется по рабочим контекстам. Т.е. это вопросы, связанные с тем, что из себя на самом деле представляют стадии пайплайна, как стадии привязываются к тем или иным рабочим нитям, как происходит передача информации между стадиями пайплайна. В принципе, нижнюю часть не обязательно делать с нуля самому. Можно использовать какой-то готовый инструмент. Скажем, Intel TBB. Или, как в моем случае, SObjectizer. С нижним уровнем связано несколько вопросов и мне хочется посмотреть, какие ответы на эти вопросы может (и может ли) предоставить SObjectizer.

Верхняя часть -- это тот DSL, который будет предоставляться пользователю для конструирования своих пайплайнов. И здесь есть ряд интересных и не исследованных для меня вопросов. Начиная от того, какую функциональность пользователь сможет получить в свои руки. И заканчивая тем, как выразить эту функциональность в C++ коде, дабы получить контроль за какими-то ошибками прямо в compile-time.

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

четверг, 21 февраля 2019 г.

[prog.concurrency] И о чем же потрындели эти трое заслуженных товарищей?

Наткнулся давеча на разговор трех мэтров конкурентного программирования: Джо Армстронга (это который папа Эрланга), Тони Хоара (это который папа модели CSP) и Карла Хьюитта (это который папа модели Акторов): Let's #TalkConcurrency Panel Discussion with Sir Tony Hoare, Joe Armstrong, and Carl Hewitt. За несколько подходов осилил стенограмму их разговоров. Но не осилил главного: что в сухом остатке?

Ну вот реально не понятно, что полезного из этой беседы мог вынести для себя человек, который заинтересовался конкурентностью? Или который плотно занимается этой темой...

Есть ощущение, что три почтенных старца потрепались о чем-то своем, изрядно поржав походу дела. И, собственно, все.

Причем Джо Армстронг -- это типичный практик. Хоар -- ученый, который занимается теорией, но теорией, имеющей непосредственное влияние на практику. Тогда как Хьюитт производит впечатление витающего в небесах теоретика, который повернут на акторах и на том, как акторы волшебным образом все разруливают в идеальном мире. Уже не в первый раз сталкиваюсь с рассуждениями Хьюитта и до сих пор не могу понять, что такого практически значимого он сделал, чтобы его мнение воспринимать всерьез.

Кстати говоря, ссылка на эту беседу была найдена на HackerNews. Там в комментариях ничего интересного не обнаружилось. Мне показалось, что доминирует типичное фанбойство Erlang-еров. Мол, в Erlang-е все зашибись, мы делали на Erlang-а ахриненные программы, ничего лучше и не пожелаешь. И все это на фоне неасиляторов с жалобами в стиле "мы не понимаем как акторы нам помогут". Ну еще и Rust-оманы в очередной раз прибежали с воплями про то, какой у них замечательный фетиш.

Хинт для тех, кто не понимает, как акторы могут помочь: акторы вовсе не обязаны вам помочь, это всего лишь один из подходов, где-то он применим, где-то нет.

Но туда же в комментарии пришел и Карл Хьюитт, выдав очередной поток какой-то мутной херни, уж простите мне мой французский. Классы ему, блин чем-то помешали. Ну прямо как в анекдоте: "Не люблю я кошек, от них шерсть, вонь..." -- "Ба! Да вы просто не умеете их готовить!"

В общем, если кто-то хотел потратить часть своего времени на прослушивание/прочтение этой беседы и/или ее обсуждения на HackerNews, то лучше не нужно. Потратьте это время лучше на изучение Erlang, Elixir, Go, Akka, CAF, SObjectizer, Vert.x, Orleans и других инструментов. А так же примеров их использования. Практической пользы будет больше.

понедельник, 4 февраля 2019 г.

[prog.c++] Небольшое послесловие про "Обедающих философов" и exception-safety

В статье про реализацию задачи про обедающих философов посредством Actors и CSP я отдельно затронул тему обеспечения exception-safety при использовании модели CSP. И, пожалуй, можно на этом моменте остановится подробнее еще раз.

Давайте представим себе, что мы захотели сделать функцию run_simulation() безопасной по отношению к исключениям.

Первое, что нам придется сделать -- это выполнить рекомендации из статьи по корректному завершению нитей для вилок. Т.е. сперва мы будем закрывать каналы, созданные для вилок, только потом будем вызывать join(). OK. С этим все понятно.

Далее нам нужно будет при возникновении каких-либо проблем завершить нити для философов.

И тут, если мы просто вызовем join(), мы опять наступим на те же грабли, не лежащие несколько по-другому. Дело в том, что внутри philosopher_process есть цикл, в котором выполняются вызовы receive(). Выход из receive() может произойти либо при получении ответа от вилки, либо при закрытии канала.

Но, если нити для вилок уже завершили свою работу, то вилки прислать ответ философу уже не смогут. И канал никто не закроет, т.к. каналом владеет сам philosopher_process, а run_simulation() к каналу доступа не получит.

Значит, каналы для философов мы так же должны создавать в run_simulation(), хранить их в контейнере, а потом принудительно закрывать прежде чем вызывать join() для нитей философов.

OK. Это уже шаг в верном направлении.

Допустим, что мы это сделали. Станет ли наше решение корректным?

К сожалению, нет. Т.к. внутри philosopher_process цикл с вызовами receive(). Из receive-то мы выйдем принудительно закрыв канал. А вот из цикла?

А из цикла мы не выйдем, т.к. для этого нужно увеличивать meals_eaten, а это происходит только при получении taken_t от правой вилки. Но ведь taken_t мы не получим, т.к. и вилки уже перестали работать, и наш канал уже закрыли.

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

В качестве сухого остатка повторю то, что говорил уже неоднократно: программировать многопоточность сложно. Особенно когда приходится работать с голыми нитями. Поэтому лично я предпочитаю использовать акторов, даже если это приводит к более многословным решениям. Все-таки при использовании акторов граблей немного поменьше.

вторник, 29 января 2019 г.

[prog.c++] "Modern" Dining Philosophers in C++ with Actors and CSP (part 2)

In the previous post we discussed several implementations of "dining philosophers problems" based on Actor Model. In this post I will try to tell about some implementations based on ideas from CSP. Forks, philosophers and waiter will be represented as std::thread and will communicate each other via CSP-channels only.

Source code can be found in the same repository.

CSP-based Implementations

Like in the previous post we will start from implementation of Dijkstra's solution, then we will go to simple solution with putting the first fork if an attempt to take the second fork fails (without arbiter), and then we will go to solution with waiter/arbiter. It means that we will see the same solutions like in previous post, but reimplemented without Actors. Moreover the same set of messages (e.g. take_t, taken_t, busy_t, put_t) from Actor-based implementations will be reused "as is" in CSP-based implementations.

понедельник, 28 января 2019 г.

[prog.c++] "Modern" Dining Philosophers in C++ with Actors and CSP (part 1)

Some time ago a reference to an interesting article "Modern dining philosophers" was published on resources like Reddit and HackerNews. The article discusses several implementations of well-known "dining philosophers problem". All those solutions were built using task-based approach. I think the article is worth reading. Therefore, if you have not read it yet, I recommend read the article. Especially if your impressions of C++ are based on C++03 or more earlier versions of C++.

However there was something that hampered me during the reading and studying proposed solutions.

I think it was usage of task-based parallelism. There are too many tasks created and scheduled thru various executors/serializers and it's hard to understand how those tasks are related one to another, in which order they are executed and on which context.

Anyway the task-based parallelism is not the single approach to be used to solve concurrent programming problems. There are different approaches and I wanted to investigate how a solution of "dining philosophers problem" can looks like if Actors and CSP models will be used.

To do that I implemented some solutions of "dining philosopher problem" with Actors and CSP models. Source code can be found in this repository. In this post you will find description of Actors-based implementation. In the next part I will tell about CSP-based implementations.

среда, 23 января 2019 г.

[prog] Любопытный момент при реализации решения "обедающих философов" с использованием очереди "обиженных" философов

Тема "обедающих философов" продолжает набирает плюсики в разных соцсетях, что означает необходимость выполнить свое обещание и представить решение на базе акторов с описанием. Над чем, собственно, сейчас и работаю.

Что пока удивило больше всего. Про саму задачу "обедающих философов" я знаю уже лет 25, если не больше. Даже помню, кто из преподавателей в нашем универе нам про нее на лекции впервые рассказывал. И помню, что за это время раза два мне приходилось ее реализовывать в, так скажем, иллюстративном варианте. Т.е. не находить оптимальное решение, а просто делать реализацию, которая лишена хотя бы проблемы дедлоков. А вот решать ее всерьез, чтобы устранить и дедлоки и голодания, да еще в строгом соответствии с исходной формулировкой... Вот этого не приходилось делать.

Сейчас по ходу написания реализации, которая использует арбитра и очередь "обиженных" философов (т.е. философов, которым вилка не досталась и они не смогли поесть), столкнулся с любопытным и изначально не очевидным для меня моментом.

В исходной статье, которая стала толчком для всей этой истории, реализация с арбитром и очередью называется WaiterFair (исходники этой реализации здесь). Хотя в этой реализации есть ошибка и проверяется там наличие только соседа справа.

Итак, в чем суть этой очереди и почему там нельзя проверять наличие обоих соседей?

понедельник, 21 января 2019 г.

[prog] И еще раз об обозримости task-based подхода

В докладе "Actors vs CSP vs Tasks..." на C++ CoreHard Autumn 2018 (видео тут, текстовая версия тут) я сказал, что когда код пишется с использованием task-based подхода, то обозримость у этого кода получается так себе. А несколько дней назад на Reddit-е всплыла ссылка на статью под названием "Modern dining philosophers". В которой как раз демонстрируется несколько подходов к решению известной задачи "обедающие философы". Но все эти подходы используют task-и.

Желающим проверить тезис о не очень хорошей обозримости task-based подхода очень рекомендую с данной статьей ознакомится. И составить собственное впечатление о том, насколько просто вам было разобраться с тем, на каком контексте каждая сущность выполняет свою работу. И насколько просто вам было убедиться в отсутствии проблем, связанных с многопоточностью.

А может быть кому-то, как и мне, оказалось непросто разобраться в логике представленных решений (особенно последних двух), т.к. детали алгоритма решения задачи "обедающих философов" оказались основательно перемешаны с деталями оформления отдельных операций в taks-и и диспетчеризации этих самых тасков.

В общем, сходите, почитайте статью. Она не новая, вышла в конце декабря 2018-го, ссылка на нее только недавно на глаза попалась. И не очень маленькая, полчаса времени, минимум, выделить придется. Составьте собственное впечатление. А будет желание -- поделитесь впечатлением в комментариях.

PS. Я думаю написать статью с разбором решения этой же задачи на базе SObjectizer-овских агентов. Кому интересно подобное "сравнение" (хотя это не будет чистой воды сравнением), не пожалейте времени поставить плюсадынку или лайк. Чем больше оных наберется, тем быстрее появится моя статья.

среда, 7 ноября 2018 г.

[prog.c++] SObjectizer-5.5.23 и so_5_extra-1.2.0

Мы все-таки добрались до релиза SObjectizer-5.5.23 и so_5_extra-1.2.0. Ничего нового по сравнению с тем, что описывалось ранее, в SObjectizer/so_5_extra не попало. Разве что специально удостоверились в том, что SObjectizer может собираться под Android посредством свежих Android NDK (проверялось на r18b).

Официальный анонс можно найти на странице проекта.

Свежую версию SObjectizer-а можно взять либо из секции Files, либо с GitHub-зеркала.

Свежую версию so_5_extra можно взять из секции Files (внутри архивов с именами so_5_extra-1.2.0-full уже находятся все внешние зависимости, включая SO-5, Asio и т.д.).

Пользуясь случаем хочу сказать большое спасибо всем, кто не только помог нам с этим релизом. И вообще всем, кто проявлял интерес к SObjectizer-у на протяжении всех этих лет. Ваше внимание и ваша помощь очень и очень сильно нам помогала. Большое спасибо еще раз.

Уже многократно говорил, но повторю еще раз: SO-5.5 развивается уже более четырех лет. Это большой срок, за это время SObjectizer обзавелся многими вещами, о некоторых из которых мы даже и подумать не могли в свое время. С некоторой ретроспективой интересующиеся могут ознакомиться в свежей статье на Хабре: "Четыре года развития SObjectizer-5.5. Как SObjectizer изменился за это время?"

Видимо, эволюция SO-5.5 подходит к своему логическому завершению. На ближайшее время у нас в планах:

  • подружить so_5_extra с CMake. Хотелось сделать это в рамках 1.2.0, но CMake в очередной раз порадовал своей простотой и понятностью. Пришлось отложить;
  • подружить so_5_extra с Boost.Asio. Сейчас so_5_extra работает только со standalone версией Asio, надо бы поддержать еще и Boost.Asio, как мы это сделали в RESTinio в свое время;
  • добавить в so_5_extra возможности для тестирования агентов. Что-то вроде инструментария для упрощения написания unit-тестов для агентов (с использованием агентов).

По поводу последнего пункта пока много непонятностей. Вероятно, для поддержки тестирования агентов потребуется сделать еще и SO-5.5.24. Будем посмотреть. Но вообще мы уже смотрим в сторону SObjectizer-5.6, где мы выбросим накопившийся в SO-5.5 старый хлам и перейдем на C++14.

В общем, работы полно. Если у кого-то есть хотелки/пожелания -- высказывайте, будем рассматривать их самым внимательным образом и, по возможности, воплощать в жизнь.

Ну а если кто-то найдет возможным поделиться в Интернетах своим опытом работы с SObjectizer-ом, то это будет просто неоценимое подспорье для нас. Нам очень не хватает публично доступных success stories. А предоставить их можете только вы. Так что если кто-то может или хочет сказать в наш адрес пару добрых слов, то самое время сделать это ;) Подробности можно обсудить по почте (eao197 на gmail точка com).

В общем, еще раз спасибо. Пробуйте SObjectizer, делитесь своими впечатлениями, высказывайте нам свои замечания. Вместе мы сделаем SObjectizer лучше. Достаточно просто посмотреть на то, что уже было сделано.

воскресенье, 4 ноября 2018 г.

[prog.c++] Кратко про C++ CoreHard Autumn 2018 (+слайды моего доклада)

Вчера с краткосрочным визитом посетил наш славный Минск. Целью визита стало посещение очередной конференции по языку C++: CoreHard Autumn 2018. В том числе и в качестве докладчика.

Конференцией был впечатлен. Порядка 300 участников, от вида полностью заполненного зала на вступительном докладе захватывало дух. Организаторы большие молодцы, за проведение столь масштабного мероприятия им огромное спасибо! Если события продолжат развиваться такими темпами, то через пару лет C++ CoreHard может сравняться с C++Russia по масштабам и значимости.

Свое выступление мне сложно оценить. Были технические заминки перед его началом, поэтому, чтобы уложиться в регламент, выдавал материал в высоком темпе. Но, вроде бы, зашло хорошо. Зрителей было даже больше, чем я ожидал, особенно с учетом того, что параллельно со мной шло еще два очень интересных доклада. Поэтому отдельное спасибо слушателям, которые пришли послушать меня.

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

А вот она же на SlideShare.


Так получилось, что в 2017 я прочел четыре разных доклада, и в этом, 2018-ом году, так же состоялось четыре разных доклада. Чувствую, что это перебор. С подготовкой доклада к этому CoreHard-у уже возникли сложности. Посему нужно будет подумать, стоит ли в следующем году заявляться на конференции так часто... Тем не менее, если кому-то интересно послушать о том, что мы делаем и для чего мы делаем, то я бы с удовольствием выступил бы перед заинтересованной аудиторией (с расширенной версией доклада, который я делал на митапе в Питере).

пятница, 2 ноября 2018 г.

[prog.memories] Беглый взгляд на эволюцию SObjectizer-5.5 за прошедшие четыре года

Первый релиз SObjectizer-а в рамках ветки 5.5 состоялся чуть больше 4-х лет назад, в начале октября 2014-го. На следующей неделе планируется релиз версии 5.5.23, которая может стать финальной в рамках ветки 5.5.

Поэтому поводу есть желание написать статью для Хабра, в которой будет сделан обзор того, что появилось в SO-5.5 за это время и как это все повлияло на сам SObjectizer, и на разработку с его использованием. По ходу подготовки этой статьи сделал небольшой конспектик изменений. И сам слегка прифигел. Привожу его в текущем, еще не обработанном виде.

Хрен знает, зачем я это делаю. Может чтобы похвастаться. Может для того, чтобы те горячие головы, которые думают, что они быстренько слепят на коленке свой акторный фреймворк вместо того, чтобы взять что-то из существующего, посмотрели и задумались: а оно того стоит?

Не стоит. Берите лучше то, что есть. Не нравится вам SObjectizer -- возьмите что-нибудь другое. Тот же CAF или QP/C++. Выбор есть. Полагаю, этот выбор будет всяко лучше повторения хотя бы части пути, который мы уже прошли. И, прошу не забывать, что речь идет не только о том, чтобы придумать и запрограммировать. Но и о том, чтобы отладить, задокументировать и донести ваше творение до других людей. Которые, возможно, думают, что лучше они сами что-нибудь на коленке слепят.

Итак, вот список с ссылками на соответствующие разделы документации. Список не полный, включал в него только самые знаковые изменения/нововведения. Этот список еще предстоит переосмыслить, отранжировать и преобразовать в статью. Но, надеюсь, общее впечатление можно составить.

Да, и в этом списке нет того, что вошло в состав so_5_extra.

среда, 31 октября 2018 г.

[prog.c++] Вторая бета-версия SObjectizer-5.5.23 и so_5_extra-1.2.0

Зафиксирована вторая бета-версия для SObjectizer-5.5.23 и so_5_extra-1.2.0. Загрузить их можно отсюда: so-5.5.23-beta2.zip и so_5_extra-1.2.0-beta2.zip (либо so_5_extra-1.2.0-beta2-full.zip).

Был исправлен просчет, допущенный при подготовке первой версии: нововведение, конверты с сообщениями, не дружили с фильтрами доставки (посыпаю голову пеплом, тупо забыл про интеграцию с фильтрами доставки). Сейчас это исправлено. Но при этом поменялся интерфейс класса envelope_t. Теперь в нем вместо двух hook-методов всего один: access_hook()

virtual void access_hook(
   access_context_t context,
   handler_invoker_t & invoker) noexcept = 0;

Метод access_hook() вызывается всегда, когда нужно получить доступ к содержимому конверта. Если конверт готов предоставить доступ, то конверт должен вызвать invoker.invoke() и передать туда ссылку на содержимое (тут все осталось как и прежде).

А вот контекст, в котором вызывается access_hook(), теперь определяется перечислением access_context_t. На данный момент в нем определены следующие варианты: handler_found (содержимое конверта нужно для вызова обработчика сообщения), transformation (содержимое конверта должно быть преобразовано в другое представление, например, в результате limit_then_transform) и inspection (содержимое конверта должно быть проанализировано, например, фильтром доставки). Со временем, возможно, список вариантов будет расширен.

Собственно, это главные изменения в so-5.5.23-beta2. Соответствующим образом были изменены нужные части в so_5_extra-1.2.0 и обновлена документация в Wiki проекта.

По срокам окончательного релиза so-5.5.23 и so_5_extra-1.2.0 прогноз пока такой же: первая декада ноября. Т.е., скорее всего, на следующей неделе. На этой вряд ли получится закрыть оставшиеся вопросы и выкатить релиз без суеты и спешки.

пятница, 19 октября 2018 г.

[prog.c++] Стали доступны первые бета-версии SObjectizer-5.5.23 и so_5_extra-1.2.0

Сегодня были зафиксированы первые бета-версии наших проектов SObjectizer и so_5_extra. Загрузить их можно отсюда: so-5.5.23-beta1.zip и so_5_extra-1.2.0-beta1.zip (либо so_5_extra-1.2.0-beta1-full.zip).

Подробнее об нововведениях рассказывается в очередной статье на Хабре.

Со сроками официально релиза пока так: ориентировочно релиз состоится в первой декаде ноября. Если успеем раньше, выкатим раньше. Но там еще много работы, в том числе и по документированию, и по проверке сборки под Android с помощью Google-овского NDK и еще разных мелочей (и не мелочей). Так что первая декада ноября выглядит более реалистично.

В общем, если кому-то интересно, что в SObjectizer-е происходит, то смотрим, делимся впечатлениями и соображениями. Пока еще есть время и возможность повлиять на то, что попадет в SO-5.5.23 и so_5_extra-1.2.0.

вторник, 16 октября 2018 г.

[prog.c++.sobjectizer] Сбылась мечта идиота: можно сделать отчеты о доставке сообщения до получателя.

Версии SO-5.5.23 и so_5_extra-1.2.0 уже начинают дышать полной грудью. В SO-5.5.23 был реализован новый механизм, который позволяет вкладывать сообщение в некий "конверт". Внутри SObjectizer-а доставка идет уже для всего конверта с вложенным в него сообщением. Сообщение из конверта достается либо когда сообщение доставлено до получателя. Либо когда сообщение по какой-то причине преобразуется из одного представления в другое (например, так происходит в случае использования limit_then_transform). Причем под "доставлено до получателя" означает не только то, что получатель извлек сообщение из очереди, но и то, что у получателя был найден обработчик для этого типа сообщения. Т.е. сообщение реально доставлено, а не просто взято из очереди.

На базе этого механизма в so_5_extra-1.2.0 добавлены средства для реализации как гарантированно отзывных таймеров, так и просто для реализации отзывных сообщений. Для отзывных сообщений, кстати говоря, сразу же придумываются сценарии, в которых их можно использовать. Так, что, наверное, эта штука может быть востребована.

Ну а в качестве примера создания собственных "конвертов" в состав so_5_extra включена самая примитивна реализация такой прикольной штуки, как отчеты о доставке отосланных сообщений до получателя.

Эти самые отчеты о доставке -- это идея фикс, которая витала в воздухе очень и очень давно. Внимание она привлекает потому, что когда агент A отсылает сообщение агенту B, то далеко не факт, что сообщение до агента B вообще дойдет. Например, сообщение может быть отвергнуто механизмом защиты агента от перегрузки (например, limit_then_drop). И временами хотелось бы знать, сообщение до B не дошло или все-таки дошло. Но вот узнать это не представлялось возможным.

Теперь же можно сделать собственный "конверт", в который будет вкладываться сообщение для B. И если конверт до B дойдет, значит и сообщение дошло. И простейшая реализация такого "конверта" включена в новый пример для so_5_extra. Исходный текст этого примера под катом, интересующиеся могут посмотреть.

вторник, 18 сентября 2018 г.

[prog.c++] Let's talk about hierarchical finite state machines and their support in SObjectizer-5.5

Finite state machine is a probably one of most basic and widespread thing in software development. Finite state machines (FSM) are actively used in many areas. For example in such niches as SCADA- and telecom systems FSM are used almost everywhere.

In this article we will try to speak about hierarchical FSM. And then we will try to take a look at FSM's support in SObjectizer-5. SObjectizer is one of a few OpenSource and live "actor" frameworks for C++ and actors in SObjectizer are FSMs. We will speak why SObjectizer's actors are FSMs and which capabilities they have.

A Brief Introduction Into Finite State Machines

It is hard to explain in a shot article such big topics as automata theory in general and finite state machines in particular. Because of that an basic understanding of these topics are required from a reader.

Advanced Finite State Machines And Their Features

There are several "advanced features" of FSM which significantly simplify usage of FSM. Let's talk about them briefly.

Disclaimer: if a reader has a good knowledge of UML's statechart diagrams then he or she doesn't find anything new here.

понедельник, 10 сентября 2018 г.

[prog.c++] Видео с митапа в Питере

Стало доступно видео моего выступления на митапе St. Petersburg C++ User Group с докладом "Акторы в C++: взгляд старого практикующего актородела":

Презентацию можно скачать в виде PDF-ки отсюда, либо же просмотреть на SlideShare или на Google Docs.

В видеозапись не вошли вопросы, которые задавали после доклада. Поэтому если кто-то что-то хочет спросить, то это можно сделать в комментариях здесь.

PS. Так же можно договорится, чтобы я подъехал в офис вашей компании и сделал подобный, но более подробный, доклад про SObjectizer.