Efficient parallel PCB design can be accomplished by using the newly developed software technology. This new technology enables multiple designers, multiple processes, and different kinds of tools to work simultaneously on the same design database and significantly increases design productivity.
Unlike the traditional approach of dividing a design into several parts and completing each part independently, this new technique can create parallel processes on a common database and automatically synchronize changes and resolve possible conflicts between the processes. This is a first in the EDA industry.
Since the widespread adoption of CAD in PCB design in the 1990s, the manufacturing field has been continuously increasing design productivity through automation and process optimization. Unfortunately, as circuit-design software technology continues to innovate, so does the need to support new signals, components, or board-level manufacturing techniques, the overall design time is barely shortened (or longer).
Without a fundamental change in design methodology, software will continue to be a follower of hardware technology rather than a leader on the curve. Concurrent engineering technology with multiple engineers working on the same design has always been a magic weapon for productivity breakthroughs. The traditional divide-and-conquer approach divides the design into parts and assigns them to engineers, eventually linking the parts together and resolving all conflicts either through coercion (automatic decisions based on predefined rules) or ingenuity (having engineers resolve conflicts individually).
This method is quite effective for schematic design of circuits, because it can directly split the design into modules and pages based on function. However, this approach still requires considerable manual work to resolve the interconnection problems between modules, such as signal name conflicts, component omissions, and so on. As long as designers can't see what each other is doing, these mistakes are likely to happen.
The best flexibility and productivity comes from a parallel design approach that allows multiple designers to work on the same design at the same time, to see what other designers are editing, and to automatically manage potential conflicts in real time.
Parallel design architecture
The new parallel design technique requires a design process manager (server) and multiple design clients running in a network environment. The main job of the server software is to receive update requests from each client, check the requests to make sure there are no design rules violated, and then synchronize each client based on the update content.
Each client must have its own dedicated processor and memory. The new parallel design architecture also assumes that the communication system can support the minimum bandwidth and maximum latency required to efficiently exchange information between clients and servers in real time. Each client sees the entire design and observes other clients' edits as the server processes them. Design databases to allow storage anywhere on the network.
This parallel design architecture allows multiple designers to work on the same design at the same time without splitting the design logically or in any other way. This is a truly real-time cooperative design environment where all the issues associated with splitting boundaries and managing data integrity during split-join operations do not arise.
Since multiple designers can work on the same design in parallel without any limitations, the overall design cycle can be significantly shortened.
Each design has an associated design team, and only members of the team are allowed to access the design data. Any team member can start a design meeting on both the server and a single client. Other clients can participate in the meeting at any time.
The design is initially loaded on the server and is initialized and synchronized when the client joins the meeting and automatically downloads the current state of the server design into the client's memory. Once the client joins the design meeting, it can edit the design using the standard editing tools available in the application.
An edit event is a separate activity initiated by the client and sent to the server as an update request. For example, moving A device from point A to point B constitutes an editing event that begins with selecting the device and ends with a mouse click (or equivalent input) indicating the new position. The edit event is sent to the server as a transaction that describes what is to be removed and what is to be added.
Each client-generated edit event must perform a local design rule check (DRC) before being sent to the server, then prioritize the edit request and queue the input message on a first-in-first-out basis. The server receives the edit request, integrates it into the design database, and then executes DRC. If no problems are found, the edit request is approved and sent to all clients through the output message queue for synchronization to the client's internal core database.
Most of the computing time is spent on the local client. On the client side, target objects are added, edited, and deleted, while all the automation associated with those edits (such as push, squeeze, and smooth) is performed. The load on the server is lighter than that on the client and therefore does not affect system performance. Tests on this environment show that the server is very responsive and does not slow down the client.