Carte™ Programming Environment
SRC’s Carte Programming Environment takes applications written in Fortran and/or C and seamlessly integrates the computational capability of MAP® processors and microprocessors into a single application executable code. This Unified Executable eliminates significant complexity for the programmer by:
- Managing the flow between the MAP and microprocessor portions of the system such that the most appropriate resource is applied to the code at the optimal time.
- Managing the actual layout of the logic in the MAP. Until today, users wanting to harness Direct Execution Logic needed to know hardware design to help them manage the complexity of these resources.
- Allowing the programmer to explicitly define concurrent execution of code within a microprocessor/Direct Execution Logic processor while providing explicit data management within the memory hierarchy. The programmer is given the ultimate access to low-level hardware capabilities; definition and creation of processor hardware from within high-level programming languages. This level of control over compute and memory access allows programmers to achieve higher computational performance.
MAP Compiler
Although Carte comprises several components, the major software component is SRC's MAP compiler which is available as a MAP/Fortran compiler or a MAP/C compiler. The SRC MAP compiler creates a Unified Executable optimized to run appropriately in both microprocessors and MAP processors. The compilation system extracts the maximum parallelism from the code and generates pipelined hardware logic that is instantiated in the MAP. The compiler generates all the required interface code to manage the movement of data to and from the MAP and to coordinate the microprocessor with the logic running in the MAP.
Libraries
All of the required interface and management code is contained in Carte’s run-time libraries. Tools such as the MAP driver, the SNAP™ driver and the associated libraries are provided with Carte, allowing the algorithm developer to easily design and implement the algorithm in a fully integrated system.
Code Development, Debugging and Optimizing Capabilities
Carte also provides users with the ability to emulate and simulate compiled code. This speeds program development and allows a developer to use standard debugging tools at the algorithm level.
In addition to its code development and debugging tools, Carte also provides optimizing capability by means of parallelism, memory management techniques and Application Specific Functional (ASF) units.
Powerful Economical Development Environment for the
Series I MAP
With the introduction of the Series I MAP, many of the memory access and
interconnect options that Carte supports in other SRC systems are not
applicable. To address this reduced feature requirement and desired lower price
point, SRC has introduced iCarte.
iCarte has the same familiar look and feel of standard Carte but without support
for features not present in the systems using the Series I MAP such as multiple
User Logic chips and shared common memory. Both ANSI C and Fortran are supported
in an identical fashion as with standard Carte.
The standard Carte debug environment remains including the ability to target
other SRC MAP types, such as the Series H, for comparison and evaluation
purposes. This allows a programmer to write an application and then see how its
performance on the Series I compares to that same code’s performance on any
other SRC MAP without actually having access to those other MAP types.
Priced at just $5,000 for a perpetual development license, iCarte provides a
very powerful, economical easy-to-use ANSI standard language development
environment for the Series I MAP.