diff --git a/include/arkode/arkode_execution_policy.h b/include/arkode/arkode_execution_policy.h deleted file mode 100644 index 526b27d3f3..0000000000 --- a/include/arkode/arkode_execution_policy.h +++ /dev/null @@ -1,52 +0,0 @@ -/* ----------------------------------------------------------------------------- - * Programmer(s): Steven B. Roberts @ LLNL - * ----------------------------------------------------------------------------- - * SUNDIALS Copyright Start - * Copyright (c) 2002-2024, Lawrence Livermore National Security - * and Southern Methodist University. - * All rights reserved. - * - * See the top-level LICENSE and NOTICE files for details. - * - * SPDX-License-Identifier: BSD-3-Clause - * SUNDIALS Copyright End - * ----------------------------------------------------------------------------- - * This header defines execution policy data structures and functions. - * ---------------------------------------------------------------------------*/ - -#ifndef ARKODE_EXECUTION_POLICY_H_ -#define ARKODE_EXECUTION_POLICY_H_ - -#ifdef __cplusplus /* wrapper to enable C++ usage */ -extern "C" { -#endif - -#include - -/* Parallelization Policy */ -typedef int (*ARKExecutionPolicyFn)(int i, N_Vector y, void* user_data); - -typedef _SUNDIALS_STRUCT_ ARKodeSplittingExecutionPolicyMem* ARKodeSplittingExecutionPolicy; - -struct ARKodeSplittingExecutionPolicyMem -{ - int (*setup)(ARKodeSplittingExecutionPolicy policy, N_Vector y, - int sequential_methods); - - int (*execute)(ARKodeSplittingExecutionPolicy policy, ARKExecutionPolicyFn fn, - N_Vector yn, N_Vector ycur, N_Vector tmp, sunrealtype* alpha, - int sequential_methods, void* user_data); - - void (*free)(ARKodeSplittingExecutionPolicy policy); - - void* data; -}; - -SUNDIALS_EXPORT void ARKodeSplittingExecutionPolicy_Free( - ARKodeSplittingExecutionPolicy* policy); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/arkode/arkode_splittingstep.h b/include/arkode/arkode_splittingstep.h index 9ff468e02c..006225e7d4 100644 --- a/include/arkode/arkode_splittingstep.h +++ b/include/arkode/arkode_splittingstep.h @@ -17,7 +17,6 @@ #ifndef ARKODE_SPLITTINGSTEP_H_ #define ARKODE_SPLITTINGSTEP_H_ -#include #include #include #include @@ -102,9 +101,6 @@ SUNDIALS_EXPORT void* SplittingStepCreate(SUNStepper* steppers, int partitions, SUNDIALS_EXPORT int SplittingStep_SetCoefficients( void* arkode_mem, SplittingStepCoefficients coefficients); -SUNDIALS_EXPORT int SplittingStep_SetExecutionPolicy( - void* arkode_mem, ARKodeSplittingExecutionPolicy policy); - SUNDIALS_EXPORT int SplittingStep_GetNumEvolves(void* arkode_mem, int partition, long int* evolves); diff --git a/include/arkode/execution_policy/arkode_execution_policy_serial.h b/include/arkode/execution_policy/arkode_execution_policy_serial.h deleted file mode 100644 index 4afff57847..0000000000 --- a/include/arkode/execution_policy/arkode_execution_policy_serial.h +++ /dev/null @@ -1,33 +0,0 @@ -/* ----------------------------------------------------------------------------- - * Programmer(s): Steven B. Roberts @ LLNL - * ----------------------------------------------------------------------------- - * SUNDIALS Copyright Start - * Copyright (c) 2002-2024, Lawrence Livermore National Security - * and Southern Methodist University. - * All rights reserved. - * - * See the top-level LICENSE and NOTICE files for details. - * - * SPDX-License-Identifier: BSD-3-Clause - * SUNDIALS Copyright End - * ----------------------------------------------------------------------------- - * The header file for the serial execution policy - * ---------------------------------------------------------------------------*/ - -#ifndef ARKODE_EXECUTION_POLICY_SERIAL_H_ -#define ARKODE_EXECUTION_POLICY_SERIAL_H_ - -#include - -#ifdef __cplusplus /* wrapper to enable C++ usage */ -extern "C" { -#endif - -SUNDIALS_EXPORT ARKodeSplittingExecutionPolicy -ARKodeSplittingExecutionPolicy_New_Serial(void); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/src/arkode/CMakeLists.txt b/src/arkode/CMakeLists.txt index cbc870b761..b494c25ecb 100644 --- a/src/arkode/CMakeLists.txt +++ b/src/arkode/CMakeLists.txt @@ -40,14 +40,12 @@ set(arkode_SOURCES arkode_relaxation.c arkode_root.c arkode_splittingstep_coefficients.c - arkode_splittingstep_executionpolicy.c arkode_splittingstep.c arkode_sprkstep_io.c arkode_sprkstep.c arkode_sprk.c arkode_user_controller.c - arkode.c - execution_policy/arkode_execution_policy_serial.c) + arkode.c) # Add variable arkode_HEADERS with the exported ARKODE header files set(arkode_HEADERS diff --git a/src/arkode/arkode_splittingstep.c b/src/arkode/arkode_splittingstep.c index 38d0134bb8..974af199b7 100644 --- a/src/arkode/arkode_splittingstep.c +++ b/src/arkode/arkode_splittingstep.c @@ -17,7 +17,6 @@ #include #include -#include #include #include "arkode_impl.h" @@ -125,7 +124,6 @@ static int splittingStep_SetCoefficients(const ARKodeMem ark_mem, With initialization types FIRST_INIT this routine: - sets/checks the splitting coefficients to be used - - sets/checks the execution policy to be used With other initialization types, this routine does nothing. ---------------------------------------------------------------*/ @@ -152,21 +150,6 @@ static int splittingStep_Init(const ARKodeMem ark_mem, const int init_type) retval = splittingStep_SetCoefficients(ark_mem, step_mem); if (retval != ARK_SUCCESS) { return retval; } - if (step_mem->policy == NULL) - { - step_mem->policy = ARKodeSplittingExecutionPolicy_New_Serial(); - if (step_mem->policy == NULL) - { - if (step_mem->coefficients == NULL) - { - arkProcessError(ark_mem, ARK_MEM_FAIL, __LINE__, __func__, __FILE__, - "Failed to allocate execution policy"); - return ARK_MEM_FAIL; - } - } - step_mem->own_policy = SUNTRUE; - } - ark_mem->interp_degree = SUNMAX(1, SUNMIN(step_mem->coefficients->order - 1, ark_mem->interp_degree)); @@ -222,7 +205,7 @@ static int splittingStep_FullRHS(const ARKodeMem ark_mem, const sunrealtype t, MSG_ARK_RHSFUNC_FAILED, t); return (ARK_RHSFUNC_FAIL); } - N_VLinearSum(SUN_RCONST(1.0), f, SUN_RCONST(1.0), ark_mem->tempv1, f); + N_VLinearSum(ONE, f, ONE, ark_mem->tempv1, f); } return ARK_SUCCESS; @@ -231,14 +214,10 @@ static int splittingStep_FullRHS(const ARKodeMem ark_mem, const sunrealtype t, /*--------------------------------------------------------------- This routine performs a sequential operator splitting method ---------------------------------------------------------------*/ -static int splittingStep_SequentialMethod(const int i, const N_Vector y, - void* const user_data) +static int splittingStep_SequentialMethod(const ARKodeMem ark_mem, + const ARKodeSplittingStepMem step_mem, + const int i, const N_Vector y) { - ARKodeMem ark_mem = (ARKodeMem)user_data; - ARKodeSplittingStepMem step_mem = NULL; - const int retval = splittingStep_AccessStepMem(ark_mem, __func__, &step_mem); - if (retval != ARK_SUCCESS) { return (retval); } - const SplittingStepCoefficients coefficients = step_mem->coefficients; #if SUNDIALS_LOGGING_LEVEL >= SUNDIALS_LOGGING_DEBUG @@ -312,11 +291,26 @@ static int splittingStep_TakeStep(const ARKodeMem ark_mem, const SplittingStepCoefficients coefficients = step_mem->coefficients; - return step_mem->policy->execute(step_mem->policy, - splittingStep_SequentialMethod, ark_mem->yn, - ark_mem->ycur, ark_mem->tempv1, - coefficients->alpha, - coefficients->sequential_methods, ark_mem); + N_VScale(ONE, ark_mem->yn, ark_mem->ycur); + retval = splittingStep_SequentialMethod(ark_mem, step_mem, 0, ark_mem->ycur); + if (retval != ARK_SUCCESS) { return retval; } + + if (coefficients->alpha[0] != ONE) + { + N_VScale(coefficients->alpha[0], ark_mem->ycur, ark_mem->ycur); + } + + for (int i = 1; i < coefficients->sequential_methods; i++) + { + N_VScale(ONE, ark_mem->yn, ark_mem->tempv1); + retval = splittingStep_SequentialMethod(ark_mem, step_mem, i, + ark_mem->tempv1); + if (retval != ARK_SUCCESS) { return retval; } + N_VLinearSum(ONE, ark_mem->ycur, coefficients->alpha[i], ark_mem->tempv1, + ark_mem->ycur); + } + + return ARK_SUCCESS; } /*--------------------------------------------------------------- @@ -382,11 +376,6 @@ static void splittingStep_Free(const ARKodeMem ark_mem) { free(step_mem->steppers); free(step_mem->n_stepper_evolves); - if (step_mem->own_policy) - { - ARKodeSplittingExecutionPolicy_Free(&step_mem->policy); - } - SplittingStepCoefficients_Free(step_mem->coefficients); free(step_mem); } @@ -451,9 +440,6 @@ static int splittingStep_SetDefaults(const ARKodeMem ark_mem) retval = splittingStep_SetOrder(ark_mem, 0); if (retval != ARK_SUCCESS) { return retval; } - if (step_mem->own_policy) { free(step_mem->policy); } - step_mem->own_policy = SUNFALSE; - /* TODO(SBR): This may cause issues if a user calls ARKodeSetDefaults. This * issues affects other ARKODE steppers as well */ ARKodeSetInterpolantType(ark_mem, ARK_INTERP_LAGRANGE); @@ -537,7 +523,6 @@ void* SplittingStepCreate(SUNStepper* const steppers, const int partitions, memcpy(step_mem->steppers, steppers, partitions * sizeof(*steppers)); step_mem->coefficients = NULL; - step_mem->policy = NULL; step_mem->n_stepper_evolves = calloc(partitions, sizeof(*step_mem->n_stepper_evolves)); if (step_mem->n_stepper_evolves == NULL) @@ -549,7 +534,6 @@ void* SplittingStepCreate(SUNStepper* const steppers, const int partitions, } step_mem->partitions = partitions; step_mem->order = 0; - step_mem->own_policy = SUNFALSE; /* Attach step_mem structure and function pointers to ark_mem */ ark_mem->step_init = splittingStep_Init; @@ -625,35 +609,6 @@ int SplittingStep_SetCoefficients(void* const arkode_mem, return ARK_SUCCESS; } -/*--------------------------------------------------------------- - Sets the execution policy. - ---------------------------------------------------------------*/ -int SplittingStep_SetExecutionPolicy(void* const arkode_mem, - ARKodeSplittingExecutionPolicy policy) -{ - ARKodeMem ark_mem = NULL; - ARKodeSplittingStepMem step_mem = NULL; - int retval = splittingStep_AccessARKODEStepMem(arkode_mem, __func__, &ark_mem, - &step_mem); - if (retval != ARK_SUCCESS) { return (retval); } - - if (policy == NULL) - { - arkProcessError(ark_mem, ARK_ILL_INPUT, __LINE__, __func__, __FILE__, - "The execution policy must be non-NULL"); - return ARK_ILL_INPUT; - } - - if (step_mem->own_policy) - { - ARKodeSplittingExecutionPolicy_Free(&step_mem->policy); - } - step_mem->policy = policy; - step_mem->own_policy = SUNFALSE; - - return ARK_SUCCESS; -} - int SplittingStep_GetNumEvolves(void* const arkode_mem, const int partition, long int* const evolves) { diff --git a/src/arkode/arkode_splittingstep_executionpolicy.c b/src/arkode/arkode_splittingstep_executionpolicy.c deleted file mode 100644 index c85e622003..0000000000 --- a/src/arkode/arkode_splittingstep_executionpolicy.c +++ /dev/null @@ -1,35 +0,0 @@ -/*--------------------------------------------------------------- - * Programmer(s): Steven B. Roberts @ LLNL - *--------------------------------------------------------------- - * SUNDIALS Copyright Start - * Copyright (c) 2002-2024, Lawrence Livermore National Security - * and Southern Methodist University. - * All rights reserved. - * - * See the top-level LICENSE and NOTICE files for details. - * - * SPDX-License-Identifier: BSD-3-Clause - * SUNDIALS Copyright End - *--------------------------------------------------------------- - * This is the implementation file for execution policy. - *--------------------------------------------------------------*/ - -#include -#include -#include - -#include "sundials_macros.h" - -/*--------------------------------------------------------------- - This routine frees all the ARKodeSplittingExecutionPolicy - memory - ---------------------------------------------------------------*/ -void ARKodeSplittingExecutionPolicy_Free(ARKodeSplittingExecutionPolicy* policy) -{ - if (policy != NULL) - { - (*policy)->free(*policy); - free(*policy); - *policy = NULL; - } -} diff --git a/src/arkode/arkode_splittingstep_impl.h b/src/arkode/arkode_splittingstep_impl.h index 1900978ece..88988b4eb6 100644 --- a/src/arkode/arkode_splittingstep_impl.h +++ b/src/arkode/arkode_splittingstep_impl.h @@ -23,12 +23,10 @@ typedef struct ARKodeSplittingStepMemRec { SUNStepper* steppers; SplittingStepCoefficients coefficients; - ARKodeSplittingExecutionPolicy policy; long int* n_stepper_evolves; int partitions; int order; - sunbooleantype own_policy; }* ARKodeSplittingStepMem; #endif diff --git a/src/arkode/execution_policy/arkode_execution_policy_serial.c b/src/arkode/execution_policy/arkode_execution_policy_serial.c deleted file mode 100644 index cfcd2da1ed..0000000000 --- a/src/arkode/execution_policy/arkode_execution_policy_serial.c +++ /dev/null @@ -1,85 +0,0 @@ -/*--------------------------------------------------------------- - * Programmer(s): Steven B. Roberts @ LLNL - *--------------------------------------------------------------- - * SUNDIALS Copyright Start - * Copyright (c) 2002-2024, Lawrence Livermore National Security - * and Southern Methodist University. - * All rights reserved. - * - * See the top-level LICENSE and NOTICE files for details. - * - * SPDX-License-Identifier: BSD-3-Clause - * SUNDIALS Copyright End - *--------------------------------------------------------------- - * This is the implementation file for the serial execution - * policy. - *--------------------------------------------------------------*/ - -#include -#include -#include - -#include "sundials_macros.h" - -/*--------------------------------------------------------------- - This routine does the setup for serial execution for which - nothing is needed. - ---------------------------------------------------------------*/ -static int setup_serial( - SUNDIALS_MAYBE_UNUSED const ARKodeSplittingExecutionPolicy policy, - SUNDIALS_MAYBE_UNUSED const N_Vector y, - SUNDIALS_MAYBE_UNUSED const int sequential_methods) -{ - return ARK_SUCCESS; -} - -/*--------------------------------------------------------------- - This routine evaluates the policy function fn in serial over - the range of sequential methods - ---------------------------------------------------------------*/ -static int execute_serial( - SUNDIALS_MAYBE_UNUSED const ARKodeSplittingExecutionPolicy policy, - const ARKExecutionPolicyFn fn, const N_Vector yn, const N_Vector ycur, - const N_Vector tmp, sunrealtype* const alpha, const int sequential_methods, - void* const user_data) -{ - N_VScale(SUN_RCONST(1.0), yn, ycur); - int retval = fn(0, ycur, user_data); - if (retval != ARK_SUCCESS) { return retval; } - - if (alpha[0] != SUN_RCONST(1.0)) { N_VScale(alpha[0], ycur, ycur); } - - for (int i = 1; i < sequential_methods; i++) - { - N_VScale(SUN_RCONST(1.0), yn, tmp); - retval = fn(i, tmp, user_data); - if (retval != ARK_SUCCESS) { return retval; } - N_VLinearSum(SUN_RCONST(1.0), ycur, alpha[i], tmp, ycur); - } - - return ARK_SUCCESS; -} - -/*--------------------------------------------------------------- - This routine does the freeing for serial execution which happens - to be nothing - ---------------------------------------------------------------*/ -static void free_serial( - SUNDIALS_MAYBE_UNUSED const ARKodeSplittingExecutionPolicy policy) -{ - // Nothing needed -} - -/*--------------------------------------------------------------- - This routine creates a serial execution policy - ---------------------------------------------------------------*/ -ARKodeSplittingExecutionPolicy ARKodeSplittingExecutionPolicy_New_Serial(void) -{ - ARKodeSplittingExecutionPolicy policy = malloc(sizeof(*policy)); - if (policy == NULL) { return NULL; } - policy->setup = setup_serial; - policy->execute = execute_serial; - policy->free = free_serial; - policy->data = NULL; - return policy; -} diff --git a/src/arkode/fmod_int32/farkode_splittingstep_mod.c b/src/arkode/fmod_int32/farkode_splittingstep_mod.c index 1025d29cca..f343e4ce69 100644 --- a/src/arkode/fmod_int32/farkode_splittingstep_mod.c +++ b/src/arkode/fmod_int32/farkode_splittingstep_mod.c @@ -727,21 +727,6 @@ SWIGEXPORT int _wrap_FSplittingStep_SetCoefficients(void *farg1, SwigClassWrappe } -SWIGEXPORT int _wrap_FSplittingStep_SetExecutionPolicy(void *farg1, SwigClassWrapper const *farg2) { - int fresult ; - void *arg1 = (void *) 0 ; - ARKodeSplittingExecutionPolicy arg2 ; - int result; - - arg1 = (void *)(farg1); - SWIG_check_nonnull(*farg2, "ARKodeSplittingExecutionPolicy", "SWIGTYPE_p_ARKodeSplittingExecutionPolicy", "SplittingStep_SetExecutionPolicy(void *,ARKodeSplittingExecutionPolicy)", return 0); - arg2 = *(ARKodeSplittingExecutionPolicy *)(farg2->cptr); - result = (int)SplittingStep_SetExecutionPolicy(arg1,arg2); - fresult = (int)(result); - return fresult; -} - - SWIGEXPORT int _wrap_FSplittingStep_GetNumEvolves(void *farg1, int const *farg2, long *farg3) { int fresult ; void *arg1 = (void *) 0 ; diff --git a/src/arkode/fmod_int32/farkode_splittingstep_mod.f90 b/src/arkode/fmod_int32/farkode_splittingstep_mod.f90 index 010112b6cb..da68d91177 100644 --- a/src/arkode/fmod_int32/farkode_splittingstep_mod.f90 +++ b/src/arkode/fmod_int32/farkode_splittingstep_mod.f90 @@ -98,10 +98,6 @@ module farkode_splittingstep_mod end type public :: FSplittingStepCreate public :: FSplittingStep_SetCoefficients - type, public :: SWIGTYPE_p_ARKodeSplittingExecutionPolicy - type(SwigClassWrapper), public :: swigdata - end type - public :: FSplittingStep_SetExecutionPolicy public :: FSplittingStep_GetNumEvolves ! WRAPPER DECLARATIONS @@ -401,16 +397,6 @@ function swigc_FSplittingStep_SetCoefficients(farg1, farg2) & integer(C_INT) :: fresult end function -function swigc_FSplittingStep_SetExecutionPolicy(farg1, farg2) & -bind(C, name="_wrap_FSplittingStep_SetExecutionPolicy") & -result(fresult) -use, intrinsic :: ISO_C_BINDING -import :: swigclasswrapper -type(C_PTR), value :: farg1 -type(SwigClassWrapper) :: farg2 -integer(C_INT) :: fresult -end function - function swigc_FSplittingStep_GetNumEvolves(farg1, farg2, farg3) & bind(C, name="_wrap_FSplittingStep_GetNumEvolves") & result(fresult) @@ -905,22 +891,6 @@ function FSplittingStep_SetCoefficients(arkode_mem, coefficients) & swig_result = fresult end function -function FSplittingStep_SetExecutionPolicy(arkode_mem, policy) & -result(swig_result) -use, intrinsic :: ISO_C_BINDING -integer(C_INT) :: swig_result -type(C_PTR) :: arkode_mem -type(SWIGTYPE_p_ARKodeSplittingExecutionPolicy), intent(in) :: policy -integer(C_INT) :: fresult -type(C_PTR) :: farg1 -type(SwigClassWrapper) :: farg2 - -farg1 = arkode_mem -farg2 = policy%swigdata -fresult = swigc_FSplittingStep_SetExecutionPolicy(farg1, farg2) -swig_result = fresult -end function - function FSplittingStep_GetNumEvolves(arkode_mem, partition, evolves) & result(swig_result) use, intrinsic :: ISO_C_BINDING diff --git a/src/arkode/fmod_int64/farkode_splittingstep_mod.c b/src/arkode/fmod_int64/farkode_splittingstep_mod.c index 1025d29cca..f343e4ce69 100644 --- a/src/arkode/fmod_int64/farkode_splittingstep_mod.c +++ b/src/arkode/fmod_int64/farkode_splittingstep_mod.c @@ -727,21 +727,6 @@ SWIGEXPORT int _wrap_FSplittingStep_SetCoefficients(void *farg1, SwigClassWrappe } -SWIGEXPORT int _wrap_FSplittingStep_SetExecutionPolicy(void *farg1, SwigClassWrapper const *farg2) { - int fresult ; - void *arg1 = (void *) 0 ; - ARKodeSplittingExecutionPolicy arg2 ; - int result; - - arg1 = (void *)(farg1); - SWIG_check_nonnull(*farg2, "ARKodeSplittingExecutionPolicy", "SWIGTYPE_p_ARKodeSplittingExecutionPolicy", "SplittingStep_SetExecutionPolicy(void *,ARKodeSplittingExecutionPolicy)", return 0); - arg2 = *(ARKodeSplittingExecutionPolicy *)(farg2->cptr); - result = (int)SplittingStep_SetExecutionPolicy(arg1,arg2); - fresult = (int)(result); - return fresult; -} - - SWIGEXPORT int _wrap_FSplittingStep_GetNumEvolves(void *farg1, int const *farg2, long *farg3) { int fresult ; void *arg1 = (void *) 0 ; diff --git a/src/arkode/fmod_int64/farkode_splittingstep_mod.f90 b/src/arkode/fmod_int64/farkode_splittingstep_mod.f90 index 010112b6cb..da68d91177 100644 --- a/src/arkode/fmod_int64/farkode_splittingstep_mod.f90 +++ b/src/arkode/fmod_int64/farkode_splittingstep_mod.f90 @@ -98,10 +98,6 @@ module farkode_splittingstep_mod end type public :: FSplittingStepCreate public :: FSplittingStep_SetCoefficients - type, public :: SWIGTYPE_p_ARKodeSplittingExecutionPolicy - type(SwigClassWrapper), public :: swigdata - end type - public :: FSplittingStep_SetExecutionPolicy public :: FSplittingStep_GetNumEvolves ! WRAPPER DECLARATIONS @@ -401,16 +397,6 @@ function swigc_FSplittingStep_SetCoefficients(farg1, farg2) & integer(C_INT) :: fresult end function -function swigc_FSplittingStep_SetExecutionPolicy(farg1, farg2) & -bind(C, name="_wrap_FSplittingStep_SetExecutionPolicy") & -result(fresult) -use, intrinsic :: ISO_C_BINDING -import :: swigclasswrapper -type(C_PTR), value :: farg1 -type(SwigClassWrapper) :: farg2 -integer(C_INT) :: fresult -end function - function swigc_FSplittingStep_GetNumEvolves(farg1, farg2, farg3) & bind(C, name="_wrap_FSplittingStep_GetNumEvolves") & result(fresult) @@ -905,22 +891,6 @@ function FSplittingStep_SetCoefficients(arkode_mem, coefficients) & swig_result = fresult end function -function FSplittingStep_SetExecutionPolicy(arkode_mem, policy) & -result(swig_result) -use, intrinsic :: ISO_C_BINDING -integer(C_INT) :: swig_result -type(C_PTR) :: arkode_mem -type(SWIGTYPE_p_ARKodeSplittingExecutionPolicy), intent(in) :: policy -integer(C_INT) :: fresult -type(C_PTR) :: farg1 -type(SwigClassWrapper) :: farg2 - -farg1 = arkode_mem -farg2 = policy%swigdata -fresult = swigc_FSplittingStep_SetExecutionPolicy(farg1, farg2) -swig_result = fresult -end function - function FSplittingStep_GetNumEvolves(arkode_mem, partition, evolves) & result(swig_result) use, intrinsic :: ISO_C_BINDING