Many companies understand that they cannot push the efficiency of their products enough with process technology gains only. This is a conclusion from the strong interest we are seeing in our Custom Compute offering. Are you ready to explore a custom core for your next SoC?
Some IP providers are proposing solutions to the previous inflexibility of processor IP, to start unlocking some of the benefits of customization. In this blog, I summarize the different propositions and assess the value and benefits they offer. Not all of them will get Custom Compute right. Let’s see why.
Different paths to customized cores
A processor that is customized to the application performs significantly better for targeted software workloads. Here “significant” means efficiency gains of the order of 1,000% or even 10,000% for some algorithms. This is not something that is possible by pushing the tools a bit further or tuning a few parameters. No, it requires modifications to the processor.
We have identified, and categorized, solutions that we have seen presented as offering the ability to customize a core:
- Full DIY – Open-source RTL code of a CPU, hacked by hand
- Limited DIY – Hand-written RTL connected to a fixed CPU through a pre-defined interface
- Automated DIY – A version of the previous, where a few tools help sporadically
- Service by IP vendor – When the IP vendor modifies the IP for a customer
- Full customization solution – Integrated methodology, tools, and IP to automate Custom Compute
On the surface, all these solutions try to tackle the same problem, but it is necessary to understand what you gain and lose with each approach.
Comparing all 5 approaches to customized cores
To compare these different solutions, I have mapped them in the graph below, using the following axes:
- Independence – how much does the solution rely on the boundaries set by the IP providers, or on their priorities
- Efficiency – how fast can the design team converge to a working solution, how optimal is the result in the application, and how easy is it to use
DIY solutions rank low in efficiency
All DIY solutions are inherently less efficient, because they require a long time to develop, but also because the lack of automation prevents the team from trying multiple options to find the best optimizations. Designing a set of custom instructions entirely by hand takes so long that there is usually no time to iterate and improve. To do better would require building models and simulating them, which means further costs and design time, and the risk that models don’t match the design.
Your IP vendor can compensate… to some extent
IP vendors can partially compensate for this lack of efficiency by doing your modifications themselves, because they know the IP and can reuse their verification environment to speed up development. However, they suffer from the same inability to iterate fast to converge to an optimal design.
Do more to keep your secrets!
A vendor’s customization service forces their customers to disclose their “secret ingredients”, in addition to imposing their choice of priorities and workload constraints.
Design teams can gain independence by designing the customization themselves, and here the ability to modify everything in the processor leads to the best capability to innovate independently.
Additional elements come into play. Changes to a processor always introduce the risk of hard-to-detect bugs, especially if the original processor is not perfectly verified, which often happens with open-source based solutions. This is usually mitigated with good test environments and best design practices, but even DIY solutions from a reputable IP vendor generally do not come with a verification solution.
If your team doesn’t implement the modifications themselves, they also run the risk of misunderstanding or bad specification of the need, in addition to the challenge of controlling the quality and timely delivery of the custom processor.
The solution? Automation
A fully automated solution, based on a high-level language and tools, enables both efficiency and independence. IP cores that have been developed with customizability in mind are easier to modify. The right tools can then generate simulation models, a compiler, a debugger, and even the RTL of the CPU. If you change a few lines of code to add a new instruction, all those are re-generated in a few minutes, and you are ready to see the effect of your modifications on the performance of your application.
It is then easy to iterate quickly and get to an optimal result for your application to unlock the real value of Custom Compute. You might have guessed it already, but automation is the approach we have chosen. In fact, we provide the right tools mentioned above.
It is tempting to claim that DIY is Custom Compute, but it takes much more to have an efficient solution that enables you to keep your secret know-how and get to an optimal processor for your application. We have been dedicated to Custom Compute for nearly 10 years and make it a reality accessible to everyone.