3

我一直在努力寻找有关设计派生类型的任何具体信息。我认为讨论这个问题的最佳方式是通过几个选项。我用派生类型的不同应用编写了一些代码部分。我更愿意为 、 和 使用nparts动态index数组refs。我省略了实际使用该结构的代码部分（没有任何代码，因为我编造了它），但显示了一个示例，并且在例程中我打算至少使用该结构中的所有值一次。

选项 A：在派生类型中使用静态数组。缺点是我必须在编译时猜测数组大小。

! Known before compile time.
nboxes = 5000
max_parts = 2000
packs = 10

Type Boxes
   Sequence
   Integer :: location, date
   Integer, Dimension(0:packs) :: nparts
   Integer, Dimension(max_parts,packs) :: index
   Real(Kind=8), Dimension(packs,packs) :: refs
End Type Boxes

type(boxes), dimension(:), allocatable :: assembly
allocate(assembly(nboxes))

! Perform some operations on assembly...
do i = 1,nboxes
   do j = 1,packs
      do k = j,packs
         example = assembly(i)%nparts(k) - assembly(i)%nparts(j)
         .
         .
         do m = 1,max_parts
            example = assembly(i)%index(m,j) + assembly(i)%refs(k,j) * assembly(i)%nparts(j)
            .
            .
         end do
      end do
   end do
end do

选项 B：在派生类型中使用动态数组。

! Defined during execution. Much better.
nboxes = 5000
max_parts = 2000
packs = 10

Type Boxes
   Sequence
   Integer :: location, date
   Integer, Dimension(:), Allocatable :: nparts
   Integer, Dimension(:,:), Allocatable :: index
   Real(Kind=8), Dimension(:,:), Allocatable :: refs
End Type Boxes

type(boxes), dimension(:), allocatable :: assembly
allocate(assembly(nboxes))
do i = 1,nboxes
   allocate(assembly(i)%nparts(0:packs))
   allocate(assembly(i)%index(max_parts,packs))
   allocate(assembly(i)%refs(packs,packs))
end do

! Perform some operations on assembly...
do i = 1,nboxes
   do j = 1,packs
      do k = j,packs
         example = assembly(i)%nparts(k) - assembly(i)%nparts(j)
         .
         .
         do m = 1,max_parts
            example = assembly(i)%index(m,j) + assembly(i)%refs(k,j) * assembly(i)%nparts(j)
            .
            .
         end do
      end do
   end do
end do

选项 C：最小化派生类型中使用的动态数组的数量，并强制assembly成为数组。请注意，在这个版本中，我们有一堆未使用的内存。例如，nparts并且index需要内存packs时间，因为assembly(packs,packs,nboxes).

! Defined during execution. Much better.
nboxes = 5000
max_parts = 2000
packs = 10

Type Boxes
   Sequence
   Integer :: location, date, nparts, index
   Real(Kind=8) :: refs
   Integer, Dimension(:), Allocatable :: index
End Type Boxes

type(boxes), dimension(:,:,:), allocatable :: assembly
allocate(assembly(packs,packs,nboxes))
do i = 1,nboxes
   do j = 1,packs
      do k = 1,packs
         allocate(assembly(k,j,i)%index(max_parts))
      end do
   end do
end do

! Perform some operations on assembly...
do i = 1,nboxes
   do j = 1,packs
      do k = j,packs
         example = assembly(k,j,i)%nparts - assembly(k,j,i)%nparts
         .
         do m = 1,max_parts
            example = assembly(k,j,i)%index(m) + assembly(k,j,i)%refs * assembly(k,j,i)%nparts
            .
            .
         end do
      end do
   end do
end do

选项 D：选项 C 的另一种排列。

问题：

  1. do哪个版本是为所示循环示例设计派生类型的正确/预期方法？考虑到我想要动态数组功能，哪个版本最优化？
  2. 可能和上面有关。内存是如何分配和访问的？使用是否SEQUENCE值得？我认为分配的数组无论如何都不会按顺序显示。这难道不是表明选项 C 是最好的，因为每个部分assembly都较小吗？
  3. 我应该将这个派生类型拆分为多个派生类型，还是完全摆脱它而只使用变量？我将在多个例程中使用这个派生类型，并将它放在一个模块中。
4

1 回答 1

2

  1. 您希望最快变化的索引成为您最内层的循环。变化最快的索引是多维数组中的第一个。因此，选项 B 接近这个目标。尽管您可能想要更改 refs 中尺寸的顺序。

  2. 由索引 (i,j) 访问的形状为 (m,n) 的二维数组的内存布局由以下顺序给出：k = i+m*(j-1)，其中k表示内存中的一维索引。派生的数据类型将包含对已分配内存的引用，并且包含的​​可分配对象的实际内存可能分散在内存中，但每个可分配数组本身都是连续的。因此，在您的选项 B 中，这assembly将是一个包含对可分配数组的引用的连续数组。和中的每一个本身都是连续的数组nparts，但 可以位于任意位置，在一个组件元素内或跨不同组件元素之间没有特定关系。用于indexrefsSEQUENCE在这里没有任何意义，它强制编译器按您声明的顺序将派生数据类型的元素放入内存中，并将禁止它重新排列它认为合适的数据类型组件，这可能限制性能。我怀疑它会在您的示例中产生很大的影响，但是当不需要它时，您应该离开它。

  3. 不，在我看来，选项 B 看起来非常合理（除了sequence）。

于 2016-12-10T06:34:12.323 回答