Add support (and tests) for optional arguments in ccpp_prebuild

scripts/common.py

@@ -29,6 +29,7 @@
 CCPP_BLOCK_COUNT         = 'ccpp_block_count'
 CCPP_BLOCK_SIZES         = 'ccpp_block_sizes'
 CCPP_THREAD_NUMBER       = 'ccpp_thread_number'
+CCPP_THREAD_COUNT        = 'ccpp_thread_count'
 
 CCPP_CHUNK_EXTENT          = 'ccpp_chunk_extent'
 CCPP_HORIZONTAL_LOOP_BEGIN = 'horizontal_loop_begin'
@@ -60,6 +61,7 @@
     CCPP_LOOP_COUNTER        : 'cdata%loop_cnt',
     CCPP_BLOCK_NUMBER        : 'cdata%blk_no',
     CCPP_THREAD_NUMBER       : 'cdata%thrd_no',
+    CCPP_THREAD_COUNT        : 'cdata%thrd_cnt',
     }
 
 STANDARD_CHARACTER_TYPE = 'character'

scripts/mkcap.py

@@ -338,24 +338,24 @@ def print_def_local(self, metadata):
             if self.type in STANDARD_VARIABLE_TYPES:
                 if self.kind:
                     if self.rank:
-                        str = "{s.type}({s._kind}), dimension{s.rank}, pointer :: {s.local_name} => null()"
+                        str = "{s.type}({s._kind}), dimension{s.rank}, pointer :: p"
                     else:
-                        str = "{s.type}({s._kind}), pointer :: {s.local_name} => null()"
+                        str = "{s.type}({s._kind}), pointer :: p"
                 else:
                     if self.rank:
-                        str = "{s.type}, dimension{s.rank}, pointer :: {s.local_name} => null()"
+                        str = "{s.type}, dimension{s.rank}, pointer :: p"
                     else:
-                        str = "{s.type}, pointer :: {s.local_name} => null()"
+                        str = "{s.type}, pointer :: p"
             else:
                 if self.kind:
                     error_message = "Generating variable definition statements for derived types with" + \
                                     " kind attributes not implemented; variable: {0}".format(self.standard_name)
                     raise Exception(error_message)
                 else:
                     if self.rank:
-                        str = "type({s.type}), dimension{s.rank}, pointer :: {s.local_name} => null()"
+                        str = "type({s.type}), dimension{s.rank}, pointer :: p"
                     else:
-                        str = "type({s.type}), pointer :: {s.local_name} => null()"
+                        str = "type({s.type}), pointer :: p"
             return str.format(s=self)
         else:
             # If the host variable is potentially unallocated, the active attribute is

scripts/mkstatic.py

@@ -15,7 +15,7 @@
 from common import encode_container
 from common import CCPP_STAGES
 from common import CCPP_T_INSTANCE_VARIABLE, CCPP_ERROR_CODE_VARIABLE, CCPP_ERROR_MSG_VARIABLE, CCPP_LOOP_COUNTER, CCPP_LOOP_EXTENT
-from common import CCPP_BLOCK_NUMBER, CCPP_BLOCK_COUNT, CCPP_BLOCK_SIZES, CCPP_THREAD_NUMBER, CCPP_INTERNAL_VARIABLES
+from common import CCPP_BLOCK_NUMBER, CCPP_BLOCK_COUNT, CCPP_BLOCK_SIZES, CCPP_THREAD_NUMBER, CCPP_THREAD_COUNT, CCPP_INTERNAL_VARIABLES
 from common import CCPP_HORIZONTAL_LOOP_BEGIN, CCPP_HORIZONTAL_LOOP_END, CCPP_CHUNK_EXTENT
 from common import CCPP_CONSTANT_ONE, CCPP_HORIZONTAL_DIMENSION, CCPP_HORIZONTAL_LOOP_EXTENT, CCPP_NUM_INSTANCES
 from common import FORTRAN_CONDITIONAL_REGEX_WORDS, FORTRAN_CONDITIONAL_REGEX
@@ -59,6 +59,12 @@
                            ),
     }
 
+# Type and variable declarations for arrays of pointers, required for optional/inactive variables
+TMPPTR_ARR_TYPE_DECLARATION = '''type :: {pointer_type_name}
+         {tmpptr_def}
+      end type {pointer_type_name}'''
+TMPPTR_ARR_DECLARATION = '''type({pointer_type_name}), dimension({dims}) :: {localname}_array'''
+
 ###############################################################################
 
 def extract_parents_and_indices_from_local_name(local_name):
@@ -182,6 +188,7 @@ def create_arguments_module_use_var_defs(variable_dictionary, metadata_define, t
     module_use = []
     var_defs = []
     local_kind_and_type_vars = []
+    local_pointer_type_defs = []
 
     # We need to run through this loop twice. In the first pass, process all scalars.
     # In the second pass, process all arrays. This is so that any potential dimension
@@ -222,9 +229,25 @@ def create_arguments_module_use_var_defs(variable_dictionary, metadata_define, t
     # and add any local pointers (required for conditionally allocated arrays)
     if tmpvars or tmpptrs:
         var_defs.append('')
-        var_defs.append('! Local variables for unit conversions, array transformations, ...')
+        var_defs.append('! Local variables/pointers for unit conversions, array transformations, ...')
         for tmpvar in list(tmpvars) + list(tmpptrs):
-            var_defs.append(tmpvar.print_def_local(metadata_define))
+            # Regular variables
+            if tmpvar in list(tmpvars):
+                var_defs.append(tmpvar.print_def_local(metadata_define))
+            # Pointers are more complicated
+            else:
+                if tmpvar.type == 'character' and 'len=' in tmpvar.kind:
+                    pointer_type_name = f"{tmpvar.type}_{tmpvar.kind.replace('=','')}_r{len(tmpvar.dimensions)}_ptr_arr_type"
+                elif tmpvar.kind:
+                    pointer_type_name = f"{tmpvar.type}_{tmpvar.kind}_rank{len(tmpvar.dimensions)}_ptr_arr_type"
+                else:
+                    pointer_type_name = f"{tmpvar.type}_default_kind_rank{len(tmpvar.dimensions)}_ptr_arr_type"
+                if not pointer_type_name in local_pointer_type_defs:
+                    var_defs.append(TMPPTR_ARR_TYPE_DECLARATION.format(pointer_type_name=pointer_type_name,
+                        tmpptr_def=tmpvar.print_def_local(metadata_define)))
+                    local_pointer_type_defs.append(pointer_type_name)
+                var_defs.append(TMPPTR_ARR_DECLARATION.format(pointer_type_name=pointer_type_name,
+                    dims=f'1:{CCPP_INTERNAL_VARIABLES[CCPP_THREAD_COUNT]}', localname=tmpvar.local_name))
             # Add special kind variables
             if tmpvar.type in STANDARD_VARIABLE_TYPES and tmpvar.kind and not tmpvar.type == STANDARD_CHARACTER_TYPE:
                 kind_var_standard_name = tmpvar.kind
@@ -1632,7 +1655,8 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                             if not conditional == '.true.':
                                 # We don't want the dimstring here - this can lead to dimension mismatches.
                                 # We know for sure that we need to reference the entire de-blocked array anyway.
-                                actions_in += '        {p} => {t}\n'.format(p=tmpptr.local_name, t=tmpvar.local_name, d=dim_string)
+                                actions_in += '        {p} => {t}\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p",
+                                                                            t=tmpvar.local_name, d=dim_string)
 
                             if var.actions['out']:
                                 # Add unit conversion after returning from the subroutine, before copying the non-blocked
@@ -1644,7 +1668,7 @@ def write(self, metadata_request, metadata_define, arguments, debug):
 
                             # If the variable is conditionally allocated, nullify pointer
                             if not conditional == '.true.':
-                                actions_out += '        nullify({p})\n'.format(p=tmpptr.local_name)
+                                actions_out += '        nullify({p})\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                             # Add the conditionals for the "before" operations
                             actions_before += '''
@@ -1663,7 +1687,8 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                             if conditional == '.true.':
                                 arg = '{local_name}={var_name},'.format(local_name=var.local_name, var_name=tmpvar.local_name)
                             else:
-                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name, ptr_name=tmpptr.local_name)
+                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name,
+                                                                        ptr_name=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                         # Variables stored in blocked data structures but without horizontal dimension not supported at this time (doesn't make sense anyway)
                         elif ccpp_stage in ['init', 'timestep_init', 'timestep_finalize', 'finalize'] and \
@@ -1706,7 +1731,8 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                                                                               d=dim_string)
                                 # If the variable is conditionally allocated, assign pointer
                                 if not conditional == '.true.':
-                                    actions_in += '        {p} => {t}{d}\n'.format(p=tmpptr.local_name, t=tmpvar.local_name, d=dim_string)
+                                    actions_in += '        {p} => {t}{d}\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p",
+                                                                                   t=tmpvar.local_name, d=dim_string)
                             if var.actions['out']:
                                 # Add unit conversion after returning from the subroutine
                                 actions_out  += '        {v}{d} = {c}\n'.format(v=tmpvar.target.replace(dim_string_target_name, ''),
@@ -1715,7 +1741,7 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                                                                                                             kind=kind_string))
                                 # If the variable is conditionally allocated, nullify pointer
                                 if not conditional == '.true.':
-                                    actions_out += '        nullify({p})\n'.format(p=tmpptr.local_name)
+                                    actions_out += '        nullify({p})\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                             if tmpvar.rank:
                                 # Add deallocate statement if the variable has a rank > 0
@@ -1739,7 +1765,8 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                                 arg = '{local_name}={var_name}{dim_string},'.format(local_name=var.local_name,
                                     var_name=tmpvar.local_name.replace(dim_string_target_name, ''), dim_string=dim_string)
                             else:
-                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name, ptr_name=tmpptr.local_name)
+                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name,
+                                                                        ptr_name=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                         # Ordinary variables, no blocked data or unit conversions
                         elif var_standard_name in arguments[scheme_name][subroutine_name]:
@@ -1750,12 +1777,12 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                             actions_out = ''
                             # If the variable is conditionally allocated, assign pointer
                             if not conditional == '.true.':
-                                actions_in += '        {p} => {t}{d}\n'.format(p=tmpptr.local_name,
+                                actions_in += '        {p} => {t}{d}\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p",
                                                                                t=var.target.replace(dim_string_target_name, ''),
                                                                                d=dim_string)
                             # If the variable is conditionally allocated, nullify pointer
                             if not conditional == '.true.':
-                                actions_out += '        nullify({p})\n'.format(p=tmpptr.local_name)
+                                actions_out += '        nullify({p})\n'.format(p=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                             if actions_in:
                                 # Add the conditionals for the "before" operations
@@ -1777,7 +1804,8 @@ def write(self, metadata_request, metadata_define, arguments, debug):
                                 arg = '{local_name}={var_name}{dim_string},'.format(local_name=var.local_name, 
                                     var_name=local_vars[var_standard_name]['name'].replace(dim_string_target_name, ''), dim_string=dim_string)
                             else:
-                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name, ptr_name=tmpptr.local_name)
+                                arg = '{local_name}={ptr_name},'.format(local_name=var.local_name,
+                                                                        ptr_name=f"{tmpptr.local_name}_array({CCPP_INTERNAL_VARIABLES[CCPP_THREAD_NUMBER]})%p")
 
                         else:
                             arg = ''

src/ccpp_types.F90

@@ -43,6 +43,9 @@ module ccpp_types
     integer, parameter :: CCPP_DEFAULT_CHUNK_NUMBER = -999
     integer, parameter :: CCPP_DEFAULT_THREAD_NUMBER = -999
 
+    !> @var The default maximum number of threads for CCPP
+    integer, parameter :: CCPP_DEFAULT_THREAD_COUNT = -999
+
 !! \section arg_table_ccpp_t
 !! \htmlinclude ccpp_t.html
 !!
@@ -64,6 +67,7 @@ module ccpp_types
        integer                                             :: blk_no = CCPP_DEFAULT_BLOCK_NUMBER
        integer                                             :: chunk_no = CCPP_DEFAULT_CHUNK_NUMBER
        integer                                             :: thrd_no = CCPP_DEFAULT_THREAD_NUMBER
+       integer                                             :: thrd_cnt = CCPP_DEFAULT_THREAD_COUNT
        integer                                             :: ccpp_instance = 1
 
     contains

src/ccpp_types.meta

@@ -50,6 +50,12 @@
   units = index
   dimensions = ()
   type = integer
+[thrd_cnt]
+  standard_name = ccpp_thread_count
+  long_name = total number of threads for threading in CCPP
+  units = index
+  dimensions = ()
+  type = integer
 [ccpp_instance]
   standard_name = ccpp_instance
   long_name = ccpp_instance