3. CLI apps#

3.1. sc#

usage: sc [-h] [-schemaversion <str>] [-design <str>]
          [-input 'fileset filetype <file>']
          [-output 'fileset filetype <file>']
          [-constraint_timing_voltage 'scenario <pin> <float>']
          [-constraint_timing_temperature 'scenario <float>']
          [-constraint_timing_libcorner 'scenario <str>']
          [-constraint_timing_pexcorner 'scenario <str>']
          [-constraint_timing_opcond 'scenario <str>']
          [-constraint_timing_mode 'scenario <str>']
          [-constraint_timing_file 'scenario <file>']
          [-constraint_timing_check 'scenario <str>']
          [-constraint_component_placement 'inst <float,float,float)>']
          [-constraint_component_partname 'inst <str>']
          [-constraint_component_halo 'inst <(float,float)>']
          [-constraint_component_rotation 'inst <float>']
          [-constraint_component_flip ['inst <bool>']]
          [-constraint_pin_placement 'name <(float,float,float)>']
          [-constraint_pin_layer 'name <str>']
          [-constraint_pin_side 'name <int>']
          [-constraint_pin_order 'name <int>']
          [-constraint_net_maxlength 'name <float>']
          [-constraint_net_maxresistance 'name <float>']
          [-constraint_net_ndr 'name <(float,float)>']
          [-constraint_net_minlayer 'name <str>']
          [-constraint_net_maxlayer 'name <str>']
          [-constraint_net_shield 'name <str>']
          [-constraint_net_match 'name <str>']
          [-constraint_net_diffpair 'name <str>']
          [-constraint_net_sympair 'name <str>']
          [-constraint_outline <[(float,float)]>]
          [-constraint_corearea <[(float,float)]>]
          [-constraint_coremargin <float>] [-constraint_density <float>]
          [-constraint_aspectratio <float>] [-remote [<bool>]]
          [-credentials <file>] [-nice <int>] [-mode <str>] [-target <str>]
          [-pdk <str>] [-uselambda [<bool>]] [-stackup <str>] [-flow <str>]
          [-O <str>] [-frontend <frontend>] [-cfg <file>] [-env 'key <str>']
          [-var 'key <str>'] [-file 'key <str>'] [-dir 'key <str>']
          [-scpath <dir>] [-loglevel <str>] [-builddir <dir>] [-jobname <str>]
          [-jobinput 'step index <str>'] [-steplist <step>]
          [-indexlist <index>] [-breakpoint [<bool>]]
          [-showtool 'filetype <tool>'] [-metricoff '<str>'] [-clean [<bool>]]
          [-hash [<bool>]] [-nodisplay [<bool>]] [-quiet [<bool>]]
          [-jobincr [<bool>]] [-novercheck [<bool>]] [-relax [<bool>]]
          [-resume [<bool>]] [-track [<bool>]] [-trace [<bool>]]
          [-skipall [<bool>]] [-skipcheck [<bool>]] [-copyall [<bool>]]
          [-show [<bool>]] [-autoinstall [<bool>]] [-registry <dir>]
          [-entrypoint <str>] [+incdir+ <dir>] [-y <dir>] [-v <file>]
          [-D <str>] [+libext+ <str>] [-param 'name <str>'] [-f <file>]
          [-flowcontinue ] [-continue ] [-timeout <str>] [-strict [<bool>]]
          [-scheduler <str>] [-cores <int>] [-memory <str>] [-queue <str>]
          [-defer <str>] [-scheduler_options <str>] [-msgevent <str>]
          [-msgcontact <str>] [-arg_step <str>] [-arg_index <str>]
          [-unit_time '<str>'] [-unit_length '<str>'] [-unit_mass '<str>']
          [-unit_temperature '<str>'] [-unit_capacitance '<str>']
          [-unit_resistance '<str>'] [-unit_inductance '<str>']
          [-unit_voltage '<str>'] [-unit_current '<str>']
          [-unit_power '<str>'] [-unit_energy '<str>'] [-fpga_partname <str>]
          [-fpga_vendor '<str>'] [-fpga_lutsize 'partname <int>']
          [-fpga_file 'partname key <str>'] [-fpga_var 'partname key <str>']
          [-fpga_board <str>] [-fpga_program [<bool>]] [-fpga_flash [<bool>]]
          [-asic_logiclib <str>] [-asic_macrolib <str>]
          [-asic_delaymodel <str>] [-asic_cells_decap '<str>']
          [-asic_cells_delay '<str>'] [-asic_cells_tie '<str>']
          [-asic_cells_hold '<str>'] [-asic_cells_clkbuf '<str>']
          [-asic_cells_clkdelay '<str>'] [-asic_cells_clkinv '<str>']
          [-asic_cells_clkgate '<str>'] [-asic_cells_clkicg '<str>']
          [-asic_cells_clklogic '<str>'] [-asic_cells_dontuse '<str>']
          [-asic_cells_filler '<str>'] [-asic_cells_tap '<str>']
          [-asic_cells_endcap '<str>'] [-asic_cells_antenna '<str>']
          [-asic_libarch '<str>'] [-asic_site 'libarch <str>']
          [-pdk_foundry 'pdkname <str>'] [-pdk_node 'pdkname <float>']
          [-pdk_lambda 'pdkname <float>] [-pdk_version 'pdkname <str>']
          [-pdk_stackup 'pdkname <str>'] [-pdk_minlayer 'pdk stackup <str>']
          [-pdk_maxlayer 'pdk stackup <str>']
          [-pdk_thickness 'pdkname stackup <float>']
          [-pdk_wafersize 'pdkname <float>']
          [-pdk_panelsize 'pdkname <(float,float>']
          [-pdk_unitcost 'pdkname <float>'] [-pdk_d0 'pdkname <float>']
          [-pdk_hscribe 'pdkname <float>'] [-pdk_vscribe 'pdkname <float>']
          [-pdk_edgemargin 'pdkname <float>'] [-pdk_density 'pdkname <float>']
          [-pdk_devmodel 'pdkname tool simtype stackup <file>']
          [-pdk_pexmodel 'pdkname tool stackup corner <file>']
          [-pdk_layermap 'pdkname tool src dst stackup <file>']
          [-pdk_display 'pdkname tool stackup <file>']
          [-pdk_aprtech 'pdkname tool stackup libarch filetype <file>']
          [-pdk_lvs_runset 'pdkname tool stackup name <file>']
          [-pdk_lvs_waiver 'tool stackup name <file>']
          [-pdk_drc_runset 'pdkname tool stackup name <file>']
          [-pdk_drc_waiver 'tool stackup name <file>']
          [-pdk_erc_runset 'pdkname tool stackup name <file>']
          [-pdk_erc_waiver 'tool stackup name <file>']
          [-pdk_fill_runset 'pdkname tool stackup name <file>']
          [-pdk_fill_waiver 'tool stackup name <file>']
          [-pdk_file 'pdkname tool key stackup <file>']
          [-pdk_directory 'pdkname tool key stackup <file>']
          [-pdk_var 'pdkname tool stackup key <str>']
          [-pdk_doc_homepage 'pdkname <file>']
          [-pdk_doc_datasheet 'pdkname <file>']
          [-pdk_doc_reference 'pdkname <file>']
          [-pdk_doc_userguide 'pdkname <file>']
          [-pdk_doc_install 'pdkname <file>']
          [-pdk_doc_quickstart 'pdkname <file>']
          [-pdk_doc_releasenotes 'pdkname <file>']
          [-pdk_doc_tutorial 'pdkname <file>'] [-tool_exe 'tool <str>']
          [-tool_sbom 'tool version <file>'] [-tool_path 'tool <dir>']
          [-tool_vswitch 'tool <str>'] [-tool_vendor 'tool <str>']
          [-tool_version 'tool <str>'] [-tool_format 'tool <file>']
          [-tool_licenseserver 'name key <str>']
          [-tool_task_warningoff 'tool task <str>']
          [-tool_task_continue ['tool task <bool>']]
          [-tool_task_regex 'tool task suffix <str>']
          [-tool_task_option 'tool task <str>']
          [-tool_task_var 'tool task key <str>']
          [-tool_task_env 'tool task step index name <str>']
          [-tool_task_file 'tool task key <file>']
          [-tool_task_dir 'tool task key <dir>']
          [-tool_task_input 'tool task step index <str>']
          [-tool_task_output 'tool task step index <str>']
          [-tool_task_stdout_destination 'task [log|output|none]']
          [-tool_task_stdout_suffix 'task <str>']
          [-tool_task_stderr_destination 'task [log|output|none]']
          [-tool_task_stderr_suffix 'task <str>']
          [-tool_task_require 'task step index <str>']
          [-tool_task_report 'task metric step index <str>']
          [-tool_task_refdir 'task <dir>']
          [-tool_task_script 'task step index <file>']
          [-tool_task_prescript 'task <file>']
          [-tool_task_postscript 'task <file>'] [-tool_task_keep 'task <str>']
          [-tool_task_threads 'task <int>']
          [-flowgraph_input 'flow step index <str,str)>']
          [-flowgraph_weight 'flow step index metric <float>']
          [-flowgraph_goal 'flow step index metric <float>']
          [-flowgraph_tool 'flow step <str>']
          [-flowgraph_task 'flow step <str>']
          [-flowgraph_taskmodule 'flow step <str>']
          [-flowgraph_args 'flow step index <str>']
          [-flowgraph_valid ['flow step index <str>']]
          [-flowgraph_timeout 'flow step 0 <float>']
          [-flowgraph_status 'flow step index <str>']
          [-flowgraph_select 'flow step index <(str,str)>']
          [-checklist_description 'standard item <str>]
          [-checklist_requirement 'standard item <str>]
          [-checklist_dataformat 'standard item <float>']
          [-checklist_rationale 'standard item <str>]
          [-checklist_criteria 'standard item <float>']
          [-checklist_task 'standard item <(str,str,str)>']
          [-checklist_report 'standard item <file>']
          [-checklist_waiver 'standard item metric <file>']
          [-checklist_ok ['standard item <str>']]
          [-metric_errors 'step index <int>']
          [-metric_warnings 'step index <int>']
          [-metric_drvs 'step index <int>']
          [-metric_unconstrained 'step index <int>']
          [-metric_coverage 'step index <float>']
          [-metric_security 'step index <float>']
          [-metric_luts 'step index <int>'] [-metric_dsps 'step index <int>']
          [-metric_brams 'step index <int>']
          [-metric_cellarea 'step index <float>']
          [-metric_totalarea 'step index <float>']
          [-metric_utilization step index <float>]
          [-metric_peakpower 'step index <float>']
          [-metric_averagepower 'step index <float>']
          [-metric_dozepower 'step index <float>']
          [-metric_idlepower 'step index <float>']
          [-metric_leakagepower 'step index <float>']
          [-metric_sleeppower 'step index <float>']
          [-metric_irdrop 'step index <float>']
          [-metric_holdpaths 'step index <float>']
          [-metric_setuppaths 'step index <float>']
          [-metric_holdslack 'step index <float>']
          [-metric_holdwns 'step index <float>']
          [-metric_holdtns 'step index <float>']
          [-metric_setupslack 'step index <float>']
          [-metric_setupwns 'step index <float>']
          [-metric_setuptns 'step index <float>']
          [-metric_fmax 'step index <float>']
          [-metric_macros 'step index <float>']
          [-metric_cells 'step index <float>']
          [-metric_registers 'step index <float>']
          [-metric_buffers 'step index <float>']
          [-metric_transistors 'step index <float>']
          [-metric_pins 'step index <float>']
          [-metric_nets 'step index <float>']
          [-metric_vias 'step index <float>']
          [-metric_wirelength 'step index <float>']
          [-metric_overflow 'step index <float>']
          [-metric_memory 'step index <float>']
          [-metric_exetime 'step index <float>']
          [-metric_tasktime 'step index <float>']
          [-metric_totaltime 'step index <float>']
          [-record_userid 'step index <str>']
          [-record_publickey 'step index <str>']
          [-record_machine 'step index <str>']
          [-record_macaddr 'step index <str>']
          [-record_ipaddr 'step index <str>']
          [-record_platform 'step index <str>']
          [-record_distro 'step index <str>']
          [-record_arch 'step index <str>']
          [-record_starttime 'step index <str>']
          [-record_endtime 'step index <str>']
          [-record_region 'step index <str>']
          [-record_scversion 'step index <str>']
          [-record_toolversion 'step index <str>']
          [-record_toolpath 'step index <str>']
          [-record_toolargs 'step index <str>']
          [-record_osversion 'step index <str>']
          [-record_kernelversion 'step index <str>']
          [-record_remoteid 'step index <str>']
          [-datasheet_feature 'name <float>']
          [-datasheet_limit_storagetemp '<(float,float)>']
          [-datasheet_limit_soldertemp '<(float,float)>']
          [-datasheet_limit_junctiontemp '<(float,float)>']
          [-datasheet_limit_tid '<(float,float)>']
          [-datasheet_limit_sel '<(float,float)>']
          [-datasheet_limit_seb '<(float,float)>']
          [-datasheet_limit_segr '<(float,float)>']
          [-datasheet_limit_set '<(float,float)>']
          [-datasheet_limit_seu '<(float,float)>']
          [-datasheet_thermal_rja '<float>']
          [-datasheet_thermal_rjct '<float>']
          [-datasheet_thermal_rjcb '<float>']
          [-datasheet_thermal_rjb '<float>']
          [-datasheet_thermal_tjt '<float>']
          [-datasheet_thermal_tjb '<float>']
          [-datasheet_reliability 'standard item <float>']
          [-datasheet_mechanical_length '<(float,float,float)>']
          [-datasheet_mechanical_width '<(float,float,float)>']
          [-datasheet_mechanical_thickness '<(float,float,float)>']
          [-datasheet_mechanical_bodyheight '<(float,float,float)>']
          [-datasheet_mechanical_bumppitch '<(float,float,float)>']
          [-datasheet_mechanical_bumpheight '<(float,float,float)>']
          [-datasheet_mechanical_bumpdiameter '<(float,float,float)>']
          [-datasheet_pin_map 'name bump <(float,float)>']
          [-datasheet_pin_type 'name mode <str>']
          [-datasheet_pin_dir 'name mode <str>']
          [-datasheet_pin_complement 'name mode <str>']
          [-datasheet_pin_standard 'name mode <str>']
          [-datasheet_pin_signal 'name mode <str>']
          [-datasheet_pin_resetvalue 'name mode <str>']
          [-datasheet_pin_vmax 'pin mode <(float,float,float)>']
          [-datasheet_pin_vnominal 'pin mode <(float,float,float)>']
          [-datasheet_pin_vol 'pin mode <(float,float,float)>']
          [-datasheet_pin_voh 'pin mode <(float,float,float)>']
          [-datasheet_pin_vil 'pin mode <(float,float,float)>']
          [-datasheet_pin_vih 'pin mode <(float,float,float)>']
          [-datasheet_pin_vcm 'pin mode <(float,float,float)>']
          [-datasheet_pin_vdiff 'pin mode <(float,float,float)>']
          [-datasheet_pin_voffset 'pin mode <(float,float,float)>']
          [-datasheet_pin_vnoise 'pin mode <(float,float,float)>']
          [-datasheet_pin_vslew 'pin mode <(float,float,float)>']
          [-datasheet_pin_vhbm 'pin mode <(float,float,float)>']
          [-datasheet_pin_vcdm 'pin mode <(float,float,float)>']
          [-datasheet_pin_vmm 'pin mode <(float,float,float)>']
          [-datasheet_pin_cap 'pin mode <(float,float,float)>']
          [-datasheet_pin_rdiff 'pin mode <(float,float,float)>']
          [-datasheet_pin_rin 'pin mode <(float,float,float)>']
          [-datasheet_pin_rup 'pin mode <(float,float,float)>']
          [-datasheet_pin_rdown 'pin mode <(float,float,float)>']
          [-datasheet_pin_rweakup 'pin mode <(float,float,float)>']
          [-datasheet_pin_rweakdown 'pin mode <(float,float,float)>']
          [-datasheet_pin_power 'pin mode <(float,float,float)>']
          [-datasheet_pin_isupply 'pin mode <(float,float,float)>']
          [-datasheet_pin_ioh 'pin mode <(float,float,float)>']
          [-datasheet_pin_iol 'pin mode <(float,float,float)>']
          [-datasheet_pin_iinject 'pin mode <(float,float,float)>']
          [-datasheet_pin_ishort 'pin mode <(float,float,float)>']
          [-datasheet_pin_ioffset 'pin mode <(float,float,float)>']
          [-datasheet_pin_ibias 'pin mode <(float,float,float)>']
          [-datasheet_pin_ileakage 'pin mode <(float,float,float)>']
          [-datasheet_pin_tperiod 'pin mode <(float,float,float)>']
          [-datasheet_pin_tpulse 'pin mode <(float,float,float)>']
          [-datasheet_pin_tjitter 'pin mode <(float,float,float)>']
          [-datasheet_pin_thigh 'pin mode <(float,float,float)>']
          [-datasheet_pin_tlow 'pin mode <(float,float,float)>']
          [-datasheet_pin_tduty 'pin mode <(float,float,float)>']
          [-datasheet_pin_bw 'pin mode <(float,float,float)>']
          [-datasheet_pin_inl 'pin mode <(float,float,float)>']
          [-datasheet_pin_dnl 'pin mode <(float,float,float)>']
          [-datasheet_pin_snr 'pin mode <(float,float,float)>']
          [-datasheet_pin_sinad 'pin mode <(float,float,float)>']
          [-datasheet_pin_sfdr 'pin mode <(float,float,float)>']
          [-datasheet_pin_imd3 'pin mode <(float,float,float)>']
          [-datasheet_pin_hd2 'pin mode <(float,float,float)>']
          [-datasheet_pin_hd3 'pin mode <(float,float,float)>']
          [-datasheet_pin_hd4 'pin mode <(float,float,float)>']
          [-datasheet_pin_nsd 'pin mode <(float,float,float)>']
          [-datasheet_pin_phasenoise 'pin mode <(float,float,float)>']
          [-datasheet_pin_enob 'pin mode <(float,float,float)>']
          [-datasheet_pin_gain 'pin mode <(float,float,float)>']
          [-datasheet_pin_pout 'pin mode <(float,float,float)>']
          [-datasheet_pin_pout2 'pin mode <(float,float,float)>']
          [-datasheet_pin_pout3 'pin mode <(float,float,float)>']
          [-datasheet_pin_vofferror 'pin mode <(float,float,float)>']
          [-datasheet_pin_vgainerror 'pin mode <(float,float,float)>']
          [-datasheet_pin_cmrr 'pin mode <(float,float,float)>']
          [-datasheet_pin_psnr 'pin mode <(float,float,float)>']
          [-datasheet_pin_s21 'pin mode <(float,float,float)>']
          [-datasheet_pin_s11 'pin mode <(float,float,float)>']
          [-datasheet_pin_s22 'pin mode <(float,float,float)>']
          [-datasheet_pin_s12 'pin mode <(float,float,float)>']
          [-datasheet_pin_noisefigure 'pin mode <(float,float,float)>']
          [-datasheet_pin_ib1db 'pin mode <(float,float,float)>']
          [-datasheet_pin_oob1db 'pin mode <(float,float,float)>']
          [-datasheet_pin_iip3 'pin mode <(float,float,float)>']
          [-datasheet_pin_tsetup 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_thold 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_tskew 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_tdelayr 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_tdelayf 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_trise 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_tfall 'pin mode relpin <(float,float,float)>']
          [-datasheet_pin_function 'name mode <str>']
          [-datasheet_pin_polarity 'name mode relpin <str>']
          [-package_depgraph 'module <(str,str>'] [-package_name <str>]
          [-package_version <str>] [-package_description <str>]
          [-package_keyword <str>] [-package_homepage <str>]
          [-package_doc_homepage <str>] [-package_doc_datasheet <str>]
          [-package_doc_reference <str>] [-package_doc_userguide <str>]
          [-package_doc_quickstart <str>] [-package_doc_releasenotes <str>]
          [-package_doc_testplan <str>] [-package_doc_signoff <str>]
          [-package_doc_tutorial <str>] [-package_repo <str>]
          [-package_dependency 'module <str>'] [-package_target <str>]
          [-package_license <str>] [-package_licensefile <file>]
          [-package_location <file>] [-package_organization <str>]
          [-package_publickey <str>] [-package_author_name 'userid <str>']
          [-package_author_email 'userid <str>']
          [-package_author_username 'userid <str>']
          [-package_author_location 'userid <str>']
          [-package_author_organization 'userid <str>']
          [-package_author_publickey 'userid <str>'] [-version]
          [source [source ...]]

    ------------------------------------------------------------
    SiliconCompiler is an open source compiler framework that
    aims to enable automated translation from source code to
    silicon.

    The sc program includes the followins steps.

    1. Read command line arguments
    2. If not set, 'design' is set to base of first source file.
    3. If not set, 'target' is set to 'skywater130_demo'.
    4. Run compilation
    5. Display summary

    Sources: https://github.com/siliconcompiler/siliconcompiler
    ------------------------------------------------------------
    

positional arguments:
  source                Input files with filetype inferred by extension

optional arguments:
  -h, --help            show this help message and exit
  -schemaversion <str>  Schema version number
  -design <str>         Design top module name
  -input 'fileset filetype <file>'
                        Input: files
  -output 'fileset filetype <file>'
                        Output: files
  -constraint_timing_voltage 'scenario <pin> <float>'
                        Constraint: pin voltage level
  -constraint_timing_temperature 'scenario <float>'
                        Constraint: temperature
  -constraint_timing_libcorner 'scenario <str>'
                        Constraint: library corner
  -constraint_timing_pexcorner 'scenario <str>'
                        Constraint: pex corner
  -constraint_timing_opcond 'scenario <str>'
                        Constraint: operating condition
  -constraint_timing_mode 'scenario <str>'
                        Constraint: operating mode
  -constraint_timing_file 'scenario <file>'
                        Constraint: SDC files
  -constraint_timing_check 'scenario <str>'
                        Constraint: timing checks
  -constraint_component_placement 'inst <(float,float,float)>'
                        Constraint: Component placement
  -constraint_component_partname 'inst <str>'
                        Constraint: Component part name
  -constraint_component_halo 'inst <(float,float)>'
                        Constraint: Component halo
  -constraint_component_rotation 'inst <float>'
                        Constraint: Component rotation
  -constraint_component_flip ['inst <bool>']
                        Constraint: Component flip option
  -constraint_pin_placement 'name <(float,float,float)>'
                        Constraint: Pin placement
  -constraint_pin_layer 'name <str>'
                        Constraint: Pin layer
  -constraint_pin_side 'name <int>'
                        Constraint: Pin side
  -constraint_pin_order 'name <int>'
                        Constraint: Pin order
  -constraint_net_maxlength 'name <float>'
                        Constraint: Net max length
  -constraint_net_maxresistance 'name <float>'
                        Constraint: Net max resistance
  -constraint_net_ndr 'name <(float,float)>'
                        Constraint: Net routing rule
  -constraint_net_minlayer 'name <str>'
                        Constraint: Net minimum routing layer
  -constraint_net_maxlayer 'name <str>'
                        Constraint: Net maximum routing layer
  -constraint_net_shield 'name <str>'
                        Constraint: Net shielding
  -constraint_net_match 'name <str>'
                        Constraint: Net matched routing
  -constraint_net_diffpair 'name <str>'
                        Constraint: Net diffpair
  -constraint_net_sympair 'name <str>'
                        Constraint: Net sympair
  -constraint_outline <[(float,float)]>
                        Constraint: Layout outline
  -constraint_corearea <[(float,float)]>
                        Constraint: Layout core area
  -constraint_coremargin <float>
                        Constraint: Layout core margin
  -constraint_density <float>
                        Constraint: Layout density
  -constraint_aspectratio <float>
                        Constraint: Layout aspect ratio
  -remote [<bool>]      Enable remote processing
  -credentials <file>   User credentials file
  -nice <int>           Tool execution scheduling priority
  -mode <str>           Compilation mode
  -target <str>         Compilation target
  -pdk <str>            PDK target
  -uselambda [<bool>]   Use lambda scaling
  -stackup <str>        Stackup target
  -flow <str>           Flow target
  -O <str>              Optimization mode
  -frontend <frontend>  Compilation frontend
  -cfg <file>           Configuration manifest
  -env 'key <str>'      Environment variables
  -var 'key <str>'      Custom variables
  -file 'key <str>'     Custom files
  -dir 'key <str>'      Custom directories
  -scpath <dir>         Search path
  -loglevel <str>       Logging level
  -builddir <dir>       Build directory
  -jobname <str>        Job name
  -jobinput 'step index <str>'
                        Input job name
  -steplist <step>      Compilation step list
  -indexlist <index>    Compilation index list
  -breakpoint [<bool>]  Breakpoint list
  -showtool 'filetype <tool>'
                        Select data display tool
  -metricoff '<str>'    Metric summary filter
  -clean [<bool>]       Clean up after run
  -hash [<bool>]        Enable file hashing
  -nodisplay [<bool>]   Headless execution
  -quiet [<bool>]       Quiet execution
  -jobincr [<bool>]     Autoincrement jobname
  -novercheck [<bool>]  Disable version checking
  -relax [<bool>]       Relax design checking
  -resume [<bool>]      Resume build
  -track [<bool>]       Enable provenance tracking
  -trace [<bool>]       Enable debug traces
  -skipall [<bool>]     Skip all tasks
  -skipcheck [<bool>]   Skip manifest check
  -copyall [<bool>]     Copy all inputs to build directory
  -show [<bool>]        Show layout
  -autoinstall [<bool>]
                        Option: auto install packages
  -registry <dir>       Option: package registry
  -entrypoint <str>     Program entry point
  +incdir+ <dir>, -I <dir>
                        Design search paths
  -y <dir>              Design module search paths
  -v <file>             Design libraries
  -D <str>              Design pre-processor symbol
  +libext+ <str>        Design file extensions
  -param 'name <str>'   Design parameter
  -f <file>             Design compilation command file
  -flowcontinue []      Flow continue-on-error
  -continue []          Implementation continue-on-error
  -timeout <str>        Option: Timeout value
  -strict [<bool>]      Option: Strict checking
  -scheduler <str>      Option: Scheduler platform
  -cores <int>          Option: Scheduler core constraint
  -memory <str>         Option: Scheduler memory constraint
  -queue <str>          Option: Scheduler queue
  -defer <str>          Option: Scheduler start time
  -scheduler_options <str>
                        Option: Scheduler arguments
  -msgevent <str>       Option: Message event trigger
  -msgcontact <str>     Option: Message contact
  -arg_step <str>       ARG: Step argument
  -arg_index <str>      ARG: Index argument
  -unit_time '<str>'    Unit: time
  -unit_length '<str>'  Unit: length
  -unit_mass '<str>'    Unit: mass
  -unit_temperature '<str>'
                        Unit: temperature
  -unit_capacitance '<str>'
                        Unit: capacitance
  -unit_resistance '<str>'
                        Unit: resistance
  -unit_inductance '<str>'
                        Unit: inductance
  -unit_voltage '<str>'
                        Unit: voltage
  -unit_current '<str>'
                        Unit: current
  -unit_power '<str>'   Unit: power
  -unit_energy '<str>'  Unit: energy
  -fpga_partname <str>  FPGA: part name
  -fpga_vendor '<str>'  FPGA: vendor name
  -fpga_lutsize 'partname <int>'
                        FPGA: lutsize
  -fpga_file 'partname key <str>'
                        FPGA: file
  -fpga_var 'partname key <str>'
                        FPGA: var
  -fpga_board <str>     FPGA: board name
  -fpga_program [<bool>]
                        FPGA: program enable
  -fpga_flash [<bool>]  FPGA: flash enable
  -asic_logiclib <str>  ASIC: logic libraries
  -asic_macrolib <str>  ASIC: macro libraries
  -asic_delaymodel <str>
                        ASIC: delay model
  -asic_cells_decap '<str>'
                        ASIC: decap cell list
  -asic_cells_delay '<str>'
                        ASIC: delay cell list
  -asic_cells_tie '<str>'
                        ASIC: tie cell list
  -asic_cells_hold '<str>'
                        ASIC: hold cell list
  -asic_cells_clkbuf '<str>'
                        ASIC: clkbuf cell list
  -asic_cells_clkdelay '<str>'
                        ASIC: clkdelay cell list
  -asic_cells_clkinv '<str>'
                        ASIC: clkinv cell list
  -asic_cells_clkgate '<str>'
                        ASIC: clkgate cell list
  -asic_cells_clkicg '<str>'
                        ASIC: clkicg cell list
  -asic_cells_clklogic '<str>'
                        ASIC: clklogic cell list
  -asic_cells_dontuse '<str>'
                        ASIC: dontuse cell list
  -asic_cells_filler '<str>'
                        ASIC: filler cell list
  -asic_cells_tap '<str>'
                        ASIC: tap cell list
  -asic_cells_endcap '<str>'
                        ASIC: endcap cell list
  -asic_cells_antenna '<str>'
                        ASIC: antenna cell list
  -asic_libarch '<str>'
                        ASIC: library architecture
  -asic_site 'libarch <str>'
                        ASIC: Library sites
  -pdk_foundry 'pdkname <str>'
                        PDK: foundry name
  -pdk_node 'pdkname <float>'
                        PDK: process node
  -pdk_lambda 'pdkname <float>
                        PDK: Lambda value
  -pdk_version 'pdkname <str>'
                        PDK: version
  -pdk_stackup 'pdkname <str>'
                        PDK: metal stackups
  -pdk_minlayer 'pdk stackup <str>'
                        PDK: minimum routing layer
  -pdk_maxlayer 'pdk stackup <str>'
                        PDK: maximum routing layer
  -pdk_thickness 'pdkname stackup <float>'
                        PDK: unit thickness
  -pdk_wafersize 'pdkname <float>'
                        PDK: wafer size
  -pdk_panelsize 'pdkname <(float,float)>'
                        PDK: panel size
  -pdk_unitcost 'pdkname <float>'
                        PDK: unit cost
  -pdk_d0 'pdkname <float>'
                        PDK: process defect density
  -pdk_hscribe 'pdkname <float>'
                        PDK: horizontal scribe line width
  -pdk_vscribe 'pdkname <float>'
                        PDK: vertical scribe line width
  -pdk_edgemargin 'pdkname <float>'
                        PDK: wafer edge keep-out margin
  -pdk_density 'pdkname <float>'
                        PDK: transistor density
  -pdk_devmodel 'pdkname tool simtype stackup <file>'
                        PDK: device models
  -pdk_pexmodel 'pdkname tool stackup corner <file>'
                        PDK: parasitic TCAD models
  -pdk_layermap 'pdkname tool src dst stackup <file>'
                        PDK: layer map file
  -pdk_display 'pdkname tool stackup <file>'
                        PDK: display file
  -pdk_aprtech 'pdkname tool stackup libarch filetype <file>'
                        PDK: APR technology files
  -pdk_lvs_runset 'pdkname tool stackup name <file>'
                        PDK: LVS runset files
  -pdk_lvs_waiver 'tool stackup name <file>'
                        PDK: LVS waiver files
  -pdk_drc_runset 'pdkname tool stackup name <file>'
                        PDK: DRC runset files
  -pdk_drc_waiver 'tool stackup name <file>'
                        PDK: DRC waiver files
  -pdk_erc_runset 'pdkname tool stackup name <file>'
                        PDK: ERC runset files
  -pdk_erc_waiver 'tool stackup name <file>'
                        PDK: ERC waiver files
  -pdk_fill_runset 'pdkname tool stackup name <file>'
                        PDK: FILL runset files
  -pdk_fill_waiver 'tool stackup name <file>'
                        PDK: FILL waiver files
  -pdk_file 'pdkname tool key stackup <file>'
                        PDK: special file
  -pdk_directory 'pdkname tool key stackup <file>'
                        PDK: special directory
  -pdk_var 'pdkname tool stackup key <str>'
                        PDK: special variable
  -pdk_doc_homepage 'pdkname <file>'
                        PDK: documentation homepage
  -pdk_doc_datasheet 'pdkname <file>'
                        PDK: datasheet
  -pdk_doc_reference 'pdkname <file>'
                        PDK: reference
  -pdk_doc_userguide 'pdkname <file>'
                        PDK: userguide
  -pdk_doc_install 'pdkname <file>'
                        PDK: install
  -pdk_doc_quickstart 'pdkname <file>'
                        PDK: quickstart
  -pdk_doc_releasenotes 'pdkname <file>'
                        PDK: releasenotes
  -pdk_doc_tutorial 'pdkname <file>'
                        PDK: tutorial
  -tool_exe 'tool <str>'
                        Tool: executable name
  -tool_sbom 'tool version <file>'
                        Tool: software BOM
  -tool_path 'tool <dir>'
                        Tool: executable path
  -tool_vswitch 'tool <str>'
                        Tool: executable version switch
  -tool_vendor 'tool <str>'
                        Tool: vendor
  -tool_version 'tool <str>'
                        Tool: version
  -tool_format 'tool <file>'
                        Tool: file format
  -tool_licenseserver 'name key <str>'
                        Tool: license servers
  -tool_task_warningoff 'tool task <str>'
                        Task: warning filter
  -tool_task_continue ['tool task <bool>']
                        Task: continue option
  -tool_task_regex 'tool task suffix <str>'
                        Task: regex filter
  -tool_task_option 'tool task <str>'
                        Task: executable options
  -tool_task_var 'tool task key <str>'
                        Task: script variables
  -tool_task_env 'tool task step index name <str>'
                        Task: environment variables
  -tool_task_file 'tool task key <file>'
                        Task: setup files
  -tool_task_dir 'tool task key <dir>'
                        Task: setup directories
  -tool_task_input 'tool task step index <str>'
                        Task: inputs
  -tool_task_output 'tool task step index <str>'
                        Task: outputs
  -tool_task_stdout_destination 'task [log|output|none]'
                        Task: Destination for stdout
  -tool_task_stdout_suffix 'task <str>'
                        Task: File suffix for redirected stdout
  -tool_task_stderr_destination 'task [log|output|none]'
                        Task: Destination for stderr
  -tool_task_stderr_suffix 'task <str>'
                        Task: File suffix for redirected stderr
  -tool_task_require 'task step index <str>'
                        Task: parameter requirements
  -tool_task_report 'task metric step index <str>'
                        Task: reports
  -tool_task_refdir 'task <dir>'
                        Task: script directory
  -tool_task_script 'task step index <file>'
                        Task: entry script
  -tool_task_prescript 'task <file>'
                        Task: pre-step script
  -tool_task_postscript 'task <file>'
                        Task: post-step script
  -tool_task_keep 'task <str>'
                        Task: files to keep
  -tool_task_threads 'task <int>'
                        Task: thread parallelism
  -flowgraph_input 'flow step index <(str,str)>'
                        Flowgraph: step input
  -flowgraph_weight 'flow step index metric <float>'
                        Flowgraph: metric weights
  -flowgraph_goal 'flow step index metric <float>'
                        Flowgraph: metric goals
  -flowgraph_tool 'flow step <str>'
                        Flowgraph: tool selection
  -flowgraph_task 'flow step <str>'
                        Flowgraph: task selection
  -flowgraph_taskmodule 'flow step <str>'
                        Flowgraph: task module
  -flowgraph_args 'flow step index <str>'
                        Flowgraph: setup arguments
  -flowgraph_valid ['flow step index <str>']
                        Flowgraph: task valid bit
  -flowgraph_timeout 'flow step 0 <float>'
                        Flowgraph: task timeout value
  -flowgraph_status 'flow step index <str>'
                        Flowgraph: task status
  -flowgraph_select 'flow step index <(str,str)>'
                        Flowgraph: task select record
  -checklist_description 'standard item <str>
                        Checklist: item description
  -checklist_requirement 'standard item <str>
                        Checklist: item requirement
  -checklist_dataformat 'standard item <float>'
                        Checklist: item data format
  -checklist_rationale 'standard item <str>
                        Checklist: item rational
  -checklist_criteria 'standard item <float>'
                        Checklist: item criteria
  -checklist_task 'standard item <(str,str,str)>'
                        Checklist: item task
  -checklist_report 'standard item <file>'
                        Checklist: item report
  -checklist_waiver 'standard item metric <file>'
                        Checklist: item metric waivers
  -checklist_ok ['standard item <str>']
                        Checklist: item ok
  -metric_errors 'step index <int>'
                        Metric: total errors
  -metric_warnings 'step index <int>'
                        Metric: total warnings
  -metric_drvs 'step index <int>'
                        Metric: total drvs
  -metric_unconstrained 'step index <int>'
                        Metric: total unconstrained
  -metric_coverage 'step index <float>'
                        Metric: coverage
  -metric_security 'step index <float>'
                        Metric: security
  -metric_luts 'step index <int>'
                        Metric: FPGA LUTs
  -metric_dsps 'step index <int>'
                        Metric: FPGA DSP slices
  -metric_brams 'step index <int>'
                        Metric: FPGA BRAM tiles
  -metric_cellarea 'step index <float>'
                        Metric: cellarea
  -metric_totalarea 'step index <float>'
                        Metric: totalarea
  -metric_utilization step index <float>
                        Metric: area utilization
  -metric_peakpower 'step index <float>'
                        Metric: peakpower
  -metric_averagepower 'step index <float>'
                        Metric: averagepower
  -metric_dozepower 'step index <float>'
                        Metric: dozepower
  -metric_idlepower 'step index <float>'
                        Metric: idlepower
  -metric_leakagepower 'step index <float>'
                        Metric: leakagepower
  -metric_sleeppower 'step index <float>'
                        Metric: sleeppower
  -metric_irdrop 'step index <float>'
                        Metric: peak IR drop
  -metric_holdpaths 'step index <float>'
                        Metric: holdpaths
  -metric_setuppaths 'step index <float>'
                        Metric: setuppaths
  -metric_holdslack 'step index <float>'
                        Metric: holdslack
  -metric_holdwns 'step index <float>'
                        Metric: holdwns
  -metric_holdtns 'step index <float>'
                        Metric: holdtns
  -metric_setupslack 'step index <float>'
                        Metric: setupslack
  -metric_setupwns 'step index <float>'
                        Metric: setupwns
  -metric_setuptns 'step index <float>'
                        Metric: setuptns
  -metric_fmax 'step index <float>'
                        Metric: fmax
  -metric_macros 'step index <float>'
                        Metric: macros
  -metric_cells 'step index <float>'
                        Metric: cells
  -metric_registers 'step index <float>'
                        Metric: registers
  -metric_buffers 'step index <float>'
                        Metric: buffers
  -metric_transistors 'step index <float>'
                        Metric: transistors
  -metric_pins 'step index <float>'
                        Metric: pins
  -metric_nets 'step index <float>'
                        Metric: nets
  -metric_vias 'step index <float>'
                        Metric: vias
  -metric_wirelength 'step index <float>'
                        Metric: wirelength
  -metric_overflow 'step index <float>'
                        Metric: overflow
  -metric_memory 'step index <float>'
                        Metric: memory
  -metric_exetime 'step index <float>'
                        Metric: exetime
  -metric_tasktime 'step index <float>'
                        Metric: tasktime
  -metric_totaltime 'step index <float>'
                        Metric: totaltime
  -record_userid 'step index <str>'
                        Record: userid
  -record_publickey 'step index <str>'
                        Record: public key
  -record_machine 'step index <str>'
                        Record: machine name
  -record_macaddr 'step index <str>'
                        Record: MAC address
  -record_ipaddr 'step index <str>'
                        Record: IP address
  -record_platform 'step index <str>'
                        Record: platform name
  -record_distro 'step index <str>'
                        Record: distro name
  -record_arch 'step index <str>'
                        Record: hardware architecture
  -record_starttime 'step index <str>'
                        Record: start time
  -record_endtime 'step index <str>'
                        Record: end time
  -record_region 'step index <str>'
                        Record: cloud region
  -record_scversion 'step index <str>'
                        Record: software version
  -record_toolversion 'step index <str>'
                        Record: tool version
  -record_toolpath 'step index <str>'
                        Record: tool path
  -record_toolargs 'step index <str>'
                        Record: tool CLI arguments
  -record_osversion 'step index <str>'
                        Record: O/S version
  -record_kernelversion 'step index <str>'
                        Record: O/S kernel version
  -record_remoteid 'step index <str>'
                        Record: remote job ID
  -datasheet_feature 'name <float>'
                        Datasheet: features
  -datasheet_limit_storagetemp '<(float,float)>'
                        Datasheet: limit storage temperature limits
  -datasheet_limit_soldertemp '<(float,float)>'
                        Datasheet: limit solder temperature limits
  -datasheet_limit_junctiontemp '<(float,float)>'
                        Datasheet: limit junction temperature limits
  -datasheet_limit_tid '<(float,float)>'
                        Datasheet: limit total ionizing dose threshold
  -datasheet_limit_sel '<(float,float)>'
                        Datasheet: limit single event latchup threshold
  -datasheet_limit_seb '<(float,float)>'
                        Datasheet: limit single event burnout threshold
  -datasheet_limit_segr '<(float,float)>'
                        Datasheet: limit single event gate rupture threshold
  -datasheet_limit_set '<(float,float)>'
                        Datasheet: limit single event transient threshold
  -datasheet_limit_seu '<(float,float)>'
                        Datasheet: limit single event upset threshold
  -datasheet_thermal_rja '<float>'
                        Datasheet: thermal junction to ambient resistance
  -datasheet_thermal_rjct '<float>'
                        Datasheet: thermal junction to case (top) resistance
  -datasheet_thermal_rjcb '<float>'
                        Datasheet: thermal junction to case (bottom)
                        resistance
  -datasheet_thermal_rjb '<float>'
                        Datasheet: thermal junction to board resistance
  -datasheet_thermal_tjt '<float>'
                        Datasheet: thermal junction to top model
  -datasheet_thermal_tjb '<float>'
                        Datasheet: thermal junction to bottom model
  -datasheet_reliability 'standard item <float>'
                        Datasheet: reliability
  -datasheet_mechanical_length '<(float,float,float)>'
                        Datasheet: limit package length
  -datasheet_mechanical_width '<(float,float,float)>'
                        Datasheet: limit package width
  -datasheet_mechanical_thickness '<(float,float,float)>'
                        Datasheet: limit total package thickness
  -datasheet_mechanical_bodyheight '<(float,float,float)>'
                        Datasheet: limit thickness of packaged body
  -datasheet_mechanical_bumppitch '<(float,float,float)>'
                        Datasheet: limit bump pitch
  -datasheet_mechanical_bumpheight '<(float,float,float)>'
                        Datasheet: limit bump height
  -datasheet_mechanical_bumpdiameter '<(float,float,float)>'
                        Datasheet: limit bump diameter
  -datasheet_pin_map 'name bump <(float,float)>'
                        Datasheet: pin map
  -datasheet_pin_type 'name mode <str>'
                        Datasheet: pin type
  -datasheet_pin_dir 'name mode <str>'
                        Datasheet: pin direction
  -datasheet_pin_complement 'name mode <str>'
                        Datasheet: pin complement
  -datasheet_pin_standard 'name mode <str>'
                        Datasheet: pin standard
  -datasheet_pin_signal 'name mode <str>'
                        Datasheet: pin interface map
  -datasheet_pin_resetvalue 'name mode <str>'
                        Datasheet: pin reset value
  -datasheet_pin_vmax 'pin mode <(float,float,float)>'
                        Datasheet: pin absolute maximum voltage
  -datasheet_pin_vnominal 'pin mode <(float,float,float)>'
                        Datasheet: pin nominal operating voltage
  -datasheet_pin_vol 'pin mode <(float,float,float)>'
                        Datasheet: pin low output voltage level
  -datasheet_pin_voh 'pin mode <(float,float,float)>'
                        Datasheet: pin high output voltage level
  -datasheet_pin_vil 'pin mode <(float,float,float)>'
                        Datasheet: pin low input voltage level
  -datasheet_pin_vih 'pin mode <(float,float,float)>'
                        Datasheet: pin high input voltage level
  -datasheet_pin_vcm 'pin mode <(float,float,float)>'
                        Datasheet: pin common mode voltage
  -datasheet_pin_vdiff 'pin mode <(float,float,float)>'
                        Datasheet: pin differential voltage
  -datasheet_pin_voffset 'pin mode <(float,float,float)>'
                        Datasheet: pin offset voltage
  -datasheet_pin_vnoise 'pin mode <(float,float,float)>'
                        Datasheet: pin random voltage noise
  -datasheet_pin_vslew 'pin mode <(float,float,float)>'
                        Datasheet: pin slew rate
  -datasheet_pin_vhbm 'pin mode <(float,float,float)>'
                        Datasheet: pin ESD human body model voltage level
  -datasheet_pin_vcdm 'pin mode <(float,float,float)>'
                        Datasheet: pin ESD charge device model voltage level
  -datasheet_pin_vmm 'pin mode <(float,float,float)>'
                        Datasheet: pin ESD machine model voltage level
  -datasheet_pin_cap 'pin mode <(float,float,float)>'
                        Datasheet: pin capacitance
  -datasheet_pin_rdiff 'pin mode <(float,float,float)>'
                        Datasheet: pin differential pair resistance
  -datasheet_pin_rin 'pin mode <(float,float,float)>'
                        Datasheet: pin input resistance
  -datasheet_pin_rup 'pin mode <(float,float,float)>'
                        Datasheet: pin output pullup resistance
  -datasheet_pin_rdown 'pin mode <(float,float,float)>'
                        Datasheet: pin output pulldown resistance
  -datasheet_pin_rweakup 'pin mode <(float,float,float)>'
                        Datasheet: pin weak pullup resistance
  -datasheet_pin_rweakdown 'pin mode <(float,float,float)>'
                        Datasheet: pin weak pulldown resistance
  -datasheet_pin_power 'pin mode <(float,float,float)>'
                        Datasheet: pin power consumption
  -datasheet_pin_isupply 'pin mode <(float,float,float)>'
                        Datasheet: pin supply current
  -datasheet_pin_ioh 'pin mode <(float,float,float)>'
                        Datasheet: pin output high current
  -datasheet_pin_iol 'pin mode <(float,float,float)>'
                        Datasheet: pin output low current
  -datasheet_pin_iinject 'pin mode <(float,float,float)>'
                        Datasheet: pin injection current
  -datasheet_pin_ishort 'pin mode <(float,float,float)>'
                        Datasheet: pin short circuit current
  -datasheet_pin_ioffset 'pin mode <(float,float,float)>'
                        Datasheet: pin offset current
  -datasheet_pin_ibias 'pin mode <(float,float,float)>'
                        Datasheet: pin bias current
  -datasheet_pin_ileakage 'pin mode <(float,float,float)>'
                        Datasheet: pin leakage current
  -datasheet_pin_tperiod 'pin mode <(float,float,float)>'
                        Datasheet: pin minimum period
  -datasheet_pin_tpulse 'pin mode <(float,float,float)>'
                        Datasheet: pin pulse width
  -datasheet_pin_tjitter 'pin mode <(float,float,float)>'
                        Datasheet: pin rms jitter
  -datasheet_pin_thigh 'pin mode <(float,float,float)>'
                        Datasheet: pin pulse width high
  -datasheet_pin_tlow 'pin mode <(float,float,float)>'
                        Datasheet: pin pulse width low
  -datasheet_pin_tduty 'pin mode <(float,float,float)>'
                        Datasheet: pin duty cycle
  -datasheet_pin_bw 'pin mode <(float,float,float)>'
                        Datasheet: pin nyquist bandwidth
  -datasheet_pin_inl 'pin mode <(float,float,float)>'
                        Datasheet: pin integral nonlinearity
  -datasheet_pin_dnl 'pin mode <(float,float,float)>'
                        Datasheet: pin differential nonlinearity
  -datasheet_pin_snr 'pin mode <(float,float,float)>'
                        Datasheet: pin signal to noise ratio
  -datasheet_pin_sinad 'pin mode <(float,float,float)>'
                        Datasheet: pin signal to noise and distortion ratio
  -datasheet_pin_sfdr 'pin mode <(float,float,float)>'
                        Datasheet: pin spurious-free dynamic range
  -datasheet_pin_imd3 'pin mode <(float,float,float)>'
                        Datasheet: pin 3rd order intermodulation distortion
  -datasheet_pin_hd2 'pin mode <(float,float,float)>'
                        Datasheet: pin 2nd order harmonic distortion
  -datasheet_pin_hd3 'pin mode <(float,float,float)>'
                        Datasheet: pin 3rd order harmonic distortion
  -datasheet_pin_hd4 'pin mode <(float,float,float)>'
                        Datasheet: pin 4th order harmonic distortion
  -datasheet_pin_nsd 'pin mode <(float,float,float)>'
                        Datasheet: pin noise spectral density
  -datasheet_pin_phasenoise 'pin mode <(float,float,float)>'
                        Datasheet: pin phase noise
  -datasheet_pin_enob 'pin mode <(float,float,float)>'
                        Datasheet: pin effective number of bits
  -datasheet_pin_gain 'pin mode <(float,float,float)>'
                        Datasheet: pin gain
  -datasheet_pin_pout 'pin mode <(float,float,float)>'
                        Datasheet: pin output power
  -datasheet_pin_pout2 'pin mode <(float,float,float)>'
                        Datasheet: pin 2nd harmonic power
  -datasheet_pin_pout3 'pin mode <(float,float,float)>'
                        Datasheet: pin 3rd harmonic power
  -datasheet_pin_vofferror 'pin mode <(float,float,float)>'
                        Datasheet: pin offset error
  -datasheet_pin_vgainerror 'pin mode <(float,float,float)>'
                        Datasheet: pin gain error
  -datasheet_pin_cmrr 'pin mode <(float,float,float)>'
                        Datasheet: pin common mode rejection ratio
  -datasheet_pin_psnr 'pin mode <(float,float,float)>'
                        Datasheet: pin power supply noise rejection
  -datasheet_pin_s21 'pin mode <(float,float,float)>'
                        Datasheet: pin rf gain
  -datasheet_pin_s11 'pin mode <(float,float,float)>'
                        Datasheet: pin rf input return loss
  -datasheet_pin_s22 'pin mode <(float,float,float)>'
                        Datasheet: pin rf output return loss
  -datasheet_pin_s12 'pin mode <(float,float,float)>'
                        Datasheet: pin rf reverse isolation
  -datasheet_pin_noisefigure 'pin mode <(float,float,float)>'
                        Datasheet: pin rf noise figure
  -datasheet_pin_ib1db 'pin mode <(float,float,float)>'
                        Datasheet: pin rf in band 1 dB compression point
  -datasheet_pin_oob1db 'pin mode <(float,float,float)>'
                        Datasheet: pin rf out of band 1 dB compression point
  -datasheet_pin_iip3 'pin mode <(float,float,float)>'
                        Datasheet: pin rf 3rd order input intercept point
  -datasheet_pin_tsetup 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin setup time
  -datasheet_pin_thold 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin hold time
  -datasheet_pin_tskew 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin timing skew
  -datasheet_pin_tdelayr 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin propagation delay (rise)
  -datasheet_pin_tdelayf 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin propagation delay (fall)
  -datasheet_pin_trise 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin rise transition
  -datasheet_pin_tfall 'pin mode relpin <(float,float,float)>'
                        Datasheet: pin fall transition
  -datasheet_pin_function 'name mode <str>'
                        Datasheet: pin function
  -datasheet_pin_polarity 'name mode relpin <str>'
                        Datasheet: pin polarity
  -package_depgraph 'module <(str,str)>'
                        Package: dependency list
  -package_name <str>   Package: name
  -package_version <str>
                        Package: version
  -package_description <str>
                        Package: description
  -package_keyword <str>
                        Package: keyword
  -package_homepage <str>
                        Package: project homepage
  -package_doc_homepage <str>
                        Package: documentation homepage
  -package_doc_datasheet <str>
                        Package: datasheet document
  -package_doc_reference <str>
                        Package: reference document
  -package_doc_userguide <str>
                        Package: userguide document
  -package_doc_quickstart <str>
                        Package: quickstart document
  -package_doc_releasenotes <str>
                        Package: releasenotes document
  -package_doc_testplan <str>
                        Package: testplan document
  -package_doc_signoff <str>
                        Package: signoff document
  -package_doc_tutorial <str>
                        Package: tutorial document
  -package_repo <str>   Package: code repository
  -package_dependency 'module <str>'
                        Package: version dependencies
  -package_target <str>
                        Package: qualified targets
  -package_license <str>
                        Package: license identifiers
  -package_licensefile <file>
                        Package: license files
  -package_location <file>
                        Package: location
  -package_organization <str>
                        Package: sponsoring organization
  -package_publickey <str>
                        Package: public key
  -package_author_name 'userid <str>'
                        Package: author name
  -package_author_email 'userid <str>'
                        Package: author email
  -package_author_username 'userid <str>'
                        Package: author username
  -package_author_location 'userid <str>'
                        Package: author location
  -package_author_organization 'userid <str>'
                        Package: author organization
  -package_author_publickey 'userid <str>'
                        Package: author publickey
  -version              show program's version number and exit

3.2. sc-dashboard#

usage: sc-dashboard [-h] [-cfg <file>] [-loglevel <str>] [-version]
                    [-port <port>]
                    [-graph_cfg <[manifest name, manifest path> [<[manifest name, manifest path> ...]]

-----------------------------------------------------------
SC app to open a dashboard for a given manifest.

To open:
    sc-dashboard -cfg <path to manifest>

To specify a different port than the default:
    sc-dashboard -cfg <path to manifest> -port 10000

To include another chip object to compare to:
    sc-dashboard -cfg <path to manifest> -graph_cfg <name of manifest> <path to other manifest>
        -graph_cfg <path to other manifest> ...
-----------------------------------------------------------

optional arguments:
  -h, --help            show this help message and exit
  -cfg <file>           Configuration manifest
  -loglevel <str>       Logging level
  -version              show program's version number and exit
  -port <port>          port to open the dashboard app on
  -graph_cfg <[manifest name, manifest path> [<[manifest name, manifest path> ...]
                        chip name - optional, path to chip manifest (json)

3.3. sc-issue#

usage: sc-issue [-h] [-cfg <file>] [-loglevel <str>] [-arg_step <str>]
                [-arg_index <str>] [-tool_task_option 'tool task <str>']
                [-tool_task_var 'tool task key <str>'] [-version] [-generate]
                [-exclude_libraries] [-exclude_pdks] [-hash_files] [-run]
                [-use <module>] [-add_library <library>] [-add_pdk <pdk>]
                [-file <file>]

-----------------------------------------------------------
Restricted SC app that generates a sharable testcase from a
failed flow or runs an issue generated with this program.

To generate a testcase, use:
    sc-issue -generate -cfg <stepdir>/outputs/<design>.pkg.json

    or include a different step/index than what the cfg_file is pointing to:
    sc-issue -generate -cfg <otherdir>/outputs/<design>.pkg.json -arg_step <step> -arg_index <index>

    or include specific libraries while excluding others:
    sc-issue -generate -cfg <stepdir>/outputs/<design>.pkg.json -exclude_libraries -add_library sram -add_library gpio

To run a testcase, use:
    sc-issue -run -file sc_issue_<...>.tar.gz
-----------------------------------------------------------

optional arguments:
  -h, --help            show this help message and exit
  -cfg <file>           Configuration manifest
  -loglevel <str>       Logging level
  -arg_step <str>       ARG: Step argument
  -arg_index <str>      ARG: Index argument
  -tool_task_option 'tool task <str>'
                        Task: executable options
  -tool_task_var 'tool task key <str>'
                        Task: script variables
  -version              show program's version number and exit
  -generate             generate a testcase
  -exclude_libraries    flag to ensure libraries are excluded in the testcase
  -exclude_pdks         flag to ensure pdks are excluded in the testcase
  -hash_files           flag to hash the files in the schema before generating
                        the manifest
  -run                  run a provided testcase
  -use <module>         modules to load into test run
  -add_library <library>
                        library to include in the testcase, if not provided
                        all libraries will be added according to the
                        -exclude_libraries flag
  -add_pdk <pdk>        pdk to include in the testcase, if not provided all
                        libraries will be added according to the -exclude_pdks
                        flag
  -file <file>          filename for the generated testcase

3.4. sc-remote#

usage: sc_remote [-h] [-credentials <file>] [-cfg <file>] [-version]
                 [-configure] [-server <server>] [-reconnect] [-cancel]
                 [-delete]

-----------------------------------------------------------
SC app that provides an entry point to common remote / server
interactions.

To generate a configuration file, use:
    sc-remote -configure

    or to specify a specific server and/or port:
    sc-remote -configure -server https://example.com
    sc-remote -configure -server https://example.com:1234

To check an ongoing job's progress, use:
    sc-issue -cfg <stepdir>/outputs/<design>.pkg.json

To cancel an ongoing job, use:
    sc-issue -cancel -cfg <stepdir>/outputs/<design>.pkg.json

To reconnect an ongoing job, use:
    sc-issue -reconnect -cfg <stepdir>/outputs/<design>.pkg.json

To delete a job, use:
    sc-issue -delete -cfg <stepdir>/outputs/<design>.pkg.json
-----------------------------------------------------------

optional arguments:
  -h, --help           show this help message and exit
  -credentials <file>  User credentials file
  -cfg <file>          Configuration manifest
  -version             show program's version number and exit
  -configure           create configuration file for the remote
  -server <server>     address of server for configure
  -reconnect           reconnect to a running job on the remote
  -cancel              cancel a running job on the remote
  -delete              delete a job on the remote

3.5. sc-run#

usage: sc-run [-h] [-cfg <file>] [-loglevel <str>] [-quiet [<bool>]]
              [-relax [<bool>]] [-version]

    -----------------------------------------------------------
    Restricted SC app that accepts one or more json based cfg files
    as inputs and executes the SC run() method.
    -----------------------------------------------------------
    

optional arguments:
  -h, --help       show this help message and exit
  -cfg <file>      Configuration manifest
  -loglevel <str>  Logging level
  -quiet [<bool>]  Quiet execution
  -relax [<bool>]  Relax design checking
  -version         show program's version number and exit

3.6. sc-server#

usage: sc-server [-h] [-auth] [-cluster <str>] [-nfs_mount <str>]
                 [-port <num>]

    Silicon Compiler Collection Remote Job Server (sc-server)
    

optional arguments:
  -h, --help        show this help message and exit
  -auth             Flag determining whether to enable authenticated and
                    encrypted jobs. Intended for testing client-side
                    authentication flags, not for securing sensitive
                    information. TBD
  -cluster <str>    Type of compute cluster to use. Valid values: [slurm,
                    local] TBD
  -nfs_mount <str>  Directory of mounted shared NFS storage. TBD
  -port <num>       Port number to run the server on. TBD

3.7. sc-show#

usage: sc-show [-h] [-design <str>] [-input 'fileset filetype <file>']
               [-cfg <file>] [-loglevel <str>] [-jobname <str>]
               [-arg_step <str>] [-arg_index <str>] [-version] [-ext <ext>]
               [-screenshot]
               [source [source ...]]

    --------------------------------------------------------------
    Restricted SC app that displays the layout of a design
    based on a file provided or tries to display the final
    layout based on loading the json manifest from:
    build/<design>/job0/<design>.pkg.json

    Examples:

    sc-show -design adder
    (displays build/adder/job0/export/0/outputs/adder.gds)

    sc-show -design adder -arg_step floorplan
    (displays build/adder/job0/floorplan/0/outputs/adder.def)

    sc-show -design adder -arg_step place -arg_index 1
    (displays build/adder/job0/place/1/outputs/adder.def)

    sc-show -design adder -jobname rtl2gds
    (displays build/adder/rtl2gds/export/0/outputs/adder.gds)

    sc-show -cfg build/adder/rtl2gds/adder.pkg.json
    (displays build/adder/rtl2gds/export/0/outputs/adder.gds)

    sc-show -design adder -ext odb
    (displays build/adder/job0/export/1/outputs/adder.odb)

    sc-show build/adder/job0/route/1/outputs/adder.def
    (displays build/adder/job0/route/1/outputs/adder.def)
    

positional arguments:
  source                Input files with filetype inferred by extension

optional arguments:
  -h, --help            show this help message and exit
  -design <str>         Design top module name
  -input 'fileset filetype <file>'
                        Input: files
  -cfg <file>           Configuration manifest
  -loglevel <str>       Logging level
  -jobname <str>        Job name
  -arg_step <str>       ARG: Step argument
  -arg_index <str>      ARG: Index argument
  -version              show program's version number and exit
  -ext <ext>            (optional) Specify the extension of the file to show.
  -screenshot           (optional) Will generate a screenshot and exit.

3.8. sup#

usage: sup <command> [options]
    

SiliconCompiler package manager

positional arguments:
  command           command to run
  name              package name(s)

optional arguments:
  -h, --help        show this help message and exit
  -v, --version     show version and ext
  -r , --registry   registry list
  -l , --loglevel   logging level
  --nodeps          don't include dependencies

------------------------------------------------------------
The Silicon Unified Packager ('sup') is the SiliconCompiler
package management utility for installing, upgrading,
configuring, and removing design packages from a local
computer.

SUP packages are...

* JSON files directly produced by SiliconCompiler
* named <design>.<semver>.sup.gz
* included in a project with the 'package,dependency' schema
* resolved with the update() core method
* installed in ~/.sc/registry by default
* organized as follows:
  <design>
         └── <version>
             ├── <jobname>
             │   ├── import (sources)
             │   └── export (results)
             ├── <jobname>
             │   ├── import
             │   └── export
             ├── <design>-<version>.html
             └── <design>-<version>.sup

Supported Commands:

check     : Check package
publish   : Publish package
install   : Install package
uninstall : Uninstall package
info      : Show package information
list      : List packages in local install cache
index     : List packages in registry

See https://docs.siliconcompiler.com for more information

------------------------------------------------------------