From 8bc14514d5dae672f92087fbd33d89d9e54aa13d Mon Sep 17 00:00:00 2001
From: Benjamin Drung <benjamin.drung@cloud.ionos.com>
Date: Wed, 11 Nov 2020 10:43:35 +0100
Subject: Fix spelling error of tuple
Signed-off-by: Benjamin Drung <benjamin.drung@cloud.ionos.com>
---
ibdm/ibdm/FatTree.cpp | 170 +++++++++++++++++++++---------------------
1 file changed, 85 insertions(+), 85 deletions(-)
diff --git a/ibdm/ibdm/FatTree.cpp b/ibdm/ibdm/FatTree.cpp
index b61e5ca..678caff 100644
--- a/ibdm/ibdm/FatTree.cpp
+++ b/ibdm/ibdm/FatTree.cpp
@@ -51,16 +51,16 @@ FatTree Utilities:
// highest value.
//
// The algorithm BFS from an arbitrary leaf switch.
-// It then allocates ID tupples to each switch ID[0..N].
+// It then allocates ID tuples to each switch ID[0..N].
// Only one digit of the ID is allowed to change when going from
// switch node to the other.
//
// We use the term "index" when we refer to
-// The digit indexed 0 ID[0] in the tupple is the rank number.
+// The digit indexed 0 ID[0] in the tuple is the rank number.
// Going down the tree the digit that might change is D[from->rank+1]
// Going up the tee the digit that might change is D[from->rank]
//
-// During the BFS each node is assigned a tupple the first time it is
+// During the BFS each node is assigned a tuple the first time it is
// visited. During the BFS we also collect the list of ports that connect to
// each value of the changing D.
//
@@ -69,8 +69,8 @@ FatTree Utilities:
// number of sub hierarchy indexes with the exact same number of ports
//
-// for comparing tupples
-struct FatTreeTuppleLess : public binary_function <vec_byte, vec_byte, bool> {
+// for comparing tuples
+struct FatTreeTupleLess : public binary_function <vec_byte, vec_byte, bool> {
bool operator()(const vec_byte& x, const vec_byte& y) const {
if (x.size() > y.size()) return false;
if (y.size() > x.size()) return true;
@@ -166,15 +166,15 @@ bool FatTreeNode::goingDown(int lid)
return false;
}
-typedef map< vec_byte, class FatTreeNode, FatTreeTuppleLess > map_tupple_ftnode;
+typedef map< vec_byte, class FatTreeNode, FatTreeTupleLess > map_tuple_ftnode;
class FatTree {
- // the node tupple is built out of the following:
+ // the node tuple is built out of the following:
// d[0] = rank
// d[1..N-1] = ID digits
IBFabric *p_fabric; // The fabric we attach to
- map_pnode_vec_byte TuppleByNode;
- map_tupple_ftnode NodeByTupple;
+ map_pnode_vec_byte TupleByNode;
+ map_tuple_ftnode NodeByTuple;
vec_int LidByIdx; // store target HCA lid by its index
unsigned int N; // number of levels in the fabric
map_str_int IdxByName;
@@ -187,11 +187,11 @@ class FatTree {
// return NULL if this check is not met or no ranking available
IBNode *getLowestLevelSwitchNode();
- // get a free tupple given the reference one and the index to change:
- vec_byte getFreeTupple(vec_byte refTupple, unsigned int changeIdx);
+ // get a free tuple given the reference one and the index to change:
+ vec_byte getFreeTuple(vec_byte refTuple, unsigned int changeIdx);
- // convert tupple to string
- string getTuppleStr(vec_byte tupple);
+ // convert tuple to string
+ string getTupleStr(vec_byte tuple);
// simply dump out the FatTree data:
void dump();
@@ -199,7 +199,7 @@ class FatTree {
// track a connection to remote switch
int trackConnection(
FatTreeNode *p_ftNode,
- vec_byte tupple, // the connected node tupple
+ vec_byte tuple, // the connected node tuple
unsigned int rank, // rank of the local node
unsigned int remRank, // rank of the remote node
unsigned int portNum, // the port number connecting to the remote node
@@ -249,9 +249,9 @@ public:
FatTreeNode* FatTree::getFatTreeNodeByNode(IBNode *p_node) {
FatTreeNode* p_ftNode;
- vec_byte tupple(N, 0);
- tupple = TuppleByNode[p_node];
- p_ftNode = &NodeByTupple[tupple];
+ vec_byte tuple(N, 0);
+ tuple = TupleByNode[p_node];
+ p_ftNode = &NodeByTuple[tuple];
return p_ftNode;
}
@@ -310,31 +310,31 @@ IBNode *FatTree::getLowestLevelSwitchNode()
return(p_leafSwitch);
}
-// get a free tupple given the reference one and the index to change:
+// get a free tuple given the reference one and the index to change:
// also track the max digit allocated per index
-vec_byte FatTree::getFreeTupple(vec_byte refTupple, unsigned int changeIdx)
+vec_byte FatTree::getFreeTuple(vec_byte refTuple, unsigned int changeIdx)
{
- vec_byte res = refTupple;
+ vec_byte res = refTuple;
int rank = changeIdx - 1;
for (uint8_t i = 0; i < 255; i++)
{
res[changeIdx] = i;
- map_tupple_ftnode::const_iterator tI = NodeByTupple.find(res);
- if (tI == NodeByTupple.end())
+ map_tuple_ftnode::const_iterator tI = NodeByTuple.find(res);
+ if (tI == NodeByTuple.end())
return res;
}
- cout << "ABORT: fail to get free tupple! (in 255 indexies)" << endl;
+ cout << "ABORT: fail to get free tuple! (in 255 indexies)" << endl;
abort();
}
-string FatTree::getTuppleStr(vec_byte tupple)
+string FatTree::getTupleStr(vec_byte tuple)
{
char buf[128];
buf[0] = '\0';
- for (unsigned int i = 0; i < tupple.size(); i++)
+ for (unsigned int i = 0; i < tuple.size(); i++)
{
if (i) strcat(buf,".");
- sprintf(buf, "%s%d", buf, tupple[i]);
+ sprintf(buf, "%s%d", buf, tuple[i]);
}
return(string(buf));
}
@@ -343,11 +343,11 @@ string FatTree::getTuppleStr(vec_byte tupple)
// correct fat tree node childPorts and parentPorts
int FatTree::trackConnection(
FatTreeNode *p_ftNode, // the connected node
- vec_byte tupple, // the connected node tupple
+ vec_byte tuple, // the connected node tuple
unsigned int rank, // rank of the local node
unsigned int remRank, // rank of the remote node
unsigned int portNum, // the port number connecting to the remote node
- unsigned int remDigit // the digit of the tupple changing to the remote node
+ unsigned int remDigit // the digit of the tuple changing to the remote node
)
{
if ( rank < remRank )
@@ -394,8 +394,8 @@ FatTree::extractCoefficients()
int anyErr = 0;
// go over all nodes
- for (map_tupple_ftnode::iterator tI = NodeByTupple.begin();
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.begin();
+ tI != NodeByTuple.end();
tI++)
{
FatTreeNode *p_ftNode = &((*tI).second);
@@ -454,11 +454,11 @@ FatTree::extractCoefficients()
if (anyErr) return 1;
- vec_byte firstLeafTupple(N, 0);
- firstLeafTupple[0] = N-1;
+ vec_byte firstLeafTuple(N, 0);
+ firstLeafTuple[0] = N-1;
maxHcasPerLeafSwitch = 0;
- for (map_tupple_ftnode::iterator tI = NodeByTupple.find(firstLeafTupple);
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.find(firstLeafTuple);
+ tI != NodeByTuple.end();
tI++)
{
FatTreeNode *p_ftNode = &((*tI).second);
@@ -506,24 +506,24 @@ FatTree::FatTree(IBFabric *p_f)
bfsQueue.push_back(p_node);
// also we always allocate the address 0..0 with "rank" digits to the node:
- vec_byte tupple(N, 0);
+ vec_byte tuple(N, 0);
// adjust the level:
- tupple[0] = p_node->rank;
- TuppleByNode[p_node] = tupple;
- NodeByTupple[tupple] = FatTreeNode(p_node);
+ tuple[0] = p_node->rank;
+ TupleByNode[p_node] = tuple;
+ NodeByTuple[tuple] = FatTreeNode(p_node);
if (FabricUtilsVerboseLevel & FABU_LOG_VERBOSE)
- cout << "-I- Assigning tupple:" << getTuppleStr(tupple) << " to:"
+ cout << "-I- Assigning tuple:" << getTupleStr(tuple) << " to:"
<< p_node->name << endl;
while (! bfsQueue.empty())
{
p_node = bfsQueue.front();
bfsQueue.pop_front();
- // we must have a tupple stored - get it
- tupple = TuppleByNode[p_node];
+ // we must have a tuple stored - get it
+ tuple = TupleByNode[p_node];
// we also need to get the fat tree node...
- p_ftNode = &NodeByTupple[tupple];
+ p_ftNode = &NodeByTuple[tuple];
// go over all the node ports
for (unsigned int pn = 1; pn <= p_node->numPorts; pn++)
@@ -543,7 +543,7 @@ FatTree::FatTree(IBFabric *p_f)
}
// now try to see if this node has already a map:
- map_pnode_vec_byte::iterator tI = TuppleByNode.find(p_remNode);
+ map_pnode_vec_byte::iterator tI = TupleByNode.find(p_remNode);
// we are allowed to change the digit based on the direction we go:
unsigned int changingDigitIdx;
@@ -563,28 +563,28 @@ FatTree::FatTree(IBFabric *p_f)
return;
}
- // do we need to allocate a new tupple?
- if (tI == TuppleByNode.end())
+ // do we need to allocate a new tuple?
+ if (tI == TupleByNode.end())
{
- // the node is new - so get a new tupple for it:
- vec_byte newTupple = tupple;
+ // the node is new - so get a new tuple for it:
+ vec_byte newTuple = tuple;
// change the level accordingly
- newTupple[0] = p_remNode->rank;
+ newTuple[0] = p_remNode->rank;
// obtain a free one
- newTupple = getFreeTupple(newTupple, changingDigitIdx);
+ newTuple = getFreeTuple(newTuple, changingDigitIdx);
- // assign the new tupple and add to next steps:
+ // assign the new tuple and add to next steps:
if (FabricUtilsVerboseLevel & FABU_LOG_VERBOSE)
- cout << "-I- Assigning tupple:" << getTuppleStr(newTupple)
+ cout << "-I- Assigning tuple:" << getTupleStr(newTuple)
<< " to:" << p_remNode->name << " changed idx:"
- << changingDigitIdx << " from:" << getTuppleStr(tupple)
+ << changingDigitIdx << " from:" << getTupleStr(tuple)
<< endl;
- TuppleByNode[p_remNode] = newTupple;
- NodeByTupple[newTupple] = FatTreeNode(p_remNode);
+ TupleByNode[p_remNode] = newTuple;
+ NodeByTuple[newTuple] = FatTreeNode(p_remNode);
- unsigned int digit = newTupple[changingDigitIdx];
+ unsigned int digit = newTuple[changingDigitIdx];
// track the connection
if (FabricUtilsVerboseLevel & FABU_LOG_VERBOSE)
@@ -592,25 +592,25 @@ FatTree::FatTree(IBFabric *p_f)
<< p_remNode->name << " through port:" << pn
<< " remDigit:" << digit << endl;
if (trackConnection(
- p_ftNode, tupple, p_node->rank, p_remNode->rank, pn, digit))
+ p_ftNode, tuple, p_node->rank, p_remNode->rank, pn, digit))
return;
bfsQueue.push_back(p_remNode);
}
else
{
- // other side already has a tupple - so just track the connection
- vec_byte remTupple = (*tI).second;
- vec_byte mergedTupple = remTupple;
+ // other side already has a tuple - so just track the connection
+ vec_byte remTuple = (*tI).second;
+ vec_byte mergedTuple = remTuple;
- unsigned int digit = remTupple[changingDigitIdx];
+ unsigned int digit = remTuple[changingDigitIdx];
if (FabricUtilsVerboseLevel & FABU_LOG_VERBOSE)
cout << "-I- Connecting:" << p_node->name << " to:"
<< p_remNode->name << " through port:" << pn
<< " remDigit:" << digit << endl;
if (trackConnection(
- p_ftNode, tupple, p_node->rank, p_remNode->rank, pn, digit))
+ p_ftNode, tuple, p_node->rank, p_remNode->rank, pn, digit))
return;
}
@@ -624,18 +624,18 @@ FatTree::FatTree(IBFabric *p_f)
// We need to decide what will be the K of the lowest switches level.
// It is possible that for all of them the number of HCAs is < num
// left ports thus we should probably use the lowest number of all
- vec_byte firstLeafTupple(N, 0);
- firstLeafTupple[0] = N-1;
+ vec_byte firstLeafTuple(N, 0);
+ firstLeafTuple[0] = N-1;
- // now restart going over all leaf switches by their tupple order and
+ // now restart going over all leaf switches by their tuple order and
// allocate mapping
int hcaIdx = 0;
- for (map_tupple_ftnode::iterator tI = NodeByTupple.find(firstLeafTupple);
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.find(firstLeafTuple);
+ tI != NodeByTuple.end();
tI++)
{
// we collect HCAs connected to the leaf switch and set their childPort
- // starting at the index associated with the switch tupple.
+ // starting at the index associated with the switch tuple.
FatTreeNode *p_ftNode = &((*tI).second);
IBNode *p_node = p_ftNode->p_node;
unsigned int pIdx = 0;
@@ -917,10 +917,10 @@ int FatTree::route()
int lid; // the target LID we propagate for this time
// go over all fat tree nodes of the lowest level
- vec_byte firstLeafTupple(N, 0);
- firstLeafTupple[0] = N-1;
- for (map_tupple_ftnode::iterator tI = NodeByTupple.find(firstLeafTupple);
- tI != NodeByTupple.end();
+ vec_byte firstLeafTuple(N, 0);
+ firstLeafTuple[0] = N-1;
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.find(firstLeafTuple);
+ tI != NodeByTuple.end();
tI++)
{
@@ -963,8 +963,8 @@ int FatTree::route()
}
// now go over all switches and route to them
- for (map_tupple_ftnode::iterator tI = NodeByTupple.begin();
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.begin();
+ tI != NodeByTuple.end();
tI++)
{
@@ -1051,9 +1051,9 @@ int FatTree::permRoute(vector<string> src, vector<string> dst)
int hcaIdx = 0;
int lid; // the target LID we propagate for this time
// extract radix
- vec_byte tmpLeafTupple(N,0);
- tmpLeafTupple[0] = N-1;
- FatTreeNode* p_ftN = &NodeByTupple[tmpLeafTupple];
+ vec_byte tmpLeafTuple(N,0);
+ tmpLeafTuple[0] = N-1;
+ FatTreeNode* p_ftN = &NodeByTuple[tmpLeafTuple];
int radix = 0;
for (int i = 0; i < p_ftN->parentPorts.size(); i++)
if(p_ftN->parentPorts[i].size())
@@ -1078,10 +1078,10 @@ int FatTree::permRoute(vector<string> src, vector<string> dst)
// build the LFTs
// go over all fat tree nodes of the lowest level
- vec_byte firstLeafTupple(N, 0);
- firstLeafTupple[0] = N-1;
+ vec_byte firstLeafTuple(N, 0);
+ firstLeafTuple[0] = N-1;
// First prepare downwards routing
- for (map_tupple_ftnode::iterator tI = NodeByTupple.find(firstLeafTupple); tI != NodeByTupple.end(); tI++) {
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.find(firstLeafTuple); tI != NodeByTuple.end(); tI++) {
FatTreeNode *p_ftNode = &((*tI).second);
IBNode *p_node = p_ftNode->p_node;
// we need to track the number of ports to handle case of missing HCAs
@@ -1124,7 +1124,7 @@ int FatTree::permRoute(vector<string> src, vector<string> dst)
// Now prepare upwards routing
hcaIdx = 0;
- for (map_tupple_ftnode::iterator tI = NodeByTupple.find(firstLeafTupple); tI != NodeByTupple.end(); tI++) {
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.find(firstLeafTuple); tI != NodeByTuple.end(); tI++) {
FatTreeNode *p_ftNode = &((*tI).second);
IBNode *p_node = p_ftNode->p_node;
@@ -1156,8 +1156,8 @@ int FatTree::permRoute(vector<string> src, vector<string> dst)
}
// now go over all switches and route to them
- for (map_tupple_ftnode::iterator tI = NodeByTupple.begin();
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::iterator tI = NodeByTuple.begin();
+ tI != NodeByTuple.end();
tI++)
{
@@ -1222,8 +1222,8 @@ void FatTree::dump()
{
unsigned int level, prevLevel = 2;
cout << "---------------------------------- FAT TREE DUMP -----------------------------" << endl;
- for (map_tupple_ftnode::const_iterator tI = NodeByTupple.begin();
- tI != NodeByTupple.end();
+ for (map_tuple_ftnode::const_iterator tI = NodeByTuple.begin();
+ tI != NodeByTuple.end();
tI++)
{
level = (*tI).first[0];
@@ -1234,7 +1234,7 @@ void FatTree::dump()
}
FatTreeNode const *p_ftNode = &((*tI).second);
- cout << " " << p_ftNode->p_node->name << " tupple:" << getTuppleStr((*tI).first) << endl;
+ cout << " " << p_ftNode->p_node->name << " tuple:" << getTupleStr((*tI).first) << endl;
for (unsigned int i = 0; i < p_ftNode->parentPorts.size(); i++)
{
if (p_ftNode->parentPorts[i].size())
--
2.25.1