diff --git a/cells/klayout/pymacros/README.md b/cells/klayout/pymacros/README.md
index 882d5558..feb46387 100644
--- a/cells/klayout/pymacros/README.md
+++ b/cells/klayout/pymacros/README.md
@@ -1,3 +1,35 @@
-# Pymacros (Pcells)
+# Klayout PCells implementation.
+
+You could use those PCells either in 2 ways:
+1. Use volare built PDK directly from: https://github.com/efabless/volare
+2. Use the PDK from this primitive library for testing purposes.
+
+## Using PCells from Volare
+Please refer to Volare documentation at: https://github.com/efabless/volare/blob/main/Readme.md
+
+## Using PCells from this repo directly.
+To use the PDK from this repo directly, you need to do the following:
+1. Go to following folder in the repo `cells/klayout` and then run the following command:
+```bash
+export KLAYOUT_HOME=`pwd`
+```
+2.(optional step to enable GUI menu for running DRC/LVS) You will need to run the following commands as well from inside `cells/klayout` folder:
+```bash
+ln -s ../../rules/klayout/drc 
+ln -s ../../rules/klayout/lvs
+ln -s ../../rules/klayout/macros
+ln -s ../../tech/klayout/gf180mcu.lyt
+ln -s ../../tech/klayout/gf180mcu.lyp
+```
+3. Go to any location where you want to start designing, and open klayout using the following command:
+```bash
+klayout -e
+```
+4. Create a new layout for testing.
+5. Press on insert instance.
+6. Go to the instance menu and select "GF180MCU" library from the library list.
+7. Select the search botton and it will give the list of PCells that is available in the library.
+8. Select any cell and it will show the cell.
+9. Go to the PCell tap and change the parameters as needed to change the layout of the PCells.
+
 
-Contains klayout pcells generator.
diff --git a/models/ngspice/testing/README.md b/models/ngspice/testing/README.md
index 2205747f..8f3c709a 100644
--- a/models/ngspice/testing/README.md
+++ b/models/ngspice/testing/README.md
@@ -6,34 +6,31 @@ Explains how to run GF180nm models-ngspice regression.
 
 ```text
 📦testing
- ┣ 📜Makefile
- ┣ 📜README.md
- ┣ 📦regression
- ┣ 📦smoke_test
- ┣ 📦180MCU_SPICE_Models
+ ┣ 📜Makefile                                   (Makefile to setup test cases)
+ ┣ 📜README.md                                  (This file)
+ ┣ 📦sc_regression/gf180mcu_fd_sc_mcu7t5v0      (Standard cells regression that simulates the standard cells using different voltage stimulus.)
+ ┣ 📦regression                                 (This is the regression folder that has a test case per device.)
+ ┣ 📦smoke_test                                 (An inverter design that simulates in all corners to make sure that all corners will work with no issue.)
+ ┣ 📦180MCU_SPICE_Models                        (Foundry measurement data used for model calibration.)
  ```
 
 ## Prerequisites
 
 At a minimum:
-
-- Git 2.35+
 - Python 3.6+
-- ngspice-36+
-
-### On Ubuntu, you can just
+- ngspice-37+
 
-`apt install -y build-essential python3`
-
-- Check this [ngspice](http://ngspice.sourceforge.net/download.html) for ngspice installation.
+Our test environment has the following:
+- Python 3.9.12
+- ngspice-37
 
 ## Regression Usage
 
-To make a full test for GF180nm models-ngspice, you could use the following command in testing directory:
+- To make a full test for GF180nm models-ngspice, you could use the following command in testing directory:
 
-```bash
-make all
-```
+    ```bash
+    make all
+    ```
 
 - You could also check allowed targets in the Makefile, using the following command:
 
@@ -43,9 +40,51 @@ make all
 
 ## **Regression Outputs**
 
-- The resulting files are in `regression/<device_folder>/` with name of `<device_name><options>` that contains:
+After running regression, you should find the following in the folder `run_<date>_<time>` under that folder you will find the folder structure:
+```text
+run_<date_time>/
+├── bjt_beta
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── bjt_cj
+│   ├── device_netlists                (Template Netlists)
+│   ├── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── bjt_iv
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── diode
+│   ├── 0_measured_data
+│   ├── device_netlists                (Template Netlists)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+│   ├── models_regression.py           (Regression script for device)
+├── mimcap_c
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── moscap_c
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_cv
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_iv_vbs
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_iv_vgs
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── resistor_r
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+└── run_log.log                        (Summary of all runs for all devices)
+```
 
-    1. A final report file of all results.
-    2. measured folder that contains measured data used in regression.
-    3. simulated folder that contains simulated data used in regression.
-    4. netlists folder that contains spice files used in simulation.
+It's important to check the `run_log.log` to see the error per device.
diff --git a/models/xyce/testing/README.md b/models/xyce/testing/README.md
index 063cc259..ee75227e 100644
--- a/models/xyce/testing/README.md
+++ b/models/xyce/testing/README.md
@@ -21,19 +21,13 @@ At a minimum:
 - Python 3.6+
 - Xyce 7.5+
 
-### On Ubuntu, you can just
-
-`apt install -y build-essential python3`
-
-- Check this [xyce](https://xyce.sandia.gov/documentation-tutorials/building-guide/) for Xyce installation.
-
 ## Regression Usage
 
-To make a full test for GF180nm models-xyce, you could use the following command in testing directory:
+- To make a full test for GF180nm models-xyce, you could use the following command in testing directory:
 
-```bash
-make all
-```
+    ```bash
+    make all
+    ```
 
 - You could also check allowed targets in the Makefile, using the following command:
 
@@ -43,9 +37,51 @@ make all
 
 ## **Regression Outputs**
 
-- The resulting files are in `regression/<device_folder>/` with name of `<device_name><options>` that contains:
+After running regression, you should find the following in the folder `run_<date>_<time>` under that folder you will find the folder structure:
+```text
+run_<date_time>/
+├── bjt_beta
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── bjt_cj
+│   ├── device_netlists                (Template Netlists)
+│   ├── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── bjt_iv
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── diode
+│   ├── 0_measured_data
+│   ├── device_netlists                (Template Netlists)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+│   ├── models_regression.py           (Regression script for device)
+├── mimcap_c
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── moscap_c
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_cv
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_iv_vbs
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── mos_iv_vgs
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+├── resistor_r
+│   ├── device_netlists                (Template Netlists)
+│   └── models_regression.py           (Regression script for device)
+│   ├── <dev>_...                      (Output folder after runing with run logs and actual netlists)
+└── run_log.log                        (Summary of all runs for all devices)
+```
 
-    1. A final report file of all results.
-    2. measured folder that contains measured data used in regression.
-    3. simulated folder that contains simulated data used in regression.
-    4. netlists folder that contains spice files used in simulation.
+It's important to check the `run_log.log` to see the error per device.
diff --git a/rules/klayout/drc/testing/run_regression.py b/rules/klayout/drc/testing/run_regression.py
index 5582f727..14f5c69f 100644
--- a/rules/klayout/drc/testing/run_regression.py
+++ b/rules/klayout/drc/testing/run_regression.py
@@ -32,6 +32,8 @@
     --run_name=<run_name>               Select your run name.
 """
 
+from subprocess import check_call
+
 from docopt import docopt
 import os
 import datetime
@@ -39,21 +41,21 @@
 import csv
 import time
 import re
-
-from sympy import arg
+import pandas as pd
+import logging
 
 def call_regression(rule_deck_path, path):
+
     t0 = time.time()
     marker_gen = []
-    rules =[]
-    ly = 0
+    rules      = []
+    ly         = 0
 
     # set folder structure for each run
     x = f"{datetime.datetime.now()}"
     x = x.replace(" ", "_")
-
     name_ext = str(rule_deck_path).replace(".drc","").split("/")[-1]
-    os.system(f"mkdir run_{x}_{name_ext}")
+    check_call(f"mkdir run_{x}_{name_ext}", shell=True)
 
     # Get the same rule deck with gds output
     with open(rule_deck_path, 'r') as f:
@@ -86,13 +88,13 @@ def call_regression(rule_deck_path, path):
     iname = path.split('.gds')
     if '/' in iname[0]:
         file = iname[0].split('/')
-        os.system(f"klayout -b -r run_{x}_{name_ext}/markers.drc -rd input={path} -rd report={file[-1]}.lyrdb -rd thr={thrCount} {switches} ")
+        check_call(f"klayout -b -r run_{x}_{name_ext}/markers.drc -rd input={path} -rd report={file[-1]}.lyrdb -rd thr={thrCount} {switches} ", shell=True)
     else:
-        os.system(f"klayout -b -r run_{x}_{name_ext}/markers.drc -rd input={path} -rd report={iname[0]}.lyrdb -rd thr={thrCount} {switches} ")
+        check_call(f"klayout -b -r run_{x}_{name_ext}/markers.drc -rd input={path} -rd report={iname[0]}.lyrdb -rd thr={thrCount} {switches} ", shell=True)
 
     marker_gen = []
-    ly = 0
-    remove_if = False
+    ly         = 0
+    remove_if  = False
 
     # Get the small rule deck with gds output
     with open(rule_deck_path, 'r') as f:
@@ -132,27 +134,32 @@ def call_regression(rule_deck_path, path):
     marker_file.close()
 
     # Generate databases
-    os.system(f"klayout -b -r run_{x}_{name_ext}/regression.drc -rd input=run_{x}_{name_ext}/merged_output.gds -rd report=database.lyrdb -rd thr={thrCount} {switches}")
-
-    # Cleaning directories
-    # os.system(f"rm -rf regression.drc markers.drc merged_output.gds")
+    check_call(f"klayout -b -r run_{x}_{name_ext}/regression.drc -rd input=run_{x}_{name_ext}/merged_output.gds -rd report=database.lyrdb -rd thr={thrCount} {switches}", shell=True)
 
     mytree = ET.parse(f'run_{x}_{name_ext}/database.lyrdb')
     myroot = mytree.getroot()
 
-    report = [["Rule_Name", "False_Positive", "False_Negative", "Total_Violations", "Not_Tested"]]
+    report = [["Rule_Name", "False_Positive", "False_Negative", "Total_Violations", "Not_Tested" , "Known_issues"]]
     conc = [["Rule_Name", "Status"]]
 
-    passed = 0
-    failed = 0
-    not_tested_counter = 0
+    # Initial counters 
+    not_tested_c = 0
+    passed       = 0
+    failed       = 0
+    known_issues = 0
+
+    # Get known issues list
+    known_issues_df = pd.read_csv("DRC_Known_issues.csv", usecols=["Rule "])
+    known_issues_list = known_issues_df["Rule "].tolist()
+
     for lrule in rules:
+
         # Values of each rule in results
-        falseNeg = 0
-        falsePos = 0
-        not_tested = 0
-        not_run = 1
-        total = 0
+        not_run         = 1        
+        not_tested      = 0        
+        falseNeg        = 0
+        falsePos        = 0
+        total_violation = 0
 
         # Check whether the rule was run or not
         for z in myroot[5]:
@@ -170,20 +177,24 @@ def call_regression(rule_deck_path, path):
                     falsePos += 1
                 if f"'{lrule}_false_negative'" == f"{z[1].text}":#(f"{rule}" in f"{z[1].text}") and ("negative" in f"{z[1].text}"):
                     falseNeg += 1
-
-        total = falsePos + falseNeg
-        report.append([lrule, falsePos, falseNeg, total, not_tested])
-        if total == 0 and not_tested == 0:
+        
+        # failed rules 
+        total_violation = falsePos + falseNeg
+        
+        report.append([lrule, falsePos, falseNeg, total_violation, not_tested , known_issues])
+        if total_violation == 0 and not_tested == 0:
             conc.append([lrule, "Pass"])
             passed += 1
         elif not_tested != 0:
             conc.append([lrule, "Not_Tested"])
-            not_tested_counter += 1
+            not_tested_c += 1
+        elif lrule in known_issues_list:
+            conc.append([lrule, "known_issues"])
+            known_issues +=1
         else:
             conc.append([lrule, "Fail"])
             failed += 1
 
-
     # Create final reports files
     with open(f'run_{x}_{name_ext}/report.csv', 'w') as f:
         writer = csv.writer(f, delimiter=',')
@@ -193,26 +204,52 @@ def call_regression(rule_deck_path, path):
         writer = csv.writer(f, delimiter=',')
         writer.writerows(conc)
 
-    print(f"\n Total rules in {name_ext} for {path}: {len(conc)} \n")
-    print(f"{passed} passed rules ")
-    print(f"{failed} failed rules ")
-    print(f"{not_tested_counter} Not tested rules \n")
+    logging.info(f"========= Summary Report in {name_ext} for {path} =========")
+    logging.info(f"Total rules: {len(conc)}")
+    logging.info(f"{not_tested_c} not tested rules")    
+    logging.info(f"{passed} passed rules ")
+    logging.info(f"{known_issues} known_issues rules ")
+    logging.info(f"{failed} failed rules ")
+    
     t1 = time.time()
-
-    print(f'Execution time {t1 - t0} s')
+    logging.info(f'Execution time {t1 - t0} s')
+    logging.info(f"===============================================================")
+
+    if failed > 0:
+        logging.info("Some unit tests has failed. Failing regression:")
+        df = pd.read_csv(f'run_{x}_{name_ext}/conclusion.csv')
+        pd.set_option('display.max_columns', None)
+        pd.set_option('display.max_rows', None)
+        pd.set_option("max_colwidth", None)
+        pd.set_option('display.width', 1000)
+        logging.info("## Full report:")
+        print(df)
+
+        print("\n")
+        logging.info("## Only failed")
+        print(df[df["Status"] == "Fail"])
+
+        exit(1)
     return report
 
 if __name__ == "__main__":
 
-    sub_report = []
-    full_report = []
+    # logs format
+    logging.basicConfig(level=logging.DEBUG, format=f"%(asctime)s | %(levelname)-7s | %(message)s", datefmt='%d-%b-%Y %H:%M:%S')
+
+    # Initial values for DRC report
+    sub_report   = []
+    full_report  = []
     final_report = [["Rule_Name", "Status"]]
-    final_detailed_report = [["Rule_Name", "False_Postive", "False_Negative", "Total_Violations", "Not_Tested"]]
+    final_detailed_report = [["Rule_Name", "False_Postive", "False_Negative", "Total_Violations", "Not_Tested" , "Known_issues"]]
 
+    # Start of execution time 
     t0 = time.time()
 
+    # Reading docopt arguments
     args = docopt(__doc__)
 
+    # DRC switches definitions 
     switches = ''
 
     if args["--no_feol"]:
@@ -230,41 +267,33 @@ def call_regression(rule_deck_path, path):
     else:
         switches = switches + '-rd offgrid=true '
 
-    # Getting threads count
-    if args["--thr"]:
-        thrCount = args["--thr"]
-    else:
-        thrCount = os.cpu_count() * 2
-
     if args["--metal_top"] in ["6K" , "9K", "11K", "30K"]:
         switches = switches + f'-rd metal_top={args["--metal_top"]} '
     else:
-        print("Top metal thickness allowed values are (6K , 9K, 11K, 30K) only")
+        logging.error("Top metal thickness allowed values are (6K , 9K, 11K, 30K) only")
         exit()
 
     if args["--mim_option"] in ["A" , "B", "NO_MIM"]:
         switches = switches + f'-rd mim_option={args["--mim_option"]} '
     else:
-        print("MIM capacitor option allowed values are (A, B, NO_MIM) only")
+        logging.error("MIM capacitor option allowed values are (A, B, NO_MIM) only")
         exit()
 
     if args["--metal_level"] in ["2" , "3", "4", "5" , "6"]:
         switches = switches + f'-rd metal_level={args["--metal_level"]}LM '
     else:
-        print("The number of metal layers in stack allowed values are (2, 3, 4, 5, 6) only")
+        logging.error("The number of metal layers in stack allowed values are (2, 3, 4, 5, 6) only")
         exit()
 
-
-    os.system("klayout -v")
-
+    # Starting regression     
+    # Getting drc rule decks
     rule_deck_path = []
-
     files = os.listdir(f'..')
-
     for file in files:
         if ".drc" in file:
             rule_deck_path.append(f"../{file}")
 
+    # Running regression
     for path in args["--path"]:
         for runset in rule_deck_path:
             return_report = call_regression(runset, path)
@@ -272,7 +301,6 @@ def call_regression(rule_deck_path, path):
         full_report.append(sub_report)
         sub_report = []
 
-
     rule_num = 0
 
     for rule in full_report[0]:
@@ -306,6 +334,6 @@ def call_regression(rule_deck_path, path):
         writer = csv.writer(f, delimiter=',')
         writer.writerows(final_report)
 
+    #  End of execution time 
     t1 = time.time()
-
-    print(f'Total execution time {t1 - t0} s')
+    logging.error(f'Total execution time {t1 - t0} s')
diff --git a/rules/klayout/drc/testing/run_sc_regression.py b/rules/klayout/drc/testing/run_sc_regression.py
index 8bd49343..60d48322 100644
--- a/rules/klayout/drc/testing/run_sc_regression.py
+++ b/rules/klayout/drc/testing/run_sc_regression.py
@@ -25,15 +25,17 @@
     --thr=<thr>         The number of threads used in run.
 
 """
+from subprocess import check_call
+
 from docopt import docopt
 import os
 import xml.etree.ElementTree as ET
-import csv
+import pandas as pd
 import time
 import concurrent.futures
 
 
-def get_results(rule_deck_path, iname, file, x):
+def get_results(results_file_path):
     """
     The function takes the path of the rule deck and the path of the gds file as inputs, then it runs
     the DRC using the rule deck on the gds file and returns the name of the gds file, the name of the
@@ -43,13 +45,12 @@ def get_results(rule_deck_path, iname, file, x):
     :param path: The path to the GDS file you want to check
     :return: the file name, the rule deck name, the violated rules and the status of the file.
     """
-    mytree = ET.parse(f"{iname[0]}_{x}.lyrdb")
+    mytree = ET.parse(results_file_path)
     myroot = mytree.getroot()
 
     violated = []
 
     for lrule in rules:
-
         # Loop on database to get the violations of required rule
         for z in myroot[7]:
             if f"'{lrule}'" == f"{z[1].text}":
@@ -57,15 +58,11 @@ def get_results(rule_deck_path, iname, file, x):
                 break
 
     if len(violated) > 0:
-        status = "Not_clean"
+        status = "not_clean"
     else:
-        status = "Clean"
-
-    rule_deck = rule_deck_path.split("../")
+        status = "clean"
 
-    print(f"\n The file {file[-1]} has violated rule deck {rule_deck[-1]} in: {len(violated)} rule/s which are: {violated} \n")
-    print(f" The file {file[-1]} with rule deck {rule_deck[-1]} is {status} \n")
-    return file[-1], rule_deck[-1], ' '.join(violated), status
+    return ' '.join(violated), len(violated), status
 
 def call_simulator(arg):
     """
@@ -76,7 +73,13 @@ def call_simulator(arg):
     :param path: The path to the GDS file you want to simulate
     :param thrCount: number of threads to use
     """
-    os.system(arg)
+    try:
+        check_call(arg, shell=True)
+        return True
+    except Exception as e:
+        print("## Run generated exception: ", arg)
+        print(str(e))
+        return False
 
 if __name__ == "__main__":
 
@@ -86,7 +89,7 @@ def call_simulator(arg):
     if os.path.exists("sc"):
         os.system("rm -rf sc")
 
-    report = [["File_Name", "Rule Deck", "Rules", "Status"]]
+    report_header = ["File_Name", "Rule Deck", "Rules", "Status"]
 
     # Get threads count
     if args["--thr"]:
@@ -94,11 +97,9 @@ def call_simulator(arg):
     else:
         thrCount = os.cpu_count() * 2
 
-    os.system("klayout -v")
-
     rule_deck_path = []
     rules = []
-    runs = []
+    runs = dict()
 
     files = os.listdir('..')
 
@@ -136,14 +137,18 @@ def call_simulator(arg):
         iname = path.split('.gds')
         file = iname[0].split('/')
         if "sc" in file[-1]:
+            print("## Extracting top cells for : ", path)
             os.system(f"klayout -b -r split_gds.rb -rd input={path}")
             print(f"File {path} was splitted into multiple gds files")
+        else:
+            print(f"## {path} Not a standard cells library GDS. We will use the full GDS. No splitting required.")
 
+    ## If this was a standard cells library, get the new list of files.
     if os.path.exists("sc"):
         other_files = os.listdir('sc')
         args["--path"] = args["--path"] + other_files
 
-    # Get input data for simulator
+    # Get input data for klayout runs and create the run list.
     for path in args["--path"]:
         x = 0
         iname = path.split('.gds')
@@ -156,34 +161,53 @@ def call_simulator(arg):
         file = iname[0].split('/')
         for runset in rule_deck_path:
             arg = f"klayout -b -r {runset} -rd input={path} -rd report={file[-1]}_{x}.lyrdb -rd thr={thrCount} -rd conn_drc=true"
-            runs.append(arg)
-            x += 1
-
-    # Run DRC
-    with concurrent.futures.ProcessPoolExecutor(max_workers=thrCount) as executor:
-        for run in runs:
-            executor.submit(call_simulator, run)
-
-    # Get results
-    for path in args["--path"]:
-        x = 0
-        iname = path.split('.gds')
-        file = iname[0].split('/')
-        if "sc" in file[-1]:
-            continue
-        if "/" not in path:
-            path = f"sc/{path}"
-        iname = path.split('.gds')
-        file = iname[0].split('/')
-        for runset in rule_deck_path:
-            if os.path.exists(f"{iname[0]}_{x}.lyrdb"):
-                file, rule_deck, violations, status = get_results(runset, iname, file, x)
-                report.append([file, rule_deck, violations, status])
+            run_id = f"{runset}|{path}|{file[-1]}_{x}.lyrdb"
+            runs[run_id] = arg
             x += 1
 
-    with open(f'sc_drc_report.csv', 'w') as f:
-        writer = csv.writer(f, delimiter=',')
-        writer.writerows(report)
+    print("## We will run klayout {} runs".format(len(runs)))
+
+    # Run All DRC runs.
+    report = []
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=thrCount) as executor:
+        # Start the load operations and mark each future with its URL
+        future_to_run_id = {executor.submit(call_simulator, runs[r]): r for r in runs}
+        for future in concurrent.futures.as_completed(future_to_run_id):
+            run_id = future_to_run_id[future]
+            run_info = run_id.split("|")
+            info = dict()
+            info["file_path"] = run_info[1]
+            info["runset"] = run_info[0]
+            info["results_file"] = run_info[2]
+            results_db_path = os.path.join(os.path.dirname(os.path.abspath(run_info[1])), run_info[2])
+
+            try:
+                run_status = future.result()
+                if run_status:
+                    violators, num_rules_violated, db_status = get_results(results_db_path)
+                    info["rules_violated"] = violators
+                    info["num_rules_violated"] = num_rules_violated
+                    info["run_status"] = db_status
+                else:
+                    info["rules_violated"] = ""
+                    info["num_rules_violated"] = 0
+                    info["run_status"] = "run throws exception"
+
+                report.append(info)
+
+            except Exception as exc:
+                print('%r generated an exception: %s' % (run_id, exc))
+
+
+    df = pd.DataFrame(report)
+    df.to_csv("ip_cells_run_report.csv", index=False)
+    pd.set_option('display.max_columns', None)
+    pd.set_option('display.max_rows', None)
+    pd.set_option("max_colwidth", None)
+    pd.set_option('display.width', 1000)
+
+    print(df)
 
     if os.path.exists("split_gds.rb"):
         os.remove("split_gds.rb")
@@ -193,3 +217,9 @@ def call_simulator(arg):
 
     t1 = time.time()
     print(f'Total execution time {t1 - t0} s')
+
+    if (df["run_status"] != "clean").any():
+        print("## Run failed as there are failures or violations.")
+        exit(1)
+    else:
+        print("## Run passed with no violations or failures.")