Здравствуйте, C.A.B, Вы писали:

CAB>Он знает.
По-моему, это — очень плохая идея.

S>>Вот у меня есть блок типа A, который генерирует -1 в степени N.
S>>Если я подключаю на вход к блоку C два идентичных блока A1 и A2, то ожидаю, что C выдаст на выходе 2*(-1)^N.
S>>Того же самого я ожидаю, подключая к обоим входам блока С блок A1.

CAB>Попробую объяснить на псевдокоде:
CAB>A a1 = new A()
CAB>A a2 = new A()
CAB>B b = new B()
CAB>C c = new C()
CAB>P printer = new P()


CAB>a1 ~> c //Блоки 'a1', 'a2' генерирующие [1, -1, 1, -1], будут подключены с входу 'Stream<Int> in' (т.е. к входу с совместимым типом) блока 'c',
CAB>a2 ~> c ~> printer //выход блока 'c' будет подключен к 'printer'.
CAB> //Все четыре блока работают асинхронно, например:
CAB> // 1. Блок 'a1' получает первым свой квант процессорного времени и отправляет сразу все четыре значения.
CAB> // 2. Которые попадают в первую очередь в блок 'c' (streamBuf выглядит как [1,-1,1,-1],[]]), 'c' не отправляет ничего на выход так как вторая очередь пуста.
CAB> // 3. Блок 'a2' выполняется затем и успевает отправить только 2 значения из 4-х.
CAB> // 4. Каждый раз при получении нового значения от 'a2', 'c' ставит его в очередь (streamBuf = [1,-1,1,-1],[1]]) и так как нет пустых очередей
CAB> // забирает по одному элементу из каждой, выполняет операцию, и отправляет результат на свой выход.
CAB> // 5. Таким образом после обработки 2-х сообщений от 'a2': streamBuf = [1,-1],[]], блоком 'printer' будет выведено: "2", "-2".
CAB> // 6. Соответсвенно по получении оставшихся 2-х сообщений от 'a2': streamBuf = [[],[]], блоком 'printer' будет выведено: "2", "-2", "2", "-2".
CAB> //PS: Такой прикольный синтаксис можно сделать в Scala, но в целом это примерно эквивалентно:
CAB> // a1.out.connectTo(c.in)
CAB> // a2.out.connectTo(c.in)
CAB> // c.out.connectTo(printer.in)

CAB>a1 ~> c //Для блока 'b' генерирующего константу, всё примерно так-же, роме того что он будет подключен к входу 'Unitary<Int> in' с отличной логикой обработки значений.
CAB>b ~> c ~> printer //Например:
CAB> // 1. Блок 'a1' опять выполняется первым и отправляет сразу все четыре значения.
CAB> // 2. streamBuf = [1,-1,1,-1]], unitaryBuf = [None]
CAB> // 3. Блок 'b' выполняется и посылает своё единственное значение: streamBuf = [1,-1,1,-1]], unitaryBuf = [Some(2)]
CAB> // 4. Блок 'c' выполняет операцию сложения для всех значений в очереди и отправляет полученные значения на выход.
CAB> // 5. Блок 'printer' выводит: "3", "1", "3", "1".
CAB>[/java]

CAB>Как то так
Вот смотрите.
1. В "традиционной" системе у нас есть блок типа C. Ему не надо вот эти 30 строк трудноотлаживаемой машинерии; вся его логика сводится к
Int Output1 { return Input1.GetValue() + Input2.GetValue()}
2. Что вы собираетесь делать с блоками, генерирующими бесконечные последовательности? У вас блок а1 собрался оптом запихать сразу всё. Если ему дать это сделать, то он напрочь забьёт очередь блока C, не дав шанса блоку а2.
3. По-прежнему не раскрыт вопрос о том, что делать с двукратным подключением блока a1 к блоку с. Оно вообще поддерживается?
4. Что делать со starvation? Где гарантия, что блок a2 вообще хоть когда-то получит свой квант процессорного времени?