commonReaderWriterBase.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2025 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <cstdio>
#include <cstdlib>
#include <string>
#include <vector>
 
#include "../../config.h"
#include "tapeReaderWriterInterface.hpp"

namespace codi {
  struct CommonReaderWriterMethods {
      std::string fileName;  

      CommonReaderWriterMethods(std::string const& name) : fileName(name) {};
      CommonReaderWriterMethods() : fileName("") {};

      std::string modifyFileName(std::string const& suffix) {
        std::string::size_type sepPosition = fileName.rfind('.');
        return fileName.substr(0, sepPosition) + suffix;
      }

      void openFile(FILE*& fileHandle, std::string const& name, std::string const& mode) {
        fileHandle = fopen(name.c_str(), mode.c_str());
        if (nullptr == fileHandle) {
          CODI_EXCEPTION("Could not open file %s", name.c_str());
        }
      }
  };

  template<typename T_Type>
  struct CommonBaseTapeWriter : public TapeWriterInterface<T_Type>, public CommonReaderWriterMethods {
      using Type = CODI_DD(T_Type, CODI_DEFAULT_LHS_EXPRESSION);  
      using Identifier = typename Type::Identifier;               
      using Tape = typename Type::Tape;                           
 
      std::vector<Identifier> inputVariables;   
      std::vector<Identifier> outputVariables;  

      CommonBaseTapeWriter(std::string const& name, std::vector<Identifier> const& in,
                           std::vector<Identifier> const& out)
          : CommonReaderWriterMethods(name), inputVariables(in), outputVariables(out) {};
 
    protected:

      void printIoText(Tape& tape) {
        FILE* ioFileHandleTxt = nullptr;
        this->openFile(ioFileHandleTxt, modifyFileName("IO.txt"), "w");
 
        fprintf(ioFileHandleTxt, "%zu Inputs = ", inputVariables.size());
        for (size_t inputCount = 0; inputCount < inputVariables.size(); inputCount++) {
          fprintf(ioFileHandleTxt, "%d   ", inputVariables[inputCount]);
        }
        fprintf(ioFileHandleTxt, "\n%zu Outputs = ", outputVariables.size());
        for (size_t outputCount = 0; outputCount < outputVariables.size(); outputCount++) {
          fprintf(ioFileHandleTxt, "%d   ", outputVariables[outputCount]);
        }
        fprintf(ioFileHandleTxt, "\nLargest Index = %d", tape.getIndexManager().getLargestCreatedIndex());
        fclose(ioFileHandleTxt);
      }

      void printIoBinary(Tape& tape) {
        FILE* ioFileHandleBinary = nullptr;
 
        this->openFile(ioFileHandleBinary, modifyFileName("IO.dat"), "wb");
 
        size_t nInputs = inputVariables.size();
        size_t nOutputs = outputVariables.size();
 
        fwrite(&nInputs, sizeof(nInputs), 1, ioFileHandleBinary);
        fwrite(&inputVariables[0], sizeof(Identifier), nInputs, ioFileHandleBinary);
        fwrite(&nOutputs, sizeof(nOutputs), 1, ioFileHandleBinary);
        fwrite(&outputVariables[0], sizeof(Identifier), nOutputs, ioFileHandleBinary);
        Identifier largestIndex = tape.getIndexManager().getLargestCreatedIndex();
        fwrite(&largestIndex, sizeof(Identifier), 1, ioFileHandleBinary);
 
        fclose(ioFileHandleBinary);
      }
  };

  template<typename T_Type>
  struct CommonBaseTapeReader : public TapeReaderInterface<T_Type>, public CommonReaderWriterMethods {
      using Type = CODI_DD(T_Type, CODI_DEFAULT_LHS_EXPRESSION);  
      using Tape = typename Type::Tape;                           
      using Identifier = typename Type::Identifier;               
 
      std::vector<Identifier> inputVariables;   
      std::vector<Identifier> outputVariables;  
      size_t nInputs;                           
      size_t nOutputs;                          
 
      Tape tape;  
 
      Identifier largestIndex;                                          
      CommonBaseTapeReader() : CommonReaderWriterMethods(), tape() {};  
 
    protected:

      void restoreIoText() {
        FILE* ioFileHandleTxt;
        this->openFile(ioFileHandleTxt, modifyFileName("IO.txt"), "r+");
 
        fscanf(ioFileHandleTxt, "%zu Inputs = ", &nInputs);
        inputVariables.resize(nInputs, 0);
        for (size_t inputCount = 0; inputCount < nInputs; inputCount++) {
          fscanf(ioFileHandleTxt, "%d   ", &inputVariables[inputCount]);
        }
        fscanf(ioFileHandleTxt, "\n%zu Outputs = ", &nOutputs);
        outputVariables.resize(nOutputs, 0);
        for (size_t outputCount = 0; outputCount < nOutputs; outputCount++) {
          fscanf(ioFileHandleTxt, "%d   ", &outputVariables[outputCount]);
        }
        fscanf(ioFileHandleTxt, "\nLargest Index = %d", &largestIndex);
        fclose(ioFileHandleTxt);
      }

      void restoreIoBinary() {
        FILE* fileIoHandleBin;
        this->openFile(fileIoHandleBin, modifyFileName("IO.dat"), "rb");
 
        fread(&nInputs, sizeof(nInputs), 1, fileIoHandleBin);
        inputVariables.resize(nInputs, 0);
        fread(inputVariables.data(), sizeof(Identifier), nInputs, fileIoHandleBin);
        fread(&nOutputs, sizeof(nOutputs), 1, fileIoHandleBin);
        outputVariables.resize(nOutputs, 0);
        fread(outputVariables.data(), sizeof(Identifier), nOutputs, fileIoHandleBin);
        fread(&largestIndex, sizeof(Identifier), 1, fileIoHandleBin);
      }

      Tape& getTape() {
        return tape;
      }

      std::vector<Identifier> const& getInputs() const& {
        return inputVariables;
      }

      std::vector<Identifier> const& getOutputs() const& {
        return outputVariables;
      }

      void updateUserIO(Identifier const& linearOffset) {
        if (Tape::TapeTypes::IsLinearIndexHandler && !TapeTraits::IsPrimalValueTape<Tape>::value) {
          // For the linear case, user IO is updated with a potential offset.
          for (size_t inputCount = 0; inputCount < inputVariables.size(); inputCount++) {
            inputVariables[inputCount] -= linearOffset;
          }
 
          for (size_t outputCount = 0; outputCount < outputVariables.size(); outputCount++) {
            outputVariables[outputCount] -= linearOffset;
          }
        }
      }
  };

  template<typename T_Type>
  struct CommonTextTapeWriter : public CommonBaseTapeWriter<T_Type> {
      using Type = CODI_DD(T_Type, CODI_DEFAULT_LHS_EXPRESSION);  
      using Base = CommonBaseTapeWriter<T_Type>;                  
 
      using Tape = typename Type::Tape;              
      using Identifier = typename Type::Identifier;  
      using Real = typename Type::Real;              
 
      bool writeDotHeaderFooter;  
 
      FILE* fileHandleGraph = nullptr;  
 
      Identifier aggregateCounter;               
      bool lastNodeWasAggregate;                 
      std::vector<Identifier> identifierPrefix;  
      std::vector<Identifier> identifierExtensions;  
      std::vector<IdentifierType> identifierType;    
 
      CommonTextTapeWriter(bool writeDotHeaderFooter, std::string const& name, std::vector<Identifier> const& in,
                           std::vector<Identifier> const& out)
          : Base(name, in, out),
            writeDotHeaderFooter(writeDotHeaderFooter),
            fileHandleGraph(nullptr),
            aggregateCounter(0),
            lastNodeWasAggregate(false),
            identifierPrefix(0),
            identifierExtensions(0),
            identifierType(0) {}  

      void start(Tape& tape) {
        // Resize vectors to maximum index.
        identifierPrefix.resize(tape.getIndexManager().getLargestCreatedIndex() + 1, 0);
        identifierExtensions.resize(tape.getIndexManager().getLargestCreatedIndex() + 1, 0);
        identifierType.resize(tape.getIndexManager().getLargestCreatedIndex() + 1, IdentifierType::Temp);
 
        // Record the input and output identifiers in the identifierType vector. This is used later to colour code the
        // nodes and avoids searching through the input and output vectors for each statement.
        for (size_t inputCount = 0; inputCount < this->inputVariables.size(); inputCount++) {
          identifierType[this->inputVariables[inputCount]] = IdentifierType::Input;
        }
 
        for (size_t outputCount = 0; outputCount < this->outputVariables.size(); outputCount++) {
          identifierType[this->outputVariables[outputCount]] = IdentifierType::Output;
        }
 
        this->openFile(fileHandleGraph, this->fileName, "w");
 
        if (writeDotHeaderFooter) {
          // Print out the header and add a color index.
          fprintf(fileHandleGraph,
                  "digraph Net {\nInputs [label = \"Inputs\", color=\"blue\"];\nOutputs [label = \"Outputs\", "
                  "color=\"red\"];\nInter [label = \"Inter\"];\n");
        }
      }

      void finish() {
        if (writeDotHeaderFooter) {
          fprintf(this->fileHandleGraph, "}");
        }
        fclose(this->fileHandleGraph);
      }
 
    protected:

      std::string formatAggregateName(Identifier const& aggregate) {
        return "Aggregate" + std::to_string(aggregate);
      }

      std::string formatNodePrefix(Identifier const& identifier) {
        std::string prefix = "";
        if (0 != identifierPrefix[identifier]) {
          prefix = formatAggregateName(identifierPrefix[identifier]) + ":";
        }
        return prefix;
      }

      std::string formatNodeName(Identifier const& identifier, int extensionOffset = 0) {
        return "A" + std::to_string(identifier) + "_" +
               std::to_string(identifierExtensions[identifier] + extensionOffset);
      }

      std::string formatNodeNameForLink(Identifier const& identifier) {
        return formatNodePrefix(identifier) + formatNodeName(identifier);
      }

      std::string nodeColorProperties(Identifier const& identifier) {
        if (identifierType[identifier] == IdentifierType::Input) {
          return "blue";
        } else if (identifierType[identifier] == IdentifierType::Output) {
          return "red";
        } else {
          return "black";
        }
      }

      std::string createNode(size_t nIdentifiers, Identifier const* identifiers, std::string const& label) {
        std::string name = "";
        std::string finalLabel = "";
        std::string shape = "";
        if (1 == nIdentifiers) {
          name = formatNodeName(identifiers[0], 1);
          finalLabel = formatNodeLabel(identifiers[0]);
          if (0 != label.size()) {
            finalLabel += " = " + label;
          }
        } else {
          aggregateCounter += 1;
          lastNodeWasAggregate = true;
          name = formatAggregateName(aggregateCounter);
          finalLabel = "{ " + label + " | {";
 
          // Update the prefix for the lhs identifiers.
          for (size_t i = 0; i < nIdentifiers; i += 1) {
            if (0 != i) {
              finalLabel += " | ";
            }
            finalLabel += "<" + formatNodeName(identifiers[i], 1) + "> " + formatNodeLabel(identifiers[i]);
          }
 
          finalLabel += "}}";
          shape = ", shape=\"record\"";
        }
 
        std::string node = name + " [label = \"" + finalLabel + "\", color=\"" + nodeColorProperties(identifiers[0]) +
                           "\"" + shape + "];\n";
        fprintf(this->fileHandleGraph, "%s", node.c_str());
 
        return name;
      }

      std::string formatNodeLabel(Identifier const& identifier) {
        std::string result;
 
        if (this->identifierType[identifier] == IdentifierType::Input) {
          result = "X";
        } else if (this->identifierType[identifier] == IdentifierType::Output) {
          result = "Y";
        } else {
          result = "T";
        }
 
        result += std::to_string(identifier);
 
        return result;
      }

      void replaceAll(std::string& str, const std::string& search, const std::string& replace) {
        size_t start_pos = 0;
        while ((start_pos = str.find(search, start_pos)) != std::string::npos) {
          str.replace(start_pos, search.length(), replace);
          start_pos += replace.length();
        }
      }

      std::string modifyMathRep(std::string const& mathRep, Identifier const* const rhsIdentifiers,
                                size_t const& nActiveValues) {
        std::string result = mathRep;
 
        // Iterate through the RHS and replace x1..xn with the identifier type and the identifier value.
        for (size_t curArg = 0; curArg < nActiveValues; curArg++) {
          std::string searchString = "x" + std::to_string(rhsIdentifiers[curArg]);
          std::string replaceString = formatNodeLabel(rhsIdentifiers[curArg]);
 
          replaceAll(result, searchString, replaceString);
        }
 
        return result;
      }

      void placeUnusedRhsNodes(Identifier const* const rhsIdentifiers, Config::ArgumentSize const& nArguments) {
        // Check if the identifierExtension is zero for any of the rhsIdentifiers. A zero extension indicates that the
        // node has not been placed. The type of the identifier is then checked to add the correct colour coding.
        for (size_t argCount = 0; argCount < nArguments; argCount++) {
          if (this->identifierExtensions[rhsIdentifiers[argCount]] == 0) {
            createNode(1, &rhsIdentifiers[argCount], "");
            updateLhsIdentifiers(1, &rhsIdentifiers[argCount]);
          }
        }
      }

      void createEdge(Identifier const& from, std::string const& to, std::string const& label = "") {
        std::string edge = formatNodeNameForLink(from) + " -> " + to;
 
        if (0 != label.size()) {
          edge += " [label=\"" + label + "\"];";
        }
        edge += "\n";
        fprintf(this->fileHandleGraph, "%s", edge.c_str());
      }

      void updateLhsIdentifiers(size_t nIdentifiers, Identifier const* identifiers) {
        for (size_t i = 0; i < nIdentifiers; i += 1) {
          this->identifierExtensions[identifiers[i]] += 1;
 
          if (lastNodeWasAggregate) {
            identifierPrefix[identifiers[i]] = aggregateCounter;
          }
        }
 
        lastNodeWasAggregate = false;
      }
  };
}