View
212
Download
0
Category
Preview:
Citation preview
We have developed an incremental computer-aideddesign library thatprovides run-time facilities to link,unlink, execute, and listfunctions. At the heartofthelibrary is anincremental loader thathelps designers anduserscustomize theirbasic tool for theirdesign environment. In thispaper, we discuss how four computer-aideddesign tools have benefited from using the library forsimulating Clanguage models, modifying and enhancinggraphical user interfaces, extending command languages,and rapidly testing new functionality. Using SCHEMA andMIDAS ascase studies, we also describe how thelibraryimproves quality and reduces time to market.
AN INCREMENTAL ENVIRONMENTFOR COMPUTER-AIDED DESIGN TOOLS
________ Judith L Schmidt, Thaddeus J. Kowalski, and David S. Smull _
Judith L. Schmidt is amember of technicalstaff in the ComputerAided Engineering andDesign Department atAT&T Bell Laboratoriesin Allentown, Pennsylvania, and David S.Smull is a supervisor inthat department.Thaddeus J. Kowalskiis a member of technical staff in the Software TechniquesResearch Departmentat AT&T Bell Laboratories in Murray Hill,New Jersey.Ms. Schmidt is Introductioncurrently working on Rapid simulation and testing is crucial to the productivity ofincreasing developer AT&T's integrated-circuit andboarddesigners and to the quality ofproductivity through their designs. AT&T computer-aided design (CAD) tools! providecomputer-aided soft- state-of-the-art features to helpdesigners produce complex circuitsware engineering tools. rapidly. Asthe CAD tools themselves become morecomplex, providingHer interests also ever-increasing functionality to an expanding customer base,severalinclude network problems become evident. (Panel 1defines acronyms andterms usedmanagement and in this paper.)artificial intelligence. The tools must servea diverse user community that requiresMs. Schmidt joined the different features, options, and capabilities. This canleadto a proliferacompany in 1988. She tion ofcommands andfeature sets that differ insubtle but significanthas a B.S.E.E. from ways. Further,a user interface that is customized foronecommunityThe Johns Hopkins may notbe effective inother environments. Simulators, which useUniversity (Baltimore, Cfanguage models to describe the behavior ofcomponents, cannotMaryland) and holds an contain allavailable models without becoming tooexpensive andM.S. in computer sci- unwieldy. In addition, newClanguagemodels are constantly beingence from the Univer- developed. To designCAD tools that spana largeuser baseandsatisfysity of Delaware these diverse needswould be an unmanageable task.(Newark). Mr. Kowalski Wehavesolved the problem by integrating an incrementalis currently examining loader" with the CAD tools. Throughthe incremental loader, users(continued on page 110) tailor these tools to suit their needs. Designers canaddcode to
AT&T TECHNICAL JOURNAL. JANUARYIFEBRUARY 1991
101
Panel 1. Acronyms and Terms
Incremental LoaderThe incremental loaderis part ofthe AT&T
C-language interpreter (c in), which is contained in thecens 3 programming environment. Cens wasdevelopedatAT&T Bell Laboratories in the Software TechniquesResearch Department and is supported by the ArtificialIntelligence Systems Department. The incrementalloader is based on the UNIX® system (Research Version,Eighth Edition4) ld command, enhanced to include the
customize the basic toolfor their environment. Bylinkingcodeas needed, toolusers can:- Augment a simulator usingC-language models for
designs.- Modify and enhancethe tool'suser interface.- Extend the tool's command set.- Rapidly test newfunctionality.This paperdescribesthe incremental loaderand howitincreases the productivity ofAT&T designers.
102
APICADcccenscicinlintmin/maxMOTIS3mouse
netlist
R&DSCHEMA
application programmer's interfacecomputer-aided designC-language compilerC-language environment systemC-language interpreterAT&T C-language interpreterC-language syntaxcheckeroptimistic and pessimisticAT&T simulatora pointing and drawing device that, when
moved across a flatsurface, causes thecursor to move on the screen. Buttonson the mouseare used for selectingactions or objects on the screen.
description ofthe electrical componentsin a circuitand their interconnections
research and developmentAT&T designcapturetool
incremental loading ofobject files. (UNIX is a registeredtrademark ofUNIX System Laboratories, Inc.)
With incremental loading, allfiles fora specificapplication do not need to be loaded at once; files canbeloaded individually, as needed. The loaderprovides thebasiccommands to linka file intomemory and executefunctions. It maintains its own symbol table, which isupdated as each file is loaded. Unlike ld, the cin loaderallows undefined and multiply defined symbols.
There are two major benefits to running a program with an incremental loader:- Rapid prototyping. Functions can be loaded and tested
without the need to write driver programs.- Reduced turnaround time. Only changed files need be
relinked.The Incremental Loader and CAD Tools. The incre
mental loaderadds to the power andflexibility ofAT&TCAD tools, enhancing the productivity ofusers in severalways. For example, users can linkcodeto modify andextendthe user interface and the command language.Theycanadd menusand dialog boxesto the tool'sinterface, or add commands that are customized for theirenvironment. The AT&T designcapture tool, SCHEMA,5provides this functionality directly to users.Some groupshavecreatedentire products basedon the incrementalloading ability in SCHEMA. One such project, Carousel, isdescribed later in this paper.
C-language models inAT&Tsimulators6.7 providea goodexample ofhowthe loaderdirectly affects designerproductivity. These models allow designers to model thelogical behavior ofa circuit. The models are linked withthe simulator to test a particular circuit. Before the incremental loading functionality wasadded, the models hadto be linked directly with the simulator's object code. Ineffect, this technique createda newsimulator, customizedfora particular model. With the incremental loader, themodels can be directly linked intothe simulator at runtime, eliminating multiple versions ofthe simulators.
Other tools use the incremental loaderto linkfunctions that provide a specific feature. Forexample, a
AT&TTECHNICALJOURNAL • JANUARY/FEBRUARY 1991
BaseApplication
sqrt(double num){}
Figure 1. Applicationand loader symboltables. Loader routines enable theapplication's symboltable to know aboutfunctions and datalocated in theloader's symbol table.ThUS, users can linkfunctions and accessdata internal to theapplication. Explicitfunction calls to theincremental loadermake buffer andsbrk available to theincremental application. Other functionsand variables areaccessible to onlyone part of the application.
103
user selects a toolfeatureby clicking (i.e., depressing) abuttonon a mouse. The loaderincrementally links, executes, and unlinksthe functions without anyfurtherinteraction. The toolprovider can ship a small executablefile, plus separatefunctions that supply extra capabilities.Only those functions that the user requests are linkedand executed.
Detailed examples ofhow SCHEMAand theAT&T simulators use the incremental loading ability arediscussedlater.
Integration with AT&T CAD. In choosing the incrementalloader, functionality wasmostimportant. Besidesproviding the desiredfunctionality, the c in incrementalloader fulfilled four basic requirements: robustness,availability on the appropriate platforms, internal support,and suitability forproduction-quality tools.
Oncewedecided that the loaderwasthe rightsolution, wedeveloped an integration plan. First, wespecified the functionality requiredby the CAD tools.Next,wedeveloped a method for integrating future
AT&T TECHNICAL JOURNAL.JANUARYIFEBRUARY 19Y1
104
versions ofthe c in loaderthat minimizes disruption tothe CAD tools, their developers, and the tools' users.Finally, weconsulted with tooldevelopers to determinehow best to present the incremental loaderto users.
Required functionality. After discussions with various CAD developers, wedecided that,at minimum, a userneedsto linkand unlink files, execute functions, listwhatfiles andfunctions are linked, and specify whatfunctionsare active within each file. In addition, the users need toaccessvarious application dataandfunctions. However,interaction between the application and the user-linkedcodeis hampered becausethe loadermaintains its ownsymbol table.
Whenthe loaderis integrated intoa CAD tool,there are two symbol tablesassociated with the runningtool: the application's symbol table and the loader's symboltable, which is completely enclosed within the application memory. Thus, a function that is loaded intotheincremental loader'ssymbol tabledoesn'tautomaticallyhave accessto the application's symbol table. To overcome this problem, weused routines in the loaderthatmake functions and datalocated in the loader'ssymboltable known to the application's symbol table. Thisallows users to linkfunctions and accessdatainternalto the application.
Figure 1 shows a base application that contains:- Amain function that doesn'treturn a value.- A sqrt function that returns a double (i.e., a double-
precision, floating-point value).- Acharacterpointer p. (A character pointer contains
the addressofa memory location that stores a character value.)
- The incremental loader.- Acharacter arraybuffer.- An sbrk function that returns a characterpointer.Incrementally loaded into this base application is:- A sqrt function that returns a double.- Amain function that doesn'treturn a value.- Aprintf function that returns an integer.- A sleep function that doesn'treturn a value.
AT&TTECHNICALJOURNAL • JANUARY/FEBRUARY 1991
- Acharacterpointer p.- Awrite function that returnsan integer.Variables andfunctions canbe made available to theincremental application byexplicit function calls to theincremental loader. In the example inFigure 1,bufferand sb r k are available to the writer ofthe incrementalapplication. Thus, a user canwrite incremental functionsthat interactdirectly with the application, which meansthat morepowerful functions canbe written. In addition,to prevent sideeffects, it is also important that somefunctions-such as the memory-allocation functions-besharedbythe baseand incremental applications. If theincremental application andthe baseapplication bothhad copies of sbrk, seriousproblems could develop.Otherfunctions andvariables are accessible to only onepart ofthe application.
Integration of future versions. CAD developers mustbe able to integrate the loaderquickly andpainlessly,and to adoptnewversions ofthe loader with little disruptionto the tool and tool users. In addition, the CAD toolshould be protected from platform dependencies. So, wedecided to wrap the loaderinan application programmer's interface (API),which insulates the CAD tools fromthese changes. The loaderandAPI are provided by theComputer Aided Engineering andDesign Departmentas a library that canbe linked with the application.
Presentation to users. Once the loader is integrated,it canbe presentedto users in two basic ways:- In the explicit approach, the CAD tool provides a com
mand lineor graphic interface. The user executesspecific commands to linkfiles andexecute functions.
- In the implicit approach, the linking ability becomesinvisible to users. For example, if a user selects a button to run a certain command, the tool could automatically linkthe desiredfunction, execute it,and unlinkthe file without additional input.
Technology TransferAsthe strategic business unitswithin AT&T
seek morebenefit from basic researchefforts, technol-
ogytransferassumesgreater importance within theR&D community. Before wediscussdetails ofhowtheAT&T CAD toolsuse the incremental loader, it is instructiveto see howthe technology transferbetween theresearch and development organizations wasaccomplished. The methodwe used worked well. It fostered aspiritofteamwork and cooperation, and led to directbenefits for both laboratories.
SCHEMA contained a partial C-Ianguage interpreter (c L}, which compiled sourcefiles intopseudoobjectfiles. SCHEMA and c i wereavailable under DigitalEquipment Corporation's VAX/VMSTM operating systemand the UNIX operating system. (VAX/VMS andVMSare trademarks of Digital Equipment Corporation.) Atthe timethat the VMS™ environment wasphasedout,the CAD developers alsowanted to upgrade c i to allowuser-defined structures.The developers decided thatc in, designed in the UNIX systemenvironment, wouldresult in a faster productand presentedan excellentopportunity forsoftware reuse. Developers Angelina andFajardo contacted Kowalski, the researcher responsiblefor c in. They discussed the problems with c i andhowthese problems mightbe solved by using c in.
Although c in would haveprovided additionalfunctionality for SCHEMA, they decided a moreappropriate solution wasto separatethe incremental loaderfromc in and incorporate it into the c i function library.Kowalski provided the incremental loader, while thedevelopers created a prototype replacement c i functionlibrary and benchmarked the solutions. TableI showsthat the newroutinesused 6G-percent less memory and96-percent less timethan the original c i systemto execute a 71-line program. Withthis success, Christman(anotherdeveloper) assistedin portingthe incrementalloaderto the Amdahl computer's UNIX time-sharingoperating system.
Afew months later,one memberofeach laboratoryassumeddirect responsibility for the transfer.Kowalski provided the basiccode,expertknowledge,and technical supportas the loaderwasintegrated into
Table I. Size and Time for ci System
System withOriginal incremental
Test system loader
Size (bytes)Program 83564 32784Input 5984 1272
TIme (seconds)Compile and link 3 3.3Linkonly < 1 <1Execute 27 < 1
the first few tools. Schmidt, a developer from the CADlaboratory, developed the API functions, performed theintegration into SCHEMA, andservedas the single pointofcontact between the two laboratories.
SCHEMA wasselected for the initial integrationbecauseit already contained a partial C-Ianguage interpreter.Thus, the interface appropriate foran incrementalloaderwaslargely inplace. Moreover, the initial prototypehad demonstrated that the integration wasfeasibleandworthwhile.
Asthe loaderwasintegrated into SCHEMA, theteamaddedfeatures in response to needs that arose during the process. The integrated product wasthen supplied to alphaandbeta users, in turn. Feedback fromthese users helped the teamto streamline and enhancethe loaderinterface. Oncethis initial effort wascompleted, the loaderAPI wasreleased to alldevelopers. Theindividual tooldevelopers then worked to integrate thetool, with helpfrom the CAD laboratory developer whowasresponsible for the loader.
Asfeature requests and errors were reported,somewerefixed within the CAD laboratory, andotherswererelayed to research. Oneexample ofa majorrequestwasa portofthe loaderto a SunMicrosystems'Spare"chip-based architecture. (Spare is a registeredtrademark ofSPARC International, Inc.) After discussionsbetween membersofresearch and development,the CAD laboratory agreed to handlethe port, with
AT&TTECHNICAL JOURNAL.JANUARY/FEBRUARY 1991
105
106
guidance from the research staff. The ported codewasthen integrated into c in. The resultwasa bigwin forbothdevelopment and research.
Examples of Loader-Tool InteractionTwo ofthe first tools to take advantage ofthe
incremental loading ability were SCHEMA and MIDAS,6
AT&T's logic simulator with min/maxtiming, which producesbothan optimistic anda pessimistic timing simulation. These tools use the loaderin many different ways tohelp designers increase productivity.
Design Capture. SCHEMA, AT&T's design capturesystem, is a powerful andflexible application used fordesign jobsthat include full custom integrated circuits(i.e., circuits designed at the transistorlevel), circuitpacks, backplanes, andequipment rackcabling.
SCHEMA users havebeen ableto linkcodethrough c i for sometime. The interpreter, c i, recognized a subset ofthe Clanguage. It allowed a user toaccess a set ofinternal SCHEMA functions that could becalled from a user-linked function. (Thefunctions weremade available to the internal application throughexplicitcalls to the loader, as depicted in Figure 1.) Userscould also customize their environment byadding orredefining user-interface objects (i.e., menus, panels,andbuttons) andcreating newcommands. The availablefunctions included display-eontrol routines, datastructureaccessroutines, and built-in command-executionroutines. The functions permitted users to:- Obtain accessto the internal database.- Change the user interface byadding buttons, menus,
anddialog boxes.- Retrieve information ongraphics primitives, symbols,
pages, and coordinates, as well as othervariables.However, c i had disadvantages. It only recog
nized a subset ofthe Clanguage; i.e., datastructureswere missing. This led to someawkward coding styles.Forexample, multiple, parallel arrayshad to be usedinstead ofa linked listofdatastructures. Asa result, it
AT&TTECHNICAL JOURNAL • JANUARY/FEBRUARY 1!lY1
wasdifficult to maintain andenhance the code. Althoughc i didprovide users with two elements that weredefined as datastructures, these elements didnot followthe C-Ianguage standard. Moreover, c i was an interpretedlanguage andwas, therefore, considerably slowerthan compiled code.
Advantages of the Incremental loader. The integrationofthe incremental loader provides two main advantages to c i users. First, users now cantakeadvantageofallC-Ianguage features, including datastructures.Second, user functions execute more quickly, becausethe loaderfunctions are compiled. The incrementallylinked (Le., compiled) codeis significantly fasterthaninterpreted code, decreasing execution time by as muchas 96percent. In addition, the memory size was greatlydecreased.
To takeadvantage ofincremental loading, userscreatefunctions outside SCHEMA and, then,issue a 1 inkfunction command at the SCHEMA command prompt.Throughthe incremental loader, SCHEMA addsthe file tothe internal symbol table andupdates the listoffiles andfunctions that are linked. The user canthen executelinked functions simply bytyping the function nameatthe SCHEMA command prompt.
Userscanlistthe functions theyhave linked byexecuting the show functions command at the command prompt. Options permit users to selectallfiles thatare linked, allfunctions that are linked, functions that arelinked within a particular file, or all files andfunctions.Linked files canbe unlinked if theyare nolongerneeded.
The incremental loading ability has become soimportant to SCHEMA users that some user communitiesare now using SCHEMA andthe incremental loaderas aframework overwhich theyare integrating customizeddesign-support systems. Forexample, the Carouselproject uses SCHEMA to offer analog integrated-eircuitdesigners an integrated design environment. Tools inthis environment include design capture, graphics editors, simulators, netlist comparators, andlayout extrac-
tors. In this environment, the internal SCHEMA databasecanbe editedby allthe tools that are incrementally linkedto SCHEMA. Editsbyone toolthen become immediatelyavailable to allthe other tools that share the database.
In addition, incrementally linked Cprograms cancustomize SCHEMA'S user interface. Theycan add highlevel functionality for several schematic entryand designentry tasks, andfordirecting tasks to other applicationprograms, such as simulators, that run concurrently butdo not share the internal database.
Without this incremental loading capability,the interaction between the tools would have to occurthroughdatabase files. That is,whenone database ischanged, each ofthe other tools must resynchronizeits own database. Clearly, this is muchmoretimeconsuming than a directinteraction.
Challenges of Integration. Integrating the loaderinto SCHEMA presentedsomeuncommon challenges.For many years, SCHEMA users had been usingci tolinktheir code. The changeto a full C-Ianguage, incrementally linked environment had to be effected withminimum disturbance to the established user community. Asubstantial amount ofworkwasdoneto maketheconversion as transparentas possible. In general,SCHEMA users should notice little changein the waytheywork. Wherethe existing user functions are syntactically and semantically correctC-Ianguage code,theconversion is trivial.
Discrepancies between e i and standard Clanguagecould causeproblems. For example, e i didnotwarnusers whenit encountered an undeclared variable;it simply assumed the variable wasan integer. Code thattookadvantage ofthese differences had to be corrected.
Another feature of e i allowed users to specifyC-Ianguage codeoutside the boundsofanyfunction.This "start-up" codewasexecuted whenthe file waslinked. To provide the samefunctionality while adheringto conventional C-Ianguage syntax, users encasetheirstart-up codeina function called file_inir. SCHEMA
has been modified to lookforthis function eachtime afile is linked and then execute the function, if present.
Quality Improvements. Userscannow make use ofthe UNIX system tools, lint and ee, to checkthe syntaxandsemantic correctness oftheir code. In addition,theycanuse cin, the C-Ianguage interpreter, to debugthe individual functions. These checksshould resultinhigher quality code. In the SCHEMA user community, theconversion from e i files to standard Clanguage codeuncovered many syntax and semantic errors.For example,oneuser's 750G-line e i module required over80syntactic and semantic corrections to conform to standardClanguage.
Simulation. In the AT&T simulators, MOTI S3 7and MIDAS, the incremental loaderallows users to createand debugC-Ianguage models andto createdrivers andmonitors fora circuit. Wewill describe the enhancementsto MIDAS as an example.
MIDAS provides a set offunction calls that permitcommunication between a C-Ianguage model andthesimulator. Forexample, a model canuse calls to accessand reportinformation abouta simulated component,control simulation activity, or begin special actions during power-up. (These MIDAs-provided functions wouldbe the functions that are made available to the incremental application throughexplicit calls to the loader, asdepicted in Figure 1.) Both circuit elements andexternalsystems (i.e., buses,memory, etc.) canbe simulatedthroughCdanguage models.
Clanguage models are functions written in theClanguage that describe the logical behavior ofcomponents. The models are linked with the simulator'sobject codeto createa customized run-time simulatorthat calls the modeled routines as needed. BecauseC-Ianguage models give users a way to model circuitbehavior ina familiar language, theyhave helped popularize model writing.
Panel 2 presentsa C'language model for a simpleAND gate. It shows two structuresthat are passed as
AT&T TECHNICAL JOURNAL.JANUARY/FEBRUARY 1991
107
108
Panel 2. C-Language Model for an AND Gate
tinclude <stdio.h>typedef struct {
int num, a, b;} XXAND2I;
typedef struct {int num, z;
} XXAND20;
intxxand2(in, out)register XXAND21 *in;XXAND20 *out;{
/* test inputs and outputs */if (in->num != (sizeof(XXAND2I) / sizeof(int)) - 1) {
fprintf(stderr,II \n \ tERROR: ETYPE () - wrong # of inputs \n ") ;
return (-1) ;}if (out->num != (sizeof(XXAND20) / sizeof(int)) - 1) {
fprintf (stderr,"\n\tERROR: ETYPE () - wrong t of outputs\n");
return(-2);}/* AND == set the result to the AND of the two inputs */out->z = «in->a) == 0 I I (in->b) == 0) ? 0
: «(in->a) == 1 && (in->b) == 1) ? 1 : 2);return(O);
parameters and correspond to the inputsand outputsofthe gate. First, the Clanguage model checksthe numberofinputs and outputs. Next, it performs a logical ANDofthe inputs. Thus, it sets the outputto:- A'1' if both inputsare '1'- A'0' if either inputis '0'- A'2' if the inputsare neither '0' nor '1'.
AT&TTECHNICAL JOURNAL • JANUARYIFEBRUARY 1991
Cfanguage models have been usedwith thesimulators for sometime, despite a variety ofproblems.For example, the models had to be linked directly to thesimulator's object code,which produced a newexecutablefile foreach set ofmodels linked. Thus, to simulatetwo versions ofthe circuit, the developer builttwo completeversions ofthe simulator. This wasa tremendous
waste ofdisk space, becauseeach designerhad a copyofthe simulator for each set ofmodels that neededto besimulated. Corrections to a model requiredthe recompilation ofthe bad section ofcode,plusa relinkoftheentire simulator. This practice directly affects designerproductivity and,therefore, designschedules.
The incremental loaderdirectly addresses theseproductivity issues.Ratherthan linking the simulatorand models to create a newsimulator, the user incrementally linksthe model intothe simulator at run time. Thesimulator's executable file remainsunchanged. If themodel has an error, the designersimply relinks thecorrectedmodel on topofthe oldmodel, replacing theoldmodel with the correctedone.The alternative wouldbe to exit the tool, remove the bad executable code,relinkthe whole simulator, and restart the simulator.
The development ofnewC-Ianguage modelsillustrates another aspectofthe benefits of incrementalloading. Currently, MIDAS linksto the standard,Clanguage model library. Whena newmodel is added,the model is incrementally linked intoMIDAS andtested.Duringthe debugging process, the newmodel canbealteredand relinked without affecting previously linkedClanguage models. Otherwise, each change to aCfanguage model would requirea recompilation andrelinkofallClanguage models, a time-consuming task.
Userscan alsowrite functions that serveasdrivers and monitors for the circuit, linkthose functionsto the program, and observethe result.The driver functiongenerates the inputvectorsfor the circuit, while themonitor function validates or records the outputsofthecircuit. Asimple example is a driverfunction that providesthe clock to drive a counter.
ConclusionIncremental loading allows users to customize
a CAD toolto suit their needs. It increasestheir productivity by helping them to customize the interface, extendthe command set, andwriteapplication programs. Simulatorusers can take advantage ofthe incremental loader
to write and debugC-Ianguage models quickly. Loadingand executing functions dynamically improves user efficiency and, therefore, affects the timeto marketfordesigns.
AcknowledgmentsWethank Healfdene Goguen andJohn Puttress
for the development and continued support ofthe c inincremental loader. Weare indebted to Helen Angelina,DonChristman, and Lincoln Fajardo for the conceptionand prototype ofthe replacement of c i with the incremental loader.
We'dliketo extendour appreciation to LeeDeschler, Jon Eiseman, JudyMiller, andSuthatNarakornpichit forbeingamong the first to integrate theloaderintotheir tools. Theyprovided valuable feedback,which led to improvements in the loaderinterface andthe addition ofimportant features.
Weespecially thank Carl Seaquist for his energy,time, and interest, which madethis project possible.
Finally, wethank Lisa Kowalski, Basant Chawla,JohnTauke,andJames Coplien for useful comments onprevious versions ofthis paper.
References1. W.A. Burling, B.]. B.Lax, L. A. O'Neill, andT. P.Pennino, "Pro
duct Design and Introduction Support Systems," AT&TTechnicaljournal, Vol. 66,No.5, September/October 1987, pp.21-38.
2. ].]. Puttressand H. H.Goguen, "Incremental Loading ofSubroutinesat Runtime," AT&T Bell Laboratories, Murray Hill, NewJersey,April 9, 1986.
3. T.]. Kowalski, Y.M. Huang, and H.V. Diamantidis, "An InterpretiveEnvironment forOperations Support Systems," AT&TTechnicaljournal, Vol. 69, No.2, March/April 1990, pp.42-51.
4. UNIX Time-Sharing System Programmer's Manual, Research Version, EighthEdition, Vol. 1,M.D.McIlroy (ed.) , AT&T BellLaboratories, MurrayHill, NewJersey, February 1985.
5. A. K. Bose,B.R. Chawla, and H. K. Gummel, "AVLSI Design System,"Proceedings ofthe 1983IEEE International Symposium onCircuits andSystems, Vol. 2,Newport Beach, California, May 2through 4,1983, IEEE, NewYork, May 1983, pp.734-737.
6. ]. Bierbauer, ]. A. Eiseman, F.A. Fazal, and]. ]. Kulikowski, "System Simulation withMIDAS," AT&TTechnical journal, Vol. 70,
AT&TTECHNICAL JOURNAL • JANUARY/FEBRUARY 1991
109
110
No. 1,January/February 1991, pp.36-51.7. R. Beale, R. Chadha, C.-F. Chen,A Prosser,and K.-M. Tham,
"Design Methodology andSimulation Toolfor Mixed AnalogDigital IntegratedCircuits," 1990IEEE International SymposiumonCircuits andSystems, Vol. 2, NewOrleans, Louisiana, May1through3,1990, IEEE, NewYork, 1990, pp. 1351-1355.
Biographies (continued)how programmer productivity can be increased. His interestsalso include artificial intelligence, operating systems,computer-aided design, text-processing environments, andreal-time systems. Mr. Kowalski joined the company in 1978.He has a 8.S.E. from the University of Michigan (Ann Arbor)and holds an M.S.E.E. and Ph.D. in electrical engineering
AT&T TECHNICAL JOURNAL.JANUARYIFEBRUARY 1991
from Carnegie-Mellon University (Pittsburgh, Pennsylvania).Mr. Smull is currently responsible for SCHEMA, AT&T's designcapture tool. His interests include programming environments, human factors, and computer graphics. Mr. Smulljoined the company in 1982. He has a 8.5. in computer science from Pennsylvania State University (University Park) andan M.S.£. from the University of Texas (El Paso).
(Manuscript received October 17, 1990)
Recommended