[Artwork] / [QisMLib]

QisMLib

Gateway to the QisMLib system

QisMLib C++ API (qismlib.h)

Data Structures (qismbase.h)

Logging (qismlog.h)

Extensions (qismextension.h)

QisMFile (qismfile.h)

typedef QisMCriticalFailureCb_fn

Signature of a callback that recieves the critical failure notification

• msg is a human-readable description of the failure

• client_handle is the context handle provided by the user when this callback was set

extern "C" {
typedef void (*QisMCriticalFailureCb_fn)(const char* msg, void* client_handle);
}

struct CadFile

Codes for recognized file types

xxxxxxxxxx
struct QISMLIB_LNX_DECLSPEC CadFile
{
  enum Type { 
    INVALID=0, /* Invalid or un-recognized file */
    GDSII=1, /* standard GDSII format */
    OASIS=2, /* standard SEMI OASIS format */
    DBLOAD=3 /* QisMLib DbLoad cache (*.dbload.*) */
  };
};

class QisMLib

xxxxxxxxxx
class QisMLib { .. };

Gateway to the QisMLib API. Allows the client to load a GDSII/OASIS/Dbload file into a QisMFile database and provides access to various QisMLib extensions

Version Control

Cast to a pointer of another version in the class hierarchy (base/derived)

• Get the latest version number. Version numbers start at 1 and are reflected in the class name using the suffix V<number>. E.g <baseclass>V<version>

• The topmost base class is version 1 (V1 implied)

• The cast returns NULL if a version number is not recognized/implemented

xxxxxxxxxx
virtual void* QisMLib_cast(const int version) = 0;
virtual const void* QisMLib_cast(const int version) const = 0;
virtual int QisMLib_latest_version() const = 0;

Get_last_error_msg()

Get more information about the last error condition in form of an error string

xxxxxxxxxx
virtual const char* Get_last_error_msg() const = 0;

Get_license_count()

Get the number of licenses reserved for a specific feature (code)

• featureCode : The code of the api/feature that requires a license to execute

• No. of licenses reserved for the specified code (>=0)

• If the number of licenses reserved for a specific feature is less than the number requested during QisMLib_initialize_once(), it's the client's choice to continue execution or treat this as an error and terminate

xxxxxxxxxx
virtual int Get_license_count(const int featureCode) const = 0;

New_loadFile_ctrl()

Create a new instance of the file load settings object to control various aspects of the file load process

• Returns a handle to a new instance of the file load settings object

• Every instance of this object must be eventually destroyed using the Delete_loadFile_ctrl method to avoid memory leak

xxxxxxxxxx
virtual QisMFileLoadCtrl* New_loadFile_ctrl() = 0;

Delete_loadFile_ctrl()

Destroy an instance of the file load settings object

xxxxxxxxxx
virtual void Delete_loadFile_ctrl(QisMFileLoadCtrl* handle) = 0;

Get_file_type()

Check if a file is of a type supported by QisMLib

• filePath : Path of an existing readable file on disk

• Success: CadFile::GDSII / CadFile::OASIS / CadFile::DBLOAD

• Error: CadFile::INVALID (call Get_last_error_msg to get error information)

• ERROR CODES : One of QisMFileError::Get_file_type_codes

xxxxxxxxxx
virtual CadFile::Type Get_file_type(const char* filePath) const = 0;

Get_dbload_version()

Get the version a Dbload file

• filePath : Path of a valid Dbload file

• Success: A non-empty version string

• Error: Empty string (call Get_last_error_msg to get error information)

• ERROR CODES : One of QisMLibError::Get_dbload_version_codes

• This method is not multi-thread safe

xxxxxxxxxx
virtual const char* Get_dbload_version(const char* filePath) const = 0;

Load_file()

Load a GDSII/OASIS/Dbload file into the QisMLib database

• filePath : Path of a valid GDSII/OASIS or Dbload file

• openSettings : Handle to an instance of the file load settings or NULL to use the default settings

• cb : Notification handler for receiving file open progress updates or NULL to disable file open progress updates

• Success : A non-null API handle to the file database. This API can be used to work file the various functions of the database

• Error : A null handle (call Get_last_error_msg to get error information)

• On linux, the file path is case sensitive

• This method notifies the client about the progress using the QisMNotify::On_qismt_progress notification. In order to recieve updates, the handler must override the On_qismt_progress method

• Returning a non-zero number from the progress callback will result in termination of the file load. That's how a client can stop the file loading process

• This method also notifies the client of potential warnings using the QisMNotify::On_qismt_warning notification. The file is loaded successfully inspite of the warnings

• Refer to QisMFileLoadCtrl api to learn about the various file load settings

• Empty cells (no boundaries, paths, references or texts) will be dropped

• QisMLib supports loading of multiple files at any given time. Each loaded file MUST be unloaded using the Unload_file method

• ERROR CODES : One of QisMFileError::Load_file_codes

xxxxxxxxxx
virtual QisMFile* Load_file(
  const char* filePath, const QisMFileLoadCtrl* openSettings, QisMNotify* cb
  ) = 0;

Unload_file()

Unload the QisMLib database

• handle : Handle to the file database

• It is the client's responsibility to ensure that:

  • No database traversal is in progress

  • All exploders have been destroyed (QisMFile::Destroy_exploder)

xxxxxxxxxx
virtual void Unload_file(QisMFile* handle) = 0;

Get_extension_api()

Get QisMExtension API by name

• apiName : Name of the QisMExtension API

• Success : Non-null API handle (to be dynamic_cast(ed) to the corresponding API interface class)

• Failure : NULL. Call Get_last_error_msg for more information

• One of QisMLibError::Get_extension_api_codes

xxxxxxxxxx
virtual QisMExtensionAPI* Get_extension_api(const char* apiName) const = 0;

Get_extension_report()

Get report about various QisMExtension(s) currently loaded

• Returns a string containing a report on loaded extensions, warnings, errors etc.

xxxxxxxxxx
virtual const char* Get_extension_report() const = 0;

class QisMLibV2

xxxxxxxxxx
class QisMLibV2: public QisMLib { .. };

Set_working_dir()

Set the working directory to control where the temporary files generated by QisMLib (acs*.bin e.t.c) are created

• dirPath : Path of a valid directory with write permissions to be set as the new working directory

• Success : true

• Failure : false. Call Get_last_error_msg for more information

• ERROR CODES : One of QisMLibError::Set_working_dir_codes

• This method changes the current working directory (for the process using QisMLib) to the specified path

• Any temporary files created by QisMLib such as the acs*.bin (for OASIS cblocks) are created in the current working directory. Therefore, this function can be used to control where these files are created

• To be effective, this method must be called immediately after QisMLib_initialize_once. Any files created before this method is called will continue to exist in the original working directory

• Calling this method will change the meaning of '.' for the process using QisMLib. Therefore the user MUST exercise caution in specifying paths that contain '.'

xxxxxxxxxx
virtual bool Set_working_dir(const char* dirPath) const = 0;

class QisMLibV3

xxxxxxxxxx
class QisMLibV3: public QisMLibV2 { .. };

Load_gds_with_memory_maps()

Load a GDSII file and use the .load memory maps if available and applicable for faster loading

• originalGdsPath : Path of the source GDSII file from which the .load memory maps were created

• memoryMapsDir : Path of the directory where the memory maps (.load and .scan) are located. If empty/NULL, the current working directory is used to look for the memory maps

• openSettings : Options to be applied during file load. If these options differ from those specified during the creation of the memory maps, the file is loaded directly and the memory maps are ignored

• progressCb : Handle to a callback handler for progress updates

• Success : A non-NULL handle to the newly created database object

• Failure : NULL. Call Get_error_msg for error information

• The specified file path MUST be GDSII only.

• Using the memory maps for faster load is subject to the map files being found and compatible with the source data and the specified setings. Otherwise, QisMLib proceeds to load the source file directly disregarding the memory maps

• Every database object created using this method MUST be eventually destroyed using QisMLib::Unload_file to avoid memory/resource leaks

xxxxxxxxxx
virtual QisMFile* Load_gds_with_memory_maps(
  const char* originalGdsPath, const char* memoryMapsDir,
  const QisMFileLoadCtrl* openSettings, QisMNotify* progressCb
  ) = 0;

class QisMLibV4

xxxxxxxxxx
class QisMLibV4: public QisMLibV3 { .. };

Set_critical_failure_cb()

Set handler to be notified in the event that the application needs to be terminated because of an unrecoverable error

• cb_fn is the callback function pointer

• client_handle is a user provided handle that will be returned back during the notification. It can be used to establish context in the client application

• At the moment, this works only on WINDOWS

• At the moment, this is invoked only if somehow one or more active licenses are lost during operation

• QisMLib will trigger an exit(1) as soon as this callback returns and even if no callback has been set

• All QisMLib based licenses used by the application will be automatically recovered

xxxxxxxxxx
virtual void Set_critical_failure_cb(
  QisMCriticalFailureCb_fn cb_fn, void* client_handle = 0
  ) = 0;

QisMLib Initialization Arguments

To be used with QisMLib_initialize_once via argC, argT, argV paramters

xxxxxxxxxx
#define QISM_ARG_DISPLAY "-display" /* argV is of type 'Display*'  
+ Use this to pass the display handle to QisMLib to enable the drawing API
  otherwise drawing API will not be available (linux only)
*/
#define QISM_ARG_USECFG "-qismcfg" /* argV is of type 'const char*' 
+ Use this to force qismlib to use a different config file (default: qismlib.cfg)
  path of which is presented by argV. If this path is NULL, no config file 
  will be used (qismlib.cfg will be ignored) and no extensions will be loaded
*/
#define QISM_ARG_NEWLOG "-log" /* argV is of type const char* */
#define QISM_ARG_APNDLOG "-log+" /* argV is of type 'const char*' */
#define QISM_ARG_LOGFP "-log*" /* **DEPRECATED DO NOT USE** */
#define QISM_ARG_LOGCB "-log~" /* argV is of type QisMLogCb* (qismlog.h)
+ Use this to enable qismlib system-wide logging. -log will create a
  new log file. -log+ will append if the file already exists. -log* will write to
  the specified stream. -log~ will result in callbacks to the specified 
  handler object. By default, logging is disabled
*/
#define QISM_ARG_STDLOG "-stdout" /* argV is ignored (pass NULL)
+ Use this to print log messages to stdout/stderr. By default, nothing is 
  written to stdout/stderr
*/
#define QISM_ARG_SCRIPT "-qismscript" /*argV is ignored (pass NULL)
+ Use this to enable scripting support in QisMLib 
*/
#define QISM_ARG_SCRIPT_LOGCLIP "-logclip" /*argV is ignored (pass NULL)
+ If scripting is enables, use this to save the log for the last command to a clipboard
*/
#define QISM_ARG_ACSV "-acsv" /* argV is of type const char* 
+ Use this to pass the vendor string for trusted licensing
*/
#define QISM_ARG_ACSP "-acsp" /* argV is of type const char*
+ Use this to pass the path of the trusted license file 
*/
#define QISM_ARG_SCRIPT_CODE "-c++" /* argV is of type const char*
+ Use this to pass the path of sample cpp file generated by the script being executed

QisMLib Initialization Environment Variables

xxxxxxxxxx
set QISM_ENV_USECFG={<cfg-path> | NULL}

• Specify the config file via this environment variable

• If not set or set to empty, qismlib.cfg will be used

• If set to a file path, that file will be used as the config file

• If set to 'NULL', no config file will be used

• If set, this setting overrides QISM_ARG_USECFG

xxxxxxxxxx
set QISM_ENV_NEWLOG=<log-path>

• Same effect as QISM_ARG_NEWLOG

• If set, this setting overrides QISM_ARG_NEWLOG

xxxxxxxxxx
set QISM_ENV_APNDLOG=<log-path>

• Same effect as QISM_ARG_APNDLOG

• If set, this setting overrides QISM_ARG_APNDLOG, QISM_ENV_NEWLOG, QISM_ARG_NEWLOG

xxxxxxxxxx
set QISM_ENV_STDLOG={ON | OFF}

• Same effect as QISM_ARG_STDLOG

• If set, this setting overrides QISM_ARG_STDLOG

Config File Format

xxxxxxxxxx
EXTENSION=<Path of the extension library (.dll/.so)>

• The configuration file is a text file that lists the extensions to be loaded during initialization of the QisMLib system (QisMLib_initialize_once)

• On each line, an extension is listed using the syntax EXTENSION={extension_dll_path} where the path MUST be the absolute path of the corresponding DLL/SO

• The extensions are guaranteed to be loaded in the order in which they appear in the file

• Any line beginning with a # is treated as a comment and ignored

• The default configuration file is qismlib.cfg and is expected to be found in the same directory as qismlib64.dll

• An application can specify it's own configuration file using the QISM_ARG_USECFG initialization argument to QisMLib_initialize_once. See qismlib.h for details

• The Get_extension_report method of QisMLib provides a report of the extensions loaded as well as any errors/warnings that may have occurred during the loading process

typedef QisMLib_p

xxxxxxxxxx
typedef void* QisMLib_p; /* Alias for QisMLib* */

QisMLib_get_lib_info()

Get library version information

• Returns a string contaning the library version information

• This function is not thread safe during the first call

xxxxxxxxxx
QISMLIB_DECLSPEC const char* QisMLib_get_lib_info();

QisMLib_initialize_once()

Initialize the library to get access to the QisMLib API

• execPath : full path of the QisMLib shared library

• reserveLicenses : A 0 terminated list of license code/reserve count pairs that require QisMLib to reserve specific counts of various licenses to avoid interruptions in execution later due to failure to acquire licenses. The format of this list is: <code 1> <count 1> <code 2> <count 2> ... <0> If the exact counts are not known yet, specify -1 to defer the acquisition of the license

• argC : Number of optional arguments

• argT : Array of arguments tags (argC count) (QISMLIB INITIALIZATION ARG TYPES)

• argV : Array of argument values matching the corresponding argT (argC count)

• errorBuf : Address of a character buffer to store the error string in case of failure

• errorBufSize : Size of the character buffer

• errorCode : Buffer to retreive the error code in case of failure

• abiVersion : QisMLib ABI (application binary interface) version. Use QISMLIB_ABI_VERSION (macro). Do not use anything else

• Success: Non-null handle to the QisMLib API (requires type-case to QisMLib*)

• Failure: NULL. Error buffer (if specified) contains the error string

• The client can use the QisMLib_initialize_once macro instead of QisMLib_initialize_once_ext function. The macro redirects to QisMLib_initialize_once_ext function with the correct abiVersion. If the abiVersion of the client's header file does not match the one QisMLib was built with, this function returns an error indicating binary incompatibility

• This function initializes the QisMLib, reserved appropriate licenses and provides access to it's main API

• It is necessary to reserve licenses upfront so that the forthcoming operations are guaranteed to run without license errors and the client program has an opportunity to control the usage of licenses from a shared pool intended for multiple processes using QisMLib and it's extensions

• Use QisMLib::Get_license_count method to check if enough licenses were acquired for the requested features and determine if the program to terminate execution due to lack of thereof

• It also loads the QisMExtensions listed in the qismlib.cfg file and initializes them to facilitate the availability of extension APIs for the client

• This function must be called only ONCE in the lifetime of the program

• The directory containing the QisMLib shared library MUST also contain acs.key, colfill.pat, gdsfont.shx, qismlib.cfg files

• Do NOT delete/free the handle returned by this function

• At the end of the application, close the QisMLib to release the resources and unload the extensions

​x
#define QISMLIB_ABI_VERSION "QisMLib ABI 2.0 2018-06-26"
#define QisMLib_initialize_once(execPath, reserveLicenses, argC, argT, argV, errorBuf, errorBufSize, errorCode) \
QisMLib_initialize_once_ext(execPath, reserveLicenses, argC, argT, argV, errorBuf, errorBufSize, errorCode, QISMLIB_ABI_VERSION)

QISMLIB_DECLSPEC QisMLib_p QisMLib_initialize_once_ext(
  const char* execPath, const int* reserveLicenses, const int argC, 
  const char* const* argT, void* const* argV, char* errorBuf, 
  const int errorBufSize, int* errorCode, const char* abiVersion
  );

QisMLib_close_once()

Close the library to free up the resources and unload the extensions

• handle : Non-null handle to the QisMLib API

• Call this function once only at the end of the application

• The QisMLib can be initialized and closed only once so calling this function does not make QisLibM ready for initialization again

• All QisMLib handles and APIs should be considered defunct once this function is called

• It is the client's responsibility to ensure:

  • All exploders have been destroyed (QisMFile::Destroy_exploder)

  • The QisMFile has been unloaded using QisMLib::Unload_file

xxxxxxxxxx
QISMLIB_DECLSPEC void QisMLib_close_once(QisMLib_p handle);

QisMLib Commands

See qismlib.h for the relevant C++ API

lib.load_file

xxxxxxxxxx
lib.load_file
&filedb={filedb_id} 
input={input_file_path}
[layermap={layer_map_str}] 
[notext] [diskload] [emptyrefs]

• Create a database from a GDSII/OASIS/DBLOAD file

• Equivalent to QisMLib::Load_file in qismlib.h

• {filedb_id} represents name of a variable associated with the newly created database

• {input_file_path} is the path of a valid GDSII/OASIS/DBLOAD file

• {layer_map_str} if used, is a string specifying the layer mapping. e.g. ALL-NULL,1-100,2:2-200:2,3-300:0

  • re-map 1:* to 100:*

  • re-map 2:2 to 200:2

  • re-map 3:* to 300:0 (combine all datatypes of 3)

  • drop all other layers

• notext if used, drops all TEXT items

• diskload if used, retains the data section of the database on disk to reduce the memory footprint at the cost of operational speed

• emptyrefs if used, loads references to empty cells

• Every database created using this command MUST be eventually unloaded using lib.unload_file to avoid resource leaks

• This command will define two new string variables {filedb_id}.grid and {filedb_id}.units corresponding to the file grid (in meters) and units (in meters). They can be referenced elsewhere in the script using (({filedb_id}.grid)) and (({filedb_id}.units)) respectively. These will only be available while the database is alive (until lib.unload_file is called)

lib.load_processed_file

xxxxxxxxxx
lib.load_processed_file
  procfile={gds}
  &filedb={id} 
  input={gds_oas_dbload}  
  [layermap={string}] 
  [notext]  
  [roiUM={lx},{ly},{ux},{uy}]  
  [cell={name}] 
  [thrnum={nt},{n_per_t}] 
  [partition={nvert}]  
  [sizingUM={x},{y}] 
  [buttingUM={overlap}] 
  [maxvert={n}] 
  [convex]  
  [corrx={x},{y},{dx},{dy}[,{x},{y},{dx},{dy}]*]  
  [affine={xform}{+{xform}}*] 'where xform={scale:{x},{y} | angle:{deg} | txyUM:{dx},{dy} | flip:{X | Y | XY} | shear:{shx},{shy}'  
  [minrep={n>0}] 
  [noarefs] 
  [jitterUM={value}] 
  [circleUM={arcsag}] 
  [dbg1={l}:{d}]
  [acsv={string} acsp={path}]

• Pre-process a GDSII/OASIS/DBLOAD file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={gds_oas_dbload} is the path of the original GDSII/OASIS or DBLOAD file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• roiUM={lx},{ly},{ux},{uy} if specified, clips the data to be processed/loaded to the specified region (in file units)

• cell={name} if specified, sets the view cell to be processed. This will be the top cell in the processed file (and the database). Otherwise the default top cell of the original will be used

• thrnum={nt},{n_per_t} if specified sets the multi-threading load. {nt} is the no. threads processing various tiles and {n_per_t} is the no. threads per tile for certain operations. Default: {no. cpus},1

• partition={nvert} if specified determines the threshold (in terms of number of vertices) for breaking up the design into tiles. Default: 75000

• sizingUM={x},{y} if specified applies +ve or -ve sizing (edge compensation) in UM

• buttingUM={overlap} if specified converts polygons will holes into butting polygons with the specified overlap in UM. Default: It uses cutlines for such polygons

• maxvert={n} if specified limits any polygons to the specified max. vertex count. Default: 8190

• convex if specified generate only polygons that are convex in X and Y

• corrx={x},{y},{dx},{dy}[,{x},{y},{dx},{dy}]* if specified, applies bi-linear transformation based on the specified measured/correction points

• affine={xform}{+{xform}}* 'where xform={scale:{x},{y} | angle:{deg} | txyUM:{dx},{dy} | flip:{X | Y | XY} | shear:{shx},{shy}' if specified, applies affine transformations in the order specified (left to right)

• minrep={n>0} if specified, forms pattern cells in the output only for polygons that repeat at least {n} times. Default: 5

• noarefs if specified does not group array-like repeating patterns into AREFs

• jitterUM={value} if specified, allows a tolerance of the specified UM value when comparing polygons for repeating patterns. Default: 0

• circleUM={arcsag} if specified will detect circles such that the max. chord error is {arcsag} in UM. Default: No circle detection

• dbg1={l}:{d} if specified writes diagnostic information (such a tiles) on the specified layer

• acsv and acsp if specified indicate the use of trusted licensing

lib.load_processed_oasis

xxxxxxxxxx
lib.load_processed_oasis
  input={oasis}  
  procfile={gds}
  &filedb={id} 
  [layermap={string}] 
  [notext]  
  [maxv={4 <= n <= 8190} | 0]
  [dropcells={sep}{regex}[{sep}{regex}]*]

• Pre-process an OASIS file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={oasis} is the path of the original OASIS file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• maxv controls how polygons with vertices greater than 8190 are handled --

  • if maxv == 0 (default), such polygons (boundaries and paths) are written to GDSII with multiple XY records per boundary/path. This format may work with some GDSII readers and may fail with some others

  • if 4 <= maxv <= 8190, such boundaries are broken up into smaller butting boundaries of max. maxv vertices and a single XY record per boundary. Paths are still written with multiple XY records per path

• dropcells if specified will drop any cell (definition and reference) that matches any of the specified dos-like regular expression {regex}. {sep} is a char used to separate the expressions

lib.load_processed_hext

xxxxxxxxxx
lib.load_processed_hext
  input={oasis}  
  procfile={gds}
  &filedb={id} 
  [layermap={string}] 
  [notext]  
  [cell={name}]
  [nopaths]
  [top={name}]
  [namemod={prefix}[,{suffix}]]
  [scale={scale}]
  [angle={degress}]
  [translateUM={dx},{dy}]
  [mirror]
  [loffx={l},{d}]
  [boxclipUM={minx},{miny},{maxx},{maxy}] | [polyclipUM={x},{y}[,{x},{y}]3+] | [rndclipUM={cx},{cy},{radius},{arcres},{arcsag}]

• Pre-process an OASIS file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={oasis} is the path of the original OASIS file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• cell={name} if specified sets the view cell (which will become the top cell in the new database)

• nopaths if specified converts all paths to boundaries. Zero-width paths will be dropped

• top={name} if specified renames the top cell in the (output and the) new database to the specified name. Otherwise, it will be same as the view cell (cell={name})

• namemod={prefix}[,{suffix}] if specified renames all cells with the specified prefix (and/or) suffix. This includes the top cell UNLESS top={name} is also used

  • To specify only a suffix, use namemod=,{suffix}

• scale, angle, translateUM and mirror (flip-Y) transform the entire output appropriately

• loffx={l},{d} if specified adds the specified offsets to the layers and datatypes

• boxclipUM=... if specified clips the data to the specified box (in microns)

• polyclipUM=... if specified clips the data to the specified polygon (in microns)

• rndclipUM=... if specified clips the data to the specified circle (cx,cy,radius and arcsag in microns; arcres in degrees)

lib.load_gds_with_mmaps

xxxxxxxxxx
lib.load_gds_with_mmaps
  &filedb={id}
  gds={path}
  [mapsdir={dir_path}]
  [layermap={layermap_string}]
  [notext]
  [memload]
  [emptyrefs]

• Load a GDSII file with the option of making use of .load memory maps (database disk image) to speed up the loading

• Equivalent to the C++ API QisMLibV3::Load_gds_with_memory_maps (qismlib.h)

• {id} is name of a variable to be associated with the newly created database object

• {path} is the path of the source GDSII file to be loaded (which was also used to create the memory maps)

• {dir_path} if specified is the directory to find the .load and .scan memory map files. If omitted, the map files are implied to reside in the current working directory

• {layermap_string} if specified filters/re-maps layers. See lib.load_file for syntax

• notext if specified ignores TEXT elements. (default: TEXT elements if present are loaded)

• memload if specified loads the database in memory for faster operations. (default: the database is loaded from disk)

• emptyrefs if specified drops all references to empty cells

• Every database object created with this command MUST be eventually destroyed using lib.unload_file to avoid memory/resource leaks

• If suitable memory maps are not found or the ones that are found have incompatible characteristics, the specified GDSII file is loaded directly without taking advantage of any memory maps just like lib.load_file

lib.unload_file

xxxxxxxxxx
lib.unload_file $filedb={filedb_id}

• Destroy a QisMFile database

• Equivalent to QisMLib::Unload_file in qismlib.h

• {filedb_id} represents name of a variable associated with the database to be destroyed

QisMLib Licensing (API)

QisMLib Version History

qismlib dll/so v3.43 (2026-01)

• New pre-processors QisMLoadProcOAS and QisMLoadProcHEXT based on QisMOasUtil and QisMHExtract respectively

qismlib dll/so v3.42.3 (2026-01)

• New API QisMLogV4 to generate a vector log (GDSII)

• Bug fix - Tile overlap during sizing in the Pre-processor

qismlib dll/so v3.42.2 (2025-12)

• New command script.capture

qismlib dll/so v3.42.1 (2025-11)

• Load pre-processor supports trusted/oem licensing

qismlib dll/so v3.42 (2025-11)

• New API and command to pre-process a GDSII/OASIS/DBLOAD design before loading (QisMFileLoadCtrlV2)

• New API and commands -- QisMBoundariesAPI

• New API functions and commands QisMBoolInstV3 to import/export settings based on a text file

• Bug Fix -- Clipping and window intersection check for round paths

• New commands script.file_size and script.phys_mem_size

• New commands file.copy_to and explcounter.count

qismlib dll/so v3.41 (2025-08)

• Uses FlexNet Licensing v11.19.8.0

qismlib dll/so v3.40 (2025-07)

• QisMBool API auto-partitioning supports polygon intersection calculation

• Config. file system changed to allow for parameters to be passed to extensions during load (no such parameters exist at the moment)

• draw.image has new color options

qismlib dll/so v3.39.1 (2025-05)

• New script options expand={uu} for script.new_window_set, explcounter.break_window_by_crossing and explcounter.break_window_by_vertnum

• script.window_set_to_file can now write the windows to Text, GDSII or OASIS

• explcounter.break_window_by_crossing has two new options, thrnum= and minvert=

• qismwinq.h has new capability to generate performance reports

qismlib dll/so v3.39 (2025-05)

• file.print_cell_tree can write to file and suppress printing the tree

• new exported function QisMCmd_set_error(..)

• Bug-fix: Merging GDSII blocks in QisMcadWriter

• New functions in qismcmd.h for working with handles (object pointers)

• Certain double script variables have more precision (12 decimal places)

• Log messages are explicitly flushed

• New API QisMExploderV4

• New commands exploder.get_cellref_boundaries and exploder.make_cellref_semiflat

• New command bool.unionize_to_file

qismlib dll/so v3.38 (2024-10)

• Display warnings from a GDSII/OASIS/Memmaps load using scripting

• Updated CQisLib 5.19 with a fix for occasional error creating DBLOAD maps

qismlib dll/so v3.37 (2024-08)

• New C++ API QisMcadWriterAPI to write GDSII/OASIS files

• cadwriter script commands now make use of the new API

• New built-in script string variable ((PLATFORM)) = WIN64 | LNX64

• Bug fix: CMD_ABORT in script.procedure did not abort

• New option extension={name} in script.if that is true only if the specified extension is loaded

• Script Error/Abort routine. Add a script.procedure called CLEANUP to define anything that needs to be done if the script terminates abruptly

• One can also use script.call CLEANUP to explicitly cleanup at the end of a normal script run

• The procedure CLEANUP will only be called for QisMScript::Run_command_file(). If the application is running individual commands directly, it's the application's/user's responsibility to cleanup appropriately

• Support for DOS-like regular-expressions in script.if

• Support for implementing flows (qismflow.h)

qismlib dll/so v3.36 (2024-04)

• Bug fix: Path to boundary conversion for round paths was not multi-thread safe

• Modified file.print_cell_tree command to receive the tree as a string

• New extern C API QisMCmd that provides a command-interface for .NET etc.

qismlib dll/so v3.35.2 (2024-01)

• commands usage.required usage.option and usage.info (handled by qismscript64.exe) are treated as comments

• new command script.ifset that set's a key to a new value only if it's defined (opposite of script.setif)

• new options for script.if -- {key}~!{value} (key does not contain value}, {key}|{key}..|{key} (OR operation), {key}&{key}..&{key} (AND operation)

qismlib dll/so v3.35.1 (2023-11)

• New API QisMScriptRunnerV2

• Now script.foreach can also run a for loop between two numbers

qismlib dll/so v3.35 (2023-11)

• Windows only --

  • License failure during library operation will cause the process to be terminated

  • Application that makes use of the new QisMLibV4 api will have the opportunity to close matters before this exit

qismlib dll/so v3.34.2 (2023-06)

• New command script.convert for converting various values from one unit to another

qismlib dll/so v3.34.1 (2023-05)

• Faster GDS writing on Windows

qismlib dll/so v3.34 (2023-05)

• Support for generating C++ code from script commands (BETA)

• QisMBool settings file name includes object index

• QisMBndryWriter supports TIF8 format for images

• New error tags (QisMError) in qismbase.h

• New API QisMLogChannels for channel specific verbose logging

• New script commands script.file_name, exploder.print_vectors

qismlib dll/so v3.33 (2022-08)

• Misc. bug fixes and improvements in qismbool and scripting

qismlib dll/so v3.32 (2022-03)

• script.foreach can read tokens from a text file

• GDS BOX will now be converted into boundary during explosion (previously ignored)

qismlib dll/so v3.31 (2022-03)

• bug fix - in the past, aref element vectors could be received without a preceding aref vector

• new advanced controls for boolean settings

qismlib dll/so v3.30 (2021-08)

• Ability to evaluate arithmetic expressions enclosed by [[..]] in script commands

• Ability to pass a list of parameters to script.call command

qismlib dll/so v3.29.1 (2021-02)

• New logging API QisMLogV2 with extended logging control

• New utility script commands script.substr, script.tokenize , script.window_set_to_string

• Misc. API changes in QisMBool, QisMFile, QisMExploder etc.

• Support for trusted licensing

qismlib dll/so v3.29 (2020-07)

• Support for compressed GDSII (.gz and .Z) on Windows (was available on linux from the start)

qismlib dll/so v3.28 (2020-07)

• Much improved explcounter.break_window_by_crossing (QisMExplCounterV4::Break_window_by_vertcross) with a nearly constant memory footprint and multi-threaded operation

qismlib dll/so v3.27.1 (2020-06)

• Relaxation of checks that prevented data grid from being too fine

qismlib dll/so v3.27 (2020-02)

• Ability to define and execute procedures in QisMScript

• New command script.if for conditional execution of commands

• New command explcounter.break_window_by_crossing for generating a density map and corresponding C++ api QisMExplCounterV4

• New API QisMLibV3 with support to make use of .load memory maps when loading a GDSII file and a corresponding script command lib.load_gds_with_mmaps

• The EXTENSION entries in the config. file can now contain relative paths or no directories at all in which case the location of those entries is implied to be relative to the location of the QisMLib dll/so

qismlib dll/so v3.26.3 (2020-01)

• New set of script command bool.* for performing boolean operations on polygons sets using the QisMBool API

• New script command cadwriter.circle

qismlib dll/so v3.26.2 (2020-01)

• New set of script commands cadwriter.* for composing a GDSII/OASIS file

qismlib dll/so v3.26.1 (2019-12)

• New command script.window_set_to_file

qismlib dll/so v3.26 (2019-12)

• lib.load_file script command defines two new string variables {filedb_id}.grid which represents the file grid in meters and {filedb_id}.units which defines the file units in meters

• New script commands script.set and script.setif to define string variables

• New API QisMWinQ to run a multi-threaded window queue with any window processing operation defined by the client

qismlib dll/so v3.25.2 (2019-11)

• Bug fix: Spatial queries failed for designed with large data extents because of an integer overflow in the construction of the spatial db

• New QisMScript command draw.image to render a view of the database to an image file on disk

qismlib dll/so v3.25.1 (2019-11)

• New API QisMBoolXV2 for computing embedding levels for boundaries in a leonov data set

qismlib dll/so v3.25 (2019-11)

• New API QisMExploderV3 to compute a density map (in form of tiles) based on the no. vertices contained within. This can be useful for efficient load sharing in multi-threaded queue operations

• Also provides a corresponding QisMScript command explcounter.break_window_by_vertnum

qismlib dll/so v3.24.4 (2019-10)

• Bug fix: QisMExploder Get_vector_data thread resources were not being freed on Linux resulting in rise in the memory footprint

qismlib dll/so v3.24.3 (2019-08)

• New API QisMWindowProbe and corresponding script command probe.window

• Misc. bug fixes

qismlib dll/so v3.24.2 (2019-08)

• Misc. additions to QisMBoolSettings (qismbool.h)

• New QisMScript commands for branching and loops

qismlib dll/so v3.24.1 (2019-07)

• New QisMBool API (QisMBoolSettingV2 -- qismbool.h) with many more controls to flavor the results of boolean operations

• QisMBStore (qismbstore.h) extended with some utility functions

• New script commands for QisMFile, QisMExploder and QisMBStore

qismlib dll/so v3.24 (2019-07)

• QisMScript. Built-in support for defining and executing script commands. Script commands can be executed by any application using QisMLib. Any code attached to the QisM system can also add commands. qismscript64.exe is a console app that can be used to run scripts

qismlib dll/so v3.23.1 (2019-06)

• QisMExplCounter (qismexplcounter.h) has a new extension QisMExplCounterV2 to compute vertex counts up to the specified nesting level

qismlib dll/so v3.23 (2019-04)

• New API : QisMFileOut (qismfileout.h). A unified interface to write boundaries to disk as GDSII/OASIS (vector) or TIFF/BMP/RAW (images)

qismlib dll/so v3.22.1 (2019-03)

• Bug fix: QisMExplCounter::Get_counts_hierarchical crashed if the specified cell did not exist

qismlib dll/so v3.22 (2018-07)

• New API : QisMLibV2::Set_working_dir to change the current working directory for the process using QisMLib

• QisMLibV2 is an extension to the QisMLib class. It can be obtained as follows QisMLibV2* v2 = (QisMLibV2*)(qismlib->QisMLib_cast(2)); If (NULL == v2) { //error: New API QisMLibV2 not supported }

qismlib dll/so v3.21 (2018-07)

• QisMDrawFlag::IFF_BITMAP8 on Windows generates BMP data (previously DIB). BMP = DIB + BITMAPFILEHEADER so that the image data can be processed by one of the many .bmp processing functions

qismlib dll/so v3.20 (2018-06)

• Break in backwards compatibility. All applications built with earlier versions of QisMLib MUST be re-built

• Method overloading removed from all classes because of incompatibilities with non-MSVC compilers on Windows

• To prevent accidental use with older QisMLib, QisMLib_initialize_once fn has been replaced by QisMLib_initialize_once_ext so that the run-time will fail immediately. The application does not have to call QisMLib_initialize_once_ext. They can continue to call QisMLib_initialize_once exactly as before. QisMLib_initialize_once is now a macro that redirects to QisMLib_initialize_once_ext

qismlib dll/so v3.12, v3.12.1 (2018-04)

• Internal limit on the number of active files/exploders removed. These are not only contrained by the system resources (or licenses in case of exploders)

qismlib dll/so v3.11 (2018-03)

• New licensed API QisMClipper (qismclipper.h) for computing interaction of boundaries and paths with a set of windows/regions

qismlib dll/so v3.10 (2018-02)

• New API QisMLog (qismlog.h) for system-wide logging in QisMLib

• Some QisMLib_initialize_once options can be delivered by environment vars

qismlib dll/so v3.9 (2017-11)

• Break in the API compatibility. All apps/libs using QisMLib 3.9 and it's extensions MUST be re-built using the new header files

• The temp. heade file qismlib_extras.h is no longer available. It's two 'C" functions have been incorporated into QisMFileLoadCtrl class (qismfile.h)

• Bug-fix: QisMBool boolean functions returned error if set A was empty. This has been fixed. Set A can be empty

• Extension to QisMExploder to explode boundaries and cell references

qismlib dll/so v3.8 (2017-10)

• Bug Fix: Unloading files did not decrement the file index resulting in QisMLib reaching the max. number of files open

qismlib dll/so v3.7 (2017-10)

• OASIS code is now optimized for multi-threaded use

• New function QisMFileLoadCtrl_ignore_text_scale and to force text scale to 0.0 upon load in order to avoid using text extents in the computation of cell extents just like OASIS

• New function QisMFileLoadCtrl_load_empty_refs to control if the empty refs are loaded. If ignore-text-scale is ON, the load-empty-refs becomes necessary for cells containing only texts since those cell's extents will become 0,0,0,0

qismlib dll/so v3.6 (2017-07)

• Support for loading multiple files enables. API remains the same. Previously, QisMLib::Load_file unloaded the previously file automatically before loading a new file. Now, each call to QisMLib::Load_file creates a new QisMFile handle

• New QisMExplCounter function that uses hierarchical explosion to get counts much faster then the other method

qismlib dll/so v3.5.1 (2017-05)

• Build error: Undefined symbol SystemInfo::Get_num_processors()

qismlib dll/so v3.5 (2017-05)

• New extension api QisMBoolX

• Bug Fix: Multi-threaded access issues affecting QisMDraw::Redraw_image for XPM format

• Improvement: All methods accepting string parameters (lists) are immune to presence of spaces

• New extension api QisMExplCounter

• Bug fix: Error message for license failure

qismlib dll/so v3.4 (2017-02)

• Bug-fix : Get_vector_data (qismexploder.h) was returning true even if the client interrupted execution via callback return code

• New QisMLib_initialize_once arg (-qismcfg) to specify a config file other than qismlib.cfg or to not load any config at all

• Bug-fix: QisMLib::Load_file crashed if QisMLib::Unload_file was used to close the previous file

• Bug-fix: Undefined reference error for QisMDrawObject::Get_display_vector_data

qismlib dll/so v3.3 (2017-01)

• Support for creating memory maps (qismfile.h - QisMFileMemoryMaps)

• API to get exploded counts for a cell+layer (QisMFile::Get_cell_layer_exploded_vertices)

• Bug-fix : Exploders were not being freed correctly leading to an error after 512 calls to QisMFile::Create_exploder

• Buf-fix : GDSII/OASIS/Dbload errors were not handled correctly

qismlib dll/so v3.2 (2016-12)

• First cut with the QisMDraw extension

qismlib dll/so v3.1 (2016-12)

• Bug fix: File was not loaded to memory inspite of the setting being ON because of improper order of execution of the SetLoadMemory setting

qismlib dll/so v3.0 (2016-10)

• First cut