On Thu, 22 Nov 2012 20:06:44 -0600, John Colvin
<john.loughran.col...@gmail.com> wrote:
On Thursday, 22 November 2012 at 21:37:19 UTC, Dmitry Olshansky wrote:
Array ops supposed to be overhead-free loops transparently leveraging
SIMD parallelism of modern CPUs. No more and no less. It's like
auto-vectorization but it's guaranteed and obvious in the form.
I disagree that array ops are only for speed.
I would argue that their primary significance lies in their ability to
make code significantly more readable, and more importantly, writeable.
For example, the vector distance between 2 position vectors can be
written as:
dv[] = v2[] - v1[]
or
dv = v2[] - v1[]
anyone with an understanding of mathematical vectors instantly
understands the general intent of the code.
With documentation something vaguely like this:
"An array is a reference to a chunk of memory that contains a list of
data, all of the same type. v[] means the set of elements in the array,
while v on it's own refers to just the reference. Operations on sets of
elements e.g. dv[] = v2[] - v1[] work element-wise along the arrays
{insert mathematical notation and picture of 3 arrays as columns next to
each other etc.}.
Array operations can be very fast, as they are sometimes lowered
directly to cpu vector instructions. However, be aware of situations
where a new array has to be created implicitly, e.g. dv = v2[] - v1[];
Let's look at what this really means: we are asking for dv to be set to
refer to the vector difference between v2 and v1. Note we said nothing
about the current elements of dv, it might not even have any! This means
we need to put the result of v2[] - v1] in a new chunk of memory, which
we then set dv to refer to. Allocating new memory takes time,
potentially taking a lot longer than the array operation itself, so if
you can, avoid it!",
anyone with the most basic programming and mathematical knowledge can
write concise code operating on arrays, taking advantage of the
potential speedups while being aware of the pitfalls.
In short:
Vector syntax/array ops is/are great. Concise code that's easy to read
and write. They fulfill one of the guiding principles of D: the most
obvious code is fast and safe (or if not 100% safe, at least not too
error-prone).
More vector syntax capabilities please!
While I think implicit allocation is a good idea in the case of variable
initialization, i.e.:
auto dv = v2[] - v1[];
however, as a general statement, i.e. dv = v2[] - v1[];, it could just as
easily be a typo and result in a silent and hard to find performance bug.
// An alternative syntax for variable initialization by an array operation
expression:
auto dv[] = v2[] - v1[];
