Cadence Custom IC Design Blogs

SKILL for the Skilled: The Partial Predicate Problem

Team SKILL — Wed, 19 Jun 2013 14:07:00 GMT

The partial predicate problem describes the type of problem encountered when a function needs to usually return a computed value, but also may need to return a special value indicating that the computation failed. Specifically, the problem arises if the caller cannot distinguish this special value from a successfully calculated value. In this posting of SKILL for the Skilled, we look at several ways to attach this problem in SKILL.

Approach 1: Returning nil to indicate failure

A very common way a SKILL function indicates to its caller that it failed to do what was requested is to return nil. For example, the SKILL function nthelem returns the Nth element of a given list, given an integer N. If the list has less than N elements, it returns nil. For example (nthelem 2 '(10 20 30)) returns 20, but (nthelem 4 '(10 20 30)) returns nil.

A limitation of this approach is that (nthelem 2 '(t nil t)) also returns nil, because nil is the second element. The caller can only trust nil to be the failure case if he knows that nil is not an element of the list.

Here is an implementation of a find function which returns the first element of a given list which matches a given predicate. Note that this example (and most of the examples in this article) only work in Scheme/Skill++ mode.

(defun find_A (predicate data)
  (car (exists x data
         (predicate x))))

Here are some examples of how it works.

(find_A oddp '(2 4 5 6 7 9))
==> 5

(find_A stringp '(this is 1 "list" of stuff))
==> "list"

(find_A numberp '(this is a list of symbols))
==> nil

(find_A listp '(t t t nil t t))
==> nil

Notice that the find_A function returns nil in two cases:

if there is no element in the given list which matches the predicate
if nil is explicitly in the given list and matches the predicate

Thus if find_A returns nil you don't know whether it found something or not.

Approach 2: Returning a given default value on failure

The following implementation of find_B attempts to settle the ambiguity by allowing the caller to specify the return value on the so-called failure case.

(defun find_B (predicate data @key default)
  (let ((tail (exists x data
                (predicate x))))
    (if tail
        (car tail)
        default)))

(find_B stringp '(this is 1 "list" of stuff) ?default 'notfound)
==> "list"

(find_B listp '(t t t nil t t) ?default 'notfound)
==> nil

(find_B numberp '(this is a list of symbols) ?default 'notfound)
==> notfound

A disadvantage of this case is that the caller might find it clumsy at the call-site to provide a value which the given function call would otherwise never return.

Approach 3: Wrapping the return value on success

Another common way is to return a wrapped value. I.e., don't return the value found/computed, but rather return a list whose first element is that computed value. The SKILL member function does just this. (member 5 '(1 2 3 4)) returns nil because the given list does not contain 5; whereas (member 3 '(1 2 3 4) returns a list (3 4). Thus the only time member returns nil is when it didn't find the value being sought.

Another function which uses this approach is errset, which returns nil if the given form to evaluated triggered an error. Otherwise, errset returns a singleton list whose first (and only) element is the value calculated. Thus (errset 6/4) returns (3), while (errset 6/0) returns nil.

An obvious advantage of this wrapping approach is that the failure condition can always be distinguished from the success case. A disadvantage is that the caller who wants to use the calculated value must unwrap the value with an additional call to car, probably after testing whether the value is nil.

Here is an implementation of find_C which wraps its return value. It only returns nil if no element of the list matches the predicate. But the caller must call car to unwrap the value.

(defun find_C (predicate data)
  (let ((tail (exists x data
                (predicate x))))
    (when tail
      (ncons (car tail)))))

(find_C stringp '(this is 1 "list" of stuff) ?default 'notfound)
==> ("list")

(find_C listp '(t t t nil t t) ?default 'notfound)
==> (nil)

(find_C numberp '(this is a list of symbols) ?default 'notfound)
==> nil

Another disadvantage of this approach is that find_C always allocates memory if it successfully finds what its looking for.

Approach 4: Continuation passing

Still another way to solve this problem in SKILL++ is by passing a continuation. This involves organizing your code a bit differently, but in the end allows a lot of flexibility. The idea is to pass an extra argument which is itself a function to call with the computed value if successful.

(defun find_D (predicate data @key (if_found (lambda (x) x)))
  (let ((tail (exists x data
                (predicate x))))
    (when tail
      (if_found (car tail)))))

The find_D function searches the given list for an element matching the condition. If successful, calls the given function, if_found and returns the value it returns. Otherwise it omits calling the if_found and simply returns nil.

Continuation passing is a generalization

As you can see from the examples below, the function find_D is actually a generalization of find_A, find_B, and find_C.

These examples work like find_A.

(find_D stringp '(this is 1 "list" of stuff))
==> "list"

(find_D listp '(t t t nil t t))
==> nil

(find_D numberp '(this is a list of symbols))
==> nil

These examples work like find_B.

(find_D stringp '(this is 1 "list" of stuff) ?if_found (lambda (x) 'notfound))
==> "list"

(find_D listp '(t t t nil t t) ?if_found (lambda (x) 'notfound))
==> notfound

(find_D numberp '(this is a list of symbols) ?if_found (lambda (x) 'notfound))
==> notfound

These examples work like find_C.

(find_D stringp '(this is 1 "list" of stuff) ?if_found ncons)
==> ("list")

(find_D listp '(t t t nil t t) ?if_found ncons)
==> (nil)

(find_D numberp '(this is a list of symbols) ?if_found ncons)
==> nil

An initial reaction of this type of coding might be that it looks more complicated. But in fact, it is often less complicated when you actually try to use it. Why is this? It is because the code at the call-site usually needs to (1) do something with the calculated value. In addition, there must be program logic, to (2) test whether the value corresponds to the success case or the failure case.

The way find_D is intended to be used, the code for case (1) goes inside the function being passed as the ?if_found argument, and the code for case (2) is already inside the find_D implementation. This is shown in the following examples.

Example using continuation passing

Assume we have a function, is_metal_shape?, which figures out whether a given shape is on a metal layer, presumably by looking at the layer name of the shape and looking in the tech file to see whether that layer has "metal" function. Here is an example of how to use find_B and find_D to add such a shape to a particular db-group.

(let ((shape (find_B is_metal_shape? cv~>shapes
                 ?default 'notfound))
   (unless (shape == 'notfound)
     (dbAddObjectToGroup dbGroup shape)))

Notice that the call to find_D is actually simpler.

(find_D is_metal_shape? cv~>shapes
    ?if_found (lambda (shape)
                (dbAddObjectToGroup dbGroup shape)))

This approach has certain advantages over all the alternatives shown above. The most obvious advantage is that there is no ambiguity at the call-site. The caller does not have to tend with the failure condition. In fact it is the function find_D itself which knows whether the sought element was found and deals with it appropriately.

Handling the found and not-found cases separately

One might also write a version of function find_D with an additional if_not_found keyword argument to handle the other case that the call-site wants to do something different if such an element is not found--for example to trigger an error.

(defun find_E (predicate data @key 
                                (if_found (lambda (x) x))
                                (if_not_found (lambda (_x) nil)))
  (let ((tail (exists x data
                (predicate x))))
    (if tail
        (if_found (car tail))
        (if_not_found))))

Summary

In the above paragraphs, we saw several common ways of dealing with the so-called partial predicate problem in SKILL.

Return nil to indicate failure
Return a given default value to indicate failure
Wrap the return value
Pass a continuation to call on success.

In general continuation passing can indeed be very complicated, but there are certainly cases such as the example shown here, where the style is simple to use and eliminates complexity from your code with no added overhead.

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

stacyw — Fri, 14 Jun 2013 17:02:00 GMT

May was a big month for new videos. It was also a month that saw the release of Virtuoso IC6.1.6, with lots of great new features and the rollout of new enhancements to the Cadence Online Support website.

Videos

1. DMS Basics Series

This is a great series of 10 videos covering various topics in mixed-signal verification, real number modeling, and mixed-signal connectivity. You'll also notice all 10 videos referenced together in sequence as a single "playlist" so you know what order to watch them in.

2. Enter Points

Demonstrates some enhancements in IC6.1.6 whereby the user can enter coordinates for commands using a form instead of pointing in the layout canvas.

3. IC6.1.6 Ruler

Demonstrates several enhancements to the ruler command in IC6.1.6.

4. Palette—IC6.1.6 Enhancement

This video discusses new modes available to invoke Palette, bindkeys, synchronization/desynchronization, editing LayerSets, and editing validity status of LPP. Some of these topics are also discussed in the solution: Palette—How to encapsulate the Layers, Objects, and Grids panels into a single assistant when undocked outside the layout window?

5. Virtuoso Parameterized Layout Generators—VPLGen

VPLGen is a new feature in 616. This video describes setting up VPLGen and generating VPLGen Pcells.

6. Toolbar Manager

This video demonstrates the new features in IC6.1.6, which allow you to easily customize the content and display of existing toolbars and to create your own toolbars.

Product Information

7. Product Documentation for IC6.1.6

As you have probably gathered from the precediing items, the initial release of Virtuoso IC6.1.6 occurred in May. A good place to start learning about new features would be the Virtuoso Platform What's New document.

8. Cadence Online Support Release Highlights

You may have also noticed several changes to the http://support.cadence.com website interface. The Highlights document summarizes what's new.

Solutions

9. How to create a single inverter symbol to represent multiple models and pass LVS

A worked example (with database) showing you how to create a parameterized inverter symbol that can represent, for example, multiple voltages, via an inherited model name.

10. Path to access MMSIM products has changed to [installation_directory]/bin in 12.1.1

The path to access the MMSIM products has been changed from <installation>/tools/bin/ or <installation>/tools.<platform>/bin/ directory to the <installation>/bin/ directory.

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

Cadence Custom IC Design Blogs

SKILL for the Skilled: The Partial Predicate Problem

Approach 1: Returning nil to indicate failure

Approach 2: Returning a given default value on failure

Approach 3: Wrapping the return value on success

Approach 4: Continuation passing

Continuation passing is a generalization

Example using continuation passing

Handling the found and not-found cases separately

Summary

See also

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

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