Integrated photonics design success is built on a software foundation
PIC Magazine spoke with Luceda Photonics to explore what sets the company’s approach to design automation apart from other software being used to create next-generation photonic integrated circuits (PICs). What began as a collaborative effort between Ghent University and imec researchers to support the design of large IC masks in 2002 has expanded to become a global system to speed PIC design cycle times, eliminate errors and simulate performance without costly prototyping.
Photonic integration is already bringing the benefits of light-speed data transfer to industries such as datacom and telecom, with new generations of PICs being created for applications that run the gamut from automotive to biomedical to quantum applications and AI. While electronic design automation (EDA) today speeds PIC design, available programmes differ greatly in power and scope; platform choices often come down to designer preference or a company-wide commitment to particular software platforms.
Luceda Photonics developed an environment called IPKISS that allows companies and researchers to use software-development best practices in photonics circuit design. This approach is seen as a means to improve design flows, allow for more automation, engender better teamwork and save companies and researchers from needless time-crunches right before a deadline.
While all designers appreciate that ‘EDA’ stands for electronic design automation, in practice the automation part of the acronym is often forgotten, remarked Luceda Photonics co-founder, Martin Fiers. Working with a global customer base has shown Fiers that at many companies, manual processes still dominate photonic design workflows, and coordination within teams can be a challenge. This is why Luceda Photonics first built its IPKISS software 15 years ago, a system today that is used by research groups and universities globally as well as manufacturers and fabless photonic design companies of all sizes.
An essential quality that distinguishes IPKISS from other design software suites is that users build circuits in a code-based environment instead of a graphical interface based approach favored by others that typically rely on linking blocks to manually construct circuit layouts. Using IPKISS, designers instead write scripts that generate designs of photonic integrated circuits. IPKISS essentially replaces point-and-click software with lines of code. This process allows designers to take best practices and techniques from software development, such as version control, continuous integration and continuous delivery (CI/CD), and apply them to photonics.
“We use code as a source of truth instead of binary data which is typically done today in CAD/EDA environments. Binary data is hard to manage since large file sizes make it difficult to share and as design versions and iterations grow, the data is hard to compare and store. On the other hand, code is human readable, easy to compare and is easier to collaborate on and share,” stated Fiers.
As Fiers further explained, the use of code became the company’s ‘go-to’ solution since it was based on the time-tested engineering concept that duplicating information in the design process is dangerous to achieving the goal of an error-free design because at some point a designer will make an error, such as copy-pasting the wrong component, or forgetting to modify a parameter in one place. But in IPKISS, the designer can define parametric cells (PCells) where all design information is integrated into one place. IPKISS then handles the transition between the different steps within a design flow, making sure that the necessary information is available and correct.
Advantages of code-driven design
• Version control: better knowledge sharing, teamwork and product quality.
• Practical automation: remove all manual steps in a design workflow that can be error-prone and time-consuming to reproduce manually.
• Continuous integration / Continuous delivery (CI/CD): better time management and predictability
Version control & teamwork
Luceda Photonics believes its code-based approach also has advantages in terms of teamwork; primarily in that code allows circuit design to benefit from version-control systems typically used in software-development. The most commonly used system is called ‘Git,’ which is accessed through collaboration platforms such as GitHub, GitLab or Bitbucket.
Git provides version control and an efficient approach to branching and merging histories of changes. A collaboration platform adds key features: issues tracking, pull requests (code review before merging), release management and automation (CI/CD). Together they enable teamwork.
Issue tracking is used to communicate about tasks to be done. Each designer has her/his own Git repository to work with. The designer makes changes to the code base, committing each of them to a branch. When ready, the designer opens a pull request on the collaboration platform. In a pull review, participants can then read the proposed changes, verify them, propose corrections and enhancements. This process spreads knowledge and promotes strong interactions within the team.
“People can learn from others and show what they are doing", says Sébastien Lardenois, Team Lead, imec Silicon Photonics Devices. "It brings teamwork into the design phase. Instead of just sharing workspace with design team members, you really work and collaborate on the same project. At the same time, you’re building re-usable knowledge. Code from previous projects can be used as starting point for a new one. It’s also a great tool for training new team-members.”
Lardenois explained some additional advantages of a code based approach include reducing the time to go through a design cycle since repeating tasks are easier to capture, and that redoing a design becomes a matter of changing a value within the code, which is as easy as pressing a button.
“The idea is to reduce errors, improve reproducibility and avoid expensive re-spins,” he said. “Imagine having a system in which you can change the position of a device on a chip, rebuild sections or rebuild an entire mask that needs to be taped-out and also check for DRC errors, rerun circuit simulations, change the geometry of a device and then rerun the full physical simulation. The designer can also rebuild compact models based on the resulting data and validate new models. All this is possible using a code-driven design flow,” Lardenois said.
Isn’t using a GUI easier than coding?
Using a visual approach is easier to a degree, but it also has downsides, remarked Fiers, offering a common issue they see in different approaches to EDA as an example. “GUI based design makes it harder to reuse parts of the drawing and keep track of why designers made certain choices. In a code-first approach, on the other hand, designers can easily re-use elements from previous design runs and automate sub-tasks by scripting. This can lead to large productivity boosts,” Fiers said. Coding enables designs from previous projects to serve as the building blocks of subsequent projects. Designs that are common to multiple projects can be stored into separate libraries, which are also version controlled. This library-centric approach, where designs are reused throughout different projects, is a key component of IPKISS. “Knowledge that is built up in one design project easily propagates to other projects through the use of design libraries, including improvements and bug fixes,” Fiers said. Once version-controlled libraries and designs are in place within IPKISS, users can start to automate the design process, which saves time, creates efficiencies and reduces errors.
Practical automation
In a typical design project, there are many subtasks that can be automated. Instead of manually repeating certain steps over and over again, automation scripts help to improve reproducibility, save time, and internalize the knowledge of the design. IPKISS is written in Python, the programming language of choice across engineering and scientific communities that makes it relatively easy to create scripts designed to automate certain subtasks.
Another benefit of programming based design is a quality common to software development: continuous integration / continuous delivery (CI/CD). In the context of PIC design, this means to continuously and automatically verify designs. This includes very basic checks, like seeing whether the syntax of the code is correct. But it also means that the circuits themselves can be regularly verified. The physical verification, like DRC and LVS, can happen every time a change is made.
The CI/CD advantage is an important key for imec. "By placing the verification early in the flow you flatten the effort needed for a release,” said Lardenois. "You avoid a peak at the end of a project. If you need to do verification manually, you typically defer the verification to the end of the flow, often at the moment of tape-out. This means that you only see problems very late in the process. But at that point making changes is very expensive because you have a complex object to modify and little time to do it. Continuous verification also carries project management advantages. “You know where you are in the design process,” said Lardenois, “Your project is in a known state, which facilitates predictions of when you will be ready.”
Learning curve
Any new type of work process has its challenges. Fiers acknowledged that switching to a script-based design flow has a steeper learning curve, and teams will need to adopt skills like coding and using Git.
“This seems like a big step, but it is manageable. An important thing to remember if switching from one system to another is that you can do this step-by-step. You don't need to implement a full flow before you see benefits. You can start small, for example by introducing a version-control system and start using code-review between team members. Over time, based on your learnings, you can then introduce new concepts such as automated tests, mask post-processing, and verification, all the way until a real tape-out."
An important aspect of choosing Luceda Photonics is the company’s concerted dedication to working with customers to achieve full value from their design investment.
“Customers of Luceda Photonics are never alone in transitioning to our software; we work with our customers to improve their user experience. We provide guidance in many ways. For customers entering the world of photonics, some of whom may be coming from free-space optics, they come to us seeking guidance to navigate the photonics world. We help them get to know all the aspects of IPKISS including setting up their design projects in the best way possible. We provide onboarding trainings for free to every customer. In addition we often have extra support meetings or training meetings with customers when a need arises. Our support channel is complimentary with the software license and we are very proud to provide continuous support to our customers,” Fiers remarked.
Productivity and predictability
When correctly implemented, a software-based approach for designing PICs saves large amounts of time and resources. The photonics industry is undeniably maturing. This means that while time-to-market remains important, PIC design managers also need to consider time-to-market-share, which is getting more important. While a design team’s genius and innovative capacities may bring a product first to market, it is the design flow that will make any design sustainable with results that are also readily repeatable. Design platforms like Luceda’s IPKISS enable knowledge sharing, team learning, and automation through the use of validated building blocks. The design flow is kept transparent through continuous integration and delivery, qualities that can help guarantee long-term design success.
