Re: Efficient Sequential Access to Arrays

[Shark8 <onewingedshark@gmail.com>]

On Sunday, July 15, 2012 12:40:08 PM UTC-6, Keean Schupke wrote:
> The Monte-Carlo simulator I am working on is now performing better in Ada than in C++ using profile-guided compilation (57k simulations per second for Ada 'vs' 56k simulations per second for C++).
> 
> However in order to achieve this performance I needed to rework the arrays as the use of Indexes was too slow. An example of this is lets say we are accessing element 5 from array A "A(5)" this requires a multiplication to access (base_address + index * record_size). To access the neighbour A(6) also requires a multiplication. Accessing the array sequentially requires a multiplication per step. 
> 
> Contrast this with C++ where we can return a pointer to the array element, and we just need to add the record_size to step to the next element.
> 
> So assuming we need this level of performance, what would be the best (and most idiomatic Ada) way to package this type of usage pattern as an abstract datatype?
> 
> 
> Cheers,
> Keean.

Hm; the problem is that such optimizations are highly dependent on assumptions that might not be true in the future. Consider, for example, compiling targeting the JVM: the arrays are not guaranteed to be continuous with contiguous components and therefore such a method would invite incorrect result/behavior to the program.

That said, if I needed to resort to such micro-optimizations I'd throw them all into a generic-package [if possible] and comment the heck out of the subprogram bodies. {Or if you're using a common pattern you might be able to explain the pattern in the package-body and then do the implementations -- You might be able to get away with a generic-iterator inside the package body.}