Somewhat unusually, this blog post is future-looking: it mostly focuses on things that don't yet exist. Its purpose is to lay out the background for community discussion about possible changes to the core API for `AbstractArray`

s, and serves as background reading and reference material for a more focused "julep" (a julia enhancement proposal). Here, often I'll use the shorthand "array" to mean `AbstractArray`

, and use `Array`

if I explicitly mean julia's concrete `Array`

type.

As the reader is likely aware, in julia it's possible to write algorithms for which one or more inputs are only assumed to be `AbstractArray`

s. This is "generic" code, meaning it should work (i.e., produce a correct result) on any specific concrete array type. In an ideal world — which julia approaches rather well in many cases — generality of code should not have a negative impact on its performance: a generic implementation should be approximately as fast as one restricted to specific array type(s). This implies that generic algorithms should be written using lower-level operations that give good performance across a wide variety of array types.

Providing efficient low-level operations is a different kind of design challenge than one experiences with programming languages that "vectorize" everything. When successful, it promotes much greater reuse of code, because efficient, generic low-level parts allow you to write a wide variety of efficient, generic higher-level functions.

Naturally, as the diversity of array types grows, the more careful we have to be about our abstractions for these low-level operations.

In discussing general operations on arrays, it's useful to have a diverse collection of concrete arrays in mind.

In core julia, some types we support fairly well are:

`Array`

: the prototype for all arrays`Range`

s: a good example of what I often consider a "computed" array, where essentially none of the values are stored in memory. Since there is no storage, these are immutable containers: you can't set values in individual slots.`BitArray`

s: arrays that can only store 0 or 1 (`false`

or`true`

), and for which the internal storage is packed so that each entry requires only one bit.`SubArray`

s: the problems this type introduced, and the resolution we adopted, probably serves as the best model for the generalizations considered here. Therefore, this case is discussed in greater detail below.

Another important class of array types in Base are sparse arrays: `SparseMatrixCSC`

and `SparseVector`

, as well as other sparse representations like `Diagonal`

, `Bidiagonal`

, and `Tridiagonal`

. These are good examples of array types where access patterns deserve careful thought. Notably, despite many commonalities in "strategy" among the 5 or so sparse parametrizations we have, implementations of core algorithms (e.g., matrix multiplication) are specialized for each sparse-like type — in other words, these mimic the "high level vectorized functions" strategy common to other languages. What we lack is a "sparse iteration API" that lets you write the main algorithms of sparse linear algebra efficiently in a generic way. Our current model is probably fine for `SparseLike*Dense`

operations, but gets to be harder to manage if you want to efficiently compute, e.g., `Bidiagonal*SparseMatrixCSC`

: the number of possible combinations you have to support grows rapidly with more sparse types, and thus represents a powerful incentive for developing efficient, generic low-level operations.

Outside of Base, there are some other mind-stretching examples of arrays, including:

`DataFrames`

: indexing arrays with symbols rather than integers. Other related types include`NamedArrays`

,`AxisArrays`

.`Interpolations`

: indexing arrays with non-integer floating-point numbers`DistributedArrays`

: another great example of a case in which you need to think through access patterns carefully

For arrays of fixed dimension, one can write algorithms that index arrays as `A[i,j,k,...]`

(good examples can be found in our linear algebra code, where everything is a vector or matrix). For algorithms that have to support arbitrary dimensionality, for a long time our fallback was linear indexing, `A[i]`

for integer `i`

. However, in general SubArrays cannot be efficiently accessed by a linear index because it results in call(s) to `div`

, and `div`

is slow. This is a CPU problem, not a Julia-specific problem. The slowness of `div`

is still true despite the recent addition of infrastructure to make it much faster — now one can make it merely "really bad" rather than "Terrible, Horrible, No Good, and Very Bad".

The way we (largely) resolved this problem was to make it possible to do cartesian indexing, `A[i,j,k,...]`

, for arrays of arbitrary dimensionality (the `CartesianIndex`

type). To leverage this in practical code, we also had to extend our iterators with the `for I in eachindex(A)`

construct. This allows one to select an iterator that optimizes the efficiency of access to elements of `A`

. In generic algorithms, the performance gains were not small, sometimes on the scale of ten- to fifty-fold. These types were described in a previous blog post.

To my knowledge, this approach has given Julia one of the most flexible yet efficient "array view" types in any programming language. Many languages base views on array *strides*, meaning situations in which the memory offset is regular along each dimension. Among other things, this requires that the underlying array is dense. In contrast, in Julia we can easily handle non-strided arrays (e.g., sampling at `[1,3,17,428,...]`

along one dimension, or creating a view of a `SparseMatrixCSC`

). We can also handle arrays for which there is no underlying storage (e.g., `Range`

s). Being able to do this with a common infrastructure is part of what makes different optimized array types useful in generic programming.

It's also worth pointing out some problems:

Most importantly, it requires that one adopt a slightly different programming style. Despite being well into another release cycle, this transition is still not complete, even in Base.

For algorithms that involve two or more arrays, there's a possibility that their "best" iterators will be of different types.

*In principle*, this is a big problem. Consider matrix-vector multiplication,`A[i,j]*v[j]`

, where`j`

needs to be in-sync for both`A`

and`v`

, yet you'd also like all of these accesses to be maximally-efficient.*In practice*, right now this isn't a burning problem: even if our arrays don't all have efficient linear indexing, to my knowledge all of our (dense) array types have efficient cartesian indexing. Since indexing by`N`

integers (where`N`

is equal to the dimensionality of the array) is always performant, this serves as a reliable default for generic code. (It's worth noting that this isn't true for sparse arrays, and the lack of a corresponding generic solution is probably the main reason we lack a generic API for writing sparse algorithms.)

Unfortunately, I suspect that if we want to add support for certain new operations or types (specific examples below), it will force us to set the latter problem on fire.

Some possible new `AbstractArray`

types pose novel challenges.

These are the front-and-center motivation for this post. These are motivated by a desire to ensure that `reshape(A, dims)`

always returns a "view" of `A`

rather than allocating a copy of `A`

. (Much of the urgency of this julep goes away if we decide to abandon this goal, in which case for consistency we should always return a copy of `A`

.) It's worth noting that besides an explicit `reshape`

, we have some mechanisms for reshaping that currently cause a copy to be created, notably `A[:]`

or `A[:, :]`

applied to a 3D array.

Similar to `SubArrays`

, the main challenge for `ReshapedArrays`

is getting good performance. If `A`

is a 3D array, and you reshape it to a 2D array `B`

, then `B[i,j]`

must be expanded to `A[k,l,m]`

. The problem is that computing the correct `k,l,m`

might result in a call to `div`

. So ReshapedArrays violate a crutch of our current ecosystem, in that indexing with `N`

integers might not be the fastest way to access elements of `B`

. From a performance perspective, this problem is substantial (see #15449, about five- to ten-fold).

In simple cases, there's an easy way to circumvent this performance problem: define a new iterator type that (internally) iterates over the parent `A`

's indexes directly. In other words, create an iterator so that `B[I]`

immediately expands to `A[I']`

, and so that the latter has "ideal" performance.

Unfortunately, this strategy runs into a lot of trouble when you need to keep two arrays in sync: if you want to adopt this strategy, you simply can't write `B[i,j]*v[j]`

for matrix-vector multiplication anymore. A potential way around *this* problem is to define a new class of iterators that operate on specific dimensions of an array (#15459), writing `B[ii,jj]*v[j]`

. `jj`

(whatever that is) and `j`

need to be in-sync, but they don't necessarily need to both be integers. Using this kind of strategy, matrix-vector multiplication

```
for j = 1:size(B, 2)
vj = v[j]
for i = 1:size(B, 1)
dest[i] += B[i,j] * vj
end
end
```

might be written in a more performant manner like this:

```
for (jj, vj) in zip(eachindex(B, Dimension{2}), v)
for (i, ii) in zip(eachindex(dest), eachindex(B, (:, jj)))
dest[i] += B[ii,jj]*vj
end
end
```

It's not too hard to figure out what `eachindex(B, Dimension{2})`

and `eachindex(B, (:, jj))`

should do: `ii`

, for example, could be a `CartesianInnerIndex`

(a type that does not yet exist) that for a particular column of `B`

iterates from `A[3,7,4]`

to `A[5,8,4]`

, where the `d`

th index component wraps around at `size(A, d)`

. The big performance advantage of this strategy is that you only have to compute a `div`

to set the bounds of the iterator on each column; the inner loop doesn't require a `div`

on each element access. No doubt, given suitable definition of `jj`

one could be even more clever and avoid calculating `div`

altogether. To the author, this strategy seems promising as a way to resolve the majority of the performance concerns about ReshapedArrays — only if you needed "random access" would you require slow (integer-based) operations.

However, a big problem is that compared to the "naive" implementation, this is rather ugly.

Julia's `Array`

type stores its entries in column-major order, meaning that `A[i,j]`

and `A[i+1,j]`

are in adjacent memory locations. For certain applications — or for interfacing with certain external code bases — it might be convenient to support row-major arrays, where instead `A[i,j]`

and `A[i,j+1]`

are in adjacent memory locations. More fundamentally, this is partially related to one of the most commented-on issues in all of julia's development history, known as "taking transposes seriously" aka #4774. There have been at least two attempts at implementation, #6837 and the `mb/transpose`

branch, and for the latter a summary of benefits and challenges was posted.

One of the biggest challenges mentioned was the huge explosion of methods that one would need to support. Can generic code come to the rescue here? There are two related concerns. The first is linear indexing: oftentimes this is conflated with "storage order," i.e., given two linear indexes `i`

and `j`

for the same array, the offset in memory is proportional to `i-j`

. For row-major arrays, this notion is not viable, because otherwise a loop

```
function copy!(dest, src)
for i = 1:length(src)
dest[i] = src[i] # trouble if `i` means "memory offset"
end
dest
end
```

would end up taking a transpose if `src`

and `dest`

don't use the same storage order. Consequently, a linear index has to be defined in terms of the corresponding cartesian (full-dimensionality) index. This isn't much of a real problem, because it's one we know how to solve: use `ind2sub`

(which is slow) when you have to, but for efficiency make row major arrays belong to the category (`LinearSlow`

) of arrays that defaults to iteration with cartesian indexes. Doing so will ensure that if one uses generic constructs like `eachindex(src)`

rather than `1:length(src)`

, then the loop above can be fast.

The far more challenging problem concerns cache-efficiency: it's much slower to access elements of an array in anything other than storage-order. Some reasonably fast ways to write matrix-vector multiplication are

```
for j = 1:size(B, 2)
vj = v[j]
for i = 1:size(B, 1)
dest[i] += B[i,j] * vj
end
end
```

for a column-major matrix `B`

, and

```
for i = 1:size(B, 1)
for j = 1:size(B, 2)
dest[i] += B[i,j] * v[j]
end
end
```

for a row-major matrix. (One can do even better than this by using a scalar temporary accumulator, but let's not worry about that here.) The key point to note is that the order of the loops has been switched.

One could generalize this by defining a `RowMajorRange`

iterator that's a lot like our `CartesianRange`

iterator, but traverses the array in row-major order. `eachindex`

claims to return an "efficient iterator," and without a doubt the `RowMajorRange`

is a (much) more efficient iterator than a `CartesianRange`

iterator for row-major arrays. So let's imagine that `eachindex`

does what it says, and returns a `RowMajorRange`

iterator. Using this strategy, the two algorithms above can be combined into a single generic implementation:

```
for I in eachindex(B)
dest[I[1]] += B[I]*v[I[2]]
end
```

Yay! Score one for efficient generic implementations.

But our triumph is short-lived. Let's return to the example of `copy!`

above, and realize that `dest`

and `src`

might be two different array types, and therefore might be most-efficiently indexed with different iterator types. We're tempted to write this as

```
function copy!(dest, src)
for (idest, isrc) in zip(eachindex(dest), eachindex(src))
dest[idest] = src[isrc]
end
dest
end
```

Up until we introduced our `RowMajorRange`

return-type for `eachindex`

, this implementation would have been fine. But we just broke it, because now this will incorrectly take a transpose in certain situations.

In other words, without careful design the goals of "maximally-efficient iteration" and "keeping accesses in-sync" are in conflict.

Julia's arrays are indexed starting at 1, whereas some other languages start numbering at 0. If you take comments on various blog posts at face value, there are vast armies of programmers out there eagerly poised to adopt julia, but who won't even try it because of this difference in indexing. Since recruiting those armies will lead to world domination, this is clearly a problem of the utmost urgency.

More seriously, there *are* algorithms which simplify if you can index outside of the range from `1:size(A,d)`

. In my own lab's internal code, we've long been using a `CenterIndexedArray`

type, in which such arrays (all of which have odd sizes) are indexed over the range `-n:n`

and for which 0 refers to the "center" element. One package which generalizes this notion is `OffsetArrays`

. Unfortunately, in practice both of these array types produce segfaults (due to built-in assumptions about when `@inbounds`

is appropriate) for many of julia's core functions; over time my lab has had to write implementations specialized for `CenterIndexedArrays`

for quite a few julia functions.

`OffsetArrays`

illustrates another conceptual challenge, which can easily be demonstrated by `copy!`

. When `dest`

is a 1-dimensional `OffsetArray`

and `src`

is a standard `Vector`

, what should `copy!`

do? In particular, where does `src[1]`

go? Does it go in the `first`

element of `dest`

, or does it get stored in `dest[1]`

(which may not be the first element).

Such examples force us to think a little more deeply about what an array really is. There seem to be two potential conceptions. One is that arrays are lists, and multidimensional arrays are lists-of-lists-of-lists-of... In such a world view, the right thing to do is to put `src[1]`

into the first slot of `dest`

, because 1 is just a synonym for `first`

. However, this world view doesn't really endow any kind of "meaning" to the index-tuple of an array, and in that sense doesn't even include the distinction conveyed by an `OffsetArray`

. In other words, in this world an `OffsetArray`

is simply nonsensical, and shouldn't exist.

If instead one thinks `OffsetArray`

s should exist, this essentially forces one to adopt a different world view: arrays are effectively associative containers, where each index-tuple is the "key" by which one retrieves a value. With this mode of thinking, `src[1]`

should be stored in `dest[1]`

.

These examples suggest a formalization of `AbstractArray`

:

`AbstractArray`

s are specialized associative containers, in that the allowable "keys" may be restricted by more than just their julia type. Specifically, the allowable keys must be representable as a cartesian product of one-dimensional lists of values. The allowed keys may depend not just on the array type but also the specific array (e.g., its size). Attempted access by keys that cannot be converted to one of the allowed keys, for that specific array, result in`BoundsError`

s.For any given array, one must be able to generate a finite-dimensional parametrization of the full domain of valid keys from the array itself. This might only require knowledge of the array size, or the keys might depend on some internal storage (think

`DataFrames`

and`OffsetArrays`

). In some cases, just the array type might be sufficient (e.g.,`FixedSizeArrays`

). By this definition, note that a`Dict{ASCII5,Int}`

, where`ASCII5`

is a type that means an ASCII string with 5 characters, would qualify as a 5-dimensional (sparse) array, but that a`Dict{ASCIIString,Int}`

would not (because there is no length limit to an`ASCIIString`

, and hence no finite dimensionality).An array may be indexed by more than one key type (i.e., keys may have multiple parametrizations). Different key parametrizations are equivalent when they refer to the same element of a given array. Linear indexes and cartesian indexes are simple examples of interconvertable representations, but specialized iterators can produce other key types as well.

Arrays may support multiple iterators that produce non-equivalent key sequences. In other words, a row-major matrix may support both

`CartesianRange`

and`RowMajorRange`

iterators that access elements in different orders.

Resolving these conflicting demands is not easy. One approach might be to decree that some of these array types simply can't be supported with generic code. It is possible that this is the right strategy. Alternatively, one can attept to devise an array API that handles all of these types (and hopefully more).

In GitHub issue #15648, we are discussing APIs that may resolve these challenges. Readers are encouraged to contribute to this discussion.