Cadence Custom IC Design Blogs

SKILL for the Skilled: Part 9, Many Ways to Sum a List

Team SKILL — Wed, 22 May 2013 16:00:00 GMT

In the previous postings of SKILL for the Skilled, we've looked at different ways to sum the elements of a list of numbers. In this posting, we'll look at at least one way to NOT sum a list.

In my most recent posting, the particular subject was how to use SKILL++ to define a make_adder function. I commented in that article that the same thing would not work in traditional SKILL. In this posting, I'd like to walk through some of the issues you would encounter if you actually tried to implement this in traditional SKILL. Understanding why it does not work in the traditional SKILL dialect may shed some light on why it does work in the SKILL++ dialect.

Remember, these are not bugs in any sense in SKILL. The fact simply is that in some subtle ways traditional SKILL and SKILL++ behave differently. You can exploit the differences to your advantage, depending on your particular application.

Recall, here is the definition of make_adder_8a as you might type it into the CIWindow.

(unless (theEnvironment)
   (toplevel 'ils))

(defun make_adder_8a ()   ; 1.1
  (let ((sum 0))          ; 1.2
    (lambda (n)           ; 1.3
      sum = sum + n)))    ; 1.4

Try it in traditional SKILL

What happens if you try to define the make_adder_9a in traditional SKILL? Here is what will happen when you try to call the function.

(when (theEnvironment)
  (resume))

(defun make_adder_9a ()  ; 2.1
  (let ((sum 0))         ; 2.2
    (lambda (n)          ; 2.3
      sum = sum + n)))   ; 2.4

You see immediately that something very subtle is different.

C = (make_adder_9a)
  ==> funobj@0x1e666390

The make_adder_9a function, when defined in traditional SKILL, returns an object which is printed something like funobj@0x1e666390. Contrast that with the SKILL++ version of the function make_adder_8a defined above, which returned an object which was printed as funobj:A. What happens if we try to call the function we just created?

(C 1)

*Error* eval: undefined function - C
<<< Stack Trace >>>
C(1)

A drastic difference is obvious when you try to call the function, C. You have an error message indicating that C is not a function. This can be confusing to the beginner SKILL++ programmer. The reason for this is that the CIWindow is in SKILL listening mode. A similar thing happens if loading code from a file with a .il file name extension as opposed to a .ils extension.

For a discussion of changing the CIWindow listening mode between SKILL and SKILL++, see SKILL for the Skilled: Part 8, Many Ways to Sum a List, or consult the Cadence SKILL documentation for the toplevel and resume.

Setting a variable in SKILL

When the CIWindow is in SKILL listening mode an expression such as

C = (make_adder_9a)

modifies (or initially defines) a global variable named C to be the value returned from the make_adder_9a function. An expression such as

(defun C ()
  (println '(1 2 3 4)))

defines a global function named C. Critically important to how traditional SKILL works is that the variable C and the function C are different and independent. Either one can be referenced, or modified independent of the other. This is both a feature of SKILL as well as a point of confusion.

In SKILL mode the following expressions are semantically equivalent in setting the value of the variable C.

C = (make_adder_9a)
(setq C (make_adder_9a))
(set 'C (make_adder_9a))

The following expressions are equivalent in defining the function C.

(defun C ()
  (println '(1 2 3 4)))

(procedure (C)
  (println '(1 2 3 4)))

(putd 'C
  (lambda ()
    (println '(1 2 3 4))))

Setting a variable in SKILL++

By contrast when the CIWindow is in SKILL++ mode, an expression such as A = (make_adder_8a) (shown above) not only sets the global variable named A, but also defines a global function named A. If you then proceed to evaluate an expression such as

(defun A ()
  (println '(1 2 3 4)))

the global variable, A and the global function A will be modified to something new, and the old value will be lost (unless of course you have saved a reference to it).

SKILL++ does not support having a global variable and global function of the same name with different values.

In SKILL++ mode all the following expressions are equivalent in setting the global variable and simultaneously defining the global function named C.

(defun C ()
  (println '(1 2 3 4)))

(procedure (C)
  (println '(1 2 3 4)))

(define (C)
  (println '(1 2 3 4)))

(define C
  (lambda ()
    (println '(1 2 3 4))))

(setq C
  (lambda ()
    (println '(1 2 3 4))))

(putd 'C
  (lambda ()
    (println '(1 2 3 4))))

LISP-1 vs LISP-2

Another way to think about the different semantics of variables and functions between SKILL and SKILL++ is that SKILL++ is a LISP-1 and traditional SKILL is a LISP-2. LISP-1 means that there is one single name space for variables and functions. LISP-2 means that there are two different names spaces, one for variables and one for functions.

Use funcall to call a function indirectly

To call a function, in SKILL mode, whose value is stored in a variable (global or otherwise), you need to use funcall. If you use funcall to call the function whose value is in the global variable D, the function is indeed called but quickly encounters an error.

D = (make_adder_9a)
  ==> funobj@0x1e666390
(funcall D 1)
*Error* eval: unbound variable - sum
<<< Stack Trace >>>
(sum + n)
(sum = (sum + n))
funobj@0x1e666390()
funcall(D 1)

For some reason, the definition of the adder created by make_adder_9a, tries to reference a global variable named sum. Let's ignore this error momentarily, and assume we already accidentally had a global variable named sum whose value happened to be 0.

sum = 0
  ==> 0
D = (make_adder_9a)
  ==> funobj@0x1e666390
(funcall D 1)
  ==> 1
(funcall D 2)
  ==> 3
(funcall D 3)
  ==> 6
(funcall D 4)
  ==> 10
(funcall D 5)
  ==> 15

This requirement of having to use funcall when calling a function indirectly is inherent to the way traditional SKILL works.

From the above experiment it deceptively seems that the SKILL function make_adder_9a behaves much the same as make_adder_8a with the exception of the calling syntax: (funcall D 1) vs (A 1).

A second SKILL adder fails

In the previous post, we used make_adder_8a to define adders B1, B2, and B3. We saw that all three adders kept track of their partial sum independently. What happens if we try to define even one additional adder using make_adder_8b?

E = (make_adder_9a)
  ==> funobj@0x1e666390
(funcall E 1)
  ==> 16
(funcall E 2)
  ==> 18
(funcall E 3)
  ==> 21

Hey wait! Why did (funcall E 1) return 16? Let's set the global sum back to 0 and try it again.

sum = 0
  ==> 0
(funcall E 1)
  ==> 1
(funcall E 2)
  ==> 3
(funcall E 3)
  ==> 6

OK, setting sum back to 0 fixes it. Now, look again at D.

(funcall D 1)
  ==> 7
(funcall E 2)
  ==> 9
(funcall D 3)
  ==> 12

It seems that D and E are both using the same variable to keep track of the partial sum. In fact, if you print the value of the variable sum you'll see that its value is now 12.

Why does this fail?

In SKILL mode, the two adders, D and E, created by two different calls to make_adder_9a do not create two independent adders as did make_adder_8a in SKILL++ mode. The reason for this is critical to an important difference between SKILL and SKILL++. Look at lines 1.2, 1.3, and 1.4 of make_adder_8a and 2.1, 2.3, and 2.4 of make_adder_9a. While these lines are textually identical, they are semantically different in that make_adder_8a is SKILL++ and make_adder_9a is traditional SKILL.

Low level details of calling a SKILL function

Suppose make_adder_8a is called twice on line 3.1 and 3.4. Each time it is called, line 1.2 allocates a new binding which associates the variable sum with a location to store the value. The two functions created on line 1.3 each time make_adder_8a is called (lines 3.1 and 3.2), reference those respective bindings. You can see from line 3.3, that each time make_adder_8a is called, a different function is returned.

The textual reference to sum on line 1.4 references and modifies the value in the location of binding depending on which of the functions it is running from. When lines 3.4, and 3.5 are evaluted, line 1.4 references and modifies the first binding which was created as a result of evaluating line 3.1. Likewise, when lines 3.6, and 3.7 are evaluted, the same line 1.4 references and modifies the second binding which was created as a result of evaluating line 3.2.

A = (make_adder_8a)      ; 3.1
  ==> funobj:A
B = (make_adder_8a)      ; 3.2
  ==> funobj:B
(eq A B)                 ; 3.3
  ==> nil
(A 1)                    ; 3.4
  ==> 1
(A 2)                    ; 3.5
  ==> 3
(B 11)                   ; 3.6
  ==> 11
(B 22)                   ; 3.7
  ==> 33

Low level details of calling a SKILL++ function

Constrast that with the very different scenaraio which what happens in make_adder_9a. In this case when make_adder_9a is called (lines 4.1 and 4.2), each time a binding is created (because the let on line 2.2 is evaluated twice), but the local function created on line 2.3 DOES NOT any explicitly reference it. In fact both times make_adder_9a is called (lines 4.1 and 4.2), the exact same function is returned as seen on line 4.3.

When make_adder_9a returns the SKILL local function created on line 1.3, the call to make_adder_9a returns and all references to the binding created on line 2.2 are subsequently lost. Thereafter, when the function D or E is called, SKILL (at calling time) searches for the currently defined variable named sum which is global.

D = (make_adder_9a)      ; 4.1
  ==> funobj:@0x1e666390
E = (make_adder_9a)      ; 4.2
  ==> funobj:@0x1e666390
(eq D E)                 ; 4.3
  ==> t
(D 1)                    ; 4.4
  ==> 1
(D 2)                    ; 4.5
  ==> 3
(E 11)                   ; 4.6
  ==> 11
(E 22)                   ; 4.7
  ==> 33

Calling the functions stored in D and E (on lines 4.4 through 4.7) have much the same effect as directly evaluating a call to a copy of the inline function shown on lines 1.3 and 1.4. For example, lines 4.5 and 4.6 (D 2) and (E 11), are equivalent to the following which has the effect of referencing and modifying the global variable named sum.

(funcall (lambda (n) sum = sum + n)
         2)
(funcall (lambda (n) sum = sum + n)
         11)

Summary

In this article we looked at several differences between SKILL and SKILL++.

funcall -- How to call functions indirectly.
- SKILL -- You must use funcall: (funcall C 1)
- SKILL++ -- You may call the function directly: (A 1)
name-space --
- SKILL -- functions and variables live in different names-spaces; the function C and the variable C are different.
- SKILL++ -- supports a single name-space; function A and the variable A are the same.
closures -- how free variables are handled
- SKILL -- does not support closures; a free variable is resolved at run-time and may resolve differently depending on how a function is called.
- SKILL++ -- supports closures ; a free variable is resolved at compile time, and refers to the same allocated location no matter how the functions references them are called.

Feedback

Please let me know if you find any of the discussion or techniques discussed in this or previous articles useful.

Thanks for reading!

Jim Newton

Virtuosity: 10 Things I Learned in April by Browsing Cadence Online Support

stacyw — Mon, 13 May 2013 20:41:00 GMT

I'll confess: I didn't learn all of this strictly by browsing http://support.cadence.com (Cadence Online Support). I also wandered over onto http://www.cadence.com/community/blogs/ii (Industry Insights blog) and http://www.cadence.com/cadence/events (Cadence Events), which were well worth a look.

Application Note

1. Demystifying NCELAB

You've gotta love any technical document that begins with the word "demystifying". Explains typical causes of and solutions for elaboration errors frequently encountered in running a digital or mixed-signal design using AMS Designer. Organized by error code. Includes descriptions, examples, solutions, and accompanying database.

Videos

2. Running Monte-Carlo Simulations with AMS in ADE-XL

Computer-narrated video describing how to set up and run Monte Carlo simulations using the AMS simulator in ADE XL

3. Virtuoso Connectivity-Driven Layout Solution Segment--Connectivity Extraction from Labels

Video segment from a Cadence physical design training course demonstrating extracting connectivity from labels

Blog

4. CDNLive Silicon Valley 2013 Proceedings Available for Download

Over 80 downloadable presentations from customers and partners discussing how they have used Cadence tools to solve real problems. Custom IC, mixed signal, low power, advanced node--you name it, you can find something interesting to learn about.

Rapid Adoption Kit

5. Digital Mixed-Signal (DMS) Implementation Using EDI and Virtuoso

Reaching out to our colleagues in the digital world. Learn about design import, early timing analysis, pin optimization, AoT block design, and top-level timing analysis. Includes database and detailed workshop instructions.

Webinars

6. TSMC-Cadence Webinars for Advanced Node Design: Addressing Layout-Dependent Effects

Archived webinar discussing the TSMC Custom Design Reference Flow 3.0, which provides a complete layout-dependent effect (LDE) flow for circuit and layout designers working at 28nm and below.

7. A Completely Validated Solution for Designing to the TSMC 20nm Process Using Cadence Tools

Upcoming webinar scheduled for May 23, 2013. Learn about how in-design design rule checking (DRC) and double patterning technology (DPT) checking can improve productivity; how to efficiently manage coloring data in front-to-back custom design flows; how local interconnect layers are supported within the Cadence Virtuoso platform, and how TSMC’s 20nm process technology and the Cadence methodology support this process.

Solutions

Not much description needed for this one. Always a handy table of information to have.

9. Fluid Guardring changes shape with newer version of Virtuoso

How to prevent Fluid Guardrings from changing shapes and spacings with changes to your Virtuoso version.

10. How to keep ADE XL jobs running even if ADE XL GUI crashes

New environment variable in ADE XL, which allows you to close the ADE XL or Virtuoso session without killing jobs that are currently running. Also works if Virtuoso crashes.

Things You Didn't Know About Virtuoso: Delta Markers in ViVA

stacyw — Thu, 09 May 2013 18:10:00 GMT

This article is dedicated to the gentleman I sat next to at lunch at CDNLive a while back who Is a CAD engineer busily supporting a large user community, but had been stumped by the question "How do I create a delta marker in VIVA?"

I'm sure he is not alone. Delta markers in IC6.1.5 ViVA (Virtuoso Visualization and Analysis Tool) are very powerful, but they can be a bit hard to find and unless you read the documentation (or this blog), you may never unlock all their useful capabilities. That's what I'm here for...

Note that the method for creating delta markers changed in IC6.1.5 ISR8, so if the instructions below doesn't work for you, you may need to update your Virtuoso version.

First, I want to direct your attention to a handy little document I put together a while ago which provides a 1-page Quick Reference to the most useful bindkeys in ViVA. Markers in ViVA are all about bindkeys, and for delta markers, you have to know just where and in what combination to use those bindkeys.

The basic summary goes like this:

M for point marker
V for vertical marker
H for horizontal marker
A/B for a/b marker (special kind of delta marker--see below)
Shift-D for delta's amongst selected markers (details below)
D for create 2nd marker and delta (details below)

A/B Markers

This is a special kind of delta marker. To create it, press A somewhere, then B somewhere else. You'll get 2 point markers labelled A and B and a delta label between them. Now, wherever you press A or B again, the original A or B marker will move to that spot and the delta values will update. Only one A/B marker allowed per window, but you can click the right mouse button (RMB) on the delta dimension line and select "Convert A/B Marker to Delta" so you can keep that information on the graph and continue playing the A/B game at another location.

Shift-D

If you have put down a bunch of markers (point, vertical, horizontal), you can select 2 or more of them (using Ctrl-click to select multiple markers) and then press Shift-D to get delta markers between all the selected markers. The cool thing about this is that you can mix point markers with vertical or horizontal markers to get delta values from a point to a line.

Bindkey D

This will probably be your most commonly-used method of creating delta markers. Simply select a point, vertical or horizontal marker (M, V, H) and then wherever you press the D key, you will get a 2nd marker of that type and the delta between. Since when you create a point, vertical or horizontal marker, it remains selected, you can use the sequence M, D, D, D... or V, D, D, D... or H, D, D, D... to get multiple markers with delta values between them with just a few keystrokes.

A few extra tips

Use the menu pick Marker->Show Delta Child Labels (or RMB in a blank area of the graph->Show Delta Child Labels) to toggle the visibility of the point marker labels at either end of the delta and only display the delta values. (IC6.1.5 ISR12) Helps reduce clutter on the graph.

Delta values between vertical markers now show up in the Vertical Marker table (IC6.1.5ISR12). Choose Window->Assistants->Vert Marker Table or use the built-in MarkerTable workspace to open the marker table. You can use Marker->Export->Vertical Markers to create a CSV file with all the marker values.

Watch them in action

If any of the above is not clear, watching this video clip should help. Note that this short clip is part of a longer video available here, covering everything you need to know about using all types of markers in ViVA. If video fails to open, click here.

Stacy Whiteman

SKILL for the Skilled: Part 8, Many Ways to Sum a List (Closures -- Functions with State)

Team SKILL — Tue, 23 Apr 2013 13:21:00 GMT

In the past several postings to this blog, we've looked at various ways to sum a given list of numbers. In this posting I'll present yet another way to do this. This time the technique will be markedly different than the previous ways, and will take advantage of a powerful feature of SKILL++, namely lexical closures. These closures will be used to implement data encapsulation, and we'll also use lexical closures to capture computation state and continue the computation later.

Put the CIWindow into SKILL++ mode

Before proceeding, we need to change the listening mode of the CIWindow. We would like the CIWindow to interpret input expressions as SKILL++ rather than traditional SKILL.

Normally, when you type SKILL expressions into the CIWindow that defines functions or defines variables, the semantics of your code is taken as traditional SKILL. If, however, you would like to have SKILL++ (Scheme) semantics, you can put the CIWindow into SKILL++ Mode by calling the function (toplevel 'ils). This function does not return immediately, but rather puts the CIWindow into a different listening mode until you call the function resume, causing the (toplevel 'ils) to return.

You can find out which listening mode the CIWindow is in either by looking at the indicate in the button left-hand corner of the CIW. If in SKILL listening mode > will be inconspicuously displayed. The > is a little difficult to notice because it is so inconspicuous.

However, if in SKILL++ listening mode ILS-> will be displayed.

You may also determine the listening mode by calling the function theEnvironment which will return either nil if in SKILL mode, or non-nil, if in SKILL++ mode.

(theEnvironment)
  ==> nil
(toplevel 'ils)
(theEnvironment)
  ==> envobj@0x18fa2020
(resume)
  ==> nil
(theEnvironment)
  ==> nil

Defining an adder

With the CIWindow in SKILL++ mode we can proceed to define a SKILL++ function.

(unless (theEnvironment)
   (toplevel 'ils))

(defun make_adder_8a ()   ; 1.1
  (let ((sum 0))          ; 1.2
    (lambda (n)           ; 1.3
      sum = sum + n)))    ; 1.4

This definition of make_adder_8a is a 4 line function, yet does a lot in its 4 lines. It is a higher-order function, as seen in SKILL for the Skilled: What is SKILL++? it is a function which returns another function. It is a function which creates and returns a special kind of function called a lexical closure. In particular the lambda on line 1.3 creates a unary function which when called will evaluate the expression on line 1.4. However, the expression on line 1.4, references a variable, sum defined on line 1.2 and which is external to the lambda. In this case sum is called a free variable.

The important feature of SKILL++ which makes this magic work is that when make_adder_8a gets called, the let on line 1.2 creates a new binding for the variable named sum. A binding is a newly allocated memory location which is associated with a named variable. The initial value stored in this memory location is 0 as indicated on line 1.2. SKILL++ then proceeds to line 1.3 where it creates an anonymous function, attaching it to this binding. The two occurrences of the name, sum, on line 1.4 (within this anonymous function) are compiled as references to the binding.

The make_adder_8a function returns the anonymous function object created on line 1.3, without evaluating the code on line 1.4. Critically this function object maintains a link to the sum binding. Thereafter when the anonymous is called, the expression on line 1.4 is evaluated and its value returned. In evaluating this expression, the value of sum (in this allocated binding) is referenced and updated by the expression sum = sum + n, n being the value passed to the anonymous function when it is called.

Testing make_adder_8a

Let's experiment with make_adder_8a. Keep in mind that make_adder_8a does not actually add anything, rather it creates a function which is capabile of adding.

A = (make_adder_8a)       ; 2.1
  ==> funobj:A
(A 1)                     ; 2.2
  ==> 1
(A 2)                     ; 2.3
  ==> 3
(A 3)                     ; 2.4
  ==> 6
(A 4)                     ; 2.5
  ==> 10
(A 5)                     ; 2.6
  ==> 15

Arduous line-by-line explanation

On line 2.1, make_adder_8a is called, and as described above a SKILL++ anonymous function object (a closure) is created and returned. This closure is stored in the global variable A.

The CIWindow prints this value as funobj:A. As mentioned before the initial value of sum is 0. Note that sum is not a global variable. Rather it is a variable which is visible only to the code on lines 1.3 and 1.4. Furthermore, notice that we have no immediate access to the variable sum. We cannot query the value of code and we cannot modify its value, except by calling the function we have just stored in the global variable A.

When line 2.2, (A 1) is evaluated, the expression on line 1.4 is evaluated: sum = sum + n with n=1; sum is updated from 0 to 1, and 1 is returned and printed into the CIWindow.

When line 2.3, (A 2) is evaluated, again the expression on line 1.4 is evaluated: sum = sum + n with n=2. This time, sum is updated from 1 to 3 and 3 is returned.

When lines 2.4, 2.5, and 2.6 are evaluated, sum = sum + n is evaluated three times with n=3, n=4, and n=5 respectively; thus sum is updated to 6, 10, and finally to 15.

Summing a list with an adder

You can use an adder as created by make_adder_8a to add the elements of a list incrementally.

A = (make_adder_8a)          ; 3.1
  ==> funobj:A
(mapcar A '(1 2 3 4 5))      ; 3.2
  ==> (1 3 6 10 15)

This call to mapcar iterates across the given list (1 2 3 4 5) and calls the function A on each iteration, each time with the successive element of the list. Since each call to A returns the current value of the partial sum, mapcar returns not he final sum, but rather the list of partial sums computed at each step of the iteration.

Multiple SKILL++ adders in parallel

You can create several adders which work independent of each other. In the following example, we create two adders, A and B. Each one internally maintains its own partial sum of the arguments given to successive calls.

B1 = (make_adder_8a)       ; 4.1
  ==> funobj:B1
B2 = (make_adder_8a)       ; 4.2
  ==> funobj:B2
B3 = (make_adder_8a)       ; 4.3
  ==> funobj:B3
(B1 1)                     ; 4.4
  ==> 1
(B2 10)                    ; 4.5
  ==> 10
(B3 100)                   ; 4.6
  ==> 100
(B1 2)                     ; 4.7
  ==> 3
(B2 20)                    ; 4.8
  ==> 30
(B3 200)                   ; 4.9
  ==> 300
(B1 3)                     ; 4.10
  ==> 6
(B2 3)                     ; 4.11
  ==> 60
(B3 30)                    ; 4.12
  ==> 600

This works because each call to make_adder_8a on lines 4.1, 4.2, and 4.3, each allocate a new closure (three in all), assign each of them respectively turn to the global variables B1, B2, andB3. Each of these three function has its own independent binding of sum, each of which is initialized to code. When lines 4.4, 4.7, and 4.10 are evaluated, the sum binding of B1 is updated, but the sum bindings of B2 and B3 are not effected. Similarly when 4.5, 4.8, and 4.11 are evaluated, the sum binding of B2 is effected. And similarly for lines 4.6, 4.9, and 4.12.

Using flet as an alternative to lambda

If you find the use of (lambda ...) to be confusing in the definition of make_adder_8a, you can, as an alternative, define the same functionality using flet.

(defun make_adder_8b ()       ; 5.1
  (let ((sum 0))              ; 5.2
    (flet ((add (n)           ; 4.3
             sum = sum + n))  ; 5.4
      add)))                  ; 5.5

This implementation of make_adder_8b uses flet to define a local function named add. The normal pattern of using flet which you've seen in previous posts of SKILL for the Skilled such as Continued Introduction to SKILL++, is to define a local function and call it. The pattern used by make_adder_8b is to define a local function and return it, allowing the function which called make_adder_8b to call it, or likewise return it to its caller.

Data Encapsulation and Object Orientation

Some programming languages present the ability to encapsulate data as part of the object model. In these languages private variables are member variables within classes, and methods in/on those classes awkwardly manipulate and access these private variables.

This unholy marriage of private data to object model is limiting in practice because it is not only object oriented programs which need to hide data. In fact, a program written in any style may need to take advantage of encapsulate. In SKILL++ (and other dialects of Scheme), data encapsulation is independent from the object system, as it should be.

In SKILL++ the let and lambda primitives behave differently than in traditional SKILL. They behave in a way which allows a function to create lexical closures. These lexical closures are then able to manipulate the state of private variables which they encapsulate.

Summary

In this article, we looked at how to use lexical closures which maintain their internal state to implement counters. We looked very lightly and abstractly into how this is implemented within the SKILL++. And we traced step by step though a couple of examples of how this works in practice.

In this way SKILL++ provides data encapsulation completely independent from the object system. While SKILL++ does indeed have an extensive, full-featured, and powerful object system, in SKILL++ you are not forced to write a program in an object oriented way just to encapsulate/hide data. Encapsulation is a feature of SKILL++ which is available to you whether you are using OO, imperative, declarative, functional, or any other style you choose.

More to come

In the next post we'll look more at the differences you'll see when defining these types of functions in SKILL++ vs in SKILL.

Virtuosity: 10 Things I Learned in March by Browsing Cadence Online Support

stacyw — Thu, 11 Apr 2013 16:26:00 GMT

Topics in March include advanced analysis in ADE GXL, taking advantage of lots of features for doing statistical analysis in ADE XL, defining bindkeys in ADE L (yes, you can do that!), plus a variety of useful details in the areas of routing and advanced custom layout.

Enjoy!

Application Notes

1. Design Tuning with Analog Design Environment GXL: Interactive and Automated Flows

Walks through a detailed example using several different advanced analysis tools, including Sensitivity Analysis, Manual Tuning, and Optimization. Includes demo database.

2. Statistical Analysis Quick Start (ADE XL)

Overview and quick reference covering the statistical analysis features in ADE XL, including setup options for Monte Carlo Sampling, defining confidence levels, using auto-stop, post-processing data using histograms, quantile plots and waveforms, and creating statistical corners.

3. Mixed-Signal PSL Assertions in AMS Designer

Provides an overview of writing mixed-signal PSL assertions to handle Verilog-AMS, analog values, etc. Includes a detailed case study, accompanying example tarkit and exercises.

Rapid Adoption Kit

4. Power, Ground and Structured Routing Implementation Flow

The flow leverages a combination of existing Virtuoso functionality, Virtuoso Routing TCL commands, and custom SKILL scripts to enable users to efficiently build custom power, ground, and structured signal routes. The flow also supports creation of power and ground rough-in during early floorplanning. This flow is intended for analog mixed-signal designs at the chip, block, and device level in Virtuoso. Includes demo database and detailed documentation providing an overview of the flow, guidelines for use in your designs and step-by-step walkthrough using the demo database.

Videos

5. Mark Nets

This video describes the Mark Net command including Mark, Save, Unmark, Options, and Retaining Via Info.

6. Generating Clones in Virtuoso

This is a demo that describes generating clones in Virtuoso. It includes topics such as creating clones as Free Objects, Group Objects, and Synchronized Family.

Solutions

7. VLS-XL: Modgen: Abutting Modgen members using SKILL (Solution 20033396)

Skill routine to use to abut all the devices in a given Modgen.

8. How to query directional spacing tables from techfile with SKILL? (Solution 20034969)

Some example Skill commands showing you how to access horizontal and vertical spacing rules from the techfile.

9. How to change nport file names for corner simulation (Solution 20040165)

You have an nport with an S-parameter file. For each corner, the nport uses a different S-parameter file. This solution shows you how to wrap up the nport as a subcircuit library with sections you can reference just like any other model file sections.

10. How to define bindkeys for ADE L window (Solution 20051691)

Shows you how to register bindkeys which will be active in the ADE L window. Examples provided to create bindkeys for "Netlist and Run" and Direct Plot commands.

SKILL for the Skilled: Part 7, Many Ways to Sum a List

Team SKILL — Mon, 25 Mar 2013 13:05:00 GMT

In this episode of SKILL for the Skilled I'll introduce a feature of the let primitive that Scheme programmers will find familiar, but other readers may have never seen before. The feature is called named let, and I'll show you how to use it to sum the numbers in a given list.

Named LET

There is a feature of let available in SKILL++ which is not available in traditional SKILL, called named let. Here is an example of how it can be used to sum a given list of numbers.

(defun sumlist_7a (numbers)
  (let REPEAT
    ((sum_so_far 0)
     (rest       numbers))
    (if rest
        (REPEAT (plus sum_so_far (car rest))
                (cdr rest))
        sum_so_far)))

In this example, the named let defines a local function named, REPEAT and calls it once with the two arguments, 0 and numbers. Of course, REPEAT is by no means a reserved word; you can name the local function any valid variable name. Within the body of the named let you may call the local function with two arguments. You may recursively call the function zero, one, or more times as your algorithm requires.

Testing the function

If we enable tracing of sumlist_7a and REPEAT, we can see what happens when calling sumlist_7a. We can see that the local function, REPEAT is called recursively several times, and that the implementation does in fact return the correct sum of the given list of numbers.

(trace sumlist_7a)
(trace REPEAT)
(sumlist_7a '(1 2 3 4 5))
|sumlist_7a((1 2 3 4 5))
||(REPEAT 0 (1 2 3 4 5))
|||(REPEAT 1 (2 3 4 5))
||||(REPEAT 3 (3 4 5))
|||||(REPEAT 6 (4 5))
||||||(REPEAT 10 (5))
|||||||(REPEAT 15 nil)
|||||||REPEAT --> 15
||||||REPEAT --> 15
|||||REPEAT --> 15
||||REPEAT --> 15
|||REPEAT --> 15
||REPEAT --> 15
|sumlist_7a --> 15
15

Equivalent to labels

The named let is more or less equivalent to a declaration and call of a local function as if by using labels. If you recall, this is exactly what was shown in sumlist_3b in SKILL for the Skilled: Many Ways to Sum a List (Part 3).

(defun sumlist_3b (numbers)
(labels ((sum (sum_so_far rest)
             (if rest
                 (sum (plus (car rest) sum_so_far)
                      (cdr rest))
                 sum_so_far)))
    (sum 0 numbers)))

If you trace sumlist_3b and sum you'll see that it executes pretty much the same thing as sumlist_7a.

(trace sumlist_3b)
(trace sum)
(sumlist_3b '(1 2 3 4 5))
|sumlist_3b((1 2 3 4 5))
||(sum 0 (1 2 3 4 5))
|||(sum 1 (2 3 4 5))
||||(sum 3 (3 4 5))
|||||(sum 6 (4 5))
||||||(sum 10 (5))
|||||||(sum 15 nil)
|||||||sum --> 15
||||||sum --> 15
|||||sum --> 15
||||sum --> 15
|||sum --> 15
||sum --> 15
|sumlist_3b --> 15
15

Illusion of jumping to the top

The illusion (or abstraction) presented by the named let is that of being able to jump back to the top of the let form, and evaluate it again with different initialization values.

Consider this simple let example.

(let loop
   ((a 10)
    (b 0))
 (println (list a b))
 (when (plusp a)
   (loop (sub1 a) 
         (add1 b))))

Which prints the following output.

(10 0)
(9 1)
(8 2)
(7 3)
(6 4)
(5 5)
(4 6)
(3 7)
(2 8)
(1 9)
(0 10)

Doesn't work in traditional SKILL

If you try to evaluate a named let in traditional SKILL (e.g., with a .il file extension), you'll get an error something like the following, which basically means that SKILL let expects a list as its first operand and you have given the symbol loop instead.

*Error* let: local bindings must be a proper list - loop

let is syntactic sugar for lambda

In SKILL++ the normal let has the same semantics as calling an unnamed function with particular parameter values. For example:

(let ((a X)
      (b Y)
      (c Z))
  (expr1 a b)
  (expr2 b c))

Is semantically the same as the following arguably less readable expression. The expression uses funcall to call a nameless function, defined by the (lambda (a b c) ...); in particular to call it with the three values X, Y, and Z. In fact the two code snippets are simply syntactical transforms of each other.

(funcall (lambda (a b c)
           (expr1 a b)
           (expr2 b c))
         X
         Y
         Z)

When you look at the equivalent lambda form of let it is immediately clear that the expressions within the lambda are not able to make recursive calls to this unnamed function. This limitation is solved by the named let.

Named let and tail-call optimization

The illusion of jumping back to the top in sort of a goto fashion is indeed what happens if tail-call-elimination is enabled via the optimizeTailCall status flag explained in SKILL for the Skilled: Many Ways to Sum a List (Part 4).

Summary

In this post I've shown some examples of how to used the named let construct of SKILL++. This construct converts the conventional let into a loop --- a loop which can be repeated by calling the label as a function, providing the next iteration's variable values.

More to come

In upcoming posts we'll continue to survey the SKILL++ language using the example of summing a list.

Virtuosity: 10 Things I Learned in February By Browsing Cadence Online Support

stacyw — Mon, 18 Mar 2013 20:53:00 GMT

February was a big month for RAKs (Rapid Adoption Kits)! If you haven't checked out the listings under Resources->Rapid Adoption Kits yet, you're missing out. You'll find databases with detailed instructions, documentation and videos on many tools, features and flows. They've become very popular and we're adding more all the time.

We're also featuring content on routing, schematic PCells, ADE XL job distribution, advanced node layout techniques and a new course on high-performance circuit simulation.

Rapid Adoption Kits

1. Creating Custom Connect Rules for AMS Simulation in ADE

Outlines the process used to create custom connect rules for mixed-signal simulation in ADE using AMS Designer. Includes a database example and step-by-step manual.

2. Spectre Device Checks

Describes the usage of the Spectre device checking feature. Spectre device checking is used to monitor if devices in your circuit are violating user-defined conditions. For example, checking to insure that low voltage devices are not inadvertently used in high voltage conditions. Checks can show warnings or cause the simulation to stop on an error. This is a very powerful feature, but can be somewhat confusing to set up, so this database and step-by-step manual will be extremely useful.

3. Using Spectre Save-Recover

Spectre and Spectre Accelerated Parallel Simulator (APS) have the capability to save a simulation state and restart the simulation from the saved state file. The simulation state for long simulations can be periodically saved to allow recovery from unforeseen circumstances, such as power outages or disk full issues. The save/recover methodology can also be used to restart simulations with different parameters or inputs. This example will illustrate using Spectre/APS Save-Recover from both ADE and command line based simulation. Includes database and detailed manual.

4. Basics of Inherited Connections

Often times in design, the same cells need to be used in different parts of the circuit that use different power supply voltages. Inherited connections provide a mechanism to selectively override net connections by placing properties on the parent instance. Therefore the same cell can be used with different power supplies without the need for explicit power and ground pins. This document describes how inherited connections work with a sample design which shows how power and ground connections for the same cell can be different in the schematic hierarchy. It also outlines the process used to resolve inherited connections. Includes an example database.

5. Passing Parameters in the Schematic Hierarchy with pPar

Schematics can be parameterized with pPar parameters to allow passing parameters from a parent instance to the lower level schematic (the child). This mechanism facilitates defining high level parameters to define the functionality of the circuit. Includes database and detailed manual.

Application Notes

6. ADE XL Job Policy Setup

This document (and the complementary ADE XL Simulation Flow document) are essential to getting the most out of the powerful job distribution capabilities in ADE XL. You'll learn about the different types of job distribution available, their options, how they work and how to set them up.

Solutions

7. How to set non-uniform Routing Tracks with IC6.1.5 VSR-RIDE and do routing

For IC6.1.5 users who wish to do gridded track based routing, this document will demonstrate how to set up the Tcl/tk commands in a script that can be run within Virtuoso Layout GXL or through the Routing Integrated Development Environment (RIDE). Tracks can be setup for all routing layers of just selected routing layers.

8. Schematic PCell Example with inherited connection. netExpression added to wire and label display

Includes sample SKILL code and testcase database to create a schematic PCell with inherited connections.

9. How to enable the color engine in ICADV12.1 and later versions like upcoming IC6.1.6

The Virtuoso Layout environment for advanced node design includes features to support metal coloring for double-patterning technologies. This solution shows you how to enable those features.

Course Announcement

10. High-Performance Simulation using Spectre Simulators v12.1

In this course, you use the enhanced technologies of Virtuoso Spectre Circuit Simulator, including the Accelerated Parallel Simulator (APS), to run fast and accurate analog simulations on large, complex, mixed-signal designs providing a significant performance gain over baseline Spectre simulation.

You explore the use of multithreading options, APS, Fast APS and APS in distributed mode. You verify the circuit performance and identify the potential failure modes by running dynamic checks with Spectre and APS and then examine the results by viewing the appropriate XML file. You run Spectre APS stitching of DSPF, SPEF, and DPF files and a postlayout simulation. You run high-capacity EMIR simulation using Spectre APS.

Stacy Whiteman

Virtuosity: 10 Things I Learned In January By Browsing Cadence Online Support

stacyw — Fri, 15 Feb 2013 16:56:00 GMT

This month's highlighted content includes helpful information on wreal modeling, mixed-signal interoperability, verification of digitally-calibrated analog circuits, device and block-level routing and lots more.

Enjoy and don't forget to leave feedback at the top of the individual content pages in COS (Cadence Online Support) to let us know what information you find most useful.

Rapid Adoption Kits

1. Guidelines on Modeling Analog Circuits with wreal

This material illustrates wreal modeling concepts by migrating a Verilog-A based model of an AM modulation-demodulation system to a wreal model with Verilog-AMS. The wreal equivalent of each block is created to build up an all digital simulation for the system. Guideline steps for creating wreal Verilog-AMS models are developed and used for developing the wreal models. The RAK includes a workshop database and detailed manual.

2. IC6.1.5 VSR (Virtuoso Space-based Router) Workshop

This workshop highlights interactive, assisted and automatic routing features available in Virtuoso Space-based Router (VSR). During the course of the workshop you will be able to apply these features to do some device and block level routing and analyze your results in R-IDE (Routing Integrated Development Environment). The RAK includes a workshop database and detailed manual.

Application Notes

3. AMS Designer INCISIVE Command-line Flow Use Model

This document provides an overview of how to run mixed-signal simulations from the command-line interface of the AMS Designer simulator using the "irun" command. It includes information on setup files, options, command syntax and mixed-language specifics, as well as examples and pointers to the workshop database and other references.

4. Calibrated Verification with ADE XL

This document focuses on a topic about which I am frequently asked by customers--how to use ADE XL to verify digitally calibrated high-performance circuits. It covers the details of the ADE XL features supporting this technique, including the use of calcVal expressions and pre-run Ocean scripts. Detailed worked examples are given, complete with accompanying database.

5. Open Access Reference Library Import

Recommendations on how to import a standard cell or IP reference library for use in OpenAccess mixed-signal design using the Incremental Technology Database (ITDB) and LEF Import.

6. ADE XL Quick Start

Given that the ADE XL User Guide is now 846 pages, this document is intended as a quick reference tutorial in using the basic functionality in ADE XL, including setting up tests, running simulations, basic post-processing, sweeps and corners.

Solutions

7. New AHDL Linter in AMS Designer 12.2

Detailed information on how to use the AHDL linter feature in AMS Designer which enables you to detect modeling issues in Verilog-A and VerilogAMS (AHDL) languages.

8. Virtuoso Encounter Mixed-Signal Flow: Quick Reference to Basics and Most Referred Solutions

This is a concise and handy reference document for using Virtuoso and Encounter to manage mixed-signal design flows that allow the mixing of digital and analog content throughout the design hierarchy. It includes information on design and technology data requirements, environmental configuration and an extensive list of links to helpful solutions, reference documents and application notes.

Video

9. Cadence Chemical Mechanical Polishing (CMP) Predictor - An Introduction

An introduction to the Cadence Chemical Mechanical Polishing Predictor. It also describes the extraction process, simulation flow and steps to monitor the job status and view extraction results.

Blog

10. Introduction to Cadence Virtuoso Advanced Node Design Environment

An introduction to the new features that are available in Cadence's Virtuoso Advanced Node design environment which support the complex requirements inherent in advanced process technologies at 22nm and below.

Stacy Whiteman

Things You Didn't Know About Virtuoso: Drag and Drop

stacyw — Wed, 13 Feb 2013 14:00:00 GMT

I love it when I'm sitting in a meeting with my colleagues or with a group of customers and someone brings up something about our software that they find annoying and another person says "Wait, why are you doing it that way? Why don't you just...". Immediately my mind says "blog time!"

One such sequence of events happened recently around the concept of "drag and drop." For those of us who have been around for a while, the idea of dragging objects, particularly text or something non-drawing related, just never springs to mind. I'll complain all day about having to re-type something or execute a long series of mouse clicks before I even try to just grab it and drag it where I want it to go.

So let's play a little game. Where are all the places in ADE L/XL/GXL and ViVA that you can perform some useful function by dragging something? I'm sure I'll miss a few, so feel free to leave additional discoveries in the comments.

In general

Drag the assistants/subwindows to rearrange, undock or tab them
Drag the toolbars to rearrange, resize or move them to other edges of the window

ADE L

Drag the rows in the different subwindows to reorder them (Design Variables, Outputs, Analyses)

ADE XL

Drag the rows in the Output Setup panel up and down to reorder them (within the same test)
Drag the columns in the Output Setup panel to rearrange them (sadly it isn't saved, but it can be very handy while you're setting things up)
Drag an output expression over to a Global Variable to have that variable value be taken from the result of one test and used as input to a different test (also referred to as combinatorial variable expressions)
In the Detail-Transpose results view, drag columns (inputs or outputs) around for easier comparison of measured values. RMB on the columns in this view to hide them.

Calculator

Drag an output expression from the Outputs Setup panel in ADE XL into the calculator buffer to create combinatorial output expressions using results from multiple tests
Drag an expression from the Stack to the Buffer
Drag an expression from the Expression Editor to the Buffer. Don't know about the Expression Editor? Time to learn!
Drag one or more expressions from the Stack to the Expression Editor.
Drag one or more expressions from the Stack, Buffer or Expression Editor and--wait for it--drop it into any text area outside of Virtuoso. Text editor, command line or it will even create a text file on your desktop.
Drag an expression from the Stack, Buffer or Expression Editor into any text field in a calculator function form. (This is the one that inspired the "aha" moment I mentioned in the first paragraph.)
Bonus Tip: Double-click on any Stack item to move it into the Buffer and push the contents of the Buffer onto the Stack

ViVA Graph

Drag traces from one subwindow to another. (Hold Ctrl while dragging to copy instead of move)
Drag traces from one strip to another (Hold Ctrl to copy)
Drag a whole strip up or down to reorder
Drag traces from the graph to the Subwindows Assistant (Window->Assistants->Subwindows if you haven't seen this). Here you can drop them in an empty area to create a new subwindow or into one of the existing subwindow thumbnails to put them there
Drag signals from the Results Browser onto the graph or the Subwindows Assistant
Drag a signal from the Results Browser into the Calculator Buffer
Pretty much anything having to do with markers (point/A/B/delta, vertical or horizontal markers and their intercept bubbles) can be moved and rearranged by dragging

So there you have it. What have I missed? As always, your feedback is welcome.

Stacy Whiteman

Introduction to Cadence Virtuoso Advanced Node Design Environment

Hiro Ishikawa — Mon, 28 Jan 2013 13:00:00 GMT

What can designers do about advanced node technology? This is an introduction to the Cadence Virtuoso Advanced Node design environment, announced Jan. 28, 2013, as a custom/analog design development environment for leading edge-advanced node technology.

Problems of Advanced Node Design

When designing with the most advanced node technologies including 22nm technology and beyond, you will encounter many new problems that no one could have anticipated from previous design work. New tools in the design flow need not require a completely new design flow. You should maximize the effectiveness of the current design environment. Then, you need to handle new problems appropriately and accordingly.

Generally speaking, you will need to pay special attention to the following things with advanced node design.

Multiple Patterning
Layout Dependent Effects (LDE)

o Length Of Diffusion (LOD) / STI Stress
o Well Proximity Effect
o Interconnect R, C, and inductance

Use of Local Interconnect Layers

Fig 1 (a) Length Of Diffusion (LOD)

Fig 1 (b) Interconnect layers

Fig 1 (c) WPE (Well Proximity Effects)

Fig 1(c) shows the WPE (Well Proximity Effect), one of the LDEs. The performance of the devices is different for 26db (~12x) depending on the placement locations of the devices from the edge of the well.

For advanced node design, those problems must be evaluated and considered in the design flow.

Current Design Flow

The current generic design flow that is mainly used for the 45nm and 32nm process nodes is shown in the following Fig 2. The current design flow represents the collected wisdom of many designers over many development processes. Indeed there is a big advantage of the current design flow because the designer has been familiar with it for a long time.

However, it is also true that the flow has the limitations listed below.

Each step is connected serially. When some steps have problems, many undesired iterations will be induced.
Automation is not used to its full potential.
Additional and incremental analysis during the design is not easy.
Hidden problems in the design including performance variance affected by LDE can go undetected until a very late phase in the design process.

The problems in the advanced nodes listed above all occurred with the previous technology, too. However, the reason that the current (existing) flow that is like the flow shown in Fig 2 is that the effects of those problems in the previous process technologies were very small, and they could be ignored. In the advanced technology required for 20nm or 14nm designs, those problems cannot be ignored. Therefore, the design process cannot be concluded unless designers detect these problems at an early stage of the design, and take necessary actions.

Also, the architectures of double patterning and Interconnect layers have already emerged in the previous technologies. However, these architectures will make a huge impact on performances of designs in advanced node technology. The design process itself needs to be re-evaluated for the advanced node design.

Fig 2. Current generic design flow

Therefore, an ideal design environment for advanced node technology is a design flow that allows the user to detect and resolve the non-ignorable problems in advanced node technology without invalidating the usability of the current design flow.

Cadence's design flow for advanced node technology

Fig 3 shows the design flow realized by Cadence Virtuoso Advanced Node design environment.

Fig 3. Cadence Virtuoso Advanced Node design environment for advanced node technology

At first, this flow does not require the user to change his current design flow. It has various enhancements for advanced node technology and inherits properties of the familiar, current design flow.

Several enhancements for advanced node technology are introduced below.

Analog Prototyping Step

In this step, the user can perform a simulation and consider the LDE before starting the actual layout. This is realized by prototyping the device layout, and simulating the design while considering LDE parameters. With this step, one can dramatically reduce the design modification work caused by performance gaps between the actual design after place and route is completed, and the initial simulation result.

It will work most effectively for considering the WPE (Well Proximity Effect) and performance effects caused by physical stress of the STI (Shallow Trench Isolation).

This step is very powerful because it not only shows LDE effects in a window, but it also allows the user to quickly check and verify characteristic changes due to LDE by running a simulation.

The following figure (Fig 4) shows this part of the step (Analog Prototyping).

Fig 4. Analog Prototyping

Module generation, Device placement Step

In the real design generation phase, the user can generate modules using Modgen and can place devices using the newly enhanced Pcells. Device placement work in advanced node technology is like pulling teeth. Very complex and rigid design rules need to be satisfied. Fig 5 shows sample complex-design rules related to the device placement. To effectively support those complex design rules, the Pcell abutment function in Cadence Virtuoso Advanced Node design environment was dramatically enhanced. The Pcell abutment function evaluates the relationship between the device to be placed and adjacent devices and realizes the best placements of devices automatically.

Fig 5. Example of complex device placement

Routing step

Routing work on the Local Interconnect Layer (LI) differs dramatically from the routing on the other routing layers. As the figure (Fig 6) shows, the LI layers exist between Metal1 and base layers. The layers allow contact-free connection. Also, the length and width of wires on the LI layers are tightly specified. The layers have very rigid constraints.

Fig 6. Local Interconnect Layers

In Cadence Virtuoso Advanced Node design environment, the user interface has been enhanced as well as the technology file so that the user can smoothly work on routing wires on the local interconnect layers (Fig 7).

Fig 7. Routing Environment for Local Interconnect Layers

Also, the DPT Assistant (Fig 8) can be used in Cadence Virtuoso Advanced Node design environment so that the routing can easily be done when considering double patterning architecture. The DPT Assistant immediately informs the user where in a design that double patterning conflict occurs.

Fig 8. Dynamic Coloring Assistant

Fig 9 shows the Odd-Loop Error Detection done by Virtuoso Integrated PVS (IPVS). In Cadence Virtuoso Advanced Node design environment, PVS, a sign-off level Design Rule Checker is fully integrated. It performs "Dynamic Signoff Checking" when a design is updated.

Fig 9. Odd-loop error detection

Conclusion

This document has been a quick introduction to new features that are available in Cadence's design development environment for advanced technology. The Cadence Virtuoso Advanced Node design environment is the brand-new design environment that not only supports each new requirement but also integrates new steps into the existing design flow without needlessly disrupting that flow.

Also, the biggest and hidden advantage of this design flow is that software will obviate the possible design problems inherent in advanced node design even if the designer is unaware of these new problems. As the result, the flow can minimize undesired iteration in the design process that was the limitation of the previous design flow. This "Correct-by-Construction" approach realized by Cadence Virtuoso Advanced Node design environment can dramatically reduce the entire design turnaround time.

Hiroshi Ishikawi

Cadence Custom IC Design Blogs

SKILL for the Skilled: Part 9, Many Ways to Sum a List

Try it in traditional SKILL

Setting a variable in SKILL

Setting a variable in SKILL++

LISP-1 vs LISP-2

Use funcall to call a function indirectly

A second SKILL adder fails

Why does this fail?

Low level details of calling a SKILL function

Low level details of calling a SKILL++ function

Summary

Feedback

Virtuosity: 10 Things I Learned in April by Browsing Cadence Online Support

Things You Didn't Know About Virtuoso: Delta Markers in ViVA

SKILL for the Skilled: Part 8, Many Ways to Sum a List (Closures -- Functions with State)

Put the CIWindow into SKILL++ mode

Defining an adder

Testing make_adder_8a

Arduous line-by-line explanation

Summing a list with an adder

Multiple SKILL++ adders in parallel

Using flet as an alternative to lambda

Data Encapsulation and Object Orientation

Summary

More to come

See Also

Virtuosity: 10 Things I Learned in March by Browsing Cadence Online Support

SKILL for the Skilled: Part 7, Many Ways to Sum a List

Virtuosity: 10 Things I Learned in February By Browsing Cadence Online Support

Virtuosity: 10 Things I Learned In January By Browsing Cadence Online Support

Things You Didn't Know About Virtuoso: Drag and Drop

Introduction to Cadence Virtuoso Advanced Node Design Environment