Difference between memory arrays and signal arrays in Amaranth

[joshkahn42]

I am trying to use Amaranth (v0.5.4) to create an array of signals that can be accessed by input signals to a module, to serve as a read/write memory buffer.
What is the difference between using the Memory Arrays vs Arrays (https://amaranth-lang.org/docs/amaranth/v0.5.4/stdlib/memory.html#module-amaranth.lib.memory vs https://amaranth-lang.org/docs/amaranth/v0.5.4/guide.html#arrays)?

The documentation in the Arrays section says "An array becomes immutable after it is indexed for the first time. The elements of the array do not themselves become immutable, but it is not recommended to mutate them as the behavior can become unpredictable."
That seems to indicate I should not use Arrays for my use case?

When I generate verilog code using a Memory Array, the verilog code seems to just be a regular array of signals in any case.

[whitequark]

The documentation in the Arrays section says "An array becomes immutable after it is indexed for the first time. The elements of the array do not themselves become immutable, but it is not recommended to mutate them as the behavior can become unpredictable." That seems to indicate I should not use Arrays for my use case?

I think there is a terminology confusion here. The Array becomes immutable in the Python sense: the Python object that is created by the Array() syntax cannot be modified at compilation time any more. The values inside, however, can be modified as usual in the generated gateware.

When I generate verilog code using a Memory Array, the verilog code seems to just be a regular array of signals in any case.

Something like a read/write buffer should use a Memory since this results in more efficient synthesis, especially for larger buffers. An Array is slightly easier to use (you do not need to explicitly care about read/write ports) but results in potentially a lot less efficient synthesis.

Hope this helps!

[joshkahn42]

That is very helpful, and is close to what I understood from the documentation, thanks!
At what size buffer would you estimate it is better practice to use Memory?

One follow up question:
For creation of a multidimensional array, if I use an Array type I can create a 2 dimensional array and then index into it with normal syntax, eg. Arr[x][y].
Is there something similar that can be done with Memory, or do I need to treat it like an unfolded array and then access it with single dimensional addresses (through the read/write port) like Mem[x*(row_size-1) + y]? For context, I am trying to avoid using multipliers within the FPGA.

[whitequark]

Is there something similar that can be done with Memory, or do I need to treat it like an unfolded array and then access it with single dimensional addresses (through the read/write port) like Mem[x*(row_size-1) + y]? For context, I am trying to avoid using multipliers within the FPGA.

The latter. You could use shift operations (or multiply by powers of 2) to avoid high resource use.