circuit.cpp

#include "circuit.h"

/******************Circuit Implementation********************/

Circuit::~Circuit()
{
  clear();
}

vector<Node*> Circuit::getPIs()
{
  vector<Node*> PIs;
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_INPUT)
      PIs.push_back(it->second);
  }
  return PIs;
}

vector<Node*> Circuit::getPOs()
{
  vector<Node*> POs;
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_OUTPUT)
      POs.push_back(it->second);
  }
  return POs;
}

int Circuit::setPI(const string &input)
{
  Node *in = findNode(input);
  assert(in != NULL);
  
  in->type = PRIMARY_INPUT;
  return 0;
}

int Circuit::setPO(const string &output)
{
  Node *out = findNode(output);
  assert(out != NULL);
  
  out->type = PRIMARY_OUTPUT;
  return 0;
}

int Circuit::setPIs(const string &input, unsigned int startBit, unsigned int endBit)
{
  for (unsigned i = startBit; i < endBit; ++i)
  {
    stringstream sstr;
    sstr << i;
    
    string name = input + "[" + sstr.str() + "]";
    assert(findNode(name) != NULL);
    setPI(name);
  }
  return 0;
}

int Circuit::setPOs(const string &output, unsigned int startBit, unsigned int endBit)
{
  for (unsigned i = startBit; i < endBit; ++i)
  {
    stringstream sstr;
    sstr << i;
    
    string name = output + "[" + sstr.str() + "]";
    assert(findNode(name) != NULL);
    setPO(name);
  }
  return 0;
}

Node* Circuit::findNode(const string &nodeName)
{
  mapIter it = nodeMap.find(nodeName);
  return (it != nodeMap.end() ? it->second : NULL);
}

Node* Circuit::createNode(const string &nodeName)
{
  Node* newNode = findNode(nodeName);
  if (newNode == NULL)
  {
    newNode = new Node(nodeName);
    nodeMap.insert(make_pair(nodeName, newNode));
  }
  
  return newNode;
}

int Circuit::print()
{
  cout << "Circuit Name: " << name << " contains " << nodeMap.size() << " nodes." << endl;
  cout << "Primary Inputs: ";
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_INPUT)
      cout << it->second->name << " ";
  }
  cout << endl;
  cout << "Primary Outputs: ";
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_OUTPUT)
      cout << it->second->name << " ";
  }
  cout << endl;
  
  cout << "Nodes:" << endl;
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    it->second->print();
    cout << endl;
  }

  return 0;
}

int Circuit::readBLIF(const string &filename)
{
  cout << "reading file " << filename << "..." << endl;
  ifstream inFile(filename.c_str());
  if (!inFile.good())
  {
    cout << "ERROR in readBLIF() - cannot open "
         << filename << " for reading." << endl;
  }
  
  // clear circuit's contents
  clear();
  
  string line;
  while (getline(inFile, line))
  {
//    cout << "processing line: " << line << endl;
    stringstream sstr;
    // skip empty lines
    if (line.length() == 0) continue;
    
    sstr << line;
    string word;
    vector<string> words;
    
    // parse each line
    while (sstr >> word)
    {
      words.push_back(word);
    }
    
    // parse non-empty lines only
    if (!words.empty())
    {
      // skip any comments
      if (words[0].find("#") != string::npos) continue;
      
      // parse model name
      if (words[0] == ".model")
      {
        for (unsigned i = 1; i < words.size(); ++i)
          name += words[i];
      }
      
      // parse primary inputs
      else if (words[0] == ".inputs")
      {
        for (unsigned i = 1; i < words.size(); ++i)
        {
          Node* inNode = createNode(words[i]);
          // node already exists
          if (inNode == NULL)
          {
            cout << "ERROR in readBLIF() (inputs) - node " << words[i] << " already exists.";
            return -1;
          }
          inNode->type = PRIMARY_INPUT;
        }
      }
      
      // parse primary outputs
      else if (words[0] == ".outputs")
      {
        for (unsigned i = 1; i < words.size(); ++i)
        {
          Node* outNode = createNode(words[i]);
          // node already exists
          if (outNode == NULL)
          {
            cout << "ERROR in readBLIF() (outputs) - node " << words[i] << " already exists.";
            return -1;
          }
          outNode->type = PRIMARY_OUTPUT;
        }
      }
      
      // parse standard logic node
      else if (words[0] == ".names" && words.size() > 2)
      {
        // find/create output node
        Node* outNode = findNode(words[words.size()-1]);
        if (outNode == NULL) outNode = createNode(words[words.size()-1]);
        else
        {
          outNode->clearTT();
          outNode->clearFanin();
        }
        
        // find/create input nodes
        for (unsigned i = 1; i < words.size()-1; ++i)
        {
          Node* inNode = findNode(words[i]);
          if (inNode == NULL) inNode = createNode(words[i]);
          outNode->addFanin(inNode);
        }
        outNode->tt.setNumVars(words.size()-2);
        
        // read truth table entries
        char c;
        do
        {
          string entry, result;
          inFile >> entry >> result;
//          cout << entry << " " << result << endl;
          if (entry.length() != outNode->getNumFanin())
          {
            cout << "ERROR in readBLIF() - number of input entries "
                 << "does not match number of fanin nodes" << endl;
            cout << "entry: " << entry << " ; vs numFanins = " << outNode->getNumFanin() << endl;
            return -1;
          }
          // only parse '1' result
          if (result == "1")
          {
            if (outNode->tt.addEntry(entry))
            {
              cout << "ERROR in readBLIF() - cannot add entry " << entry
                   << " to truth table." << endl;
              return -1;
            }
          }
          getline(inFile, result);
          c = inFile.peek(); // look at next character
//          cout << "c: " << c << endl;
        } while (c == '1' || c == '0' || c == '-');
      }
      
      // parse logic ZERO and ONE nodes
      else if (words[0] == ".names" && words.size() == 2)
      {
        Node* outNode = findNode(words[1]);
        if (outNode == NULL) outNode = createNode(words[1]);
        else
        {
          outNode->clearTT();
          outNode->clearFanin();
        }
        // if next line is '1', then logic 1
        if (inFile.peek() == '1')
        {
          outNode->type = ONE_NODE;
          inFile.get();  // throw away '1'
        }
        else
        {
          outNode->type = ZERO_NODE;
        }
      }
      
      // parse end of file
      else if (words[0] == ".end") break;
      
      // error
      else
      {
        cout << "ERROR in readBLIF() - invalid line " << words[0] << endl;
        cout << "Possibly wrong format?" << endl;
        return -1;
      }
    }
  }
  
  cout << "file " << filename << " successfully read." << endl;
  inFile.close();
  return 0;
}

int Circuit::writeBLIF(const string &filename)
{
  ofstream outFile(filename.c_str());
  if (!outFile.good())
  {
    cout << "ERROR in writeBLIF() - cannot open "
         << filename << " for writing." << endl;
    return -1;
  }
  
  // print model name
  outFile << ".model " << name << endl << endl;
  
  // print primary inputs
  outFile << ".inputs ";
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_INPUT)
      outFile << it->first << " ";
  }
  outFile << endl << endl;
  
  // print primary outputs
  outFile << ".outputs ";
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second->type == PRIMARY_OUTPUT)
      outFile << it->first << " ";
  }
  outFile << endl << endl;
  
  // print nodes
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    // must explicitly write 0 node
    if (it->second->type == ZERO_NODE)
    {
      outFile << ".names " << it->second->name << endl;
      outFile << endl;
    }
    // must explicitly write 1 node
    else if (it->second->type == ONE_NODE)
    {
      outFile << ".names " << it->second->name << endl;
      outFile << "1" << endl << endl;
    }
    else if (it->second->type != PRIMARY_INPUT)
    {
      outFile << ".names ";
      for (unsigned i = 0; i < it->second->getNumFanin(); ++i)
        outFile << it->second->getFanin()[i]->name << " ";
      outFile << it->second->name << endl;
      
      const TruthTable &theTT = it->second->tt;
      for (unsigned i = 0; i < theTT.logic.size(); ++i)
      {
        for (unsigned j = 0; j < theTT.logic[i].size(); ++j)
        {
          switch(theTT.logic[i][j])
          {
            case ZERO: outFile << "0"; break;
            case ONE:  outFile << "1"; break;
            case DC:   outFile << "-"; break;
          }
        }
        outFile << " 1" << endl;
      }
      outFile << endl;
    }
  }
  
  outFile << ".end" << endl;
  outFile.close();
  
  cout << "File " << filename << " successfully written." << endl;
  
  return 0;
}

int Circuit::clear()
{
  for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
  {
    if (it->second != NULL)
      delete it->second;
  }
  nodeMap.clear();
  return 0;
}

void Circuit::printTopo()
{
	vector<Node*> PIs = getPIs();			//primary inputs
	map<string, Node*> PImap;
	vector<Node*> POs = getPOs();			//primary outputs
	map<string, Node*> POmap;
	map<string, Node*> InternalsMapBase;	//map of internal nodes
	map<string, Node*> InternalsMap;		//map of internal nodes
	vector<Node*> Internals;				//generally ordered list of internal nodes
	vector<Node*> tempFanIn;				//placeholder vector for working vector

	//generate the map of PIs
	for (int i = 0; i < PIs.size(); i++)
	{
		PImap.insert(pair<string, Node*>(PIs[i]->getName(), PIs[i]));
	}

	//generate the map of POs
	for (int i = 0; i < POs.size(); i++)
	{
		POmap.insert(pair<string, Node*>(POs[i]->getName(), POs[i]));
	}

	//generate the map of internal gates
	for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
	{
		if (it->second->type == INTERNAL)
		{
			InternalsMapBase.insert(*it);
		}
	}


	//order the internal gates
	bool good = true;
	for (mapIter it = InternalsMapBase.begin(); it != InternalsMapBase.end(); )
	{
		good = true;
		tempFanIn = it->second->getFanin();
		for (int i = 0; i < tempFanIn.size(); i++)	//check all the fanIns
		{
			if ((PImap.find(tempFanIn[i]->getName()) == PImap.end()) && (InternalsMap.find(tempFanIn[i]->getName()) == PImap.end()))	//don't have this fanIn yet, don't add to vector yet
			{
				good = false;
				break;
			}
		}

		if (good)	//all fanIns have already been seen, push it into the ordered vector, InternalMap, and delete it from the source map
		{
			Internals.push_back(it->second);
			InternalsMap.insert(pair<string, Node*>(it->first, it->second));
			InternalsMapBase.erase(it);
			it = InternalsMapBase.begin();	//to make sure I don't reference out of bounds, will eventually get through, despite inefficiency
		}
		else it++;

		if ((it == InternalsMapBase.end()) && (InternalsMapBase.size() > 0))	//if we're at the end of the gates, but there are still more to add, go back to beginning and run again
		{
			it = InternalsMapBase.begin();
		}
	}

	//output the Topo
	cout << "*** Topological order:" << endl;
	for (int i = 0; i < PIs.size(); i++) cout << PIs[i]->getName() << ' ';
	for (int i = 0; i < Internals.size(); i++) cout << Internals[i]->getName() << ' ';
	for (int i = 0; i < POs.size(); i++)
	{
		cout << POs[i]->getName();
		if (i != (POs.size() - 1)) cout << ' ';
		else cout << endl;
	}
}

void Circuit::simOutputs(string inputFile)
{
	vector<Node*> PIs = getPIs();			//primary inputs
	map<string, Node*> PImap;
	vector<Node*> POs = getPOs();			//primary outputs
	map<string, Node*> POmap;
	map<string, Node*> InternalsMapBase;	//map of internal nodes
	map<string, Node*> InternalsMap;		//map of internal nodes
	vector<Node*> Internals;				//generally ordered list of internal nodes
	vector<Node*> tempFanIn;				//placeholder vector for working vector
	ifstream ifs;
	string tempName;
	string charVal;
	int tempVal;

	//In this instance, the topological sort is reused to preface the value propagation through the circuit, if nodes are traversed in topological order
	//then I don't have to worry about checking if the fanIn nodes have been set yet
	
	//generate the map of PIs
	for (int i = 0; i < PIs.size(); i++)
	{
		PImap.insert(pair<string, Node*>(PIs[i]->getName(), PIs[i]));
	}

	//generate the map of POs
	for (int i = 0; i < POs.size(); i++)
	{
		POmap.insert(pair<string, Node*>(POs[i]->getName(), POs[i]));
	}

	//generate the map of internal gates
	for (mapIter it = nodeMap.begin(); it != nodeMap.end(); it++)
	{
		if (it->second->type == INTERNAL)
			InternalsMapBase.insert(*it);
	}
	//order the internal gates
	bool good = true;
	for (mapIter it = InternalsMapBase.begin(); it != InternalsMapBase.end();)
	{
		good = true;
		tempFanIn = it->second->getFanin();
		for (int i = 0; i < tempFanIn.size(); i++)	//check all the fanIns
		{
			if ((PImap.find(tempFanIn[i]->getName()) == PImap.end()) && (InternalsMap.find(tempFanIn[i]->getName()) == PImap.end()))	//don't have this fanIn yet, don't add to vector yet
			{
				good = false;
				break;
			}
		}

		if (good)	//all fanIns have already been seen, push it into the ordered vector, InternalMap, and delete it from the source map
		{
			Internals.push_back(it->second);
			InternalsMap.insert(pair<string, Node*>(it->first, it->second));
			InternalsMapBase.erase(it);
			it = InternalsMapBase.begin();	//to make sure I don't reference out of bounds, will eventually get through, despite inefficiency
		}
		else it++;

		if ((it == InternalsMapBase.end()) && (InternalsMapBase.size() > 0))	//if we're at the end of the gates, but there are still more to add, go back to beginning and run again
		{
			it = InternalsMapBase.begin();
		}
	}

	//initialize the file stream for input
	ifs.open(inputFile.c_str());
	if (!ifs.good()) cout << "input file is bad, or empty\n";

	while (ifs.good())	//initialize all the PrimaryInput nodes with values
	{
		tempName.clear();
		charVal.clear();
		getline(ifs, tempName, ' ');
		getline(ifs, charVal, '\n');
		tempVal = atoi(charVal.c_str());
		PImap.find(tempName)->second->setVal(tempVal);
	}

	for (int i = 0; i < Internals.size(); i++)	//propagate the values through the topologically ordered internal nodes
	{
		Internals[i]->cascade();
	}

	cout << "*** Outputs:" << endl;			//begin output
	for (int i = 0; i < POs.size(); i++)	//push values through to the primary outputs
	{
		POs[i]->cascade();
		cout << POs[i]->getName() << " = " << POs[i]->getVal();		//output to screen as values are calculated
		if (i != (POs.size() - 1)) cout << ", ";
		else cout << endl;
	}
}