[foreign-memaccess+abi] RFR: 8270376: Finalize API for memory copy [v3]

[Maurizio Cimadamore]

On Wed, 14 Jul 2021 11:24:46 GMT, Maurizio Cimadamore <mcimadamore at openjdk.org> wrote:

>> This patch ties up some loose ends with the MemoryCopy API, and it also prepares the ground for some other related refactorings in this area.
>> 
>> The meat of this patch is represented by the various changes in MemoryCopy, where all methods were renamed to simply `copy`, and the length parameter (now called `elementCount`) is always moved to the end.
>> 
>> I've also simplified naming of parameters, as I think distinguishing between `index` and `offset` is enough (e.g. an array has an index, a segment has an offset).
>> 
>> You will see that, at the very end of the class, three more copy methods have been added, which deal fully in terms of segments. I have also moved the complex layout-based memory segment copy operation (which does the swap) as a static method in this class, as I believe the static form makes the method more regular and usable.
>> 
>> I've made some changes to our uses of `copyFrom` in the linker, to use the new methods in `MemoryCopy` when the copy operation was performing slicing in the source/target segment, which I think makes the code more readable. Of course these changes are completely optional and could be omitted as well.
>
> Maurizio Cimadamore has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Fix whitespaces

I have finished reorganizing the code (as per previous proposal). I think the new organization makes a lot of sense: MemorySegment has static copy primitives which are general, and are front and center. `MemoryCopy` is conceptually mostly convenience (e.g. avoid slicing and creating views) - although internally we do things differently to avoid performance issues - but we hope that someday we'll be able to reconcile the two paths. In this sense `MemoryCopy` and `MemoryAccess` now look similar - in that it's clear they mostly provide sugar.

I'll deal with the `copyFrom` instance methods in a different PR, but this one sets the foundation: `copyFrom` are just more fluent, sugary, methods which are implemented using the static primitives. This is now made clear both by the API (copyFrom is a `default` method) and by the javadoc, which clearly says that a call to copyFrom can be rewritten as a call to the static copy method.

-------------

PR: https://git.openjdk.java.net/panama-foreign/pull/568