Max Device terribly slow inside Live

i'm not sure if i understand your approach.

actually i don't connect just two things. i connect every node with every node....

though a routing in graph G1:
1=>2
2=>1

is forbidden and you could say routing 2=>1 is not needed, a routing for graph G2:
1=>3
2=>1

is indeed possible... so the routing 2=>1 is required in generall, although in the specific graph G1 it is not used.

you see, i do not build the routings depending on the graph. j could do this by creating max objects and connect them but that is a different aproach. i have a static max routing that can be configured to realize any graph possible.

maybe i'm too lost in my current asap-design to understand how your graph setup above shall work maybe give me a little hint. how are the matrixes connected? how do you enable/disable a particular routing?

i will describe in detail how it works currently:

in my approach there is a input matrix [11, 1] that mixes all inputs together. then i have a vst plugin that gets fed by the input matrix. then it goes to an output matrix [1, 11] that can send to any output(s).these two matrix~ exist for every channel. confguring is done by manipulating the input and the output matrix of every channel.

that could be put to pseudo code ala

perChannel: receive~[n] -> matrix~[11, 1] -> vst~ -> matrix[1, 11] -> send~[n]

so the routings in graph G3:
0=>1
1=>2
2=>0

is done by setting
c[1].InputMatrix = [1,0,0]
c[1].OutputMatrix= [0,0,1]
c[2].InputMatrix=[0,1,0]
c[2].OutputMatrix=[1,0,0]

the main input/output c[0] is treated specially though the iomatrix for c0 is
c[0].InputMatrix=[0,0,1]
c[2].OutputMatrix=[0,1,0]

the trick is just that c[0].Output[0] is connected to the main output Co0 rather than to the internal routing C0. Corresponding to that the input[0] of c[0] does not get it's signal from the internal routing C0 but from the main input Ci0.

so in the above matrix the signal flows like:
Ci0=>C1=>C2=>C0->Co0

that thing with the special handling of the first dot in the matrix is quite confusing... but to realize what happens, see that setting the first dot in the matrixctrl (top left) does not result in a feedback loop but just maps main input to main output directly. so

enabled[x,x] = x== 0

this is a static rule for the matrix. the rest of the enabled states for
enabled[x,y] where x!= y
is done dynamically depending on the setting of the other dots.

this is done in this patcher which exist for every channel. so in my current patch which supports 11 channels the patcher exists 11 times. the main in/out handling is done by [p ReceiveMain] p[MainOutOut]

ps: here is the method Matrix.GetFeedbackLoops

      internal IEnumerable<int[]> GetFeedbackLoops(int aColumn, int aRow)
      {
         var aFeedbackLoops = new List<int[]>();
         foreach (var aCurrRow in Enumerable.Range(0, this.IoCount))
         {
            this.GetFeedbackLoops(aColumn, aRow, aCurrRow, 
                new List<int>(), aFeedbackLoops);
         }
         return aFeedbackLoops.ToArray();
      }

     private void GetFeedbackLoops(int aColumn,
                                   int aRow, 
                                   int aCurrRow, 
                                   List<int> aPath, 
                                   List<int[]> aFeedbackLoops
                                   )
      {
         foreach (var aCurrCol in Enumerable.Range(0, this.IoCount))
         {
            if (aCurrCol == 0)
            {
               // out[0] is main out.
               // => Mapping to out[0] always possible. 
            }
            else if ((aRow == aCurrRow && aCurrCol == aColumn)
            || this[aCurrCol, aCurrRow])
            {
               if (aPath.Contains(aCurrCol))
               {
                  aFeedbackLoops.Add(aPath.ToArray());
               }
               else
               {
                  aPath.Add(aCurrCol);
                  this.GetFeedbackLoops(aColumn, 
                                        aRow, 
                                        aCurrCol, 
                                        aPath, 
                                        aFeedbackLoops);
                  aPath.RemoveAt(aPath.Count - 1);
               }
            }
         }
      }