Python Scripting for VLSI Automation

Prerequisites for Enrollment:

Students should have the following knowledge and skills before enrolling in the course:

1. Basic Linux Terminal Usage:

● Navigating directories: cd, ls, pwd, mkdir, rmdir

● File operations: cat, cp, mv, rm, touch, vi
● Managing processes: kill, bg, fg
● File permissions: chmod, chown, chgrp
● Redirection and pipes: >, >>, <, |, tee
● Search commands: grep, find, locate
● Package management: apt-get, pip (for Python packages)
● Cron jobs: Basic understanding of scheduling tasks using crontab

2. Understanding of VLSI Concepts:

● Familiarity with terms like regression, log files, simulation tools, and basic knowledge
of VLSI design/verification processes (though this will be covered contextually in the
course).

Course Plan: 20 Days

Day 1-2: Introduction to Python for VLSI Automation

● Day 1: Python Basics

○ Topics: Syntax, data types (Integers, Strings, Lists, Tuples, Dictionaries, and
Sets)
○ Exercises: Basic calculations, list manipulations, and dictionary operations.
○ Objective: Understand Python’s syntax and its data structures.
● Day 2: Control Structures
○ Topics: Loops (for, while), Conditional Statements (if, elif, else)
○ Exercises: Write simple programs using loops and conditionals.
○ Objective: Implement control flow structures for automation tasks.

Day 3-4: Functions, File Handling & Exception Handling

● Day 3: Functions
 ○ Topics: Defining and calling functions, default arguments.
○ Exercises: Creating functions for modular code.
○ Objective: Learn to break down tasks into reusable functions.
● Day 4: File Handling & Exception Handling
○ Topics: Reading/writing text, CSV, binary files, try-except-finally blocks.
○ Exercises: Handling file read/write errors and file parsing.
○ Objective: Master file input/output operations and exception handling for
automation scripts.

Day 5-6: Modules and Packages

● Day 5: Modules and Packages

○ Topics: Importing and creating Python modules and packages.
○ Exercises: Create a module for utility functions and import it into scripts.
○ Objective: Understand how to structure larger projects using modules and
packages.
● Day 6: OS and Subprocess Modules
○ Topics: Working with the OS (os) and subprocess modules.
○ Exercises: Automate directory navigation and run shell commands using
subprocess.
○ Objective: Interact with the operating system from Python scripts.

Day 7-8: Directory Operations & Regular Expressions

● Day 7: Directory Operations

○ Topics: Directory navigation, file manipulations (os.path, shutil).
○ Exercises: Automate directory creation and cleanup.
○ Objective: Automate the setup and cleanup of files and directories for VLSI
regression.
● Day 8: Regular Expressions
○ Topics: Using re module for text parsing and pattern matching.
○ Exercises: Extracting data from logs or text files using regex.
○ Objective: Learn how to parse log files and other text-based results.

Day 9-10: Excel Parsing and Manipulation

● Day 9: OpenPyXL & Pandas for Excel Parsing

○ Topics: Reading and writing Excel (.xlsx) files using OpenPyXL.
○ Exercises: Automating the reading and writing of test case results in Excel.
○ Objective: Learn to automate Excel-related tasks in VLSI regression.
● Day 10: Pandas for Data Manipulation
○ Topics: Using Pandas DataFrames for data manipulation.
 ○ Exercises: Parse large Excel sheets using Pandas and perform basic data
analysis.
○ Objective: Master handling large datasets and manipulating Excel data with
Pandas.

Day 11-12: VLSI Regression Automation

● Day 11: Automating Regression Tasks

○ Topics: Automating directory creation, log file parsing, and regression setup.
○ Exercises: Automate the execution of simulations and collection of results.
○ Objective: Implement automation for running simulations, generating logs,
and storing results.
● Day 12: Parallel Execution in Regression
○ Topics: Using multiprocessing to run multiple simulations concurrently.
○ Exercises: Run simulations in parallel and gather results efficiently.
○ Objective: Optimize regression tasks by parallelizing them.

Day 13-14: Interaction with Environment and Simulation Tools

● Day 13: Environment Interaction

○ Topics: Sourcing environment scripts and running simulation tools via tcl
script (run.do file).
○ Exercises: Set up environment variables and automate tool execution.
○ Objective: Learn to interact with tools and environments using Python.
● Day 14: Log File Parsing in Regression
○ Topics: Using regular expressions and Pandas for parsing simulation logs.
○ Exercises: Automate extracting pass/fail status from simulation logs.
○ Objective: Automate log parsing to detect test outcomes efficiently.

Day 15-16: Email Automation

● Day 15: Sending Emails with smtplib

○ Topics: Automating email sending via SMTP.
○ Exercises: Send basic emails using Python.
○ Objective: Learn how to send emails from Python scripts.
● Day 16: Email Attachments and HTML Formatting
○ Topics: Sending emails with attachments, HTML formatting using
email.mime.
○ Exercises: Send reports with simulation results attached.
○ Objective: Craft emails with HTML content and attachments for automation
reports.
Day 17-18: Scheduling and Cron Jobs

● Day 17: Cron Jobs in Linux

○ Topics: Scheduling tasks with crontab.
○ Exercises: Schedule Python scripts to run at specific times using cron.
○ Objective: Automate the execution of scripts periodically using cron.
● Day 18: Programmatic Scheduling in Python
○ Topics: Using schedule and APScheduler libraries for scheduling within
Python.
○ Exercises: Schedule tasks using Python-based schedulers.
○ Objective: Master internal Python scheduling for periodic automation tasks.

Day 19-20: Data Visualization & Best Practices

● Day 19: Data Visualization

○ Topics: Using Matplotlib and Seaborn for visualizing regression results.
○ Exercises: Plot regression results for better insight and reporting.
○ Objective: Learn basic data visualization to enhance reporting.
●
● Day 20: Final Project
○ Topics:
● UVM Testbench protocol scripting
● UVM RAL (Register Abstraction Layer) scripting
○ Exercises: create UVM testbenches and register abstraction layers to
automate VLSI verification tasks

NOTE: This is the tentative daily plan; day-to-day topics may vary based on the progression
of the course or adjustments made for following classes. The sequence and content of
classes may be modified to accommodate the learning pace and specific needs of students.