Double Patterning Technique

power routing basics

Power routing basics :

• How to calculate number of core power/ground pads required?

Lets assume 1Watt power is consumed by chip and 1V is ss corner voltage

Power = Voltage*Current

P=V*I 

I = P/V

  =1/1

  = 1 ampere = 1000 milli ampere

Assume each pad can drive maximum of 100mA current.

No.of power pads required (p) = 1000/100=10  pads

No.of ground pads required (g) = p = 10 pads

Ideally 10 ground pads and 10  power pads are sufficient. In most of the cases the power distribution may not be uniform meaning the pads which are placed in the centre of chip are more effective as the sinks at centre might have less resistive paths. So we need to add more pads lets say 30% more pads.

So, no.of power/ground pads = (1+0.3)*10=13

• How to calculate the core PG ring width? Given Jmax (maximum current density of metal layer = 50mA/um)
• Core PG ring width = (Total current)/(No.of sides *Jmax)

             = 1000/(4*50)=5 u

• How to calculate pad to core trunk width?
• Pad to core trunk width = total current/(no.of sides * Jmax)

                                            = 1000/(4*50)=5 u

• How to calculate strap width and no.of straps for a block? Given width of block is W and height of block as H. Total power of block as P
• Let I = P/V
• Total current from top and bottom = (I * W)/(W+H)
• Let current is equally be supplied from top and bottom.
• Itop = Ibottom = (I * W)/(W+H)
• Similarly Ileft = Iright = (I * H)/(W+H)
• With 1% voltage drop at a node in the center
• Reffective (from Vertical) = (0.01*(VDD/2))/Itop
• Reffective (from Horizontal) = (0.01*(VDD/2))/Ileft

• Width of Straps based on EM limits :
• Total width of Vertical strap (Wvstrap-em) = Itop /Jmax
• Total width of horizontal strap (Whstrap-em) = Ileft /Jmax
• Now assume initial width of strap to be 5X of min-width
• Wvstrap = 5*0.07=0.35 (0.07 is the min width for metal6)
• Rstripe-v = (Rpsq * H)/Wvstrap
• Note :  Rpsq =  Rho/thickness
• No.of vertical straps = Nvstraps = Rstripe-v / Reffective
• Now check the total width of vertical straps = Nvstraps * Wvstrap is greater than or equal to Wvstrap-em else increase the Wvstrap accordingly.

TCL example scripts

In this post, I will upload sample scripts to refer : (Under cons)

EXAMPLE : 1

For the engineers who are familiar with static timing analysis, as a programmer I want to calculate arrival time, required time, slack at each node using the given circuit. The example script will be able to demonstrate some of the tcl functions. The following circuit 10 nodes excluding (Out node), delay of each node is represented in the brackets. The objective of this program is to write a TCL script to analyse the slack at each and every node using graph based slack analysis.

Brief introduction about the graph based STA :

We need to break the entire program into three sections :

1. Arrival time calculation (AT)

2. Required time calculation (RT)

3. Slack calculation. 

First we need to calculate AT at each node, Let's do hand calculation of arrival time at few nodes. Arrival time at node 'A' is 10 as delay of node  'A' is 10 and then it passes through node 'D' whose delay is '8',  so the arrival time at node 'D' is 18 adding the delay of traversed path. But we can reach D by traversing IN->B->D accounting the delay of 13 (5+8), so we need to choose bigger one of the two arrival times (18,13) and assign that  arrival time to node 'D' in this case it is '18'. We need to repeat the same for all the nodes.

In the second section we need to calculate the required time starting from out node 'O'. In general we might be given required time by the clock specification. But in this case we take RT as the max of all the arrival times.

The above circuit can be represented using the adjacency matrix. Please refer to following link to know more about adjacency matrix. https://en.wikipedia.org/wiki/Adjacency_matrix

	set ifile [open sta_inputs.txt r]
	set i 0
	while { [gets $ifile line] != -1 } {
	set j 0
	foreach val $line {
	set orig($i,$j) $val
	incr j
	}
	incr i
	}
	close $ifile
	#set arrival time,required time matrices
	array set atmat [array get orig]
	array set rtmat [array get orig]
	#procedures used
	proc getmaxcol { mat itr } {
	upvar $mat mat1
	set ctr [expr int (sqrt ([llength [array names mat1]]))]
	set max $mat1($itr,$itr)
	for { set i 0 } { $i < $ctr } { incr i } {
	if { $max < $mat1($i,$itr) } { set max $mat1($i,$itr) }
	}
	return $max
	}
	proc getminrow { mat itr } {
	upvar $mat mat1
	set ctr [expr int (sqrt ([llength [array names mat1]]))]
	set min $mat1($itr,$itr)
	for { set i 0 } { $i < $ctr } { incr i } {
	if { $min > $mat1($itr,$i) } { set min $mat1($itr,$i) }
	}
	return $min
	}
	#arrival time calculation
	set ctr [expr int (sqrt ([llength [array names orig]]))]
	for { set i 0 } { $i < $ctr } { incr i } {
	set max [getmaxcol atmat $i]
	for {set j 0 } { $j < $ctr } { incr j } {
	if { $atmat($i,$j) != 0 } {
	set atmat($i,$j) [expr $atmat($i,$j)+$max]
	}
	}
	}
	set rt [getmaxcol atmat 0]
	for { set i 0 } { $i < $ctr } { incr i } {
	set arrival($i) [getmaxcol atmat $i]
	if { $rt < $arrival($i) } { set rt $arrival($i) }
	}
	#required time calculation
	set n [expr $ctr - 1]
	#set rt [getmaxcol atmat $n]
	for { set i $n } { $i >= 0 } { incr i -1 } {
	for { set j $n } { $j >= 0 } { incr j -1 } {
	if { $rtmat($i,$j) != 0 } {
	set rtmat($i,$j) [expr [getminrow rtmat $j] - $rtmat($i,$j)]
	} else {
	set rtmat($i,$j) $rt;
	}
	}
	}
	for { set i 0 } { $i < $ctr } { incr i } {
	set required($i) [getminrow rtmat $i]
	}
	for {set i 0 } { $i < $ctr } { incr i } {
	set slack($i) [ expr $required($i) - $arrival($i)]
	}
	puts "Node :: arrival_time :: reqd_time :: slack"
	for {set i 0 } { $i < $ctr } { incr i } {
	puts "$i :: $arrival($i) :: $required($i) :: $slack($i)"
	}

view raw sta.tcl hosted with ❤ by GitHub

	0 10 5 2 0 0 0 0 0 0
	0 0 0 0 8 0 0 0 0 0
	0 0 0 0 8 7 0 0 0 0
	0 0 0 0 0 7 0 0 0 0
	0 0 0 0 0 0 4 0 0 0
	0 0 0 0 0 0 4 0 0 0
	0 0 0 0 0 0 0 6 3 0
	0 0 0 0 0 0 0 0 0 0
	0 0 0 0 0 0 0 0 0 2
	0 0 0 0 0 0 0 0 0 0

view raw sta_inputs.txt hosted with ❤ by GitHub

physical design

Please visit this blog to learn/discuss all about physical design tips, techniques, fundamentals.

regex

Regex,regsub  :

A regular expression is simply a description of a pattern that describes a set of possible characters in an input string.

Example :

	#I want to replace dog with cat in the following statement
	set exp1 "someone let the dog out of bag"
	#First check whether dog is present in bag or not
	set val [regexp (dog) $exp1 sub1 sub2 sub3]
	puts $sub1
	if { $val } {
	regsub dog $exp1 cat exp2
	}
	puts "original expression : $exp1"
	puts "modified expression : $exp2"
	set exp3 "I have one black dog, one white dog and one brown dog in my bag"
	#replace all dogs with corresponding cats
	regsub -all dog $exp3 cat exp4
	puts $exp4
	#When you don't want to include particular pattern in sub-pattern use ?:
	set exp5 "Sasken LSI TI Mirafra"
	regexp "(Sasken|Smartplay).*(?:LSI|Avago).*(Mirafra)" $exp5 sub1 sub2 sub3
	#Output :
	#% puts $sub1
	#Sasken LSI TI Mirafra
	#% puts $sub2
	#Sasken
	#% puts $sub3
	#Mirafra
	set exp6 "Ooh La La Tu Hai Meri Fantasy "
	regexp -nocase (oo)? $exp6 sub1
	puts $sub1
	#If I want to search starting with ^O and ending with y
	regexp "^O.*y$" $exp6
	#Loop through all the words in the exp6 and put the words which doesn't start with vowels
	foreach var $exp6 {
	if { [regexp -nocase {^[^aeiou]} $var ] } {
	puts $var
	}
	}
	#Output
	#La
	#La
	#Tu
	#Hai
	#Meri
	#Fantasy

view raw regex_demo.tcl hosted with ❤ by GitHub

strings

Strings

• A string is a sequence of letters, it always need not be enclosed in the quotes until you use some white spaces in between the words. Tcl is a string based language it provides rich set of operations on strings.

Examples :

set str1 one

set str2 "two three"

set str3 I\ need\ not\ enclose\ this\ in\ quotes

• Following operations can be executed on strings:
• string compare
• string equal
• string length
• string match #global expression
• string toupper
• string tolower
• string totitle #it will convert the starting letter of string to uppercase
• string index
• string range
• string reverse

Example :

	set str1 Tcl
	set str2 "Tcl programmer"
	set str3 tcl
	#The string compare command compares strings character by character. If it finds that the first characters of both strings are equal,
	#it continues with the second character, until the end. It returns 0 if the strings are equal and -1
	#if a non-matching character in the first string is located in the ASCII table before the character of the second string.
	#The 1 number is returned if the non-matching character of the first string is located after the character of the second string.
	puts [string compare $str1 $str2 ] ; #output is -1
	puts [string compare -length 3 $str3 $str2 ] ; #output is 1
	puts [string compare -length 3 $str1 $str2 ] ; #output is 0, it checks first 3 letters in the string
	#string equal can be used to compare strings, it returns 1 if they are true else 0 for false. It checks for case
	puts [string equal $str2 $str3 ] ; #output is 0
	puts [string equal -length 3 $str2 $str3 ] ; #output is 1, it checks first 3 letters in the string
	puts [string length $str1] ; #output is 3
	puts [string match Tcl* $str2] ; #global expression
	puts [string toupper $str1] ; #Output : TCL
	puts [string tolower $str1]; #Output : tcl
	#string totitle #it will convert the starting letter of string to uppercase
	puts [string totitle $str3]; # Output : Tcl
	#To get the last letter of the string
	puts [string index $str1 end]
	#to get range of letters
	puts [string range $str2 2 5]; #output : l pr
	puts [string reverse $str2]
	#Output:remmargorp lcT

view raw strings.tcl hosted with ❤ by GitHub

lists

• Lists
• Lists are equivalent to arrays in the conventional programming language like C.
• Lists can be expanded and collapsed on the fly.

• Example 1:
• set list1 "a  b c d"