Earlier this month, Catalytic announced that it had acquired Celoxica’s electronic system level (ESL) business. Catalytic is a start-up company that sells a MATLAB-to-C translation tool used to accelerate simulation and implementation of signal processing algorithms. Celoxica, on the other hand, developed a C-to-FPGA translation tool for creating hardware implementations of computationally demanding algorithms. Put the two tools together, and what do you get?
Potentially, you get seamless MATLAB-to-FPGA translation, within a single development environment. This could be a neat trick—if Catalytic can overcome a few hurdles.
In recent years a number of companies have fielded C-to-FPGA tools; in addition to Celoxica, such companies include Mentor Graphics, Impulse Accelerated Technologies, and several others. Then there’s Accelchip (acquired by Xilinx), which developed a MATLAB-to-FPGA translation tool. Typically, these companies have either promoted their tools to hardware engineers, with the promise of improved productivity from working in C rather than HDL, or they’ve promoted them to algorithm and software engineers as a way to create hardware implementations of performance-critical functions without having to really do hardware design. As usual when trying to convince people to do things differently, it has been challenging to get these tools and methodologies widely adopted—which may be why Celoxica decided to put its ESL business up for sale and re-focus on so-called “high-performance computing” applications, such as gene sequencing.
But Catalytic saw Celoxica’s decision to sell the ESL business as an opportunity, and jumped on it. Catalytic’s position is that the idea of a C-to-FPGA synthesis tool (and by extension, a MATLAB-to-FPGA tool) has always been a good one, but only recently have the combination of more-demanding algorithms, increasing time-to-market pressures, and bigger FPGA capacities created the necessary synergy for success. Catalytic has already gained some traction with its MATLAB-to-C tool (and we should note here that Mathworks has its own MATLAB to C tool). From Catalytic’s perspective, it makes sense to push it a step further and go all the way to an FPGA. By doing so, Catalytic hopes to attract a wider pool of customers looking for fast prototyping, simulation, and implementation.
The company has not yet announced how the two tools will interact or when we can expect to see an integrated MATLAB-to-FPGA tool, but there are likely to be some technical challenges that need to be addressed first. As with all translators, one consideration will be the efficiency of the generated implementations. Going through multiple translation stages (MATLAB to C, C to HDL) could make it difficult to achieve efficient results. Often, the output quality of a translation tool depends on whether the input code is written in a way that caters to the translator’s strengths and weaknesses. So, for example, you would want to write your C code for Celoxica’s C-to-FPGA translator in a way that enables it to generate more efficient FPGA implementations. This means that Catalytic’s front-end MATLAB-to-C converter may need to be tweaked to produce C code that is tailored for the subsequent C-to-FPGA step.
Another challenge that arises with some translation tools is that their output can be difficult to debug. Say you implement your algorithm in MATLAB, run it through the translator, and end up with a dysfunctional (or deeply inefficient) FPGA implementation. With two translators chained together, figuring what went wrong (and where) could be a challenging process.
Another interesting question is how designs will be migrated from floating-point to fixed-point in Catalytic’s future MATLAB-to-FPGA flow. Most digital signal processing algorithms are initially developed using floating-point data types for ease of development, but are ultimately implemented using fixed-point data types for minimum hardware cost and power consumption. In a typical digital signal processing software design flow, the algorithm designer creates a floating-point implementation of an algorithm in MATLAB, then creates (either manually or using a translation tool) a floating-point C implementation, then converts this to a fixed-point C implementation—which is then compiled on a processor and optimized as necessary. If Catalytic fields a MATLAB-to-FPGA translator, it’s not clear where (or if) the float-to-fixed migration would occur. However, as part of its earlier MATLAB-to-C tool development work, Catalytic invested significant effort in developing tools and libraries to support fixed-point MATLAB implementations. It may be Catalytic’s intention that the designer will either work in fixed-point from the outset, or do the conversion in the MATLAB domain. By way of comparison, Xilinx’s MATLAB-to-FPGA tool includes automatic floating-point to fixed-point conversion, but in our experience, float-to-fixed migration requires careful analysis and sometimes, algorithm restructuring. It’s not particularly well-suited to a push-button approach.
Clearly, Catalytic faces significant challenges in bringing an effective MATLAB-to-FPGA tool to market. The company is betting (to the tune of $3 million of its precious start-up capital) that it can overcome these challenges and field a product that will attract a significant number of engineers. Even if Catalytic cannot completely overcome the technical challenges, there may well be many customers who will settle for reduced implementation efficiency and additional debug effort in exchange for faster simulations and faster migration to an FPGA. And Catalytic is right; algorithms are getting more complicated all the time, and manual translation is becoming more painful.
Add new comment