tableMapping

  1"""
  2List of all pip packages imported
  3"""
  4
  5import difflib
  6import itertools
  7import json
  8import logging
  9import os
 10import re
 11import sys
 12
 13import jellyfish
 14import numpy as np
 15import pandas as pd
 16import yaml
 17from tabulate import tabulate
 18
 19# ===========================================================================================
 20# ======================================= Begin Class =======================================
 21# ===========================================================================================
 22
 23
 24class TableMapping:
 25    """
 26    Generates a golden model for a particular SRAM memory table map config
 27    using a respective TCAM memory table map and configs.
 28    """
 29
 30    # * ----------------------------------------------------------------- Variables
 31    def __init__(self):
 32        """
 33        Constructor: Initializes all the class variables
 34
 35        **Public Variables:**
 36        :param str prjWorkDir:                  current project working dir
 37        :param str sramTableDir:                abs path of SRAM table map folder
 38        :param str tcamTableConfigsFilePath:    abs path of TCAM table map config file
 39        :param str tcamTableConfigsFileName:    TCAM table map config file name
 40        :param str tcamTableXlsxFilePath:       abs path of TCAM table map XLSX file
 41        :param str tcamTableXlsxFileName:       TCAM table map XLSX file name
 42        :param str sramTableXlsxFilePath:       abs path of generated SRAM table map XLSX file
 43        :param str sramTableXlsxFileName:       SRAM table map XLSX file name
 44        :param str sramTableHtmlFilePath:       abs path of generated SRAM table map HTML file
 45        :param str sramTableHtmlFileName:       SRAM table map HTML file name
 46        :param str sramTableJsonFilePath:       abs path of generated SRAM table map JSON file
 47        :param str sramTableJsonFileName:       SRAM table map JSON file name
 48        :param str sramTableTxtFilePath:        abs path of generated SRAM table map TXT file
 49        :param str sramTableTxtFileName:        SRAM table map TXT file name
 50
 51        **Protected Variables:**
 52        :param dict _tcamTableConfigs:      TCAM table map configs
 53        :param DataFrame _tcamTable:        TCAM table map
 54        :param DataFrame _sramTable:        SRAM table map
 55        :param DataFrame _tcamQSAddrTable:  TCAM table map query addr sub str
 56        :param DataFrame _sramQSAddrTable:  SRAM table map query addr sub str
 57
 58        **Private Variables:**
 59        :param int __tcamQueryStrLen:   `queryStrLen` of a particular TCAM table config
 60        :param int __tcamSubStrLen:     `subStrLen` of a particular TCAM table config
 61        :param int __tcamTotalSubStr:   `totalSubStr` of a particular TCAM table config
 62        :param int __tcamPotMatchAddr:  `potMatchAddr` of a particular TCAM table config
 63        :param int __sramTableRows:     SRAM table map row count
 64        :param int __sramTableCols:     SRAM table map col count
 65        :param list __tcamRows:         TCAM table map row count vector
 66        :param list __tcamCols:         TCAM table map col count vector
 67        :param list __tcamColVec:       TCAM table map sub string address col count vector
 68        :param list __sramRows:         SRAM table map row count vector
 69        :param list __sramRowVec:       SRAM table map sub string address row count vector
 70        :param list __sramCols:         SRAM table map col count vector
 71        """
 72        # * ------------------- public vars
 73        self.prjWorkDir = ""
 74        self.sramTableDir = ""
 75        self.tcamTableConfigsFilePath = ""
 76        self.tcamTableConfigsFileName = ""
 77        self.tcamTableXlsxFilePath = ""
 78        self.tcamTableXlsxFileName = ""
 79        self.sramTableXlsxFilePath = ""
 80        self.sramTableXlsxFileName = ""
 81        self.sramTableHtmlFilePath = ""
 82        self.sramTableHtmlFileName = ""
 83        self.sramTableJsonFilePath = ""
 84        self.sramTableJsonFileName = ""
 85        self.sramTableTxtFilePath = ""
 86        self.sramTableTxtFileName = ""
 87        # * ------------------- protected vars
 88        self._tcamTableConfigs = {}
 89        self._tcamTable = pd.DataFrame
 90        self._sramTable = pd.DataFrame
 91        self._tcamQSAddrTable = pd.DataFrame
 92        self._sramQSAddrTable = pd.DataFrame
 93        # * ------------------- private vars
 94        self.__tcamQueryStrLen = 0
 95        self.__tcamSubStrLen = 0
 96        self.__tcamTotalSubStr = 0
 97        self.__tcamPotMatchAddr = 0
 98        self.__sramTableRows = 0
 99        self.__sramTableCols = 0
100        self.__tcamRows = []
101        self.__tcamCols = []
102        self.__tcamColVec = []
103        self.__sramRows = []
104        self.__sramRowVec = []
105        self.__sramCols = []
106        # * logging config
107        logging.basicConfig(
108            level=logging.DEBUG,
109            filename="./logs/tableMapping.log",
110            format="%(asctime)s | %(filename)s | %(funcName)s | %(levelname)s | %(lineno)d | %(message)s",
111        )
112
113    # * ----------------------------------------------------------------- Functions
114    def getPrjDir(self, verbose):
115        """
116        Obtain the absolute path of the current working directory.
117
118        :param int verbose: print information in verbose mode.
119        :return str: absolute path of the current project working directory.
120        """
121        self.prjWorkDir = os.getcwd()
122        logging.info("Project working dir: %s", self.prjWorkDir)
123        printVerbose(verbose, f"Project working dir: {self.prjWorkDir}")
124        return self.prjWorkDir
125
126    def getYAMLFilePath(self, verbose):
127        """
128        Obtain the absolute path of file tcamTables.yaml.
129
130        :param int verbose: print information in verbose mode.
131        :return str: absolute path of the current project working directory.
132        """
133        # * get tcamTables config file path
134        tempPath = os.path.join(self.prjWorkDir, "compiler/configs/tcamTables.yaml")
135        if os.path.isfile(tempPath) is True:
136            self.tcamTableConfigsFilePath = tempPath
137            self.tcamTableConfigsFileName = os.path.basename(tempPath)
138            logging.info('"FOUND": TCAM table config file path: %s', self.tcamTableConfigsFilePath)
139            printVerbose(verbose, f'"FOUND": TCAM table config file path: {self.tcamTableConfigsFilePath}')
140            return self.tcamTableConfigsFilePath
141        logging.error('"NOT FOUND": TCAM table config file path: %s', self.tcamTableConfigsFilePath)
142        sys.exit(f'"NOT FOUND": TCAM table config file path: {self.tcamTableConfigsFilePath}')
143
144    def readYAML(self, filePath, verbose):
145        """
146        Read a particular YAML config file
147
148        :param str filePath: absolute path of file tcamTables.yaml.
149        :param int verbose: print information in verbose mode.
150        :return dict: dictionary containing all the TCAM table configs.
151        """
152        with open(filePath, encoding="utf-8") as file:
153            self._tcamTableConfigs = yaml.full_load(file)
154        # print(json.dumps(self._tcamTableConfigs,indent=4))
155        # print(yaml.dump(self._tcamTableConfigs,sort_keys=False,default_flow_style=False))
156        logging.info("Read TCAM table config file: %s", self.tcamTableConfigsFilePath)
157        printVerbose(verbose, f"Read TCAM table config file: {self.tcamTableConfigsFilePath}")
158        return self._tcamTableConfigs
159
160    def printYAML(self, debug):
161        """
162        Print all present configs of a YAML file either in JSON or YAML style.
163
164        :param int debug: print information in debug mode.
165        """
166        printDebug(debug, "Printing TCAM table configs")
167        print(json.dumps(self._tcamTableConfigs, indent=4))
168        # print(yaml.dump(self._tcamTableConfigs,sort_keys=False,default_flow_style=False))
169        logging.info("Printed TCAM table configs")
170
171    def getTCAMConfig(self, tcamConfig):
172        """
173        Check if a particular tcamTable config exists in file tcamTables.yaml. If found store the config params in vars.
174        - **__tcamQueryStrLen:**    saves `queryStrLen`
175        - **__tcamSubStrLen:**      saves `subStrLen`
176        - **__tcamTotalSubStr:**    saves `totalSubStr`
177        - **__tcamPotMatchAddr:**   saves `potMatchAddr`
178
179        :param str tcamConfig: TCAM table config name e.g. tcamTableX
180        :return dict: dictionary containing the respective table map config.
181        """
182        # * look for specific tcam config in compiler/configs/tcamTables.yaml
183        if tcamConfig in self._tcamTableConfigs.keys():
184            tempConfig = self._tcamTableConfigs[tcamConfig]
185            # * save tcam config vars
186            self.__tcamQueryStrLen = tempConfig["queryStrLen"]
187            self.__tcamSubStrLen = tempConfig["subStrLen"]
188            self.__tcamTotalSubStr = tempConfig["totalSubStr"]
189            self.__tcamPotMatchAddr = tempConfig["potMatchAddr"]
190            # * print specific tcam config
191            # print(type(tempConfig))
192            logging.info('"FOUND" Required TCAM Config [%s]', tcamConfig)
193            print('"FOUND" Required TCAM Config [%s]', tcamConfig)
194            logging.info("TCAM Config Data [%s] = %s", tcamConfig, tempConfig)
195            return tempConfig
196        logging.error('"NOT FOUND": TCAM Config [%s]', tcamConfig)
197        sys.exit(f'"NOT FOUND": Required TCAM table config [{tcamConfig}]')
198
199    def getTCAMTableFilePath(self, tcamConfig, verbose):
200        """
201        Obtain the absolute path of file **tcamTableX.xlsx** which represents the TCAM memory table map.
202
203        :param str tcamConfig: TCAM table config name e.g. tcamTableX
204        :param int verbose: print information in verbose mode.
205        :return str: absolute path of the TCAM table mapping file.
206        """
207        # * find the specific tcam table map in compiler/lib/
208        tempPath = os.path.join(self.prjWorkDir, "compiler/lib/" + tcamConfig + ".xlsx")
209        if os.path.isfile(tempPath) is True:
210            self.tcamTableXlsxFilePath = tempPath
211            self.tcamTableXlsxFileName = os.path.basename(tempPath)
212            logging.info('"FOUND" TCAM table map XLSX file path: %s', self.tcamTableXlsxFilePath)
213            printVerbose(verbose, f'"FOUND" TCAM table map XLSX file path: {self.tcamTableXlsxFilePath}')
214            return self.tcamTableXlsxFilePath
215        logging.error('"NOT FOUND": TCAM table map XLSX file path: %s', self.tcamTableXlsxFilePath)
216        sys.exit(f'"NOT FOUND": TCAM table map XLSX file path {self.tcamTableXlsxFilePath}')
217
218    def printDF(self, dataFrame, heading):
219        """
220        Display the contents of a particular data frame.
221
222        :param DataFrame dataFrame: particular data frame object.
223        :param str heading: Title above data frame.
224        """
225        print("\n")
226        print("Printing dataframe: %s", heading)
227        print(tabulate(dataFrame, headers="keys", showindex=True, disable_numparse=True, tablefmt="github"), "\n")
228        logging.info("Printing dataframe: %s", str(heading))
229
230    def getTcamTableMap(self):
231        """
232        Getter function for the TCAM table map
233
234        :return DataFrame: TCAM table map dataframe object
235        """
236        return self._tcamTable
237
238    def getSramTableMap(self):
239        """
240        Getter function for the SRAM table map
241
242        :return DataFrame: SRAM table map dataframe object
243        """
244        return self._sramTable
245
246    def readTCAMTable(self, verbose):
247        """
248        Read the contents of a **tcamTableX.xlsx** TCAM memory table map as a data frame.
249
250        :param int verbose: print information in verbose mode.
251        :return int: list containing dimensions of TCAM table memory map.
252        """
253        # * store tcam table in dataframe
254        self._tcamTable = pd.read_excel(self.tcamTableXlsxFilePath, skiprows=2, index_col=None, engine="openpyxl")
255        # * get num of rows and col from tcam table
256        tcamTableRows = self._tcamTable.shape[0]
257        tcamTableCols = self._tcamTable.shape[1]
258        # * compare row/col of tcam table with respective yaml config
259        if tcamTableRows == self.__tcamPotMatchAddr and tcamTableCols - 1 == self.__tcamQueryStrLen:
260            logging.info('"MATCH FOUND": TCAM table map rows == TCAM table YAML config potMatchAddr')
261            printVerbose(verbose, '"MATCH FOUND": TCAM table map rows == TCAM table YAML config potMatchAddr')
262            logging.info('"MATCH FOUND": TCAM table map cols == TCAM table YAML config queryStrLen')
263            printVerbose(verbose, '"MATCH FOUND": TCAM table map cols == TCAM table YAML config queryStrLen')
264            return [tcamTableRows, tcamTableCols]
265        logging.error('"MATCH NOT FOUND": TCAM table map rows != TCAM table YAML config potMatchAddr')
266        logging.error('"MATCH NOT FOUND": TCAM table map cols != TCAM table YAML config queryStrLen')
267        sys.exit('"MATCH NOT FOUND": MISMATCH in TCAM table map and YAML config rows/cols')
268
269    def getSRAMTableDim(self, verbose):
270        """
271        Generate the dimensions of the SRAM table map data frame using TCAM table map configs.
272
273        :param int verbose: print information in verbose mode.
274        :return int: list containing dimensions of SRAM table memory map.
275        """
276        self.__sramTableRows = self.__tcamTotalSubStr * pow(2, self.__tcamSubStrLen)
277        self.__sramTableCols = self.__tcamPotMatchAddr
278        logging.info("SRAM table rows [{%4d}] cols [{%4d}]", self.__sramTableRows, self.__sramTableCols)
279        printVerbose(verbose, f"SRAM table rows [{self.__sramTableRows}] cols [{self.__sramTableCols}]")
280        return [self.__sramTableRows, self.__sramTableCols]
281
282    def genSRAMTable(self, verbose):
283        """
284        Create an empty SRAM table map data frame containing respective row addresses and column headings.
285
286        :param int verbose: print information in verbose mode.
287        """
288        # * create temp vars
289        sramTableAddrList = []
290        sramColHeadings = []
291        # * create row address
292        for i in range(self.__tcamTotalSubStr):
293            for j in range(2**self.__tcamSubStrLen):
294                padding = "0" + str(self.__tcamSubStrLen) + "b"
295                # sramTableAddrList.append(format(j, '#012b'))  # with 0b prefix
296                sramTableAddrList.append(format(j, padding))  # without 0b prefix
297            logging.info("Created [{%4d}] SRAM addresses from search query [{%4d}]", j + 1, i)
298            printVerbose(verbose, f"Created [{j+1}] SRAM addresses from search query [{i}]")
299        # * create col headings
300        for k in reversed(range(self.__tcamPotMatchAddr)):
301            heading = "D" + str(k)
302            sramColHeadings.append(heading)
303            logging.info("Created column heading %s", heading)
304        # * gen empty m*n sram table
305        self._sramTable = pd.DataFrame(index=np.arange(self.__sramTableRows), columns=np.arange(self.__sramTableCols))
306        # * rename column headings
307        self._sramTable.columns = sramColHeadings
308        # * insert addr col at position 0
309        self._sramTable.insert(0, "Addresses", sramTableAddrList, allow_duplicates=True)
310        logging.info("Created empty [%d x %d] SRAM table", self._sramTable.shape[0], self._sramTable.shape[1])
311        printVerbose(verbose, f"Created empty [{self._sramTable.shape[0]} x {self._sramTable.shape[1]}] SRAM table")
312
313    def createSRAMTableDir(self, verbose):
314        """
315        Create a directory to store SRAM table maps in various formats.
316
317        :param int verbose: print information in verbose mode.
318        :return str: absolute path of the SRAM table map directory.
319        """
320        # * create sramTables dir if it doesn't exist
321        self.sramTableDir = os.path.join(self.prjWorkDir, "sramTables")
322        if os.path.exists(self.sramTableDir) is False:
323            os.makedirs("sramTables")
324            logging.info("Created sramTables dir: %s", self.sramTableDir)
325            printVerbose(verbose, f"Created sramTables dir: {self.sramTableDir}")
326        return self.sramTableDir
327
328    def splitRowsAndCols(self, debug):
329        """
330        Create TCAM and SRAM table map row and column vectors based on TCAM table config parameters.
331
332        :param int debug: print information in debug mode.
333        :return list: list containing TCAM and SRAM row and column vectors.
334        """
335        # * store tcam and sram table in temp vars
336        tcamDF = self._tcamTable
337        sramDF = self._sramTable
338        logging.info("TCAM table (r*c): %s", tuple(tcamDF.shape))
339        logging.info("SRAM table (r*c): %s", tuple(sramDF.shape))
340        # * create tcamRows vector
341        self.__tcamRows = np.arange(0, self.__tcamPotMatchAddr, 1).tolist()
342        logging.info("TCAM table row vector: %s", list(self.__tcamRows))
343        printDebug(debug, f"TCAM table row vector: {*self.__tcamRows,}")
344        # * create tcamCols vector
345        self.__tcamCols = np.arange(1, self.__tcamQueryStrLen + 1, 1).tolist()
346        logging.info("TCAM table col vector: %s", list(self.__tcamCols))
347        printDebug(debug, f"TCAM table col vector: {*self.__tcamCols,}")
348        # * create tcamColVec vector and split in equal pieces
349        self.__tcamColVec = np.array_split(self.__tcamCols, self.__tcamTotalSubStr)
350        for i in range(len(self.__tcamColVec)):
351            self.__tcamColVec[i] = self.__tcamColVec[i].tolist()
352            logging.info("TCAM table col split vector [%d]: %s", i, list(self.__tcamColVec[i]))
353            printDebug(debug, f"TCAM table col split vector [{i}]: {self.__tcamColVec[i]}")
354        # * create sramRows vector
355        self.__sramRows = np.arange(0, self.__tcamTotalSubStr * 2**self.__tcamSubStrLen, 1).tolist()
356        logging.info("SRAM table row vector: %s", list(self.__sramRows))
357        printDebug(debug, f"SRAM table row vector: {self.__sramRows}")
358        # * create sramRowVec vector and split in equal pieces
359        self.__sramRowVec = np.array_split(self.__sramRows, self.__tcamTotalSubStr)
360        for i in range(len(self.__sramRowVec)):
361            self.__sramRowVec[i] = self.__sramRowVec[i].tolist()
362            logging.info("SRAM table row split vector [%d]: %s", i, list(self.__sramRowVec[i]))
363            printDebug(debug, f"SRAM table row split vector [{i}]: {self.__sramRowVec[i]}")
364        # * create sramCols vector
365        self.__sramCols = np.arange(0, self.__tcamPotMatchAddr + 1, 1).tolist()
366        logging.info("SRAM table col vector: %s", list(self.__sramCols))
367        printDebug(debug, f"SRAM table col vector: {self.__sramCols}")
368        return [self.__tcamRows, self.__tcamColVec, self.__sramRowVec, self.__sramCols]
369
370    def isolateTCAMSearchQueries(self, verbose, debug):
371        """
372        Create a data frame containing all the sub strings in original format from all the TCAM table search queries.
373
374        :param int verbose: print information in verbose mode.
375        :param int debug: print information in debug mode.
376        """
377        tcamDF = self._tcamTable
378        count1 = 0
379        self._tcamQSAddrTable = pd.DataFrame(columns=["TCAM Query Str Addr", "PMA", "QS col"])
380
381        # * ----- add all original search queries in dataframe
382        # * iterate through tcam table rows
383        for row in range(len(tcamDF)):
384            # * iterate through tcam table cols
385            for col in range(len(self.__tcamColVec)):
386                # * search and concat search query string address in tcam table
387                tempAddr = [str(c) for c in list(tcamDF.iloc[row, self.__tcamColVec[col]])]
388                tempAddr = "".join(tempAddr)
389                # * append row in sqSubStrAddrDf data frame
390                tempRow = [tempAddr, row, col]
391                self._tcamQSAddrTable.loc[count1] = tempRow
392                count1 += 1
393                logging.info("TCAM Search Queries Table | Addr: %s | TCAM Row: %5d | Sub String Col: %5d |", tempAddr, row, col)
394                printDebug(debug, f"TCAM Search Queries Table | Addr: {tempAddr} | TCAM Row: {row} | Sub String Col: {col} |")
395        if verbose:
396            self.printDF(self._tcamQSAddrTable, "Original TCAM Search Query Address Table")
397
398    def generateSRAMSubStr(self, verbose, debug):
399        """
400        Generate all possible combinations of all sub strings from the original TCAM table search queries.
401
402        :param int verbose: print information in verbose mode.
403        :param int debug: print information in debug mode.
404        """
405        count2 = 0
406        self._sramQSAddrTable = pd.DataFrame(columns=["SRAM Query Str Addr", "PMA", "QS col"])
407
408        # * ----- find all possible alternatives for X based addr
409        # * create array of N bit bin addresses
410        queryStrBinAddrList = np.arange(2**self.__tcamSubStrLen).tolist()
411        padding = "0" + str(self.__tcamSubStrLen) + "b"
412        for item in queryStrBinAddrList:
413            dec2Bin = format(item, padding)
414            queryStrBinAddrList = queryStrBinAddrList[:item] + [dec2Bin] + queryStrBinAddrList[item + 1 :]
415        logging.info("N bit bin addr list: %s", list(queryStrBinAddrList))
416        logging.info("N bit bin addr list len: %d", len(queryStrBinAddrList))
417        if verbose or debug:
418            print("N bit bin addr list: %s", list(queryStrBinAddrList))
419            print("N bit bin addr list len: %d", len(queryStrBinAddrList))
420
421        # * get origSQ addr
422        tempQSAddrList = self._tcamQSAddrTable["TCAM Query Str Addr"].to_list()
423        tempQSPmaList = self._tcamQSAddrTable["PMA"].to_list()
424        tempQSColList = self._tcamQSAddrTable["QS col"].to_list()
425
426        printDebug(debug, f"Search Query addr list: {tempQSAddrList}")
427        printDebug(debug, f"Search Query addr list len: {len(tempQSAddrList)}\n")
428        # * map the 'bX in search queries to 0 and 1
429        for (oldAddr, pma, qscol) in zip(tempQSAddrList, tempQSPmaList, tempQSColList):
430            # * if 'bX in search query then find all possible alternatives and add in table
431            if "x" in oldAddr:
432                for newAddr in queryStrBinAddrList:
433                    matching = jellyfish.damerau_levenshtein_distance(oldAddr, newAddr)
434                    if matching == len(re.findall("x", oldAddr)):
435                        printVerbose(
436                            verbose,
437                            f"count = {count2} | orig Search Query = {oldAddr} | " f"new Search Query = {newAddr} | matching ratio = {matching} |",
438                        )
439                        logging.info(
440                            "count = %d | orig Search Query = %s | new Search Query = %s | matching ratio = %f |", count2, oldAddr, newAddr, matching
441                        )
442                        self._sramQSAddrTable.loc[count2] = [newAddr, pma, qscol]
443                        count2 += 1
444            # * else simply add search query in table as is
445            else:
446                printVerbose(verbose, f"count = {count2} | orig Search Query = {oldAddr} | new Search Query = {oldAddr} | matching ratio = {0} |")
447                logging.info("count = %d | orig Search Query = %s | new Search Query = %s | matching ratio = %f |", count2, oldAddr, oldAddr, 0)
448                self._sramQSAddrTable.loc[count2] = [oldAddr, pma, qscol]
449                count2 += 1
450
451        if verbose:
452            self.printDF(self._sramQSAddrTable, "Original SRAM Search Query Address Table")
453
454    def mapTCAMtoSRAM(self, verbose, debug):
455        """
456        Map all possible combinations of TCAM table map sub strings to SRAM table map sub strings.
457
458        :param int verbose: print information in verbose mode.
459        :param int debug: print information in debug mode.
460        """
461        sramDF = self._sramTable
462        sramAddrList = self._sramQSAddrTable["SRAM Query Str Addr"].to_list()
463        tcamRowList = self._sramQSAddrTable["PMA"].to_list()
464        sramColList = self._sramQSAddrTable["QS col"].to_list()
465
466        if len(tcamRowList) == len(sramColList):
467            for (queryStr, pma, qsCol) in itertools.zip_longest(sramAddrList, tcamRowList, sramColList):
468                # * create sram table subsections based on query str
469                tempSRAMTable = sramDF.iloc[self.__sramRowVec[qsCol], self.__sramCols]
470                logging.info("Search Query mapping portion: %d", qsCol)
471                printDebug(debug, f"Search Query mapping portion: {qsCol}")
472                # print(tabulate(tempSRAMTable,headers='keys',tablefmt='github'),'\n')
473                # * find specific mapping cell in sram table
474                rowIndex = tempSRAMTable.index[tempSRAMTable["Addresses"] == queryStr].to_list()[0]
475                colIndex = len(self.__sramCols) - pma - 1
476                # print('sram rowIndex: ',rowIndex,type(rowIndex))
477                # print('sram colIndex: ',colIndex,type(colIndex))
478                # * find specific entry
479                oldSramTableEntry = sramDF.iloc[rowIndex, colIndex]
480                # print(sramDF.iloc[rowIndex,colIndex])
481                # * replace specific entry
482                sramDF.iat[rowIndex, colIndex] = 1
483                # * print before and after
484                if verbose or debug:
485                    logging.info("SRAM table cell [%d, %d] | Value = %s -> %s", rowIndex, colIndex, oldSramTableEntry, sramDF.iat[rowIndex, colIndex])
486                    printDebug(debug, f"SRAM table cell [{rowIndex}, {colIndex}] | Value = {oldSramTableEntry} -> {sramDF.iat[rowIndex,colIndex]}")
487            # * add zeros in empty cells
488            sramDF = sramDF.fillna(0)
489            self._sramTable = sramDF
490        else:
491            logging.error('"MATCH NOT FOUND": TCAM table rows != SRAM table cols config potMatchAddr')
492            sys.exit('"MATCH NOT FOUND": MISMATCH in TCAM table map and YAML config rows/cols')
493
494    def writeSRAMtoXlsx(self):
495        """
496        Generates an SRAM table map in XLSX format.
497
498        :return str: absolute path of the SRAM table map `.xlsx` file.
499        """
500        # * create sram table file path and name
501        self.sramTableXlsxFileName = os.path.basename(self.tcamTableXlsxFileName.replace("tcam", "sram"))
502        self.sramTableXlsxFilePath = os.path.join(self.sramTableDir, self.sramTableXlsxFileName)
503        # * create excel file in dir sramTables
504        # writer = pd.ExcelWriter(self.sramTableXlsxFilePath,engine='xlsxwriter')
505        # writer.save()
506        # * apply formatting to dataframe
507        self._sramTable.style.applymap(highlightCell).to_excel(
508            excel_writer=self.sramTableXlsxFilePath, sheet_name=self.sramTableXlsxFileName, na_rep="", header=True, index=True, engine="openpyxl"
509        )
510        logging.info("Created SRAM table XLSX file: %s", self.sramTableXlsxFilePath)
511        print("Created SRAM table XLSX file: %s", self.sramTableXlsxFilePath)
512        return self.sramTableXlsxFilePath
513
514    def writeSRAMtoHtml(self):
515        """
516        Generates an SRAM table map in HTML format.
517
518        :return str: absolute path of the SRAM table map `.html` file.
519        """
520        # * create sram table file path and name
521        self.sramTableHtmlFileName = os.path.basename(self.tcamTableXlsxFileName.replace("tcam", "sram").replace(".xlsx", ".html"))
522        self.sramTableHtmlFilePath = os.path.join(self.sramTableDir, self.sramTableHtmlFileName)
523        # * create html file in dir sramTables
524        self._sramTable.to_html(self.sramTableHtmlFilePath, index=True, header=True, justify="center", classes="table table-stripped")
525        logging.info("Created SRAM table HTML file: %s", self.sramTableHtmlFilePath)
526        print("Created SRAM table HTML file: %s", self.sramTableHtmlFilePath)
527        return self.sramTableHtmlFilePath
528
529    def writeSRAMtoJson(self):
530        """
531        Generates an SRAM table map in JSON format.
532
533        :return str: absolute path of the SRAM table map `.json` file.
534        """
535        # * create sram table file path and name
536        self.sramTableJsonFileName = os.path.basename(self.tcamTableXlsxFileName.replace("tcam", "sram").replace(".xlsx", ".json"))
537        self.sramTableJsonFilePath = os.path.join(self.sramTableDir, self.sramTableJsonFileName)
538        # * create json file in dir sramTables
539        self._sramTable.to_json(self.sramTableJsonFilePath, orient="index", indent=4)
540        logging.info("Created SRAM table JSON file: %s", self.sramTableJsonFilePath)
541        print("Created SRAM table JSON file: %s", self.sramTableJsonFilePath)
542        return self.sramTableJsonFilePath
543
544    def writeSRAMtoTxt(self):
545        """
546        Generates an SRAM table map in TXT format.
547
548        :return str: absolute path of the SRAM table map `.txt` file.
549        """
550        # * create sram table file path and name
551        self.sramTableTxtFileName = os.path.basename(self.tcamTableXlsxFileName.replace("tcam", "sram").replace(".xlsx", ".txt"))
552        self.sramTableTxtFilePath = os.path.join(self.sramTableDir, self.sramTableTxtFileName)
553        # * create txt file in dir sramTables
554        myTable = tabulate(self._sramTable, headers="keys", showindex=True, disable_numparse=True, tablefmt="github")
555        with open(self.sramTableTxtFilePath, "w", encoding="utf-8") as file:
556            file.write(myTable)
557        logging.info("Created SRAM table Txt file:  %s", self.sramTableTxtFilePath)
558        print("Created SRAM table Txt file:  %s", self.sramTableTxtFilePath)
559        return self.sramTableTxtFilePath
560
561
562# ===========================================================================================
563# ======================================== End Class ========================================
564# ===========================================================================================
565
566
567def printVerbose(verbose, msg):
568    """
569    Prints a string if verbose flag is active.
570
571    :param int verbose: print information in verbose mode.
572    :param str msg: Message to be printed in verbose mode.
573    """
574    if verbose:
575        print(str(msg))
576
577
578def printDebug(debug, msg):
579    """
580    Prints a string if debug flag is active.
581
582    :param int debug: print information in debug mode.
583    :param str msg: Message to be printed in debug mode.
584    """
585    if debug:
586        print(str(msg))
587
588
589def highlightCell(val):
590    """
591    Colors SRAM table map cells in XLSX file depending upon their value.
592
593    :param int val: numerical value of a particular cell.
594    :return str: cell background color code as a hex RBG value.
595    """
596    if val == 1:
597        color = "#E5961A"
598    elif val == 0:
599        color = "#E4EA15"
600    else:
601        color = "#D8C05A"
602    return f"background-color: {color}"