Change FH -> HF

Swap F and H inds

Author: charleskawczynski

NEWS.md

@@ -21,12 +21,12 @@ PR [#2033](https://github.com/CliMA/ClimaCore.jl/pull/2033) introduces new
 constructors for `DataLayout`s. Instead of writing
 ```julia
 array = rand(FT, Nv, Nij, Nij, 3, Nh)
-data = VIJFH{S, Nv, Nij}(array)
+data = VIJHF{S, Nv, Nij}(array)
 ```
 
 You can now write
 ```julia
-data = VIJFH{S}(ArrayType{FT}, rand; Nv, Nij, Nh)
+data = VIJHF{S}(ArrayType{FT}, rand; Nv, Nij, Nh)
 ```
 and grab the `array` with `parent(data)` (if you need).
 

docs/src/api.md

@@ -28,10 +28,10 @@ DataLayouts.DataF
 DataLayouts.IF
 DataLayouts.IJF
 DataLayouts.VF
-DataLayouts.IFH
-DataLayouts.IJFH
-DataLayouts.VIFH
-DataLayouts.VIJFH
+DataLayouts.IHF
+DataLayouts.IJHF
+DataLayouts.VIHF
+DataLayouts.VIJHF
 ```
 
 ## Geometry

examples/hybrid/sphere/solid_body_rotation_3d.jl

@@ -247,7 +247,7 @@ discrete_hydrostatic_balance!(ρ, p, z_top / n_vert, grav)
 # set up initial condition: not discretely balanced; only create a Field as a place holder
 Yc = map(coord -> init_sbr_thermo(coord.z), c_coords)
 # put the dicretely balanced ρ and ρe into Yc
-parent(Yc.ρ) .= ρ  # Yc.ρ is a VIJFH layout
+parent(Yc.ρ) .= ρ  # Yc.ρ is a VIJHF layout
 parent(Yc.ρe) .= ρe
 
 # initialize velocity: at rest

ext/cuda/data_layouts.jl

@@ -1,8 +1,8 @@
 
 import ClimaCore.DataLayouts: AbstractData
 import ClimaCore.DataLayouts: FusedMultiBroadcast
-import ClimaCore.DataLayouts: IJKFVH, IJFH, VIJFH, VIFH, IFH, IJF, IF, VF, DataF
-import ClimaCore.DataLayouts: IJFHStyle, VIJFHStyle, VFStyle, DataFStyle
+import ClimaCore.DataLayouts: IJKFVH, IJHF, VIJHF, VIHF, IHF, IJF, IF, VF, DataF
+import ClimaCore.DataLayouts: IJHFStyle, VIJHFStyle, VFStyle, DataFStyle
 import ClimaCore.DataLayouts: promote_parent_array_type
 import ClimaCore.DataLayouts: parent_array_type
 import ClimaCore.DataLayouts: isascalar

ext/cuda/data_layouts_mapreduce.jl

@@ -20,7 +20,7 @@ end
 function mapreduce_cuda(
     f,
     op,
-    data::Union{DataLayouts.VF, DataLayouts.IJFH, DataLayouts.VIJFH};
+    data::Union{DataLayouts.VF, DataLayouts.IJHF, DataLayouts.VIJHF};
     weighted_jacobian = OnesArray(parent(data)),
     opargs...,
 )
@@ -83,7 +83,7 @@ function mapreduce_cuda_kernel!(
     gidx = _get_gidx(tidx, bidx, effective_blksize)
     reduction = CUDA.CuStaticSharedArray(T, shmemsize)
     reduction[tidx] = 0
-    (Nv, Nij, Nf, Nh) = _get_dims(dataview)
+    (Nv, Nij, Nh, Nf) = _get_dims(dataview)
     nitems = Nv * Nij * Nij * Nf * Nh
 
     # load shmem
@@ -115,21 +115,21 @@ end
 @inline _dataview(pdata::AbstractArray{FT, 2}, fidx) where {FT} =
     view(pdata, :, fidx:fidx)
 
-# for IJFH DataLayout
+# for IJHF DataLayout
 @inline function _get_dims(pdata::AbstractArray{FT, 4}) where {FT}
-    (Nij, _, Nf, Nh) = size(pdata)
-    return (1, Nij, Nf, Nh)
+    (Nij, _, Nh, Nf) = size(pdata)
+    return (1, Nij, Nh, Nf)
 end
 @inline _dataview(pdata::AbstractArray{FT, 4}, fidx) where {FT} =
-    view(pdata, :, :, fidx:fidx, :)
+    view(pdata, :, :, :, fidx:fidx)
 
-# for VIJFH DataLayout
+# for VIJHF DataLayout
 @inline function _get_dims(pdata::AbstractArray{FT, 5}) where {FT}
-    (Nv, Nij, _, Nf, Nh) = size(pdata)
-    return (Nv, Nij, Nf, Nh)
+    (Nv, Nij, _, Nh, Nf) = size(pdata)
+    return (Nv, Nij, Nh, Nf)
 end
 @inline _dataview(pdata::AbstractArray{FT, 5}, fidx) where {FT} =
-    view(pdata, :, :, :, fidx:fidx, :)
+    view(pdata, :, :, :, :, fidx:fidx)
 
 @inline function _cuda_reduce!(op, reduction, tidx, reduction_size, N)
     if reduction_size > N

ext/cuda/data_layouts_threadblock.jl

@@ -24,7 +24,7 @@ criteria:
    in the thread partition
  - The order of the thread partition should
    follow the fastest changing index in the
-   datalayout (e.g., VIJ in VIJFH)
+   datalayout (e.g., VIJ in VIJHF)
 """
 function partition end
 
@@ -46,25 +46,25 @@ bounds to ensure that the result of
 """
 function is_valid_index end
 
-##### VIJFH
-@inline function partition(data::DataLayouts.VIJFH, n_max_threads::Integer)
+##### VIJHF
+@inline function partition(data::DataLayouts.VIJHF, n_max_threads::Integer)
     (Nij, _, _, Nv, Nh) = DataLayouts.universal_size(data)
     Nv_thread = min(Int(fld(n_max_threads, Nij * Nij)), Nv)
     Nv_blocks = cld(Nv, Nv_thread)
     @assert prod((Nv_thread, Nij, Nij)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nv_thread, Nij, Nij))),$n_max_threads)"
     return (; threads = (Nv_thread, Nij, Nij), blocks = (Nv_blocks, Nh))
 end
-@inline function universal_index(::DataLayouts.VIJFH)
+@inline function universal_index(::DataLayouts.VIJHF)
     (tv, i, j) = CUDA.threadIdx()
     (bv, h) = CUDA.blockIdx()
     v = tv + (bv - 1) * CUDA.blockDim().x
     return CartesianIndex((i, j, 1, v, h))
 end
-@inline is_valid_index(::DataLayouts.VIJFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.VIJHF, I::CI5, us::UniversalSize) =
     1 ≤ I[4] ≤ DataLayouts.get_Nv(us)
 
-##### IJFH
-@inline function partition(data::DataLayouts.IJFH, n_max_threads::Integer)
+##### IJHF
+@inline function partition(data::DataLayouts.IJHF, n_max_threads::Integer)
     (Nij, _, _, _, Nh) = DataLayouts.universal_size(data)
     Nh_thread = min(
         Int(fld(n_max_threads, Nij * Nij)),
@@ -75,30 +75,30 @@ end
     @assert prod((Nij, Nij)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nij, Nij))),$n_max_threads)"
     return (; threads = (Nij, Nij, Nh_thread), blocks = (Nh_blocks,))
 end
-@inline function universal_index(::DataLayouts.IJFH)
+@inline function universal_index(::DataLayouts.IJHF)
     (i, j, th) = CUDA.threadIdx()
     (bh,) = CUDA.blockIdx()
     h = th + (bh - 1) * CUDA.blockDim().z
     return CartesianIndex((i, j, 1, 1, h))
 end
-@inline is_valid_index(::DataLayouts.IJFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.IJHF, I::CI5, us::UniversalSize) =
     1 ≤ I[5] ≤ DataLayouts.get_Nh(us)
 
-##### IFH
-@inline function partition(data::DataLayouts.IFH, n_max_threads::Integer)
+##### IHF
+@inline function partition(data::DataLayouts.IHF, n_max_threads::Integer)
     (Ni, _, _, _, Nh) = DataLayouts.universal_size(data)
     Nh_thread = min(Int(fld(n_max_threads, Ni)), Nh)
     Nh_blocks = cld(Nh, Nh_thread)
     @assert prod((Ni, Nh_thread)) ≤ n_max_threads "threads,n_max_threads=($(prod((Ni, Nh_thread))),$n_max_threads)"
     return (; threads = (Ni, Nh_thread), blocks = (Nh_blocks,))
 end
-@inline function universal_index(::DataLayouts.IFH)
+@inline function universal_index(::DataLayouts.IHF)
     (i, th) = CUDA.threadIdx()
     (bh,) = CUDA.blockIdx()
     h = th + (bh - 1) * CUDA.blockDim().y
     return CartesianIndex((i, 1, 1, 1, h))
 end
-@inline is_valid_index(::DataLayouts.IFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.IHF, I::CI5, us::UniversalSize) =
     1 ≤ I[5] ≤ DataLayouts.get_Nh(us)
 
 ##### IJF
@@ -125,21 +125,21 @@ end
 end
 @inline is_valid_index(::DataLayouts.IF, I::CI5, us::UniversalSize) = true
 
-##### VIFH
-@inline function partition(data::DataLayouts.VIFH, n_max_threads::Integer)
+##### VIHF
+@inline function partition(data::DataLayouts.VIHF, n_max_threads::Integer)
     (Ni, _, _, Nv, Nh) = DataLayouts.universal_size(data)
     Nv_thread = min(Int(fld(n_max_threads, Ni)), Nv)
     Nv_blocks = cld(Nv, Nv_thread)
     @assert prod((Nv_thread, Ni)) ≤ n_max_threads "threads,n_max_threads=($(prod((Nv_thread, Ni))),$n_max_threads)"
     return (; threads = (Nv_thread, Ni), blocks = (Nv_blocks, Nh))
 end
-@inline function universal_index(::DataLayouts.VIFH)
+@inline function universal_index(::DataLayouts.VIHF)
     (tv, i) = CUDA.threadIdx()
     (bv, h) = CUDA.blockIdx()
     v = tv + (bv - 1) * CUDA.blockDim().x
     return CartesianIndex((i, 1, 1, v, h))
 end
-@inline is_valid_index(::DataLayouts.VIFH, I::CI5, us::UniversalSize) =
+@inline is_valid_index(::DataLayouts.VIHF, I::CI5, us::UniversalSize) =
     1 ≤ I[4] ≤ DataLayouts.get_Nv(us)
 
 ##### VF