The Right Tool for the Job
The days of programming in a one-size-fits all language are quickly becoming a thing of the past, especially for multicore and many-core systems. SequenceL is the right tool for the multicore and many-core programming job, addressing all the root issues facing developers targeting these platforms. And SequenceL is not just for high performance on multicore platforms; it’s also the best choice when software security & correctness count and for the fastest time to market.
SequenceL is a compact, powerful functional programming language and auto-parallelizing tool set that quickly and easily converts algorithms to robust, massively parallel code. This makes it a powerful tool to explore different algorithms and innovations, then quickly convert them to robust, performant production code that runs on a multitude of modern hardware platforms.
As the tool flow below shows, SequenceL works in concert with open industry standard languages and tools. It retains and leverages key strengths of C++, including performance, programmer familiarity, wide platform support, and available frameworks & tools. It also relies on C++ (or Java, Python, C#, Fortran, etc.) for I/O since the inventors saw no need to re-invent that. In fact, many users simply think of it as an easy-to-use, front-end/pre-processor to C++ that creates a uniquely disruptive, yet natural, evolution to address the impediments to truly exploit multicore computing platforms. So add a real power tool to your toolbox and see just how productive you can be compared to all other manual, brute-force parallel programming approaches.
Matlab on Steroids!
- Express problems in Engineering terms
- Get it right the first time: algorithms written in SequenceL often match their definition
- Originally developed as an executable specification language for NASA
- Greatly simplifies programming effort
- Facilitates validation and verification
- Automatic, race-free parallelization
- Exposes all parallelisms in a program, even fine grain parallelisms users may never see
- User does not specify how or when to parallelize a program
- No need for locks or threading constructs
- Transportable across any number of cores, OS’s and architectures
- Automatic OpenCL generation make it quick & easy to explore whether algorithms benefit from GPU acceleration
- Purely functional, declarative language and toolset
- Declare what to compute, not how to compute it
- No need to specify how to disassemble or assemble non-scalars
- Statically typed with automatic type inference
- Absence of side effects makes it impossible for user to add race conditions
- Compact, intuitive
- ~15 grammar rules (compared to 150+ for Java)
- Does not re-invent I/O; works in concert with industry standards such as C++, Java, Python, C#, Fortran
SequenceL at a Glance
|An easy means of turning algorithms into robust, race-free, massively parallelized (and vectorized) C++ and OpenCL code||A “silver bullet” compiler attempting to solve the “dusty deck” problem (e.g.- unachievable "black box" that auto-magically converts old serial code into modern parallel code)|
|A true integrated solution that includes high abstraction language, IDE, debugger, interpreter, auto-parallelizing compiler, and platform-specific runtime environment||Like all the other "point tools" pursuing the multicore market that leave the hard work to users|
|A patented self-parallelizing toolset that unleashes full multicore performance||A multicore or MPI code profiler|
|Used to create multicore libraries and applications||Yet another set of math libraries|
|Built on open industry standards||A multicore debugging or testing tool|