Add arrays of arrays definition more simple

[hupo376787]

Background and Motivation

Many other languages can use
double[][] x = new double[5][3];
But donet can only do like this:

double[][] x = new double[5][];
for (int i = 0; i<= 4; i++)
      x[i] = new int[3];

Proposed API

Add double[][] x = new double[5][3];

[jkotas]

This is C# limitation. .NET runtime does supports allocating jagged arrays in one shot.

[hupo376787]

But C# is in evolution, can we change😊

[svick]

I'm curious, how? Which API or IL opcode can do that?

[hupo376787]

Java
https://stackoverflow.com/questions/12231453/syntax-for-creating-a-two-dimensional-array

[jkotas]

.NET runtime does supports allocating jagged arrays in one shot.
Which API or IL opcode can do that?

Arrays have intrinsic constructors provided by runtime magic.

int[,,,] has:

• .ctor(int, int, int, int). This is the constructor that C# calls.
• .ctor(int, int, int, int, int, int, int, int). Second constructor that provides lower bounds.

int[][][][] has constructors that map to this proposal:

• .ctor(int)
• .ctor(int, int)
• .ctor(int, int. int)
• .ctor(int, int, int, int)

[CyrusNajmabadi]

But donet can only do like this:

I feel like this is trivially solvable with:

var array = CreateArray(5, 3);

And then just have a helper function that does this.

[svick]

If you're in this situation, why wouldn't you use a 2D array? I.e.:

double[,] x = new double[5, 3];

[spydacarnage]

Because they're inefficient in comparison to a 1D array of 1D arrays.

…

On Sun, 22 Nov 2020 at 14:01, Petr Onderka ***@***.***> wrote: If you're in this situation, why wouldn't you use a 2D array? I.e.: double[,] x = new double[5, 3]; — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#4167 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADIEDQL6C7I47GWZAAOZK33SREKVPANCNFSM4T6PX7FA> .

[HaloFour]

My understanding is that this is no longer true with .NET Core (and was never true with Mono). Multidimensional arrays should be faster but .NET Framework had a fairly inefficient method of bounds checking.

[spydacarnage]

I've seen some recent benchmarks run, and I'm fairly sure they were running Core 3.1 - the SD arrays were a good 50% quicker.

…

On Sun, 22 Nov 2020 at 14:32, HaloFour ***@***.***> wrote: My understanding is that this is no longer true with .NET Core (and was never true with Mono). Multidimensional arrays _should_be faster but .NET Framework had a fairly inefficient method of bounds checking. — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#4167 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADIEDQKS5GMYEQE3J44GUPDSREOIJANCNFSM4T6PX7FA> .

[HaloFour]

Looks like there are still JIT workitems out there to improve their performance: dotnet/runtime#35293

I'd be curious to see different benchmarks against .NET 5 (or Mono, since I've read a few reports that this performance difference doesn't exist on that runtime). Either way it seems like an implementation detail that can be fixed by the runtime and not an intrinsic behavior of multidimensional arrays. Bounds checking aside you'd think that they'd have better performance due to memory locality, since the individual array elements in a jagged array could be anywhere.

My only (minor) concern with syntax like var foo = new T[x][y]; is that it hides the fact that there are x separate allocations going on.

[jkotas]

Some of the overhead of multidimensional arrays is by design and cannot be easily fixed. For example, all multidimensional arrays have lower-bounds. Lower-bounds are very rarely used, but they have to accounted for by the codegen. The existence of lower-bounds also restricts how much optimizations the JIT can do e.g. for bounds-elimination.

[spydacarnage]

I've just had it confirmed - it was on 3.1, but he's going to run it again against NET5 when he gets the chance.

…

On Sun, 22 Nov 2020 at 14:43, HaloFour ***@***.***> wrote: Looks like there are still JIT workitems out there to improve their performance: dotnet/runtime#35293 <dotnet/runtime#35293> I'd be curious to see different benchmarks against .NET 5 (or Mono, since I've read a few reports that this performance difference doesn't exist on that runtime). Either way it seems like an implementation detail that can be fixed by the runtime and not an intrinsic behavior of multidimensional arrays. Bounds checking aside you'd think that they'd have better performance due to memory locality, since the individual array elements in a jagged array could be anywhere. My only (minor) concern with syntax like var foo = new T[x][y]; is that it hides the fact that there are *x* separate allocations going on. — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#4167 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADIEDQKLRMNSDU4AIQR3HRLSREPSDANCNFSM4T6PX7FA> .