Chapter 9: Conclusion

The objective of this concluding chapter is to provide an overview of the Agents system, to analyse some useful development opportunities in its design and to offer some suggestions about how future research on the topics related to it could be carried out.

9.1 Overview

The three key issues affecting the design of the Agents system were flexibility, innovation and speed. It was decided that the first two, flexibility and innovation, were going to be more important. There was an emphasis on a flexible solution, that could offer more freedom of design, by using recent new ideas, such as software components.

9.1.1 Flexibility

In the Agents system, flexibility is mainly delivered to the user as a richer set of layout options. As shown in chapter 8, the system can generate layout for BICMOS and CMOS circuits, can mix small analogue cells with a digital design and has fabrication process independence. The system can, as well, tackle unusual layouts, such as the ones with central power lines.

Flexibility at performance level was obtained using scalability, the quality of a program to adapt to the resources of the hardware it is running on. As table 8.1 showed, the Agents system can run using just the resources of a single PC computer, or it can run on powerful workstations. It can run on just one machine, for example a Sun Sparc workstation, or, if more power is made available to it by adding more machines through a network, the program can use the extra resources to improve performance proportionally. This scalability was achieved mainly by the use of the client-server model.

Portability measures how easy it is to port a program to a new environment. Currently, Agents runs on two different computer architectures: the Intel 386 family (486 and Pentiun machines) and the Sparc family (Sun and Axil workstations). And on two different flavours of Unix: the System V family (Linux and Solaris 2.X) and the BSD family (SunOs 4.X). Portability and the use of a combination of client-server communication with a standard circuit description language (EDIF) makes the program easy to integrate to other systems.

9.1.2 Innovation

The main conceptual innovation brought into the Agents system is the software agents concept: the division of the system into software components that can work independently, but together, to solve cooperatively a problem.

The Agents system shows that this idea works at the system level, in the four servers, and at a program level, where the agent objects are used. Agents shows that complex behaviour can come from the interaction of simple entities working together. In addition, the system successfully uses the genetic algorithm to generate layout.

9.1.3 Speed

The Agents system did not aim for high speed and did not attempt to be particularly fast. Flexibility and innovation were considered more important issues than speed during the program's design.

Despite not being designed to be fast, Agents is not a particularly slow system. It has been shown that if speed is really an issue for a particular application, the program can scale up to allow speed increases by using more computer power. More hardware can buy extra speed.

9.2 Development opportunities

The Agents system can not be considered a finished application as yet. It is still at an alpha version stage. There is work to be done to get the program to a commercial level. There are, as well, points that offer opportunities for further development:

During the development of Agents, to reduce the program's complexity, and thus make it manageable by just one coder, some compromises had to be made. This affected especially the program's speed. The routines that were simplified in this way should now be revised and faster versions adopted.
The bugs still present in the program have to be fixed. Parallel programs are more difficult to debug them serial ones. The use of the genetic algorithm, with it random components, makes things even worse. No large program, however, is bug free, but an acceptable level has to be achieved.
The genetic algorithm is very susceptible to its parameters, such as cross-over and mutation rates. These parameters were adjusted, but a finer adjustment may be necessary to improve performance a bit further.
The version of EDIF used by the program is rather old, it should be upgraded at least to the popular version 2.0.0. The servers should be upgraded to use full KQML (Knowledge Query and Manipulation Language) language and not just a subset of it.

Apart from these changes, the system has to be used. That is the best way of finding bugs and getting feedback from the users for new improvements. These changes do not affect the basic structure of the program. They are expected in a system moving from alpha version to a full commercial version.

9.3 Future research

The development of the Agents system sparks a number of questions. Software agents is a new but booming field, as many companies try to develop it, and many important questions will have to be solved. Software agents usually rely on parallel systems (distributed or not) and, even more important, parallel systems are becoming main stream in the computer market. These fields are bound to be hot areas of research in the next few years.

Connected specifically to the Agents system there are some topics that should be of interest to the future development of layout generation programs, as well as to researchers studying software agents or parallel distributed systems:

The Agents system is not able to learn. Any future improvement in its abilities to layout circuits has to be achieved by manually adding new rules to it. A number of schemes for learning could be tried out.
The agent objects, used by Agents system, have a good degree of fine granularity parallelism in them. They are not complex enough and too small to justify running as servers, but many of them would be ideal to run as threads (small lightweight processes that share the same area of memory) on a parallel machine. The type of parallel machine best suited to run this kind of program, a machine with many processors running a symmetrical multiprocessor operational system (such as Solaris 2.X or Windows NT) will get more and more common in the near future. This makes this kind of development very interesting.
New algorithms for search, like the bidirectional search algorithm [75] and other specific parallel algorithms could be tried. Another option is to use simpler engines to search the layout possibilities. They would be modelled after the artificial ants constructed by Jefferson from UCLA [76]. In this program, small finite state machines (the ants) learn how to successfully traverse a poor marked trail using genetic algorithm. The better an ant can negotiate its way through the trail, the more it reproduces. The ant's chromosome hold information about how each stimulus makes the ant change its behaviour and thus negotiates each step of the trail. A similar finite state machine could be used to negotiate which paths the router tries first, based on the environment around them.
Integrating and debugging parallel systems is a field of research on its own. The Agents development would profit very much of any development in this area. The system already uses some structures to prevent bugs. These structures test the data consistency in the beginning of many routines. They do not affect the programs performance, because they are not compiled into the final version, a compile flag takes them out. For this reason, they can do quite a lot of testing to ensure data integrity and that bugs are found as near as possible to the place where they are being generated. This kind of debugging techniques, added to servers that monitor other servers behaviour, such as the two auxiliary servers used by Agents (the Debug and the Graphic servers), could greatly help to tackle integration and debugging of parallel systems.
The philosophy that competence should emerge out of the collective behaviour of a large number of relatively simple entities is used in many other behaviour-based systems, such as Mobots [38]. But how to discover which simple behaviours will add up to make the complex behaviour one is after? The current method is trial and error, but a better one could be found.

The Agents system has demonstrated that a distributed system based on software agents working together can generate flexible layout. It has shown that a program like this can exploit the new trends in mainstream computer hardware, such as distributed processing, and, finally, it poses many new questions that should lead to interesting research in the future.

9.1 - Overview
9.1.1 - Flexibility
9.1.2 - Innovation
9.1.3 - Speed
9.2 - Development opportunities
9.3 - Future research

 Next             Contents        Talk to me