2
MIT Laboratory for Computer Science, March 2003 127 Spongepaint: A General Purpose C++ Framework for VLSI Layout Christopher Batten and Krste Asanovi´ c Introduction: A designer usually has two choices when deciding how to translate a logic-level design into actual layout: use an interactive editor to manually generate layout or use a standard cell library and a synthesis tool to auto- matically generate layout. Although manual layout offers the designer the most control and results in highly optimized layout, it is time-consuming to create and modify. Automatic layout is convenient and flexible but can produce layout with significantly poorer performance and higher energy consumption than full-custom designs. There has also been work on a third design methodology called procedural layout, which involves using a program to describe the steps required to create a layout. Procedural layout attempts to combine the convenience and flexibility of automatic layout without sacrificing the control and quality of manual layout. Spongepaint is a new general purpose C++ framework suitable for procedural layout. Using a general purpose programming language offers significant advantages over other custom procedural layout languages: optimized compilers are readily available, most of our designers are already fa- miliar with the language, and the library is easily extendible. Spongepaint provides a framework for layout at several abstraction levels which makes it suitable for use in a wide range of designs including datapaths, memory arrays, and parameterized leaf cells. In addition to producing fabrication quality layout, Spongepaint will enable rapid area and energy estimation for microarchitectural blocks. Approach: Spongepaint is implemented in C++ and uses a simple object hierarchy to promote ease of use at any abstraction level. The Spongepaint abstraction levels are illustrated in Figure 1. The Spongepaint primitives include classes corresponding to the basic layout constructs such as rectangles, labels, and containers (called cells) to hold these basic constructs. Spongepaint tools are collections of functions which operate on primitives and cells to provide a convenient interface to the higher abstraction levels. Tools are usually simple and perform tasks such as point-to- point routing, array pitch matching, and file I/O. Spongepaint builders use several parameters to actually generate a cell. Builders are more complex than tools and can include sophisticated synthesis routines. Applications use any of the lower abstraction levels to actually instantiate a layout. As an example, consider the process of building a data cache. The circuit designer would first create a leaf SRAM cell and a leaf sense-amp cell using a traditional interactive layout editor. The designer would then write an application which might first use an spDecoderBuilder to create an appropriate decoder for the cache. The application would use the cell output from the spDecoderBuilder and the two leaf cells as input to a spDataCacheBuilder. The spDataCacheBuilder might use a more general spCacheBuilder which in turn uses Spongepaint tools to create an array of SRAM cells, possibly flip alternating cells, pitch match the sense-amps, and wire the decoder to the SRAM array. Notice that although the abstraction levels help the designer, there is no need for the designer to blindly use given builders. A designer can directly manipulate primitives with the tools, or write a custom builder which better implements the desired automation. The ability for the designer to easily use any abstraction level is a fundamental Spongepaint design goal. Figure 1: Abstraction Levels Progress and Future: The Spongepaint primitives and a datapath builder were originally developed by Gong Ke Shen and implemented in Java [1]. We are currently porting Spongepaint to C++. The primitives, several basic tools, and file I/O tools supporting both Magic and GDSII file formats have all been implemented. A standard cell datapath generator has been developed which leverages a supplied standard cell library to create compact semi-custom layout. Figure 2 shows a generated eight-bit counter datapath, and Figure 3 shows the adder and register block for a similar counter datapath in more detail. Notice how the datapath generator must carefully orchestrate cell abutment, column pitch matching, data bus routing, control signal routing, and the adder carry chain. We are currently working on cache builders, register file builders, and more flexible datapath builders which use custom leaf cells. Spongepaint will be used extensively in the development of the SCALE architecture. As an example, the SCALE lane array will first be described in C++ using Spongepaint. The designer can then write a Spongepaint application to generate the layout for several design points. Area, performance, and energy characterizations can be gathered from the generated layout, and the designer will be able alter the C++ lane array definition to meet various design goals. The
