Параллелизм без потоков: очевидно и вероятно

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

Статья о GIL и его поведении. Поинт автора был в том, что даже атомарная операция тип +=, казалось бы исполняемая в одном цикле блокировки GIL все равно не атомарная и без синхронизации мютексом не обойтись, как могло бы показаться неопытным разработчикам. В общем, как то так, а не вот так, как у вас. К сожалению, гора родила мышь.

Поскольку у вас и ссылка на исходную статью битая, позволю себе: https://habr.com/ru/amp/publications/764420/

Если ваша ВКП за окошками не использует потоки или процессы - это не параллельное программирование, а в лучшем случае конкурентное, если же использует - вы наглый обманщик :)

"Крайняя статья". Даль и Ожегов в гробу перевернулись.

Окошки напоминают Windows, Windows система многопоточная, скорее всего запущена на многоядерном проце, вряд ли у вас Pentium 1. Что такое ВКП и почему оно без потоков?

Уважаемый Вячеслав, у Вас есть удивительнейшая способность изложить материал так, что полёт мысли будет понятен очень немногим.

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

Если хочется эзотерики, её тоже есть у меня. Возьмём LabVIEW, нарисуем два параллельных for цикла, инкрементирующих одну и ту же переменную по тысяче раз:

Это классическое состояние гонки (race condition), мы не можем сказать в какой момент произойдёт чтение и запись, циклы не синхронизированы, результат выполнения на выходе неопределён, будет где-то между 1000 и 2000 (типичная ошибка, которую почти все новички делают, кстати).

Что мы можем сделать - добавить семафор, блокируюший критическую секцию:

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

Если нужно получить 1000, можно воспользоваться рандеву, тогда будет так (этот паттерн редко используется, но тем не менее):

Теперь я торможу оба цикла перед записью и мне уже без разницы, отработает один или оба - они теперь синхронизированы и результат на выходе будет строго 1000.

Теоретически можно и автоматы можно навесить с синхронизацией переходов, но зачем?

В случае ПЛК есть своя специфика - там жёсткий реалтайм и циклическое выполнение кода, где происходит чтение переменных/работа с ними/запись, хотя и там можно состояние гонки сделать, если очень захотеть, а можно действительно сделать "потокобезопасный" код без использования общепринятых методик.

Операции CAS в Питоне возможны?

Вот что получается у меня. Но сначала схема триггера и описание ее работы из книги Фрике:

Схема триггера

Выдержки из нее:

Описание работы триггера по Фрике

В своей статье я доказываю это по другому, но в целом формальные результаты совпадают.

А вот что получилось реально в ВКПа

Триггер в ВКПа

Здесь два варианта. Верхний - триггер с нулевой задержкой элементов. Следующий - с задержками (у меня по 5 тактов дискретного времени на переходах в 0 и 1. Задержки транспортные. С задержками видно, что триггер при переключении проходит через запрещенное состояние выходов - 00 (см. также выше граф автомата Фрике). У Вас, похоже, переключение элементов проходит мгновенно.

Обратим внимание на "хвост" осциллограмм: триггер входит в режим генерации (см. также Фрике). Попыток "отсечь" ошибочную комбинацию на входах нет, как ее нет и в схеме триггера.

Да. До самой левой "отсекающей линии" - это установка триггера в такое же исходное состояние, как и у Вас.

...Старею, наверное.

Да... Но от этого страховки нет :( Но в процессе, ведь, что-то и приобретается... Тот же опыт... Так что не все так печально ;) Но... продолжим.

Вы приблизились к идеалу. Тут, как говорится, мастерство не пропьешь. Но вопросы еще остались. Во-первых, все же хотелось видеть решение, которое структурно как "почти как в учебнике". А еще лучше чтобы просто "как в учебнике". Что-то похожее было возникло (см. выше), но потом ушло... Из последней схемы, как я понял, есть "обвес", который и реализует обратные связи. И все было бы хорошо, если бы его можно было спрятать и рисовать схемы "как в учебнике",

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

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

Давайте проверим Ваш "обвес", добавив в решение еще один процесс (см. выше про еще один элемент ИЛИ-НЕ). Мне бы хотелось на это посмотреть (хотелось бы, чтобы это было интересно и Вам). Во-первых, можно увидеть насколько это просто, во-вторых, будет ли при этом желаемый результат. А каким он должен быть известно. По крайней мере, - мне :)

Не, этот элемент (Build Array) к триггеру не имеет отношения, он просто собирает пять битов (два входных, два выходных и ИЛИ-НЕ) в массив, который потом конвертируется для отображения на цифровом графике. Если его убрать, то триггер работать не перестанет, просто мы графика лишимся.

Длительность импульса - просто один такт. Тут крутится for цикл, никакого другого тактового генератора здесь нет. Мне проще на Си показать, вот практически полностью эквивалентный код (длины массивов я захардкодил, мы ж не в продакшене):

#include <ansi_c.h>
#include <stdbool.h>

BOOL RS_Trigg (BOOL S, BOOL R, BOOL *Q, BOOL *_Q)
{
	static BOOL q = false;
	static BOOL _q = true;
	BOOL s = !(q || S);
	BOOL r = !(_q || R);
	*_Q = _q = s;
	*Q = q = r;
	return !(q || _q);
}

void main (int argc, char *argv[])
{
	int s[12] = {0,1,0,0,0,1,0,0,0,0,0,0};
	int r[12] = {0,0,0,1,0,1,0,0,0,0,1,0};
	BOOL S[72], R[72], Q[72], OrNot[72], notQ[72];
	
	for (int i = 0; i < 12; i++){
		for(int j = 0; j < 6; j++){
			S[i * 6 + j] = (BOOL)s[i];
			R[i * 6 + j] = (BOOL)r[i];
		}
	}
		
	for (int i = 0;  i < 72; i++) OrNot[i] = RS_Trigg(S[i], R[i], &Q[i], &notQ[i]);
	
	printf("\n     S:"); for (int i = 0;  i < 72; i++) printf("%d", S[i]);
	printf("\n     R:"); for (int i = 0;  i < 72; i++) printf("%d", R[i]);
	printf("\n     Q:"); for (int i = 0;  i < 72; i++) printf("%d", Q[i]);
	printf("\n  NotQ:"); for (int i = 0;  i < 72; i++) printf("%d", notQ[i]);
	printf("\n OrNot:"); for (int i = 0;  i < 72; i++) printf("%d", OrNot[i]);
}

Ну а результат:

     S:000000111111000000000000000000111111000000000000000000000000000000000000
     R:000000000000000000111111000000111111000000000000000000000000111111000000
     Q:000000011111111111000000000000000000101010101010101010101010000000000000
  NotQ:111111000000000000011111111111000000101010101010101010101010111111111111
 OrNot:000000100000000000100000000000111111010101010101010101010101000000000000

Это ровно то, что на графике выше изображено.

Вообще LabVIEW нынче бесплатна для некоммерческого использования в виде Community Edition, а по всем вопросам можно на форум LabVIEW Portal обращаться - там очень доброжелательные ребята и всем охотно помогают, я тоже там бываю.

...но хочу поблагодарить за приятное и конструктивное общение, спасибо!

И Вам... большое спасибо!

Добавлю еще немного блочного state-конструктива :) Это пример того, как, имея только один блок - типа ИЛИ-НЕ, можно создать уже любую схему - RS-триггер и т.п.

#include <QCoreApplication>
#include <stdbool.h>
static int aState[3] = {0,0,0};
static int aTmpState[3] = {0,0,0};
void OR_Not (int nState[], int nTmpState[], bool x1, bool x2)
{
    if (*nState==0 && !x1&&!x2) { *nTmpState = 1; }
    else if (*nState==1 && x1) { *nTmpState = 0; }
    else if (*nState==1 && x2) { *nTmpState = 0; }
}
void CopyState () { for (int i=0; i<3; i++) { aState[i] = aTmpState[i]; } }

void RS_Trigg (bool S, bool R)
{
    OR_Not (&aState[0], &aTmpState[0], S, aState[1]);
    OR_Not (&aState[1], &aTmpState[1], aState[0], R);
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    int s[14] = {1,0, 0,1,0,0,0,1,0,0,0,0,0,0};
    int r[14] = {1,1, 0,0,0,1,0,1,0,0,0,0,1,0};
    bool S[70], R[70], Q[70], OrNot[70], notQ[70];

    for (int i = 0; i < 14; i++){
        for(int j = 0; j < 5; j++){
            S[i * 5 + j] = (bool)s[i];
            R[i * 5 + j] = (bool)r[i];
        }
    }
    for (int i = 0; i < 14; i++){
        for(int j = 0; j < 5; j++){
            Q[i * 5 + j] = 0;
            OrNot[i * 5 + j] = 0;
            notQ[i * 5 + j] = 0;
        }
    }
    for (int i = 0;  i < 70; i++) {
        RS_Trigg(S[i], R[i]);
        OR_Not (&aState[2], &aTmpState[2], aState[0], aState[1]);
        Q[i] = aState[1];
        notQ[i] = aState[0];
        OrNot[i] = aState[2];
        CopyState();
    }
    printf("\n     S:"); for (int i = 0;  i < 70; i++) printf("%d", S[i]);
    printf("\n     R:"); for (int i = 0;  i < 70; i++) printf("%d", R[i]);
    printf("\n     Q:"); for (int i = 0;  i < 70; i++) printf("%d", Q[i]);
    printf("\n  NotQ:"); for (int i = 0;  i < 70; i++) printf("%d", notQ[i]);
    printf("\n OrNot:"); for (int i = 0;  i < 70; i++) printf("%d", OrNot[i]);
    printf("\n");
    return a.exec();
}

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

Соответственно смотрим на результат работы

Результаты работы

После прочтения этой статьи понял анекдот про программистов))

Летят Холмс с Ватсоном на воздушном шаре. И спят в полете. Просыпаются
над какой-то незнакомой землей, видят - внизу какой-то хрен коров пасет.
Снизились они и спрашивают мужика:
- Скажите, сэр, где мы находимся?
- На воздушном шаре.
- Спасибо, сэр! - и летят вверх. Холмс задумчиво говорит:
- Интересная местность, Ватсон! Программист пасет коров!
- Холмс, а с чего вы взяли, что он программист?
- Это элементарно! Во-первых, он долго думал над ответом. Во-вторых, его
ответ был абсолютно точен. И в третьих - абсолютно бесполезен!