public RingTopology(ClusterType clusterType, List <ConnectionItem> connectionRule, int iter = 100)
{
//generate clusters
ConnectionRule = connectionRule;
Clusters = new List <AbstractCluster>();
int processorsCount = 0,
currentCluster = 0;
while (processorsCount < iter)
{
AbstractCluster cluster = new AbstractCluster(currentCluster++, clusterType);
Clusters.Add(cluster);
processorsCount += cluster.NodesCount;
}
//create globalMatrix
GlobalMatrix = new int[processorsCount, processorsCount];
var clustersLocalMatrix = Clusters[0].LocalMatrix;
ClustersProcessorsCount = Clusters[0].NodesCount;
//set matrix diagonal
for (int i = 0; i < clustersLocalMatrix.GetLength(0); i++)
{
for (int j = 0; j < clustersLocalMatrix.GetLength(1); j++)
{
for (int k = 0; k < Clusters.Count; k++)
{
if (clustersLocalMatrix[i, j] == 1)
{
GlobalMatrix[i + k * ClustersProcessorsCount, j + k * ClustersProcessorsCount] =
clustersLocalMatrix[i, j];
}
}
}
}
//set matrix by rule
//go through clusters from 2nd
for (var i = 1; i < Clusters.Count; i++)
{
ConnectClustersByRule(i - 1, i);
}
//make ring
if (Clusters.Count > 1)
{
ConnectClustersByRule(Clusters.Count - 1, 0);
}
}
public TreeTopology(ClusterType clusterType, List <ConnectionItem> connectionRuleCrossLevels,
List <ConnectionItem> connectionRuleInnerLevel, List <ConnectionItem> connectionRuleInnerSide, int levels = 100)
{
//generate clusters
ConnectionRuleCrossLevels = connectionRuleCrossLevels;
ConnectionRuleInnerLevel = connectionRuleInnerLevel;
ConnectionRuleInnerSide = connectionRuleInnerSide;
Clusters = new List <AbstractCluster>();
int processorsCount = 0,
currentCluster = 0;
int rank = Libraries.ClusterMatrices[clusterType].GetLength(0);
var clusters = Math.Pow(2, levels) - 1;
var clustersWithotLastLevel = Math.Pow(2, levels - 1) - 1;
while (processorsCount < rank * clusters)
{
AbstractCluster cluster = new AbstractCluster(currentCluster++, clusterType);
Clusters.Add(cluster);
processorsCount += cluster.NodesCount;
}
processors = processorsCount;
//create globalMatrix
GlobalMatrix = new int[processorsCount, processorsCount];
var clustersLocalMatrix = Clusters[0].LocalMatrix;
ClustersProcessorsCount = Clusters[0].NodesCount;
//set matrix diagonal
for (int i = 0; i < clustersLocalMatrix.GetLength(0); i++)
{
for (int j = 0; j < clustersLocalMatrix.GetLength(1); j++)
{
for (int k = 0; k < Clusters.Count; k++)
{
if (clustersLocalMatrix[i, j] == 1)
{
GlobalMatrix[i + k * ClustersProcessorsCount, j + k * ClustersProcessorsCount] =
clustersLocalMatrix[i, j];
}
}
}
}
if (Clusters.Count > 1)
{
//levels
for (var i = 0; i < clustersWithotLastLevel; i++)
{
ConnectClustersByRule(2 * i + 1, i, ConnectionRuleCrossLevels);
ConnectClustersByRule(2 * i + 2, i, ConnectionRuleCrossLevels);
}
//innerlevel
var start = 0;
var last = 1;
for (var i = 1; i < levels; i++)
{
start += (int)Math.Pow(2, i - 1);
last += (int)Math.Pow(2, i);
for (var j = start; j < last - 1; j++)
{
ConnectClustersByRule(j + 1, j, ConnectionRuleInnerLevel);
//innerSide
if (j % 2 == 1)
{
ConnectClustersByRule(j + 1, j, ConnectionRuleInnerSide);
}
}
}
}
}
public MeshTopology(ClusterType clusterType, List <ConnectionItem> connectionRuleRowInner,
List <ConnectionItem> connectionRuleRowOuter, List <ConnectionItem> connectionRuleColInner,
List <ConnectionItem> connectionRuleColOuter, int iter = 100)
{
//generate clusters
ConnectionRuleRowInner = connectionRuleRowInner;
ConnectionRuleRowOuter = connectionRuleRowOuter;
ConnectionRuleColInner = connectionRuleColInner;
ConnectionRuleColOuter = connectionRuleColOuter;
Clusters = new List <AbstractCluster>();
int processorsCount = 0,
currentCluster = 0;
int rank = Libraries.ClusterMatrices[clusterType].GetLength(0);
while (processorsCount < rank * iter * iter)
{
AbstractCluster cluster = new AbstractCluster(currentCluster++, clusterType);
Clusters.Add(cluster);
processorsCount += cluster.NodesCount;
}
//create globalMatrix
GlobalMatrix = new int[processorsCount, processorsCount];
var clustersLocalMatrix = Clusters[0].LocalMatrix;
ClustersProcessorsCount = Clusters[0].NodesCount;
//set matrix diagonal
for (int i = 0; i < clustersLocalMatrix.GetLength(0); i++)
{
for (int j = 0; j < clustersLocalMatrix.GetLength(1); j++)
{
for (int k = 0; k < Clusters.Count; k++)
{
if (clustersLocalMatrix[i, j] == 1)
{
GlobalMatrix[i + k * ClustersProcessorsCount, j + k * ClustersProcessorsCount] =
clustersLocalMatrix[i, j];
}
}
}
}
if (Clusters.Count > 1)
{
//Row
for (int i = 1; i < iter + 1; i++)
{
for (int j = 1; j < iter; j++)
{
var item1 = iter * (i - 1) + (j - 1);
var item2 = iter * (i - 1) + (j);
ConnectClustersByRule((item2), (item1), ConnectionRuleRowInner);
}
var item3 = iter * (i - 1) + (iter - 1);
var item4 = iter * (i - 1) + (0);
ConnectClustersByRule((item3), (item4), ConnectionRuleRowOuter);
}
//Col
for (int i = 1; i < iter; i++)
{
for (int j = 1; j < iter + 1; j++)
{
ConnectClustersByRule(iter * (i) + (j - 1), iter * (i - 1) + (j - 1), ConnectionRuleColInner);
}
ConnectClustersByRule(iter * (iter - 1) + (i - 1), (i - 1), ConnectionRuleColOuter);
}
}
}
