Choice of Language:
Most simulation tools are based on their own language, grammar, and syntax, to support
the fundamental functions of control-branching, evaluation and assignment of state-variables,
and I/O. (Can be done with any true programming language.)
This negatively impacts:
- Cost,
- Training,
- Portability,
- Flexibility,
- Efficiency,
- Openness / Integration
Choosing a standard language such as C is advantageous because:
- Avoids our need to develop, support, and maintain
unique parsers, compilers, optimizers, debuggers, and general
development environment for a custom language.
Or to port it to the variety of platforms.
This is one of the most significant costs or investments in most tools.
(The costs to re-invent another compiler/optimizer/debugger/etc..)
- Majority of platforms already support C-language, so
porting / proliferation comes to us for free. Highly portable.
- Training - C/C++ is the most popular language. (Has been for years,
trends continue to grow. New language developments such as Java are C-based.)
By far the largest
majority of staff and recruits already have knowledge and experience
in C. No need to train staff for a new one-shot language.
(Staff can re-use their C-skills on many things.)
- Natural link to existing applications, models, software.
Anything that can be called or done from C can be done in CSIM.
Supports:
- Integration, Hardware/Software co-design,
Application or control code developed within a CSIM model
can be simply lifted and compiled on your embedded processor
for your target application with little manual manipulation.
No language translation needed.
- Multi-level interaction/design/development.
- C nicely supports highly abstract modeling, such as purely mathematical
or functional, and stochastic or analytical modeling, while
also capably supporting low-level detailed digital
design with its standard built-in bit-level operators.
(Even VHDL does not have that!)
- Significant application libraries exist and are freely available to
the CSIM user. For example, graphical, mathematical, analytical
routines and software is available on the world-wide-web from
universities and government. For example, in the mathematical domain,
BLAS-I,II,III, EIG-PACK, LIN-PACK, LA-PACK, various DSP libs,
IMSL, Numerical Recipes, Image processing GIMP, etc..
CSIM is just another package that adds-to, (or multiplies), the
value of R&D that already exists and continues to grow
(critical mass with momentum).
- Feature set: C language has features that are
easier to learn and use than special languages.
It's simplicity and power have lead to its popularity and
wide acceptance.
(Many languages have come and gone.
In effect, the technical world has passed judgment.)
- Console and file I/O in C is immediately available,
and can be used to print informative messages during development,
while this is limited in most special languages, for example
VHDL, BONes, etc..
- Efficiency. By its very nature, C is very efficient. Also all
known platforms have significant (basically un-matchable)
investment in making C run most efficiently, reliably, robustly,
and correctly.
- Many powerful development aids are available (most already come for free!), such as,
interactive symbolic debuggers (gdb, dbx, ddt, etc.), optimizers, grammar checkers (lint),
run-time monitors/profilers (prof, gprof), Purify, etc..
- C is more standard than proprietary languages.
This makes CSIM a more standard approach and environment than
other tools which are based on closed-end languages.
In comparing your IP (Intellectual-Property) investment in models developed in
a proprietary language tool versus CSIM, the overwhelming majority of your IP
will be captive in the proprietary tool. While, your IP invested
in CSIM models can much more readily be ported to a wider variety of other tools,
environments, and systems.
- Our approach is easily ported to any language. If a new desired language comes along,
we can easily move to whatever language becomes popular, because
we don't care what the language or compiler actually are.
CSIM just passes the user's behavioral code to any compiler.
Only a few small support routines need be ported.