1

I'm trying to integrate two Fortran 9x codes which contain data arrays with opposite array ordering. One code (I'll call it the old code) has an established library of subroutines and I am trying to take advantage of these with the other (new) code as efficiently as possible (i.e. not having to create temporary arrays just to reorder an array and pass it to a subroutine and then have to replace the old array with the new reordered result). For example,

Old code:
oldarray(1:n,1) -> variable 1 for n elements
oldarray(1:n,2) -> variable 2 for n elements
.. and so on

new code:
newarray(1,1:n) -> variable 1 for n elements
newarray(1,1:n) -> variable 2 for n elements
.. and so on

The variable indices do not necessarily relate between the two codes. If I only need one variable to pass to a procedure, I just pass newarray(1,1:n) and the procedure doesn't know the difference. However, if a procedure from the old code requires variables 1-6 of oldarray which might correspond to variables 2,6,8,1,4,3 (I just picked arbitrary numbers) of newarray, is it possible to create a pointer that I could pass to the procedure? On a simpler side, would it be possible to just create pointer for the tranpose of the new array? As an example, pointer(1000,6) points to newarray(6,1000).

Note: It is not possible to rewrite the new code to use the same array ordering because both codes use an array ordering that best suits its loop structures which cannot be changed.

Also, I have very little experience with pointers. I know I can create a derived datatype which consists of an array of pointers but I don't think I would be able to pass that to a procedure in the manner required (I could be wrong as I also have very little experience with derived datatypes). The reference book I have (Fortran 95/2003 for Scientists and Engineers) only explores advanced applications of pointers in terms of linked lists and trees. I have also found little Fortran pointer information outside of what is covered in this book on the internet.

Thank you for your help.

Improve this question

1 Answer 1

Reset to default
1

I think the answer is no, you can't do this, and it wouldn't help anyway.

You can do all sorts of super-cool things with array pointers, with strides across arrays, etc, but I don't see on the face of it how you can change the order of the data.

So I could be wrong on this and it is possible, but then the question is: how would it help you? Presumably you want to user pointers to re-arrange the data without copying; but when you're passing such a thing around, the compiler is allowed to do copy-in, copy-out; eg, create a temporary array, copy the data in, pass it to the subroutine, and copy the data out upon return. And in fact that would almost certainly be the right thing to do in this case, performance-wise; that way the old code could be accessing memory in the fast order, and the transpose-copy could be done in a fast way, as well.

So I suspect the right way to treat this problem is to do the copy-in/copy-out approach yourself explicitly.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

This is for a CFD code in which there can be many millions of elements with double precision variables and explicitly creating these temporary arrays could easily get into the Gb's of memory (ideally this size problem would be done on a cluster so this would be spread out across many systems). I also realize that if the pointer method is possible, there could be a significant decrease in performance due to memory access with the old loop structures. But I would take decreased performance versus needing memory that doesnt exist.
But that's the thing - even with pointers, whether those copies are made or not is out of your control. At least if you're making the copies, you know exactly how much memory is being required.
Also, it's not necessarily reordering the data as much as passing only the desired memory addresses I would like altered. From my understanding a pointer is just a link to a memory address that is occupied by the target. If that is right, it seems in theory you could have a set of memory addresses that correspond to an array but in a reordered manner without actually reordering the array.
Absolutely correct, but array pointers allow you to take slices, but that preserves data order. (eg, integer, pointer, dimension(:) :: p; integer, dimension(5), target :: a; p=>a([1,4]) -- p(1) (a(1)) still comes before p(2) (a(4)), just with fewer elements between 'em.) You're looking for something that looks like an array, but is actually a list of pointers to data out of the order of underlying data array, and I don't see how to easily do this. And again, even if you could, the compiler could turn that into a set of copies behind your back and be fully standards compliant.
I've done some tests with ifort, and at least in what I've been able to determine from using 'top', it seems that the optimization we use with ifort doesn't create copies (there is also a good chance this is something top wouldn't show and I wouldn't know better). However, the old code is used on many architectures (Sun, Cray, etc.) so I have no idea how those corresponding compilers would act in this situation. I thought this might be something clean and somewhat efficient but I'm guessing the explicit method is my best option. Thanks for your help.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.