Faster Opening of GDSII Files with Offline Prep

Opening a large (say 5-50 GB) GDSII file for display takes some time. For example, a 50GB file could take an hour to display even on very powerful workstation.

Before a file can be displayed it has to be scanned; various data structures, including a quad tree, must be built and loaded into memory. Only after these organizational structures are computed and loaded into memory can the display begin.

Check out the video below to see how you can create a cache file directly from Qckvu3 and load it instead of the GDSII file for faster opening.

Offline Processing

Engineers working in failure analysis labs (who often pay $600 per hour to rent time on equipment such as FIBs) have addressed this problem in the past by running their large layout files through an offline processor the night before they are scheduled to use the machine. The processor scans the file, creates the quad tree and then saves the results to a disk file we call a memory cache.

When the FA engineer comes in and is ready to use the FIB, he loads the memory cache and sees the display in a minute instead of an hour.

QckCache: Qckvu3's Off Line Processor

We recently updated Qckvu3 (version 3.50) to support opening of memory cache files and this version now ships with a companion program called: QckCache. QckCache is a command line program that you use to produce the memory cache.

There are two files produced: a scan file which ends in .scan and a database file which ends in .db.

In addition to creating the cache files, one can also specify layers to ignore (or include) and cells to ignore (or include). These layer and cell filters can be used judiciously on large files to remove data you don't need to look at thus reducing the file size and improving display performance.

The memory cache files are quite large but disk space is very cheap these days and generally the tradeoff between the user's time and disk space is a favorable one.

QckCache Command Syntax

qckcache input_file [options]

where:

 input_file            path/filename to the GDSII stream file to be processed.

[options]

 -outdir:dir           dir is the directory where the cache files will be generated 
                       (.dbload and .scan) If not specified the default is the
                       QckCache run directory.

 -ilayers:layers       layers (and datatypes) to be included.  
                       All other layers will be excluded.

 -xlayers:layers       layers (and datatypes) to be excluded.  
                       All other layers will be included.
                   
                       -ilayers and -xlayers cannot be used simultaneously

 -xcells:cells         cell names to be excluded.
                       e.g. "-xcells:VIA,CONT,PAD"

 -xdosexp:cells        cell names to be excluded specified in DOS expressions.
                       e.g. "-xdosexp:*VIA*,*DMx"

 -xregexp:cells        cell names to be excluded specified in regular expressions.
                       e.g. "-xregexp:^.*VIA.*$,^.*DMx$"
                       -xdosexp and -xregexp cannot be used simultaneously

Example 1 - 1.5GB File on a 4GB Workstation

We will start with a relatively small file and test it on a $500 Linux RH4 workstation equipped with 4GB of RAM and an older Athlon CPU. The file we will use is called caw_test1.gds. It has about 40 layers, 8600 cell definitions and 6 layers of metal. We will always use the option: Load File to Memory.

Qckvu3 Loading Time - from the time we press OK in the file open dialog until the display starts drawing is 1:29.

Qckvu3 Memory Footprint - this is determined using the top program:

   PID   USER      PR  NI  VIRT  RES   SHR S %CPU  %MEM   TIME+   COMMAND
   17232 stevedb   15   0  2097m 1.9g  11m S  0.0  57.1   1:02.18 qckvu3.exe  

According to Qckvu3, 650MB was required for loading the file to memory. The balance used is for the scan data, quad tree and Qckvu3's executable. The opening time for a 1.5GB file was about one and a half minutes or one minute per GB.

Run QckCache

Now let's run QckCache on this file to build a memory map. We run this from our home directory where the file caw_test1.gds is located:

$ $CAD/caw/bin/qckcache.exe caw_test1.gds

QckCache v1.00 (April 5, 2010)
Copyright © 2010 Artwork Conversion Software, Inc.
(831)426-6163  info@artwork.com  www.artwork.com

Scanning... 100%
Scanning in 0 min 22 sec

Loading... 100%
Loading in 0 min 28 sec

Saving... 100%
Saved in 0 min 33 sec

Finished creating cache files:
/home/stevedb/caw_test1/caw_test1.gds.dbload.l64
/home/stevedb/caw_test1/caw_test1.gds.scan.l64

So it took about the same time to create the memory cache files as it did to open the file directly using Qckvu3.

If you look at the size of the files:

-rw-rw-rw- 1 stevedb users 1524334592 Sep  3  2009 caw_test1.gds
-r--r--r-- 1 stevedb users 1675258701 Apr  6 04:15 caw_test1.gds.dbload.l64
-r--r--r-- 1 stevedb users   15205254 Apr  6 04:14 caw_test1.gds.scan.l64

you will note that the .dbload.164 files is 1.67 GB which is actually larger than the original GDSII file and the .scan.l64 file is 15 MB which is only 1% of the source file. This is an indicator that the file under test has an unusual structure or organization.

Loading Memory Maps Directly into Qckvu3

To open a cache file use Qckvu3's file pulldown and click on the item: Select GDSII Cache

A dialog will open enabling you to choose the cache file.

Select the file caw_test1.gds.dbload.l64 for opening.

Opening the file will take about 20 seconds as compared to 90 seconds for opening the original GDSII file. This is an unusual GDSII file in that most of our test cases result in a much faster ratio between loading the cache and the original file.

Example 2 - 32GB File on a 32GB Workstation

Our second example uses a 32GB GDSII stream file running on a quad opteron workstation equipped with 32GB of RAM. Here is the data of interest:

Qckvu3 GDSII Loading Time - from the time we press OK in the file open dialog until the display starts drawing - 15:30 mm:ss

Qckvu3 Memory Footprint - this is determined using the top program:

PID   USER      PR  NI  VIRT   RES  SHR  S  %CPU   %MEM    TIME+     COMMAND
15758 tester    19   4  14.4g  14g  13m  S     0   45.4    9:59.79   qckvu3.exe

QckCache time to generate cache file it took the qckcache program 15:15 mm:ss to generate the two cache files -- approximately the same amount of time as to open the file for viewing.

Size of Cache File:

-r--r--r-- 1 tester users 14879422000 Apr  9 12:37 spika_quad.gds.dbload.l64
-r--r--r-- 1 tester users   153597268 Apr  9 12:36 spika_quad.gds.scan.l64

Time to open Cache File - 00:40 mm:ss

This is a tremendous improvement 40 seconds vs. 15 minutes.