# Copyright 2020-2021 Efabless Corporation
# ECO Flow Copyright 2021 The University of Michigan
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

proc global_routing_or {args} {
    handle_deprecated_command global_routing
}

proc translate_min_max_layer_variables {args} {
    if { [info exists ::env(GLB_RT_MINLAYER) ] } {
        set ::env(RT_MIN_LAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(GLB_RT_MINLAYER) - 1}]]
        puts_warn "You're using GLB_RT_MINLAYER in your configuration, which is a deprecated variable that will be removed in the future."
        puts_warn "We recommend you update your configuration as follows:"
        puts_warn "\tset ::env(RT_MIN_LAYER) {$::env(RT_MIN_LAYER)}"
    }

    if { [info exists ::env(GLB_RT_MAXLAYER) ] } {
        set ::env(RT_MAX_LAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(GLB_RT_MAXLAYER) - 1}]]
        puts_warn "You're using GLB_RT_MAXLAYER in your configuration, which is a deprecated variable that will be removed in the future."
        puts_warn "We recommend you update your configuration as follows:"
        puts_warn "\tset ::env(RT_MAX_LAYER) {$::env(RT_MAX_LAYER)}"
    }

    if { [info exists ::env(GLB_RT_CLOCK_MINLAYER) ] } {
        set ::env(RT_CLOCK_MIN_LAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(GLB_RT_CLOCK_MINLAYER) - 1}]]
        puts_warn "You're using GLB_RT_CLOCK_MINLAYER in your configuration, which is a deprecated variable that will be removed in the future."
        puts_warn "We recommend you update your configuration as follows:"
        puts_warn "\tset ::env(RT_CLOCK_MIN_LAYER) {$::env(RT_CLOCK_MIN_LAYER)}"
    }

    if { [info exists ::env(GLB_RT_CLOCK_MAXLAYER) ] } {
        set ::env(RT_CLOCK_MAX_LAYER) [lindex $::env(TECH_METAL_LAYERS) [expr {$::env(GLB_RT_CLOCK_MAXLAYER) - 1}]]
        puts_warn "You're using GLB_RT_CLOCK_MAXLAYER in your configuration, which is a deprecated variable that will be removed in the future."
        puts_warn "We recommend you update your configuration as follows:"
        puts_warn "\tset ::env(RT_CLOCK_MAX_LAYER) {$::env(RT_CLOCK_MAX_LAYER)}"
    }
}

proc global_routing_cugr {args} {
    if { $::env(DIODE_INSERTION_STRATEGY) == 3 } {
        puts_err "DIODE_INSERTION_STRATEGY 3 is only valid when OpenROAD is used for global routing."
        puts_err "Please try a different strategy."
        return -code error
    }
    try_catch cugr \
        -lef $::env(MERGED_LEF_UNPADDED) \
        -def $::env(CURRENT_DEF) \
        -output $::env(SAVE_GUIDE) \
        -threads $::env(ROUTING_CORES) \
        |& tee $::env(TERMINAL_OUTPUT) [index_file $::env(routing_logs)/global.log]
    file copy -force $::env(CURRENT_DEF) $::env(SAVE_DEF)
}

proc groute_antenna_extract {args} {
    set options {
        {-from_log required}
    }
    set flags {}
    parse_key_args "groute_antenna_extract" args arg_values $options flags_map $flags

    set value [exec python3 $::env(SCRIPTS_DIR)/extract_antenna_count.py < $arg_values(-from_log)]

    return value
}

proc global_routing_fastroute {args} {
    set saveLOG [index_file $::env(routing_logs)/global.log]

    translate_min_max_layer_variables
    run_openroad_script $::env(SCRIPTS_DIR)/openroad/groute.tcl -indexed_log $saveLOG
    if { $::env(DIODE_INSERTION_STRATEGY) == 3 } {
        puts_info "Starting FastRoute Antenna Repair Iterations..."
        set_def $::env(SAVE_DEF)
        set_guide $::env(SAVE_GUIDE)
        set iter 2

        set prevDEF1 $::env(SAVE_DEF)
        set prevDEF2 $::env(SAVE_DEF)
        set prevGUIDE1 $::env(SAVE_GUIDE)
        set prevGUIDE2 $::env(SAVE_GUIDE)
        set prevLOG1 $saveLOG
        set prevLOG2 $saveLOG

        set prevAntennaVal [groute_antenna_extract -from_log [index_file $::env(routing_logs)/global.log]]

        while {$iter <= $::env(GLB_RT_MAX_DIODE_INS_ITERS) && $prevAntennaVal > 0} {
            set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/global_$iter.def]
            set ::env(SAVE_GUIDE) [index_file $::env(routing_tmpfiles)/global_$iter.guide]
            set saveLOG [index_file $::env(routing_logs)/global_$iter.log]
            set replaceWith "INSDIODE$iter"
            try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/replace_prefix_from_def_instances.py -op "ANTENNA" -np $replaceWith -d $::env(CURRENT_DEF)
            puts_info "FastRoute Iteration $iter"
            puts_info "Antenna Violations Previous: $prevAntennaVal"
            run_openroad_script $::env(SCRIPTS_DIR)/openroad/groute.tcl -indexed_log $saveLOG
            set currAntennaVal [groute_antenna_extract -from_log $saveLOG]
            puts_info "Antenna Violations Current: $currAntennaVal"
            if { $currAntennaVal >= $prevAntennaVal } {
                set iter [expr $iter - 1]
                set ::env(SAVE_DEF) $prevDEF1
                set ::env(SAVE_GUIDE) $prevGUIDE1
                set saveLOG $prevLOG1
                break
            } else {
                set prevAntennaVal $currAntennaVal
                set iter [expr $iter + 1]
                set prevDEF1 $prevDEF2
                set prevGUIDE1 $prevGUIDE2
                set prevLOG1 $prevLOG2
                set prevDEF2 $::env(SAVE_DEF)
                set prevGUIDE2 $::env(SAVE_GUIDE)
                set prevLOG2 $saveLOG
            }
            set_def $::env(SAVE_DEF)
            set_guide $::env(SAVE_GUIDE)
        }
    }
}

proc global_routing {args} {
    increment_index
    TIMER::timer_start
    puts_info "Running Global Routing..."
    set ::env(SAVE_GUIDE) [index_file $::env(routing_tmpfiles)/global.guide]
    set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/global.def]

    set tool "openroad"
    if { $::env(GLOBAL_ROUTER) == "cugr" } {
        set tool "cugr"
        global_routing_cugr
    } else {
        global_routing_fastroute
    }

    set_def $::env(SAVE_DEF)
    set_guide $::env(SAVE_GUIDE)

    TIMER::timer_stop

    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "global routing - $tool"
}

proc detailed_routing_tritonroute {args} {
    set ::env(TRITONROUTE_FILE_PREFIX) $::env(routing_tmpfiles)/detailed
    set ::env(TRITONROUTE_RPT_PREFIX) $::env(routing_reports)/detailed

    translate_min_max_layer_variables
    run_openroad_script $::env(SCRIPTS_DIR)/openroad/droute.tcl -indexed_log [index_file $::env(routing_logs)/detailed.log]

    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/tr_drc_to_klayout_drc.py \
        -i $::env(routing_reports)/detailed.drc \
        -o $::env(routing_reports)/detailed.klayout.xml \
        --design-name $::env(DESIGN_NAME)

    quit_on_tr_drc
}

proc detailed_routing_drcu {args} {
    try_catch drcu \
        -lef $::env(MERGED_LEF_UNPADDED) \
        -def $::env(CURRENT_DEF) \
        -guide $::env(CURRENT_GUIDE) \
        -threads $::env(ROUTING_CORES) \
        -tat 99999999 \
        -output $::env(routing_results)/$::env(DESIGN_NAME).def \
        |& tee $::env(TERMINAL_OUTPUT) [index_file $::env(routing_logs)/detailed.log]
}

proc detailed_routing {args} {
    increment_index
    TIMER::timer_start
    puts_info "Running Detailed Routing..."

    set ::env(SAVE_DEF) $::env(routing_results)/$::env(DESIGN_NAME).def
    if { $::env(ECO_ENABLE) == 1 && $::env(ECO_ITER) == 0 } {
        set ::env(SAVE_DEF) $::env(eco_results)/arcdef/$::env(ECO_ITER)_post-route.def
    }

    set tool "openroad"
    if {$::env(RUN_ROUTING_DETAILED)} {
        if { $::env(DETAILED_ROUTER) == "drcu" } {
            set tool "drcu"
            detailed_routing_drcu
        } else {
            detailed_routing_tritonroute
        }
    } else {
        exec echo "SKIPPED!" >> [index_file $::env(routing_logs)/detailed.log]
    }

    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "detailed_routing - $tool"
    set_def $::env(SAVE_DEF)
}

proc ins_fill_cells_or {args} {
    handle_deprecated_command ins_fill_cells
}

proc ins_fill_cells {args} {
    increment_index

    if {$::env(FILL_INSERTION)} {
        TIMER::timer_start
        puts_info "Running Fill Insertion..."
        set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/fill.def]
        run_openroad_script $::env(SCRIPTS_DIR)/openroad/fill.tcl -indexed_log [index_file $::env(routing_logs)/fill.log]
        set_def $::env(SAVE_DEF)
        TIMER::timer_stop
        exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "fill insertion - openroad"
    } else {
        exec echo "SKIPPED!" >> [index_file $::env(routing_logs)/fill.log]
    }

}

proc power_routing {args} {
    increment_index
    TIMER::timer_start
    puts_info "Routing top-level power nets..."

    set options {
        {-lef optional}
        {-def optional}
        {-power optional}
        {-ground optional}
        {-output_def optional}
        {-extra_args optional}
    }
    set flags {}
    parse_key_args "power_routing" args arg_values $options flags_map $flags

    set_if_unset arg_values(-lef) $::env(MERGED_LEF)
    set_if_unset arg_values(-def) $::env(CURRENT_DEF)
    set_if_unset arg_values(-power) $::env(VDD_PIN)
    set_if_unset arg_values(-ground) $::env(GND_PIN)
    set_if_unset arg_values(-output_def) [index_file $::env(routing_tmpfiles)/$::env(DESIGN_NAME).power_routed.def]
    set_if_unset arg_values(-extra_args) ""


    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/power_route.py\
        --input-lef $arg_values(-lef)\
        --input-def $arg_values(-def)\
        --core-vdd-pin $arg_values(-power)\
        --core-gnd-pin $arg_values(-ground)\
        -o $arg_values(-output_def)\
        {*}$arg_values(-extra_args) |& tee [index_file $::env(routing_logs)/power_routing.log] $::env(TERMINAL_OUTPUT)

    set_def $arg_values(-output_def)
    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "top level power routing - power_route.py"
}

proc gen_pdn {args} {
    increment_index
    TIMER::timer_start
    puts_info "Generating PDN..."

    set ::env(SAVE_DEF) [index_file $::env(floorplan_tmpfiles)/pdn.def]
    set ::env(PGA_RPT_FILE) [index_file $::env(floorplan_tmpfiles)/pdn.pga.rpt]

    run_openroad_script $::env(SCRIPTS_DIR)/openroad/pdn.tcl \
        |& -indexed_log [index_file $::env(floorplan_logs)/pdn.log]


    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "pdn generation - openroad"

    quit_on_unconnected_pdn_nodes

    set_def $::env(SAVE_DEF)
}


proc ins_diode_cells_1 {args} {
    increment_index
    TIMER::timer_start
    puts_info "Running Diode Insertion..."
    set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/diodes.def]

    run_openroad_script $::env(SCRIPTS_DIR)/openroad/diodes.tcl -indexed_log [index_file $::env(routing_logs)/diodes.log]

    set_def $::env(SAVE_DEF)

    write_verilog $::env(synthesis_results)/$::env(DESIGN_NAME)_diodes.v -log $::env(routing_logs)/write_verilog.with_diodes.log
    set_netlist $::env(synthesis_results)/$::env(DESIGN_NAME)_diodes.v

    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "diode insertion - openroad"
    if { $::env(LEC_ENABLE) } {
        logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
    }
}

proc ins_diode_cells_4 {args} {
    increment_index
    TIMER::timer_start
    puts_info "Running Diode Insertion..."
    set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/diodes.def]

    # Select diode cell
    if { $::env(DIODE_INSERTION_STRATEGY) == 5 } {
        if { ! [info exists ::env(FAKEDIODE_CELL)] } {
            puts_err "DIODE_INSERTION_STRATEGY $::env(DIODE_INSERTION_STRATEGY) is only valid when FAKEDIODE_CELL is defined."
            puts_err "Please try a different strategy."
            return -code error
        }
        set ::antenna_cell_name $::env(FAKEDIODE_CELL)
    } else {
        set ::antenna_cell_name $::env(DIODE_CELL)
    }

    # Custom script
    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/place_diodes.py -l $::env(MERGED_LEF) -id $::env(CURRENT_DEF) -o $::env(SAVE_DEF) --diode-cell $::env(DIODE_CELL)  --diode-pin  $::env(DIODE_CELL_PIN) --fake-diode-cell $::antenna_cell_name  |& tee $::env(TERMINAL_OUTPUT) [index_file $::env(routing_logs)/diodes.log]

    set_def $::env(SAVE_DEF)

    # Legalize
    detailed_placement_or -def $::env(CURRENT_DEF) -log $::env(routing_logs)/diode_legalization.log

    # Update netlist
    write_verilog $::env(synthesis_results)/$::env(DESIGN_NAME)_diodes.v -log $::env(routing_logs)/write_verilog.with_diodes.log
    set_netlist $::env(synthesis_results)/$::env(DESIGN_NAME)_diodes.v

    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "diode insertion - place_diodes.py"
    if { $::env(LEC_ENABLE) } {
        logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
    }
}

proc apply_route_obs {args} {
    puts_info "Adding routing obstructions..."
    # keep a warning for a while
    puts_warn "Specifying a routing obstruction is now done using the coordinates"
    puts_warn "of its bounding box instead of the now deprecated (x, y, size_x, size_y)."

    try_catch $::env(OPENROAD_BIN) -python $::env(SCRIPTS_DIR)/add_def_obstructions.py \
        --input-def $::env(CURRENT_DEF) \
        --lef $::env(MERGED_LEF) \
        --obstructions $::env(GLB_RT_OBS) \
        --output [file rootname $::env(CURRENT_DEF)].obs.def |& tee $::env(TERMINAL_OUTPUT) $::env(routing_logs)/obs.log
    puts_info "Obstructions added over $::env(GLB_RT_OBS)"
    set_def [file rootname $::env(CURRENT_DEF)].obs.def
}

proc add_route_obs {args} {
    if {[info exists ::env(GLB_RT_OBS)]} {
        apply_route_obs
    }
}

proc run_spef_extraction {args} {
    set options {
        {-log required}
        {-rcx_lib optional}
        {-rcx_lef optional}
        {-rcx_rules optional}
        {-process_corner optional}
    }
    parse_key_args "run_spef_extraction" args arg_values $options

    set_if_unset arg_values(-rcx_lib) $::env(LIB_SYNTH_COMPLETE)
    set_if_unset arg_values(-rcx_lef) $::env(MERGED_LEF_UNPADDED)
    set_if_unset arg_values(-rcx_rules) $::env(RCX_RULES)

    set ::env(RCX_LIB) $arg_values(-rcx_lib)
    set ::env(RCX_LEF) $arg_values(-rcx_lef)
    set ::env(RCX_RULESET) $arg_values(-rcx_rules)

    if { ![file exists $::env(RCX_RULESET)]} {
        puts_err "RCX ruleset '$::env(RCX_RULESET)' does not exist."
        return -code error
    }
    if { ![file exists $::env(RCX_LEF)]} {
        puts_err "Technology LEF file '$::env(RCX_LEF)' does not exist."
        return -code error
    }

    increment_index
    TIMER::timer_start
    set log [index_file $arg_values(-log)]

    set ec_postfix ""
    if { [info exists arg_values(-process_corner)]} {
        set ec_postfix " at the $arg_values(-process_corner) process corner"
    }

    puts_info "Running SPEF Extraction$ec_postfix..."

    if { $::env(SPEF_EXTRACTOR) == "def2spef" } {
        puts_warn "def2spef/spef_extractor has been removed. OpenROAD OpenRCX will be used instead."
        set ::env(SPEF_EXTRACTOR) "openrcx"
    }

    run_openroad_script $::env(SCRIPTS_DIR)/openroad/rcx.tcl -indexed_log $log

    TIMER::timer_stop
    exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "parasitics extraction - openroad"
}

proc run_routing {args} {
    puts_info "Routing..."

    if { $::env(ECO_ENABLE) == 1 && $::env(ECO_ITER) == 0 } {
        set log          "$::env(eco_logs)"
        set path         "$::env(eco_results)"
        set fix_path     "$::env(eco_results)/fix"
        set def_path     "$::env(eco_results)/def"
        set net_path     "$::env(eco_results)/net"
        set spef_path    "$::env(eco_results)/spef"
        set sdf_path     "$::env(eco_results)/sdf"
        set arc_def_path "$::env(eco_results)/arcdef"
        file mkdir $log
        file mkdir $path
        file mkdir $fix_path
        file mkdir $def_path
        file mkdir $net_path
        file mkdir $spef_path
        file mkdir $sdf_path
        file mkdir $arc_def_path
    }
    if { $::env(ECO_ENABLE) == 1 && $::env(ECO_ITER) != 0 } {
        set ::env(CURRENT_DEF)     $::env(eco_results)/def/eco_$::env(ECO_ITER).def
        set ::env(CURRENT_NETLIST) $::env(eco_results)/net/eco_$::env(ECO_ITER).v
    }
    set ::env(ROUTING_CURRENT_DEF) $::env(CURRENT_DEF)

    # |----------------------------------------------------|
    # |----------------   5. ROUTING ----------------------|
    # |----------------------------------------------------|
    set ::env(CURRENT_STAGE) routing
    run_resizer_timing_routing

    if { [info exists ::env(DIODE_CELL)] && ($::env(DIODE_CELL) ne "") } {
        if { ($::env(DIODE_INSERTION_STRATEGY) == 1) || ($::env(DIODE_INSERTION_STRATEGY) == 2) } {
            ins_diode_cells_1
        }
        if { ($::env(DIODE_INSERTION_STRATEGY) == 4) || ($::env(DIODE_INSERTION_STRATEGY) == 5) } {
            ins_diode_cells_4
        }
    }

    use_original_lefs

    add_route_obs

    #legalize if not yet legalized
    if { ($::env(DIODE_INSERTION_STRATEGY) != 4) && ($::env(DIODE_INSERTION_STRATEGY) != 5) } {
        detailed_placement_or -def $::env(CURRENT_DEF) -log $::env(routing_logs)/diode_legalization.log
    }

    # if diode insertion does *not* happen as part of global routing, then
    # we can insert fill cells early on
    if { ($::env(DIODE_INSERTION_STRATEGY) != 3) && ($::env(ECO_ENABLE) ==0 || $::env(ECO_FINISH) ==1) } {
        ins_fill_cells
    }

    global_routing

    if { ($::env(DIODE_INSERTION_STRATEGY) == 3) && ($::env(ECO_ENABLE) ==0 || $::env(ECO_FINISH) ==1) } {
        # Doing this here can be problematic and is something that needs to be
        # addressed in FastRoute since fill cells *might* occupy some of the
        # resources that were already used during global routing causing the
        # detailed router to suffer later.
        ins_fill_cells
    }

    set global_routed_netlist [index_file $::env(routing_tmpfiles)/global.v]
    write_verilog $global_routed_netlist -log $::env(routing_logs)/write_verilog_global.log
    set_netlist $global_routed_netlist
    if { $::env(LEC_ENABLE) } {
        logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
    }

    # detailed routing
    detailed_routing

    set detailed_routed_netlist [index_file $::env(routing_tmpfiles)/detailed.v]

    write_verilog $detailed_routed_netlist -log $::env(routing_logs)/write_verilog_detailed.log

    # for lvs
    set_netlist $detailed_routed_netlist

    if { $::env(ECO_ENABLE) == 1 && $::env(ECO_ITER) != 0 } {
        set_netlist $::env(eco_results)/net/eco_$::env(ECO_ITER).v
    }

    if { $::env(LEC_ENABLE) } {
        logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
    }

    scrot_klayout -layout $::env(CURRENT_DEF) -log $::env(routing_logs)/screenshot.log

    # spef extraction at the three corners

    ## Calculate Runtime To Routing
    set ::env(timer_routed) [clock seconds]
}

proc run_resizer_timing_routing {args} {
    if { $::env(GLB_RESIZER_TIMING_OPTIMIZATIONS) == 1} {
        increment_index
        TIMER::timer_start
        puts_info "Running Global Routing Resizer Timing Optimizations..."
        set ::env(SAVE_DEF) [index_file $::env(routing_tmpfiles)/resizer_timing.def]
        set ::env(SAVE_SDC) [index_file $::env(routing_tmpfiles)/resizer_timing.sdc]
        run_openroad_script $::env(SCRIPTS_DIR)/openroad/resizer_routing_timing.tcl -indexed_log [index_file $::env(routing_logs)/resizer.log]
        set_def $::env(SAVE_DEF)
        set ::env(CURRENT_SDC) $::env(SAVE_SDC)

        TIMER::timer_stop
        exec echo "[TIMER::get_runtime]" | python3 $::env(SCRIPTS_DIR)/write_runtime.py "resizer timing optimizations - openroad"

        write_verilog $::env(routing_results)/$::env(DESIGN_NAME).resized.v -log $::env(routing_logs)/write_verilog.log
        set_netlist $::env(routing_results)/$::env(DESIGN_NAME).resized.v

        if { $::env(LEC_ENABLE) && [file exists $::env(PREV_NETLIST)] } {
            logic_equiv_check -rhs $::env(PREV_NETLIST) -lhs $::env(CURRENT_NETLIST)
        }

    } else {
        puts_info "Skipping Global Routing Resizer Timing Optimizations."
    }
}


package provide openlane 0.9