A3 is designed to maximize developer productivity and runtime performance.
Features (WIP)
Simple
☐ 0 dependency management - no need to download, build, or include.
☑ 1 integer type.
☐ 1 floating point type.
☑ 1 container types.
☑ GUI editor - don't waste time on formatting & style, better code navigation, and more.
☑ Arguments always passed by reference (zero overhead).
Safe
☐ Zero overhead automatic memory management.
☑ Zero overhead automatic bound checking.
☑ Safe parallelism: No data races, deadlocks, and so on.
Fast
☑ Automatic data structure selection.
☐ Automatic memory layout optimizations.
☐ Automatic vectorization.
☑ Automatic multithreading.
☐ Automatic general-purpose GPU computing.
☐ Automatic distributed computing.
☑ Automatic padding minimization.
☑ Automatic space-time tradeoffs, given a memory budget.
And many more automatic high level optimizations.
A3 supports exporting C++ and Python libraries to be integrated with existing codebases.
Benchmarks
TL;DR: Measuring the speed up from optimizations the compiler does for you requires not manually implementing them.
The benchmarks measure the performance of code with similar level of complexity.
The reason is that performance is 2 dimentional problem - running time and the amount of programming work.
Given full control over the hardware, infinite time, and sufficiently smart programmer, an optimal implementation can be achieved, but it's not feasible.
In other words the purpose of these benchmarks is to measure how much speedup you get for the same amount of programming work.
Find smallest
Insert 10 random [0,100] integers into a container, and then find the smallest one.
Naive C++ implementations uses std::vector, or std::set which takes care of sorting.
The A3 compiler automatically picks a data structure with static allocation because of the small number of elements.
Lookup
Insert 100 random {[0,99],[0,99]} key-value pairs of integers into a map, and then randomly lookup one of these elements.
Naive C++ implementation uses std::unordered_map, and the A3 compiler uses a lookup table.
Automatic incremental computing
a tree of relative positions and computing the absolute position of each node.
`cpp`: C++ implementation without incremental computing.
`cpp_IC`: C++ with incremental computing, storing the abs position and checking if it needs to be updated.
`A3`: similar to the cpp one, and the compiler automatically generates incremental computing code.