Strange Illegal Instruction: 4 (mac) or SIGSEGV (linux) on array code in "main" proc

[mratsim]

cc @narimiran

The following throws Illegal instruction: 4 on my Mac in normal and release compilation mode.
It throws SIGSEGV on narimiran Manjaro Linux

import math, times, strformat

const
  dz = 0.01
  z = 100
  spaceSteps = int(z / dz)
  timeSteps = 10000
  dt = 0.12 / timeSteps
  alpha = 2.0
  startingTemp = 30.0
  oscillations = 20.0


proc f(T: array[spaceSteps, float]): array[spaceSteps-2, float] =
  for i in 0 .. spaceSteps-3:
    result[i] = alpha * (T[i] - 2.0 * T[i+1] + T[i+2]) / dz^2


proc eulerSolve(Ts: var array[timeSteps, array[spaceSteps, float]]) =
  for t in 0 ..< timeSteps-1:
    let
      k = f(Ts[t])
    for i in 1 .. spaceSteps-2:
      Ts[t+1][i] = Ts[t][i] + dt * k[i-1]
    Ts[t+1][spaceSteps-1] = Ts[t+1][spaceSteps-2]

proc main() =
  var Ts: array[timeSteps, array[spaceSteps, float]]

  for t in 0 ..< timeSteps:
    Ts[t][0] = startingTemp - oscillations * sin(2.0 * PI * t.float / timeSteps)
    for s in 1 ..< spaceSteps:
      Ts[t][s] = startingTemp

  Ts.eulerSolve()


let start = cpuTime()
main()
let stop = cpuTime()

let elapsed = stop - start
echo &"Native array Euler solve - time taken: {elapsed} seconds”

What is strange is that putting everything in a global context works:

import math, times, strformat

const
  dz = 0.01
  z = 100
  spaceSteps = int(z / dz)
  timeSteps = 10000
  dt = 0.12 / timeSteps
  alpha = 2.0
  startingTemp = 30.0
  oscillations = 20.0


proc f(T: array[spaceSteps, float]): array[spaceSteps-2, float] =
  for i in 0 .. spaceSteps-3:
    result[i] = alpha * (T[i] - 2.0 * T[i+1] + T[i+2]) / dz^2


proc eulerSolve(Ts: var array[timeSteps, array[spaceSteps, float]]) =
  for t in 0 ..< timeSteps-1:
    let
      k = f(Ts[t])
    for i in 1 .. spaceSteps-2:
      Ts[t+1][i] = Ts[t][i] + dt * k[i-1]
    Ts[t+1][spaceSteps-1] = Ts[t+1][spaceSteps-2]

# proc main() =
#   var Ts: array[timeSteps, array[spaceSteps, float]]

#   for t in 0 ..< timeSteps:
#     Ts[t][0] = startingTemp - oscillations * sin(2.0 * PI * t.float / timeSteps)
#     for s in 1 ..< spaceSteps:
#       Ts[t][s] = startingTemp

#   Ts.eulerSolve()


let start = cpuTime()
#main()

var Ts: array[timeSteps, array[spaceSteps, float]]

for t in 0 ..< timeSteps:
  Ts[t][0] = startingTemp - oscillations * sin(2.0 * PI * t.float / timeSteps)
  for s in 1 ..< spaceSteps:
    Ts[t][s] = startingTemp

Ts.eulerSolve()
let stop = cpuTime()

let elapsed = stop - start
echo &"Native array Euler solve - time taken: {elapsed} seconds”

[jangko]

this also crash on windows 10/64bit with the appearance of "this program stop working" msgbox.

move var Ts declaration to global scope also prevent program crash.

var Ts: array[timeSteps, array[spaceSteps, float]]

[jangko]

I think I know the problem,
the size of the array is 800.000.000 bytes, or 800 millions bytes, on the STACK!!!
I guess you also know the solution now....... 😄

[Araq]

Stack overflow?

[narimiran]

I guess you also know the solution now

In my original solution (where timeSteps and spaceSteps can be even larger) I replaced that 2D array with a seq of arrays.

In the example above, it seems like the array size is ok if it is defined in the global scope, but not if it is defined in some procedure. Why is that?

[Araq]

In the example above, it seems like the array size is ok if it is defined in the global scope, but not if it is defined in some procedure. Why is that?

Because globals are not on the stack.

[narimiran]

Because globals are not on the stack.

Ok, so globally defined array[10000, array[10000, float]] works because it isn't on the stack.

Why doesn't globally defined array[50000, array[10000, float]] work (SIGSEGV), while newSeq[array[10000, float]](50000) does work if neither of them is on the stack?

[Araq]

Not sure, because the binary formats are not designed for it?

[jangko]

Why doesn't globally defined array[50000, array[10000, float]] work (SIGSEGV)

50000 x 10000 x 8 is almost 4GB. Linux 32bit has 3GB limit for each process global data size.
is your linux a 32bit or 64bit one?

while newSeqarray[10000, float] does work if neither of them is on the stack?

seq is allocated on the heap, not on the stack nor on the 'global' data section.
what is your language background? java, javascript, ruby, php, python, lua?
they don't have this kind of problem. This kind of problem not Nim or C weakness either, interpreted language usually don't have access to different memory region.

[narimiran]

is your linux a 32bit or 64bit one?

64 bit

what is your language background?

Python.

seq is allocated on the heap, not on the stack nor on the 'global' data section.

I thought "global arrays" would also be on the heap, just as seqs. If that's not the case, that answers my question.

[jangko]

is your linux a 32bit or 64bit one?
64 bit

interesting, windows 10/64bit only give 2GB limit for global data size.
I thought linux 64bit will give more than 3GB limit, turn out that's not the case