Pass a subarray that is only read as a referene, not copy the data

[FantasticNerd]

When a subarray is created, the data is copied from the origin-array.

The LabVIEW Compiler does not recognise if the subarray data is then only read.

It would be a major improvement for memory and even CPU usage if the compiler recognised that some part of the array is only read and pass only a reference to that part of the array in the memory.

[crossrulz]

It actually does do that.  For more details: https://lavag.org/topic/7307-another-reason-why-copy-dots-is-a-bad-name-for-buffer-allocations/#comm... 

[wiebe@CARYA]

Sadly, the corner cases of Delete From Array (index 0 or length left open) always return a copy of the data, where they could always return sub-arrays.

AFAIK, The removed part of Delete From Array could always be a sub array but it never does.

Replacing those cases of Delete From Array with one or two Split Strings is more code but can be a lot faster.

Note that decimate array and transpose array also return sub-arrays.

Note that the same applies to strings (some functions return sub-strings).

[Intaris]

---

---

Sadly, the corner cases of Delete From Array (index 0 or length left open) always return a copy of the data, where they could always return sub-arrays.

AFAIK, The removed part of Delete From Array could always be a sub array but it never does.

But wouldn't both of these options lead to fragmented array storage in RAM? Currently, arrays need to be contiguous. This would have serious performance side-effects further down the line to such an extent that array operation performance would become nearly impossible to predict.

I think in this local case it might have cases where it would be beneficial, but overall as a language implementation I think the way LabVIEW does it is much preferable to be honest.

[wiebe@CARYA]

The deleted array (length wired) can always be a sub array.

If only length is wired, the resulting "subset" can always be a sub array.

These split string variants are exact synonyms, but (AFAIK, always) much faster:

The array with subset deleted could be a sub array even if both index and length are wired, but this wouldn't be known at run time. As sub array or not is determined at compile time, this situation can't be optimized. Of course it could always return a sub array, as a sub array could point to the entire original, but I suppose that could cause overhead.

[wiebe@CARYA]

> options lead to fragmented array storage in RAM? Currently, arrays need to be contiguous. This would have serious performance side-effects further down the line to such an extent that array operation performance would become nearly impossible to predict.

It seems to me sub arrays actually prevent fragmentation.

In stead of copying data, sub arrays are clusters containing the pointer, an index, steps side and length. Pretty much like C++ strides.