Java-Based OCT - A CAD Data Manager

written by Francis Chan

Objective

OCT is a data manager for VLSI/CAD applications. It has been a major component of the Berkeley CAD framework and has been used in many CAD applications and projects since the 1980s.

The development of the Java-based OCT package marked WELD group's first attempt to gain experience in evaluating efficient techniques and data structures for representing CAD data formats and models and managing data in a network environment, with the use of an object-oriented database backend.

There were a number of reasons why we chose to port the OCT package as the first-cut network data model. Structurally, the use of generic attachments among OctObjects to represent object linkage/relationship translated well into an object-oriented model. While architecturally simple, the OCT package could be used to build and traverse arbitrarily large and complex objects, using simple mechanisms such as Attach, InitGenContents and InitGenContainers. Developed originally at UC Berkeley, OCT is a data model known and understood well within the research (UC Berkeley CAD) group. Modifying some of the OCT-compliant legacy tools to work in a network environment with the Java-based OCT and Java front-ends was one of the considerations for future extensions and experiments. The resulting package would be a good base-object structure for the class assignments and project for a graduate class in design technology at UC Berkeley. This translates to a solid user base for implementation and usage testing.

Technical Introduction

Because of OCT's architectural elegance and simplicity, Java-based OCT has retained many of original OCT's features, properties and structural representation mechanism. The basic unit in a design is the cell. A cell is the portion of a design that the user wishes to consider as a unit. A cell may have many views, such as "schematic", "symbolic", "physical", "simulation", etc. Each view has a facet named "contents" which contains the actual definition of the view and various application-dependent "interface" facets. Facets, which exist beneath the level of views, contain instances of other cells, which may in turn contain instances of other cells.

Facets consist of a collection of objects that are related by attaching one to another. The basic OCT system allows OctObjects such as bags, boxes, terminals, etc. to be arbitrarily attached to each other. The main mechanism of traversing these relationships is by InitGenContents (for generating the contents vector of objects attached) and InitGenContainers (for generating the containers vector of objects which the object is attached to).

OCT imposes no restriction on the interpretation of data and few restrictions on the organization of OctObjects. It is left to the application developer to implement policies that assign meanings to the organization and structure of data represented using OCT.

Figure 1 OCT Data Structure Example.

Figure 1 shows an example of an OCT structure (that was used as the basic cell of a class assignment (explained later in detail)). The ovals represent OctObjects and the links represent Attachment relationships among OctObjects.

Implementation Description

While we tried to retain as much of the original flavor of OCT as possible, this implementation differs in many ways from the original OCT system. New concepts, structures and organizations have been introduced and, at the same time, unsuitable features have been discarded.

The three main implementational differences between Java-based OCT and the original OCT are:

  1. The client/user code is written it in Java, an object-oriented programming language, as opposed to C, which is a procedural language. Object-oriented design and organization can and has been utilized.
  2. An object-oriented database is used as a data back-end (for load, save, queries, etc.), whereas the original OCT made use of UNIX files.
  3. Since the Java-based version of OCT was designed to be able to work in both a Internet and LAN environment, a lot of emphasis has been placed on protocol efficiency and minimization of (network) transactions for network storage and retrieval.

Functional Description

The (Oct)object manipulation mechanisms are all supported in this Java-based implementation and are embedded in the OctObject implementation which all other OctObjects inherit.

These mechanisms include:

DeleteCommit and DetachCommit were added to the list of manipulation mechanisms due to the need to differentiate between local and remote object processing. Objects that exists only dynamically on the client side or operations that need not be committed can make local calls (Delete, Detach); operations which require the persistent object/data server to record the updates need to explicitly call the methods (DeleteCommit, DetachCommit) that invoke remote calls over the network so that the respective operations can be executed by the data server.

Applications

The Java-based OCT package was used in two assignments of the class Design Technology for Integrated Electronic Systems (EE 244, UC Berkeley, Fall 96). The assignments involved the place-and-route and display of a netlist (consisting of 10X10 cells) and the subsequent use of partitioning algorithms to optimize the placement of the cells (see Figure 2 below). The purpose of the assignment, in addition to introducing CAD concepts to the students, was to test and demonstrate the usability and ease of programming of Java by regular students/engineers, as well as the acceptable performance of Java applets/applications in a computing- and user-interface-intensive setting.
Figure 2.  Snapshot of one of the homework examples that used Java-based Oct as the base object data structure.

The figure shows a Java applet that allows users to choose multiple partitioning algorithms and visualize the placement of the cells/results. During execution, various costs of the placement are also displayed (by the line graph and bar chart) to the user.


Modified: June 20, 1997
Feedback: (fchan@eecs.berkeley.edu)