From a126422dcc8c873a2e3a2f81c9bfde5ab7b1ca22 Mon Sep 17 00:00:00 2001 From: David Beckingsale Date: Fri, 9 Jan 2026 13:15:30 -0800 Subject: [PATCH 01/27] Update umpire_shroud.yaml for untracked pools --- src/umpire/interface/umpire_shroud.yaml | 43 +++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 77bc05bab..2b68a2e62 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -261,6 +261,49 @@ declarations: template_suffix: _prefetcher function_suffix: "" + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t initial_size, size_t block); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + template_suffix: _list_pool_untracked + function_suffix: "" + - instantiation: + format: + template_suffix: _quick_pool_untracked + function_suffix: "" + - instantiation: + format: + template_suffix: _resource_aware_pool_untracked + function_suffix: "" + + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t object_size); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + template_suffix: _fixed_pool_untracked + function_suffix: "" + - instantiation: + format: + template_suffix: _monotonic_untracked + function_suffix: "" + - instantiation: + format: + template_suffix: _slot_pool_untracked + function_suffix: "" + + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + template_suffix: _mixed_pool_untracked + function_suffix: "" + - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From a6371817d2f5113dbfc681a74acf7c08a4a2c938 Mon Sep 17 00:00:00 2001 From: David Beckingsale Date: Tue, 3 Feb 2026 19:45:10 -0800 Subject: [PATCH 02/27] Use splicer to work around bool template param issue --- src/umpire/interface/umpire_shroud.yaml | 80 ++++++++++++------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 2b68a2e62..f4c98b6e8 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -261,48 +261,48 @@ declarations: template_suffix: _prefetcher function_suffix: "" - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t initial_size, size_t block); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - template_suffix: _list_pool_untracked - function_suffix: "" - - instantiation: - format: - template_suffix: _quick_pool_untracked - function_suffix: "" - - instantiation: - format: - template_suffix: _resource_aware_pool_untracked - function_suffix: "" + # Untracked pool allocators - using splicer to handle bool template parameter + - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t object_size); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - template_suffix: _fixed_pool_untracked - function_suffix: "" - - instantiation: - format: - template_suffix: _monotonic_untracked - function_suffix: "" - - instantiation: - format: - template_suffix: _slot_pool_untracked - function_suffix: "" + - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - template_suffix: _mixed_pool_untracked - function_suffix: "" + - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + + - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + + - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + + - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + + - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + splicer: + c: | + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From f19355b1b0ceb2dba9e00bdfb9c6410078aa0fd1 Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 4 Feb 2026 03:46:34 +0000 Subject: [PATCH 03/27] Update C/FORTRAN interface --- .../c_fortran/wrapResourceManager.cpp | 240 +++++++++++ .../interface/c_fortran/wrapResourceManager.h | 76 ++++ src/umpire/interface/c_fortran/wrapfumpire.f | 387 ++++++++++++++++++ 3 files changed, 703 insertions(+) diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index b0c39f875..e328017ba 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -675,6 +675,246 @@ umpire_allocator * umpire_resourcemanager_make_allocator_bufferify_prefetcher( // splicer end class.ResourceManager.method.make_allocator_bufferify_prefetcher } +umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + // splicer end class.ResourceManager.method.make_allocator_list_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_list_pool_untracked(SHCXX_name, + *SHCXX_allocator, initial_size, block); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_list_pool_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + // splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_quick_pool_untracked(SHCXX_name, + *SHCXX_allocator, initial_size, block); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + // splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_resource_aware_pool_untracked( + SHCXX_name, *SHCXX_allocator, initial_size, block); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + // splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_fixed_pool_untracked(SHCXX_name, + *SHCXX_allocator, object_size); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + // splicer end class.ResourceManager.method.make_allocator_monotonic_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_monotonic_untracked(SHCXX_name, + *SHCXX_allocator, object_size); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_monotonic_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + // splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_slot_pool_untracked(SHCXX_name, + *SHCXX_allocator, object_size); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked_bufferify +} + +umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t smallest_fixed_obj_size, + size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, + size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, + size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked + umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); + SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); + // splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked +} + +umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t smallest_fixed_obj_size, + size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, + size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, + size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes, + umpire_allocator * SHC_rv) +{ + umpire::ResourceManager *SH_this = + static_cast(self->addr); + // splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked_bufferify + const std::string SHCXX_name(name, Lname); + umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); + umpire::Allocator * SHCXX_rv = new umpire::Allocator; + *SHCXX_rv = SH_this->makeAllocator_mixed_pool_untracked(SHCXX_name, + *SHCXX_allocator, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHCXX_rv; + SHC_rv->idtor = 1; + return SHC_rv; + // splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked_bufferify +} + void umpire_resourcemanager_add_alias(umpire_resourcemanager * self, const char * name, umpire_allocator allocator) { diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.h b/src/umpire/interface/c_fortran/wrapResourceManager.h index fd4ebe729..525f4e133 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.h +++ b/src/umpire/interface/c_fortran/wrapResourceManager.h @@ -186,6 +186,82 @@ umpire_allocator * umpire_resourcemanager_make_allocator_bufferify_prefetcher( umpire_allocator allocator, int device_id, umpire_allocator * SHC_rv); +umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t initial_size, size_t block, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t object_size, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked( + umpire_resourcemanager * self, const char * name, + umpire_allocator allocator, size_t smallest_fixed_obj_size, + size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, + size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, + size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes, + umpire_allocator * SHC_rv); + +umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( + umpire_resourcemanager * self, const char * name, int Lname, + umpire_allocator allocator, size_t smallest_fixed_obj_size, + size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, + size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, + size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes, + umpire_allocator * SHC_rv); + void umpire_resourcemanager_add_alias(umpire_resourcemanager * self, const char * name, umpire_allocator allocator); diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index a09bd4ec6..db0704526 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -242,6 +242,13 @@ module umpire_mod procedure :: make_allocator_naming_shim => resourcemanager_make_allocator_naming_shim procedure :: make_allocator_mixed_pool => resourcemanager_make_allocator_mixed_pool procedure :: make_allocator_prefetcher => resourcemanager_make_allocator_prefetcher + procedure :: make_allocator_list_pool_untracked => resourcemanager_make_allocator_list_pool_untracked + procedure :: make_allocator_quick_pool_untracked => resourcemanager_make_allocator_quick_pool_untracked + procedure :: make_allocator_resource_aware_pool_untracked => resourcemanager_make_allocator_resource_aware_pool_untracked + procedure :: make_allocator_fixed_pool_untracked => resourcemanager_make_allocator_fixed_pool_untracked + procedure :: make_allocator_monotonic_untracked => resourcemanager_make_allocator_monotonic_untracked + procedure :: make_allocator_slot_pool_untracked => resourcemanager_make_allocator_slot_pool_untracked + procedure :: make_allocator_mixed_pool_untracked => resourcemanager_make_allocator_mixed_pool_untracked procedure :: add_alias => resourcemanager_add_alias procedure :: remove_alias => resourcemanager_remove_alias procedure :: get_allocator_for_ptr => resourcemanager_get_allocator_for_ptr @@ -910,6 +917,252 @@ function c_resourcemanager_make_allocator_bufferify_prefetcher( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_bufferify_prefetcher + function c_resourcemanager_make_allocator_list_pool_untracked( & + self, name, allocator, initial_size, block, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_list_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_list_pool_untracked + + function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & + self, name, Lname, allocator, initial_size, block, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_list_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_list_pool_untracked_bufferify + + function c_resourcemanager_make_allocator_quick_pool_untracked( & + self, name, allocator, initial_size, block, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_quick_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_quick_pool_untracked + + function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & + self, name, Lname, allocator, initial_size, block, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_quick_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify + + function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & + self, name, allocator, initial_size, block, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_resource_aware_pool_untracked + + function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & + self, name, Lname, allocator, initial_size, block, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify + + function c_resourcemanager_make_allocator_fixed_pool_untracked( & + self, name, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_fixed_pool_untracked + + function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & + self, name, Lname, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify + + function c_resourcemanager_make_allocator_monotonic_untracked( & + self, name, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_monotonic_untracked + + function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & + self, name, Lname, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_monotonic_untracked_bufferify + + function c_resourcemanager_make_allocator_slot_pool_untracked( & + self, name, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_slot_pool_untracked + + function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & + self, name, Lname, allocator, object_size, SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify + + function c_resourcemanager_make_allocator_mixed_pool_untracked( & + self, name, allocator, smallest_fixed_obj_size, & + largest_fixed_obj_size, max_initial_fixed_pool_size, & + fixed_size_multiplier, quick_pool_initial_alloc_size, & + quick_pool_min_alloc_size, quick_pool_align_bytes, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_mixed_pool_untracked") + use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: smallest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: largest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: max_initial_fixed_pool_size + integer(C_SIZE_T), value, intent(IN) :: fixed_size_multiplier + integer(C_SIZE_T), value, intent(IN) :: quick_pool_initial_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_min_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_mixed_pool_untracked + + function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & + self, name, Lname, allocator, smallest_fixed_obj_size, & + largest_fixed_obj_size, max_initial_fixed_pool_size, & + fixed_size_multiplier, quick_pool_initial_alloc_size, & + quick_pool_min_alloc_size, quick_pool_align_bytes, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_mixed_pool_untracked_bufferify") + use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T + import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule + implicit none + type(umpire_SHROUD_resourcemanager_capsule), intent(IN) :: self + character(kind=C_CHAR), intent(IN) :: name(*) + integer(C_INT), value, intent(IN) :: Lname + type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator + integer(C_SIZE_T), value, intent(IN) :: smallest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: largest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: max_initial_fixed_pool_size + integer(C_SIZE_T), value, intent(IN) :: fixed_size_multiplier + integer(C_SIZE_T), value, intent(IN) :: quick_pool_initial_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_min_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes + type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv + type(C_PTR) SHT_rv + end function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify + subroutine c_resourcemanager_add_alias(self, name, allocator) & bind(C, name="umpire_resourcemanager_add_alias") use iso_c_binding, only : C_CHAR @@ -3093,6 +3346,140 @@ function resourcemanager_make_allocator_prefetcher(obj, name, & ! splicer end class.ResourceManager.method.make_allocator_prefetcher end function resourcemanager_make_allocator_prefetcher + function resourcemanager_make_allocator_list_pool_untracked(obj, & + name, allocator, initial_size, block) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_list_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + initial_size, block, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_list_pool_untracked + end function resourcemanager_make_allocator_list_pool_untracked + + function resourcemanager_make_allocator_quick_pool_untracked(obj, & + name, allocator, initial_size, block) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_quick_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + initial_size, block, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked + end function resourcemanager_make_allocator_quick_pool_untracked + + function resourcemanager_make_allocator_resource_aware_pool_untracked( & + obj, name, allocator, initial_size, block) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: initial_size + integer(C_SIZE_T), value, intent(IN) :: block + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + initial_size, block, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked + end function resourcemanager_make_allocator_resource_aware_pool_untracked + + function resourcemanager_make_allocator_fixed_pool_untracked(obj, & + name, allocator, object_size) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + object_size, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked + end function resourcemanager_make_allocator_fixed_pool_untracked + + function resourcemanager_make_allocator_monotonic_untracked(obj, & + name, allocator, object_size) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_monotonic_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + object_size, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_monotonic_untracked + end function resourcemanager_make_allocator_monotonic_untracked + + function resourcemanager_make_allocator_slot_pool_untracked(obj, & + name, allocator, object_size) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: object_size + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_slot_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + object_size, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked + end function resourcemanager_make_allocator_slot_pool_untracked + + function resourcemanager_make_allocator_mixed_pool_untracked(obj, & + name, allocator, smallest_fixed_obj_size, & + largest_fixed_obj_size, max_initial_fixed_pool_size, & + fixed_size_multiplier, quick_pool_initial_alloc_size, & + quick_pool_min_alloc_size, quick_pool_align_bytes) & + result(SHT_rv) + use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T + class(UmpireResourceManager) :: obj + character(len=*), intent(IN) :: name + type(UmpireAllocator), value, intent(IN) :: allocator + integer(C_SIZE_T), value, intent(IN) :: smallest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: largest_fixed_obj_size + integer(C_SIZE_T), value, intent(IN) :: max_initial_fixed_pool_size + integer(C_SIZE_T), value, intent(IN) :: fixed_size_multiplier + integer(C_SIZE_T), value, intent(IN) :: quick_pool_initial_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_min_alloc_size + integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes + type(UmpireAllocator) :: SHT_rv + ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked + type(C_PTR) :: SHT_prv + SHT_prv = c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + smallest_fixed_obj_size, largest_fixed_obj_size, & + max_initial_fixed_pool_size, fixed_size_multiplier, & + quick_pool_initial_alloc_size, quick_pool_min_alloc_size, & + quick_pool_align_bytes, SHT_rv%cxxmem) + ! splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked + end function resourcemanager_make_allocator_mixed_pool_untracked + subroutine resourcemanager_add_alias(obj, name, allocator) use iso_c_binding, only : C_INT class(UmpireResourceManager) :: obj From 6d0c691e06bd53ec898b56149dc4c3cd16363a2a Mon Sep 17 00:00:00 2001 From: David Beckingsale Date: Wed, 4 Feb 2026 08:25:54 -0800 Subject: [PATCH 04/27] Fixup splicer code to match generated code --- src/umpire/interface/umpire_shroud.yaml | 87 +++++++++++++++++++++---- 1 file changed, 73 insertions(+), 14 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index f4c98b6e8..5edc0d2f8 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -265,44 +265,103 @@ declarations: - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) splicer: c: | - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From b6b24424989eb069e6386be5c5d34492f9a01fc4 Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 1 Apr 2026 19:08:04 +0000 Subject: [PATCH 05/27] Update C/FORTRAN interface --- .../c_fortran/wrapResourceManager.cpp | 87 ++++++++++++++++--- 1 file changed, 73 insertions(+), 14 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index e328017ba..b9180152f 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -683,8 +683,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_list_pool_untracked } @@ -716,8 +724,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked } @@ -749,8 +765,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_unt umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, initial_size, block); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked } @@ -782,8 +806,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked } @@ -815,8 +847,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_monotonic_untracked } @@ -848,8 +888,16 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, object_size); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked } @@ -884,8 +932,19 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked( umpire::ResourceManager *SH_this = static_cast(self->addr); // splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked - umpire::Allocator *SHCXX_allocator = static_cast(allocator.addr); - SHCXX_rv = SH_this->makeAllocator(name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + SHC_rv->cmemflags = SWIG_MEM_RVALUE; + return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked } From ef7eea67539a0dccfaf88154cd6206ed714b2e9e Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Wed, 1 Apr 2026 12:50:26 -0700 Subject: [PATCH 06/27] shortening func names --- src/umpire/interface/c_fortran/wrapfumpire.f | 18 +++++++++--------- src/umpire/interface/umpire_shroud.yaml | 3 +++ 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index db0704526..54a435d27 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -1001,11 +1001,11 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & - self, name, Lname, allocator, initial_size, block, & - SHT_crv) & - result(SHT_rv) & - bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify") + function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & + self, name, Lname, allocator, initial_size, block, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify") use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule implicit none @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferif integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify + end function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -3394,9 +3394,9 @@ function resourcemanager_make_allocator_resource_aware_pool_untracked( & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & - name, len_trim(name, kind=C_INT), allocator%cxxmem, & - initial_size, block, SHT_rv%cxxmem) + SHT_prv = c_resourcemanager_make_allocator_ra_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked end function resourcemanager_make_allocator_resource_aware_pool_untracked diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 5edc0d2f8..0b00aac31 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -262,6 +262,9 @@ declarations: function_suffix: "" # Untracked pool allocators - using splicer to handle bool template parameter + # Note: Keep generated Fortran identifiers <= 63 chars (gfortran default limit). + # The ResourceAwarePool untracked + bufferify wrapper is particularly close to + # the limit due to the extra `_bufferify` suffix. - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) splicer: c: | From 582f6539ae050d99e1f05286f98e42ffb72296aa Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 1 Apr 2026 20:02:27 +0000 Subject: [PATCH 07/27] Update C/FORTRAN interface --- src/umpire/interface/c_fortran/wrapfumpire.f | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index 54a435d27..db0704526 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -1001,11 +1001,11 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & - self, name, Lname, allocator, initial_size, block, & - SHT_crv) & - result(SHT_rv) & - bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify") + function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & + self, name, Lname, allocator, initial_size, block, & + SHT_crv) & + result(SHT_rv) & + bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify") use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T import :: umpire_SHROUD_allocator_capsule, umpire_SHROUD_resourcemanager_capsule implicit none @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify + end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -3394,9 +3394,9 @@ function resourcemanager_make_allocator_resource_aware_pool_untracked( & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_ra_pool_untracked_bufferify(obj%cxxmem, & - name, len_trim(name, kind=C_INT), allocator%cxxmem, & - initial_size, block, SHT_rv%cxxmem) + SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & + name, len_trim(name, kind=C_INT), allocator%cxxmem, & + initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked end function resourcemanager_make_allocator_resource_aware_pool_untracked From acec2a03175530df91ca7345f07c72aefcd8298f Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Wed, 1 Apr 2026 13:52:25 -0700 Subject: [PATCH 08/27] codex fixing the github action for this case --- .github/actions/shroud/entrypoint.sh | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/.github/actions/shroud/entrypoint.sh b/.github/actions/shroud/entrypoint.sh index 7fd949634..313c8260b 100755 --- a/.github/actions/shroud/entrypoint.sh +++ b/.github/actions/shroud/entrypoint.sh @@ -1,5 +1,7 @@ #!/bin/bash +set -euo pipefail + git config --global --add safe.directory /github/workspace git config --global --add safe.directory /github/workspace/.radiuss-ci git config --global --add safe.directory /github/workspace/blt @@ -14,3 +16,26 @@ mkdir build && cd build cmake -DCMAKE_CXX_COMPILER=clang++ -DSHROUD_EXECUTABLE=/usr/local/bin/shroud .. make -j 3 generate_umpire_shroud +# Shroud v0.12.2 can generate a Fortran interface identifier longer than the +# 63-character limit enforced by gfortran, which breaks downstream builds. +# Keep the exported C symbol unchanged (bind(C,name=...)), but shorten the +# internal Fortran procedure name and its call sites. +python3 - <<'PY' +from __future__ import annotations + +from pathlib import Path + +path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapfumpire.f") +old = "c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify" +new = "c_resourcemanager_make_allocator_ra_pool_untracked_bufferify" + +if not path.exists(): + raise SystemExit(f"Expected generated file not found: {path}") + +text = path.read_text(encoding="utf-8", errors="strict") +if old not in text: + # If Shroud changes its naming to avoid the long identifier, no-op cleanly. + raise SystemExit(0) + +path.write_text(text.replace(old, new), encoding="utf-8") +PY From 83e114619d982e2c0dfd431ef1e45e9a7d770538 Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 1 Apr 2026 21:06:26 +0000 Subject: [PATCH 09/27] Update C/FORTRAN interface --- src/umpire/interface/c_fortran/wrapfumpire.f | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index db0704526..8d2de960b 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -1001,7 +1001,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & + function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferif integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify + end function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -3394,7 +3394,7 @@ function resourcemanager_make_allocator_resource_aware_pool_untracked( & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_ra_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked From de9602c0b8c8f4294702bdb8b03530009b5ae71b Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Wed, 1 Apr 2026 14:29:53 -0700 Subject: [PATCH 10/27] codex attempt to make fixes for CI --- .github/actions/shroud/entrypoint.sh | 78 +++++-- .../c_fortran/wrapResourceManager.cpp | 33 ++- src/umpire/interface/umpire_shroud.yaml | 193 +++++++++--------- 3 files changed, 170 insertions(+), 134 deletions(-) diff --git a/.github/actions/shroud/entrypoint.sh b/.github/actions/shroud/entrypoint.sh index 313c8260b..8d3a8e477 100755 --- a/.github/actions/shroud/entrypoint.sh +++ b/.github/actions/shroud/entrypoint.sh @@ -16,26 +16,76 @@ mkdir build && cd build cmake -DCMAKE_CXX_COMPILER=clang++ -DSHROUD_EXECUTABLE=/usr/local/bin/shroud .. make -j 3 generate_umpire_shroud -# Shroud v0.12.2 can generate a Fortran interface identifier longer than the -# 63-character limit enforced by gfortran, which breaks downstream builds. -# Keep the exported C symbol unchanged (bind(C,name=...)), but shorten the -# internal Fortran procedure name and its call sites. +# Post-process Shroud outputs for toolchain compatibility. python3 - <<'PY' from __future__ import annotations from pathlib import Path -path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapfumpire.f") -old = "c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify" -new = "c_resourcemanager_make_allocator_ra_pool_untracked_bufferify" -if not path.exists(): - raise SystemExit(f"Expected generated file not found: {path}") +def patch_wrapfumpire() -> None: + path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapfumpire.f") + old = "c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify" + new = "c_resourcemanager_make_allocator_ra_pool_untracked_bufferify" -text = path.read_text(encoding="utf-8", errors="strict") -if old not in text: - # If Shroud changes its naming to avoid the long identifier, no-op cleanly. - raise SystemExit(0) + if not path.exists(): + raise SystemExit(f"Expected generated file not found: {path}") -path.write_text(text.replace(old, new), encoding="utf-8") + text = path.read_text(encoding="utf-8", errors="strict") + if old not in text: + # If Shroud changes its naming to avoid the long identifier, no-op cleanly. + return + + # Shroud v0.12.2 can generate a Fortran interface identifier longer than the + # 63-character limit enforced by gfortran. + path.write_text(text.replace(old, new), encoding="utf-8") + + +def patch_wrapresourcemanager() -> None: + path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapResourceManager.cpp") + if not path.exists(): + raise SystemExit(f"Expected generated file not found: {path}") + + text = path.read_text(encoding="utf-8", errors="strict") + + # Newer Umpire Shroud capsules do not contain SWIG-style memory flags. + text = text.replace(" SHC_rv->cmemflags = SWIG_MEM_RVALUE;\n", "") + + # For the special *_untracked wrappers, Shroud generates the bufferify + # overloads by calling a (non-existent) C++ ResourceManager method. Patch + # those calls into the intended makeAllocator<..., false>(...) instantiations. + text = text.replace( + "makeAllocator_list_pool_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_quick_pool_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_resource_aware_pool_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_fixed_pool_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_monotonic_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_slot_pool_untracked", + "makeAllocator", + ) + text = text.replace( + "makeAllocator_mixed_pool_untracked", + "makeAllocator", + ) + + path.write_text(text, encoding="utf-8") + + +patch_wrapfumpire() +patch_wrapresourcemanager() PY diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index b9180152f..862ca9899 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -691,7 +691,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked( SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_list_pool_untracked } @@ -708,8 +707,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_list_pool_untracked(SHCXX_name, - *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -732,7 +731,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked( SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked } @@ -749,8 +747,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_quick_pool_untracked(SHCXX_name, - *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -773,7 +771,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_unt SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked } @@ -790,7 +787,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_unt umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_resource_aware_pool_untracked( + *SHCXX_rv = SH_this->makeAllocator( SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -814,7 +811,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked( SHC_name_cxx, *SHC_allocator_cxx, object_size); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked } @@ -831,8 +827,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_fixed_pool_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -855,7 +851,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked( SHC_name_cxx, *SHC_allocator_cxx, object_size); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_monotonic_untracked } @@ -872,8 +867,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_monotonic_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -896,7 +891,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked( SHC_name_cxx, *SHC_allocator_cxx, object_size); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked } @@ -913,8 +907,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_slot_pool_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -943,7 +937,6 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked( quick_pool_min_alloc_size, quick_pool_align_bytes); SHC_rv->addr = SHC_rv_cxx; SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; return SHC_rv; // splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked } @@ -963,8 +956,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_mixed_pool_untracked(SHCXX_name, - *SHCXX_allocator, smallest_fixed_obj_size, + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 0b00aac31..53e4f0ebb 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -265,106 +265,99 @@ declarations: # Note: Keep generated Fortran identifiers <= 63 chars (gfortran default limit). # The ResourceAwarePool untracked + bufferify wrapper is particularly close to # the limit due to the extra `_bufferify` suffix. - - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; - - - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, - largest_fixed_obj_size, max_initial_fixed_pool_size, - fixed_size_multiplier, quick_pool_initial_alloc_size, - quick_pool_min_alloc_size, quick_pool_align_bytes); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - SHC_rv->cmemflags = SWIG_MEM_RVALUE; - return SHC_rv; + - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From 0d65d0ab660e47d9a96df57d2e79ef8f2b33df95 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Wed, 1 Apr 2026 14:40:28 -0700 Subject: [PATCH 11/27] codex fix for tabs --- src/umpire/interface/umpire_shroud.yaml | 186 ++++++++++++------------ 1 file changed, 93 insertions(+), 93 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 53e4f0ebb..924a2cc22 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -265,99 +265,99 @@ declarations: # Note: Keep generated Fortran identifiers <= 63 chars (gfortran default limit). # The ResourceAwarePool untracked + bufferify wrapper is particularly close to # the limit due to the extra `_bufferify` suffix. - - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, - largest_fixed_obj_size, max_initial_fixed_pool_size, - fixed_size_multiplier, quick_pool_initial_alloc_size, - quick_pool_min_alloc_size, quick_pool_align_bytes); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; + - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From 20d4c1e10d70ad94588259e47b6a5bfd5251c8fd Mon Sep 17 00:00:00 2001 From: github-actions Date: Wed, 1 Apr 2026 21:42:46 +0000 Subject: [PATCH 12/27] Update C/FORTRAN interface --- .../c_fortran/wrapResourceManager.cpp | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index 862ca9899..963bd20d9 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -707,8 +707,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -747,8 +747,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -827,8 +827,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -867,8 +867,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -907,8 +907,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -956,8 +956,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( - SHCXX_name, *SHCXX_allocator, smallest_fixed_obj_size, + *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); From 4bf705b1c3013c111282c73df79376459e5dbef7 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Thu, 2 Apr 2026 15:51:40 -0700 Subject: [PATCH 13/27] removing patch, adding F_name_impl --- .github/actions/shroud/entrypoint.sh | 74 ------------------------- src/umpire/interface/umpire_shroud.yaml | 2 + 2 files changed, 2 insertions(+), 74 deletions(-) diff --git a/.github/actions/shroud/entrypoint.sh b/.github/actions/shroud/entrypoint.sh index 8d3a8e477..37ae2a6d1 100755 --- a/.github/actions/shroud/entrypoint.sh +++ b/.github/actions/shroud/entrypoint.sh @@ -15,77 +15,3 @@ git submodule update --init --recursive mkdir build && cd build cmake -DCMAKE_CXX_COMPILER=clang++ -DSHROUD_EXECUTABLE=/usr/local/bin/shroud .. make -j 3 generate_umpire_shroud - -# Post-process Shroud outputs for toolchain compatibility. -python3 - <<'PY' -from __future__ import annotations - -from pathlib import Path - - -def patch_wrapfumpire() -> None: - path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapfumpire.f") - old = "c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify" - new = "c_resourcemanager_make_allocator_ra_pool_untracked_bufferify" - - if not path.exists(): - raise SystemExit(f"Expected generated file not found: {path}") - - text = path.read_text(encoding="utf-8", errors="strict") - if old not in text: - # If Shroud changes its naming to avoid the long identifier, no-op cleanly. - return - - # Shroud v0.12.2 can generate a Fortran interface identifier longer than the - # 63-character limit enforced by gfortran. - path.write_text(text.replace(old, new), encoding="utf-8") - - -def patch_wrapresourcemanager() -> None: - path = Path("/github/workspace/src/umpire/interface/c_fortran/wrapResourceManager.cpp") - if not path.exists(): - raise SystemExit(f"Expected generated file not found: {path}") - - text = path.read_text(encoding="utf-8", errors="strict") - - # Newer Umpire Shroud capsules do not contain SWIG-style memory flags. - text = text.replace(" SHC_rv->cmemflags = SWIG_MEM_RVALUE;\n", "") - - # For the special *_untracked wrappers, Shroud generates the bufferify - # overloads by calling a (non-existent) C++ ResourceManager method. Patch - # those calls into the intended makeAllocator<..., false>(...) instantiations. - text = text.replace( - "makeAllocator_list_pool_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_quick_pool_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_resource_aware_pool_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_fixed_pool_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_monotonic_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_slot_pool_untracked", - "makeAllocator", - ) - text = text.replace( - "makeAllocator_mixed_pool_untracked", - "makeAllocator", - ) - - path.write_text(text, encoding="utf-8") - - -patch_wrapfumpire() -patch_wrapresourcemanager() -PY diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 924a2cc22..375859a9a 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -292,6 +292,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_allocator_ra_pool_untracked splicer: c: | const std::string SHC_name_cxx(name); From 716b656d7a283c6d9e1b128439744433cee00e62 Mon Sep 17 00:00:00 2001 From: github-actions Date: Thu, 2 Apr 2026 22:54:42 +0000 Subject: [PATCH 14/27] Update C/FORTRAN interface --- .../interface/c_fortran/wrapResourceManager.cpp | 14 +++++++------- src/umpire/interface/c_fortran/wrapfumpire.f | 14 +++++++------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index 963bd20d9..3b5ea7307 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -707,7 +707,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_list_pool_untracked(SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -747,7 +747,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_quick_pool_untracked(SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -787,7 +787,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_unt umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator( + *SHCXX_rv = SH_this->makeAllocator_resource_aware_pool_untracked( SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -827,7 +827,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_fixed_pool_untracked(SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -867,7 +867,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_monotonic_untracked(SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -907,7 +907,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_slot_pool_untracked(SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -956,7 +956,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator(SHCXX_name, + *SHCXX_rv = SH_this->makeAllocator_mixed_pool_untracked(SHCXX_name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index 8d2de960b..ee10c3a01 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -244,7 +244,7 @@ module umpire_mod procedure :: make_allocator_prefetcher => resourcemanager_make_allocator_prefetcher procedure :: make_allocator_list_pool_untracked => resourcemanager_make_allocator_list_pool_untracked procedure :: make_allocator_quick_pool_untracked => resourcemanager_make_allocator_quick_pool_untracked - procedure :: make_allocator_resource_aware_pool_untracked => resourcemanager_make_allocator_resource_aware_pool_untracked + procedure :: make_allocator_resource_aware_pool_untracked => make_allocator_ra_pool_untracked procedure :: make_allocator_fixed_pool_untracked => resourcemanager_make_allocator_fixed_pool_untracked procedure :: make_allocator_monotonic_untracked => resourcemanager_make_allocator_monotonic_untracked procedure :: make_allocator_slot_pool_untracked => resourcemanager_make_allocator_slot_pool_untracked @@ -1001,7 +1001,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & + function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify + end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -3382,8 +3382,8 @@ function resourcemanager_make_allocator_quick_pool_untracked(obj, & ! splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked end function resourcemanager_make_allocator_quick_pool_untracked - function resourcemanager_make_allocator_resource_aware_pool_untracked( & - obj, name, allocator, initial_size, block) & + function make_allocator_ra_pool_untracked(obj, name, allocator, & + initial_size, block) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3394,11 +3394,11 @@ function resourcemanager_make_allocator_resource_aware_pool_untracked( & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_ra_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked - end function resourcemanager_make_allocator_resource_aware_pool_untracked + end function make_allocator_ra_pool_untracked function resourcemanager_make_allocator_fixed_pool_untracked(obj, & name, allocator, object_size) & From d6e53afa1609d0d995e207c0b71a58aac9636511 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Mon, 6 Apr 2026 11:15:17 -0700 Subject: [PATCH 15/27] more edits to shorten names --- src/umpire/interface/c_fortran/wrapfumpire.f | 126 +++++++++---------- src/umpire/interface/umpire_shroud.yaml | 35 +++++- 2 files changed, 93 insertions(+), 68 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index 8d2de960b..fc89d0856 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -472,7 +472,7 @@ function c_resourcemanager_make_allocator_list_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_list_pool - function c_resourcemanager_make_allocator_bufferify_list_pool( & + function c_resourcemanager_make_alloc_dynamic_p_list_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -488,7 +488,7 @@ function c_resourcemanager_make_allocator_bufferify_list_pool( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_list_pool + end function c_resourcemanager_make_alloc_dynamic_p_list_bufferify function c_resourcemanager_make_allocator_quick_pool(self, name, & allocator, initial_size, block, SHT_crv) & @@ -506,7 +506,7 @@ function c_resourcemanager_make_allocator_quick_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_quick_pool - function c_resourcemanager_make_allocator_bufferify_quick_pool( & + function c_resourcemanager_make_alloc_quick_p_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -522,7 +522,7 @@ function c_resourcemanager_make_allocator_bufferify_quick_pool( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_quick_pool + end function c_resourcemanager_make_alloc_quick_p_bufferify function c_resourcemanager_make_allocator_resource_aware_pool( & self, name, allocator, initial_size, block, SHT_crv) & @@ -540,7 +540,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool - function c_resourcemanager_make_allocator_bufferify_resource_aware_pool( & + function c_resourcemanager_make_alloc_res_aware_p_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -556,7 +556,7 @@ function c_resourcemanager_make_allocator_bufferify_resource_aware_pool( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_resource_aware_pool + end function c_resourcemanager_make_alloc_res_aware_p_bufferify function c_resourcemanager_make_allocator_advisor(self, name, & allocator, advice_op, device_id, SHT_crv) & @@ -574,7 +574,7 @@ function c_resourcemanager_make_allocator_advisor(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_advisor - function c_resourcemanager_make_allocator_bufferify_advisor( & + function c_resourcemanager_make_alloc_alloc_advisor_bufferify( & self, name, Lname, allocator, advice_op, Ladvice_op, & device_id, SHT_crv) & result(SHT_rv) & @@ -591,7 +591,7 @@ function c_resourcemanager_make_allocator_bufferify_advisor( & integer(C_INT), value, intent(IN) :: device_id type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_advisor + end function c_resourcemanager_make_alloc_alloc_advisor_bufferify function c_resourcemanager_make_allocator_named(self, name, & allocator, SHT_crv) & @@ -607,7 +607,7 @@ function c_resourcemanager_make_allocator_named(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_named - function c_resourcemanager_make_allocator_bufferify_named(self, & + function c_resourcemanager_make_alloc_named_alloc_bufferify(self, & name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_named") @@ -620,7 +620,7 @@ function c_resourcemanager_make_allocator_bufferify_named(self, & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_named + end function c_resourcemanager_make_alloc_named_alloc_bufferify function c_resourcemanager_make_allocator_thread_safe(self, & name, allocator, SHT_crv) & @@ -636,7 +636,7 @@ function c_resourcemanager_make_allocator_thread_safe(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_thread_safe - function c_resourcemanager_make_allocator_bufferify_thread_safe( & + function c_resourcemanager_make_alloc_thread_safe_bufferify( & self, name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_thread_safe") @@ -649,7 +649,7 @@ function c_resourcemanager_make_allocator_bufferify_thread_safe( & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_thread_safe + end function c_resourcemanager_make_alloc_thread_safe_bufferify function c_resourcemanager_make_allocator_fixed_pool(self, name, & allocator, object_size, SHT_crv) & @@ -666,7 +666,7 @@ function c_resourcemanager_make_allocator_fixed_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_fixed_pool - function c_resourcemanager_make_allocator_bufferify_fixed_pool( & + function c_resourcemanager_make_alloc_fixed_p_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_fixed_pool") @@ -680,7 +680,7 @@ function c_resourcemanager_make_allocator_bufferify_fixed_pool( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_fixed_pool + end function c_resourcemanager_make_alloc_fixed_p_bufferify function c_resourcemanager_make_allocator_aligned_allocator( & self, name, allocator, object_size, SHT_crv) & @@ -697,7 +697,7 @@ function c_resourcemanager_make_allocator_aligned_allocator( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_aligned_allocator - function c_resourcemanager_make_allocator_bufferify_aligned_allocator( & + function c_resourcemanager_make_alloc_aligned_alloc_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_aligned_allocator") @@ -711,7 +711,7 @@ function c_resourcemanager_make_allocator_bufferify_aligned_allocator( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_aligned_allocator + end function c_resourcemanager_make_alloc_aligned_alloc_bufferify function c_resourcemanager_make_allocator_size_limiter(self, & name, allocator, object_size, SHT_crv) & @@ -728,7 +728,7 @@ function c_resourcemanager_make_allocator_size_limiter(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_size_limiter - function c_resourcemanager_make_allocator_bufferify_size_limiter( & + function c_resourcemanager_make_alloc_size_limit_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_size_limiter") @@ -742,7 +742,7 @@ function c_resourcemanager_make_allocator_bufferify_size_limiter( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_size_limiter + end function c_resourcemanager_make_alloc_size_limit_bufferify function c_resourcemanager_make_allocator_monotonic(self, name, & allocator, object_size, SHT_crv) & @@ -759,7 +759,7 @@ function c_resourcemanager_make_allocator_monotonic(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_monotonic - function c_resourcemanager_make_allocator_bufferify_monotonic( & + function c_resourcemanager_make_alloc_monotonic_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_monotonic") @@ -773,7 +773,7 @@ function c_resourcemanager_make_allocator_bufferify_monotonic( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_monotonic + end function c_resourcemanager_make_alloc_monotonic_bufferify function c_resourcemanager_make_allocator_slot_pool(self, name, & allocator, object_size, SHT_crv) & @@ -790,7 +790,7 @@ function c_resourcemanager_make_allocator_slot_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_slot_pool - function c_resourcemanager_make_allocator_bufferify_slot_pool( & + function c_resourcemanager_make_alloc_slot_p_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_slot_pool") @@ -804,7 +804,7 @@ function c_resourcemanager_make_allocator_bufferify_slot_pool( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_slot_pool + end function c_resourcemanager_make_alloc_slot_p_bufferify function c_resourcemanager_make_allocator_naming_shim(self, & name, allocator, SHT_crv) & @@ -820,7 +820,7 @@ function c_resourcemanager_make_allocator_naming_shim(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_naming_shim - function c_resourcemanager_make_allocator_bufferify_naming_shim( & + function c_resourcemanager_make_alloc_naming_shim_bufferify( & self, name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_naming_shim") @@ -833,7 +833,7 @@ function c_resourcemanager_make_allocator_bufferify_naming_shim( & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_naming_shim + end function c_resourcemanager_make_alloc_naming_shim_bufferify function c_resourcemanager_make_allocator_mixed_pool(self, name, & allocator, smallest_fixed_obj_size, & @@ -860,7 +860,7 @@ function c_resourcemanager_make_allocator_mixed_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_mixed_pool - function c_resourcemanager_make_allocator_bufferify_mixed_pool( & + function c_resourcemanager_make_alloc_mixed_p_bufferify( & self, name, Lname, allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & @@ -884,7 +884,7 @@ function c_resourcemanager_make_allocator_bufferify_mixed_pool( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_mixed_pool + end function c_resourcemanager_make_alloc_mixed_p_bufferify function c_resourcemanager_make_allocator_prefetcher(self, name, & allocator, device_id, SHT_crv) & @@ -901,7 +901,7 @@ function c_resourcemanager_make_allocator_prefetcher(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_prefetcher - function c_resourcemanager_make_allocator_bufferify_prefetcher( & + function c_resourcemanager_make_alloc_alloc_prefetch_bufferify( & self, name, Lname, allocator, device_id, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_prefetcher") @@ -915,7 +915,7 @@ function c_resourcemanager_make_allocator_bufferify_prefetcher( & integer(C_INT), value, intent(IN) :: device_id type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_bufferify_prefetcher + end function c_resourcemanager_make_alloc_alloc_prefetch_bufferify function c_resourcemanager_make_allocator_list_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -933,7 +933,7 @@ function c_resourcemanager_make_allocator_list_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_list_pool_untracked - function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -949,7 +949,7 @@ function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_list_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify function c_resourcemanager_make_allocator_quick_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -967,7 +967,7 @@ function c_resourcemanager_make_allocator_quick_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_quick_pool_untracked - function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_quick_p_u_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -983,7 +983,7 @@ function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_quick_p_u_bufferify function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -1001,7 +1001,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_res_aware_p_u_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_ra_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_res_aware_p_u_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1034,7 +1034,7 @@ function c_resourcemanager_make_allocator_fixed_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_fixed_pool_untracked - function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_fixed_p_u_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify") @@ -1048,7 +1048,7 @@ function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_fixed_p_u_bufferify function c_resourcemanager_make_allocator_monotonic_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1065,7 +1065,7 @@ function c_resourcemanager_make_allocator_monotonic_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_monotonic_untracked - function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & + function c_resourcemanager_make_alloc_monotonic_u_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify") @@ -1079,7 +1079,7 @@ function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_monotonic_untracked_bufferify + end function c_resourcemanager_make_alloc_monotonic_u_bufferify function c_resourcemanager_make_allocator_slot_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1096,7 +1096,7 @@ function c_resourcemanager_make_allocator_slot_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_slot_pool_untracked - function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_slot_p_u_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify") @@ -1110,7 +1110,7 @@ function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_slot_p_u_bufferify function c_resourcemanager_make_allocator_mixed_pool_untracked( & self, name, allocator, smallest_fixed_obj_size, & @@ -1137,7 +1137,7 @@ function c_resourcemanager_make_allocator_mixed_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_mixed_pool_untracked - function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_mixed_p_u_bufferify( & self, name, Lname, allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & @@ -1161,7 +1161,7 @@ function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_mixed_p_u_bufferify subroutine c_resourcemanager_add_alias(self, name, allocator) & bind(C, name="umpire_resourcemanager_add_alias") @@ -3107,7 +3107,7 @@ function resourcemanager_make_allocator_list_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_list_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_list_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_dynamic_p_list_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_list_pool @@ -3125,7 +3125,7 @@ function resourcemanager_make_allocator_quick_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_quick_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_quick_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_quick_p_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_quick_pool @@ -3143,7 +3143,7 @@ function resourcemanager_make_allocator_resource_aware_pool(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_resource_aware_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_res_aware_p_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool @@ -3161,7 +3161,7 @@ function resourcemanager_make_allocator_advisor(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_advisor type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_advisor(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_alloc_advisor_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & advice_op, len_trim(advice_op, kind=C_INT), device_id, & SHT_rv%cxxmem) @@ -3177,7 +3177,7 @@ function resourcemanager_make_allocator_named(obj, name, allocator) & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_named type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_named(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_named_alloc_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_named @@ -3193,7 +3193,7 @@ function resourcemanager_make_allocator_thread_safe(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_thread_safe type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_thread_safe(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_thread_safe_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_thread_safe @@ -3210,7 +3210,7 @@ function resourcemanager_make_allocator_fixed_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_fixed_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_fixed_p_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_fixed_pool @@ -3227,7 +3227,7 @@ function resourcemanager_make_allocator_aligned_allocator(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_aligned_allocator type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_aligned_allocator(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_aligned_alloc_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_aligned_allocator @@ -3244,7 +3244,7 @@ function resourcemanager_make_allocator_size_limiter(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_size_limiter type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_size_limiter(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_size_limit_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_size_limiter @@ -3261,7 +3261,7 @@ function resourcemanager_make_allocator_monotonic(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_monotonic type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_monotonic(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_monotonic_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_monotonic @@ -3278,7 +3278,7 @@ function resourcemanager_make_allocator_slot_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_slot_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_slot_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_slot_p_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_slot_pool @@ -3294,7 +3294,7 @@ function resourcemanager_make_allocator_naming_shim(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_naming_shim type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_naming_shim(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_naming_shim_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_naming_shim @@ -3320,7 +3320,7 @@ function resourcemanager_make_allocator_mixed_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_mixed_pool(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_mixed_p_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & smallest_fixed_obj_size, largest_fixed_obj_size, & max_initial_fixed_pool_size, fixed_size_multiplier, & @@ -3340,7 +3340,7 @@ function resourcemanager_make_allocator_prefetcher(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_prefetcher type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_bufferify_prefetcher(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_alloc_prefetch_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & device_id, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_prefetcher @@ -3358,7 +3358,7 @@ function resourcemanager_make_allocator_list_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_list_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_list_pool_untracked @@ -3376,7 +3376,7 @@ function resourcemanager_make_allocator_quick_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_quick_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_quick_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked @@ -3394,7 +3394,7 @@ function resourcemanager_make_allocator_resource_aware_pool_untracked( & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_ra_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_res_aware_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked @@ -3411,7 +3411,7 @@ function resourcemanager_make_allocator_fixed_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_fixed_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked @@ -3428,7 +3428,7 @@ function resourcemanager_make_allocator_monotonic_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_monotonic_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_monotonic_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_monotonic_untracked @@ -3445,7 +3445,7 @@ function resourcemanager_make_allocator_slot_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_slot_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_slot_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked @@ -3471,7 +3471,7 @@ function resourcemanager_make_allocator_mixed_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_mixed_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & smallest_fixed_obj_size, largest_fixed_obj_size, & max_initial_fixed_pool_size, fixed_size_multiplier, & diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 375859a9a..10aab0ef4 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -176,14 +176,17 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_dynamic_p_list template_suffix: _list_pool function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_quick_p template_suffix: _quick_pool function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_res_aware_p template_suffix: _resource_aware_pool function_suffix: "" @@ -193,6 +196,7 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_alloc_advisor template_suffix: _advisor function_suffix: "" @@ -202,10 +206,12 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_named_alloc template_suffix: _named function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_thread_safe template_suffix: _thread_safe function_suffix: "" @@ -215,22 +221,27 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_fixed_p template_suffix: _fixed_pool function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_aligned_alloc template_suffix: _aligned_allocator function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_size_limit template_suffix: _size_limiter function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_monotonic template_suffix: _monotonic function_suffix: "" - instantiation: format: + F_name_impl_template: make_alloc_slot_p template_suffix: _slot_pool function_suffix: "" @@ -240,6 +251,7 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_naming_shim template_suffix: _naming_shim function_suffix: "" @@ -249,6 +261,7 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_mixed_p template_suffix: _mixed_pool function_suffix: "" @@ -258,14 +271,16 @@ declarations: cxx_template: - instantiation: format: + F_name_impl_template: make_alloc_alloc_prefetch template_suffix: _prefetcher function_suffix: "" - # Untracked pool allocators - using splicer to handle bool template parameter - # Note: Keep generated Fortran identifiers <= 63 chars (gfortran default limit). - # The ResourceAwarePool untracked + bufferify wrapper is particularly close to - # the limit due to the extra `_bufferify` suffix. + # Untracked pool allocators - using splicer to handle bool template parameter. + # Keep generated Fortran bufferify helper identifiers comfortably below the + # 63-character gfortran limit by using shorter impl names. - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_alloc_dynamic_p_list_u splicer: c: | const std::string SHC_name_cxx(name); @@ -279,6 +294,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_alloc_quick_p_u splicer: c: | const std::string SHC_name_cxx(name); @@ -293,7 +310,7 @@ declarations: - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) format: - F_name_impl: make_allocator_ra_pool_untracked + F_name_impl: make_alloc_res_aware_p_u splicer: c: | const std::string SHC_name_cxx(name); @@ -307,6 +324,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_fixed_p_u splicer: c: | const std::string SHC_name_cxx(name); @@ -320,6 +339,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_monotonic_u splicer: c: | const std::string SHC_name_cxx(name); @@ -333,6 +354,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_slot_p_u splicer: c: | const std::string SHC_name_cxx(name); @@ -346,6 +369,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + format: + F_name_impl: make_alloc_mixed_p_u splicer: c: | const std::string SHC_name_cxx(name); From defc8a154b532db2a121f2e36bdab3bf890fcddd Mon Sep 17 00:00:00 2001 From: github-actions Date: Mon, 6 Apr 2026 18:30:50 +0000 Subject: [PATCH 16/27] Update C/FORTRAN interface --- src/umpire/interface/c_fortran/wrapfumpire.f | 183 +++++++++---------- 1 file changed, 90 insertions(+), 93 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index a5fe4a24c..39a8990c8 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -242,13 +242,13 @@ module umpire_mod procedure :: make_allocator_naming_shim => resourcemanager_make_allocator_naming_shim procedure :: make_allocator_mixed_pool => resourcemanager_make_allocator_mixed_pool procedure :: make_allocator_prefetcher => resourcemanager_make_allocator_prefetcher - procedure :: make_allocator_list_pool_untracked => resourcemanager_make_allocator_list_pool_untracked - procedure :: make_allocator_quick_pool_untracked => resourcemanager_make_allocator_quick_pool_untracked - procedure :: make_allocator_resource_aware_pool_untracked => make_allocator_ra_pool_untracked - procedure :: make_allocator_fixed_pool_untracked => resourcemanager_make_allocator_fixed_pool_untracked - procedure :: make_allocator_monotonic_untracked => resourcemanager_make_allocator_monotonic_untracked - procedure :: make_allocator_slot_pool_untracked => resourcemanager_make_allocator_slot_pool_untracked - procedure :: make_allocator_mixed_pool_untracked => resourcemanager_make_allocator_mixed_pool_untracked + procedure :: make_allocator_list_pool_untracked => make_alloc_dynamic_p_list_u + procedure :: make_allocator_quick_pool_untracked => make_alloc_quick_p_u + procedure :: make_allocator_resource_aware_pool_untracked => make_alloc_res_aware_p_u + procedure :: make_allocator_fixed_pool_untracked => make_alloc_fixed_p_u + procedure :: make_allocator_monotonic_untracked => make_alloc_monotonic_u + procedure :: make_allocator_slot_pool_untracked => make_alloc_slot_p_u + procedure :: make_allocator_mixed_pool_untracked => make_alloc_mixed_p_u procedure :: add_alias => resourcemanager_add_alias procedure :: remove_alias => resourcemanager_remove_alias procedure :: get_allocator_for_ptr => resourcemanager_get_allocator_for_ptr @@ -472,7 +472,7 @@ function c_resourcemanager_make_allocator_list_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_list_pool - function c_resourcemanager_make_alloc_dynamic_p_list_bufferify( & + function c_resourcemanager_make_allocator_bufferify_list_pool( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -488,7 +488,7 @@ function c_resourcemanager_make_alloc_dynamic_p_list_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_dynamic_p_list_bufferify + end function c_resourcemanager_make_allocator_bufferify_list_pool function c_resourcemanager_make_allocator_quick_pool(self, name, & allocator, initial_size, block, SHT_crv) & @@ -506,7 +506,7 @@ function c_resourcemanager_make_allocator_quick_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_quick_pool - function c_resourcemanager_make_alloc_quick_p_bufferify( & + function c_resourcemanager_make_allocator_bufferify_quick_pool( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -522,7 +522,7 @@ function c_resourcemanager_make_alloc_quick_p_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_quick_p_bufferify + end function c_resourcemanager_make_allocator_bufferify_quick_pool function c_resourcemanager_make_allocator_resource_aware_pool( & self, name, allocator, initial_size, block, SHT_crv) & @@ -540,7 +540,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool - function c_resourcemanager_make_alloc_res_aware_p_bufferify( & + function c_resourcemanager_make_allocator_bufferify_resource_aware_pool( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -556,7 +556,7 @@ function c_resourcemanager_make_alloc_res_aware_p_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_res_aware_p_bufferify + end function c_resourcemanager_make_allocator_bufferify_resource_aware_pool function c_resourcemanager_make_allocator_advisor(self, name, & allocator, advice_op, device_id, SHT_crv) & @@ -574,7 +574,7 @@ function c_resourcemanager_make_allocator_advisor(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_advisor - function c_resourcemanager_make_alloc_alloc_advisor_bufferify( & + function c_resourcemanager_make_allocator_bufferify_advisor( & self, name, Lname, allocator, advice_op, Ladvice_op, & device_id, SHT_crv) & result(SHT_rv) & @@ -591,7 +591,7 @@ function c_resourcemanager_make_alloc_alloc_advisor_bufferify( & integer(C_INT), value, intent(IN) :: device_id type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_alloc_advisor_bufferify + end function c_resourcemanager_make_allocator_bufferify_advisor function c_resourcemanager_make_allocator_named(self, name, & allocator, SHT_crv) & @@ -607,7 +607,7 @@ function c_resourcemanager_make_allocator_named(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_named - function c_resourcemanager_make_alloc_named_alloc_bufferify(self, & + function c_resourcemanager_make_allocator_bufferify_named(self, & name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_named") @@ -620,7 +620,7 @@ function c_resourcemanager_make_alloc_named_alloc_bufferify(self, & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_named_alloc_bufferify + end function c_resourcemanager_make_allocator_bufferify_named function c_resourcemanager_make_allocator_thread_safe(self, & name, allocator, SHT_crv) & @@ -636,7 +636,7 @@ function c_resourcemanager_make_allocator_thread_safe(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_thread_safe - function c_resourcemanager_make_alloc_thread_safe_bufferify( & + function c_resourcemanager_make_allocator_bufferify_thread_safe( & self, name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_thread_safe") @@ -649,7 +649,7 @@ function c_resourcemanager_make_alloc_thread_safe_bufferify( & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_thread_safe_bufferify + end function c_resourcemanager_make_allocator_bufferify_thread_safe function c_resourcemanager_make_allocator_fixed_pool(self, name, & allocator, object_size, SHT_crv) & @@ -666,7 +666,7 @@ function c_resourcemanager_make_allocator_fixed_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_fixed_pool - function c_resourcemanager_make_alloc_fixed_p_bufferify( & + function c_resourcemanager_make_allocator_bufferify_fixed_pool( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_fixed_pool") @@ -680,7 +680,7 @@ function c_resourcemanager_make_alloc_fixed_p_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_fixed_p_bufferify + end function c_resourcemanager_make_allocator_bufferify_fixed_pool function c_resourcemanager_make_allocator_aligned_allocator( & self, name, allocator, object_size, SHT_crv) & @@ -697,7 +697,7 @@ function c_resourcemanager_make_allocator_aligned_allocator( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_aligned_allocator - function c_resourcemanager_make_alloc_aligned_alloc_bufferify( & + function c_resourcemanager_make_allocator_bufferify_aligned_allocator( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_aligned_allocator") @@ -711,7 +711,7 @@ function c_resourcemanager_make_alloc_aligned_alloc_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_aligned_alloc_bufferify + end function c_resourcemanager_make_allocator_bufferify_aligned_allocator function c_resourcemanager_make_allocator_size_limiter(self, & name, allocator, object_size, SHT_crv) & @@ -728,7 +728,7 @@ function c_resourcemanager_make_allocator_size_limiter(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_size_limiter - function c_resourcemanager_make_alloc_size_limit_bufferify( & + function c_resourcemanager_make_allocator_bufferify_size_limiter( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_size_limiter") @@ -742,7 +742,7 @@ function c_resourcemanager_make_alloc_size_limit_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_size_limit_bufferify + end function c_resourcemanager_make_allocator_bufferify_size_limiter function c_resourcemanager_make_allocator_monotonic(self, name, & allocator, object_size, SHT_crv) & @@ -759,7 +759,7 @@ function c_resourcemanager_make_allocator_monotonic(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_monotonic - function c_resourcemanager_make_alloc_monotonic_bufferify( & + function c_resourcemanager_make_allocator_bufferify_monotonic( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_monotonic") @@ -773,7 +773,7 @@ function c_resourcemanager_make_alloc_monotonic_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_monotonic_bufferify + end function c_resourcemanager_make_allocator_bufferify_monotonic function c_resourcemanager_make_allocator_slot_pool(self, name, & allocator, object_size, SHT_crv) & @@ -790,7 +790,7 @@ function c_resourcemanager_make_allocator_slot_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_slot_pool - function c_resourcemanager_make_alloc_slot_p_bufferify( & + function c_resourcemanager_make_allocator_bufferify_slot_pool( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_slot_pool") @@ -804,7 +804,7 @@ function c_resourcemanager_make_alloc_slot_p_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_slot_p_bufferify + end function c_resourcemanager_make_allocator_bufferify_slot_pool function c_resourcemanager_make_allocator_naming_shim(self, & name, allocator, SHT_crv) & @@ -820,7 +820,7 @@ function c_resourcemanager_make_allocator_naming_shim(self, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_naming_shim - function c_resourcemanager_make_alloc_naming_shim_bufferify( & + function c_resourcemanager_make_allocator_bufferify_naming_shim( & self, name, Lname, allocator, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_naming_shim") @@ -833,7 +833,7 @@ function c_resourcemanager_make_alloc_naming_shim_bufferify( & type(umpire_SHROUD_allocator_capsule), intent(IN), value :: allocator type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_naming_shim_bufferify + end function c_resourcemanager_make_allocator_bufferify_naming_shim function c_resourcemanager_make_allocator_mixed_pool(self, name, & allocator, smallest_fixed_obj_size, & @@ -860,7 +860,7 @@ function c_resourcemanager_make_allocator_mixed_pool(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_mixed_pool - function c_resourcemanager_make_alloc_mixed_p_bufferify( & + function c_resourcemanager_make_allocator_bufferify_mixed_pool( & self, name, Lname, allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & @@ -884,7 +884,7 @@ function c_resourcemanager_make_alloc_mixed_p_bufferify( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_mixed_p_bufferify + end function c_resourcemanager_make_allocator_bufferify_mixed_pool function c_resourcemanager_make_allocator_prefetcher(self, name, & allocator, device_id, SHT_crv) & @@ -901,7 +901,7 @@ function c_resourcemanager_make_allocator_prefetcher(self, name, & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_prefetcher - function c_resourcemanager_make_alloc_alloc_prefetch_bufferify( & + function c_resourcemanager_make_allocator_bufferify_prefetcher( & self, name, Lname, allocator, device_id, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_bufferify_prefetcher") @@ -915,7 +915,7 @@ function c_resourcemanager_make_alloc_alloc_prefetch_bufferify( & integer(C_INT), value, intent(IN) :: device_id type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_alloc_prefetch_bufferify + end function c_resourcemanager_make_allocator_bufferify_prefetcher function c_resourcemanager_make_allocator_list_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -933,7 +933,7 @@ function c_resourcemanager_make_allocator_list_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_list_pool_untracked - function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify( & + function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -949,7 +949,7 @@ function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify + end function c_resourcemanager_make_allocator_list_pool_untracked_bufferify function c_resourcemanager_make_allocator_quick_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -967,7 +967,7 @@ function c_resourcemanager_make_allocator_quick_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_quick_pool_untracked - function c_resourcemanager_make_alloc_quick_p_u_bufferify( & + function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -983,7 +983,7 @@ function c_resourcemanager_make_alloc_quick_p_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_quick_p_u_bufferify + end function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & self, name, allocator, initial_size, block, SHT_crv) & @@ -1001,7 +1001,7 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_resource_aware_pool_untracked - function c_resourcemanager_make_alloc_res_aware_p_u_bufferify( & + function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -1017,7 +1017,7 @@ function c_resourcemanager_make_alloc_res_aware_p_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_res_aware_p_u_bufferify + end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify function c_resourcemanager_make_allocator_fixed_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1034,7 +1034,7 @@ function c_resourcemanager_make_allocator_fixed_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_fixed_pool_untracked - function c_resourcemanager_make_alloc_fixed_p_u_bufferify( & + function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify") @@ -1048,7 +1048,7 @@ function c_resourcemanager_make_alloc_fixed_p_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_fixed_p_u_bufferify + end function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify function c_resourcemanager_make_allocator_monotonic_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1065,7 +1065,7 @@ function c_resourcemanager_make_allocator_monotonic_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_monotonic_untracked - function c_resourcemanager_make_alloc_monotonic_u_bufferify( & + function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify") @@ -1079,7 +1079,7 @@ function c_resourcemanager_make_alloc_monotonic_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_monotonic_u_bufferify + end function c_resourcemanager_make_allocator_monotonic_untracked_bufferify function c_resourcemanager_make_allocator_slot_pool_untracked( & self, name, allocator, object_size, SHT_crv) & @@ -1096,7 +1096,7 @@ function c_resourcemanager_make_allocator_slot_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_slot_pool_untracked - function c_resourcemanager_make_alloc_slot_p_u_bufferify( & + function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify") @@ -1110,7 +1110,7 @@ function c_resourcemanager_make_alloc_slot_p_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_slot_p_u_bufferify + end function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify function c_resourcemanager_make_allocator_mixed_pool_untracked( & self, name, allocator, smallest_fixed_obj_size, & @@ -1137,7 +1137,7 @@ function c_resourcemanager_make_allocator_mixed_pool_untracked( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_mixed_pool_untracked - function c_resourcemanager_make_alloc_mixed_p_u_bufferify( & + function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & self, name, Lname, allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & @@ -1161,7 +1161,7 @@ function c_resourcemanager_make_alloc_mixed_p_u_bufferify( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_alloc_mixed_p_u_bufferify + end function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify subroutine c_resourcemanager_add_alias(self, name, allocator) & bind(C, name="umpire_resourcemanager_add_alias") @@ -3107,7 +3107,7 @@ function resourcemanager_make_allocator_list_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_list_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_dynamic_p_list_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_list_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_list_pool @@ -3125,7 +3125,7 @@ function resourcemanager_make_allocator_quick_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_quick_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_quick_p_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_quick_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_quick_pool @@ -3143,7 +3143,7 @@ function resourcemanager_make_allocator_resource_aware_pool(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_res_aware_p_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_resource_aware_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool @@ -3161,7 +3161,7 @@ function resourcemanager_make_allocator_advisor(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_advisor type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_alloc_advisor_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_advisor(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & advice_op, len_trim(advice_op, kind=C_INT), device_id, & SHT_rv%cxxmem) @@ -3177,7 +3177,7 @@ function resourcemanager_make_allocator_named(obj, name, allocator) & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_named type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_named_alloc_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_named(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_named @@ -3193,7 +3193,7 @@ function resourcemanager_make_allocator_thread_safe(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_thread_safe type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_thread_safe_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_thread_safe(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_thread_safe @@ -3210,7 +3210,7 @@ function resourcemanager_make_allocator_fixed_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_fixed_p_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_fixed_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_fixed_pool @@ -3227,7 +3227,7 @@ function resourcemanager_make_allocator_aligned_allocator(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_aligned_allocator type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_aligned_alloc_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_aligned_allocator(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_aligned_allocator @@ -3244,7 +3244,7 @@ function resourcemanager_make_allocator_size_limiter(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_size_limiter type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_size_limit_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_size_limiter(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_size_limiter @@ -3261,7 +3261,7 @@ function resourcemanager_make_allocator_monotonic(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_monotonic type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_monotonic_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_monotonic(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_monotonic @@ -3278,7 +3278,7 @@ function resourcemanager_make_allocator_slot_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_slot_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_slot_p_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_slot_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_slot_pool @@ -3294,7 +3294,7 @@ function resourcemanager_make_allocator_naming_shim(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_naming_shim type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_naming_shim_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_naming_shim(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_naming_shim @@ -3320,7 +3320,7 @@ function resourcemanager_make_allocator_mixed_pool(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_mixed_p_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_mixed_pool(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & smallest_fixed_obj_size, largest_fixed_obj_size, & max_initial_fixed_pool_size, fixed_size_multiplier, & @@ -3340,14 +3340,14 @@ function resourcemanager_make_allocator_prefetcher(obj, name, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_prefetcher type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_alloc_prefetch_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_bufferify_prefetcher(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & device_id, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_prefetcher end function resourcemanager_make_allocator_prefetcher - function resourcemanager_make_allocator_list_pool_untracked(obj, & - name, allocator, initial_size, block) & + function make_alloc_dynamic_p_list_u(obj, name, allocator, & + initial_size, block) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3358,14 +3358,14 @@ function resourcemanager_make_allocator_list_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_list_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_list_pool_untracked - end function resourcemanager_make_allocator_list_pool_untracked + end function make_alloc_dynamic_p_list_u - function resourcemanager_make_allocator_quick_pool_untracked(obj, & - name, allocator, initial_size, block) & + function make_alloc_quick_p_u(obj, name, allocator, initial_size, & + block) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3376,13 +3376,13 @@ function resourcemanager_make_allocator_quick_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_quick_p_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_quick_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked - end function resourcemanager_make_allocator_quick_pool_untracked + end function make_alloc_quick_p_u - function make_allocator_ra_pool_untracked(obj, name, allocator, & + function make_alloc_res_aware_p_u(obj, name, allocator, & initial_size, block) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T @@ -3394,14 +3394,13 @@ function make_allocator_ra_pool_untracked(obj, name, allocator, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_res_aware_p_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked - end function make_allocator_ra_pool_untracked + end function make_alloc_res_aware_p_u - function resourcemanager_make_allocator_fixed_pool_untracked(obj, & - name, allocator, object_size) & + function make_alloc_fixed_p_u(obj, name, allocator, object_size) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3411,14 +3410,13 @@ function resourcemanager_make_allocator_fixed_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_fixed_p_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked - end function resourcemanager_make_allocator_fixed_pool_untracked + end function make_alloc_fixed_p_u - function resourcemanager_make_allocator_monotonic_untracked(obj, & - name, allocator, object_size) & + function make_alloc_monotonic_u(obj, name, allocator, object_size) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3428,14 +3426,13 @@ function resourcemanager_make_allocator_monotonic_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_monotonic_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_monotonic_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_monotonic_untracked - end function resourcemanager_make_allocator_monotonic_untracked + end function make_alloc_monotonic_u - function resourcemanager_make_allocator_slot_pool_untracked(obj, & - name, allocator, object_size) & + function make_alloc_slot_p_u(obj, name, allocator, object_size) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3445,17 +3442,17 @@ function resourcemanager_make_allocator_slot_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_slot_p_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_slot_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked - end function resourcemanager_make_allocator_slot_pool_untracked + end function make_alloc_slot_p_u - function resourcemanager_make_allocator_mixed_pool_untracked(obj, & - name, allocator, smallest_fixed_obj_size, & - largest_fixed_obj_size, max_initial_fixed_pool_size, & - fixed_size_multiplier, quick_pool_initial_alloc_size, & - quick_pool_min_alloc_size, quick_pool_align_bytes) & + function make_alloc_mixed_p_u(obj, name, allocator, & + smallest_fixed_obj_size, largest_fixed_obj_size, & + max_initial_fixed_pool_size, fixed_size_multiplier, & + quick_pool_initial_alloc_size, quick_pool_min_alloc_size, & + quick_pool_align_bytes) & result(SHT_rv) use iso_c_binding, only : C_INT, C_PTR, C_SIZE_T class(UmpireResourceManager) :: obj @@ -3471,14 +3468,14 @@ function resourcemanager_make_allocator_mixed_pool_untracked(obj, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_alloc_mixed_p_u_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & smallest_fixed_obj_size, largest_fixed_obj_size, & max_initial_fixed_pool_size, fixed_size_multiplier, & quick_pool_initial_alloc_size, quick_pool_min_alloc_size, & quick_pool_align_bytes, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked - end function resourcemanager_make_allocator_mixed_pool_untracked + end function make_alloc_mixed_p_u subroutine resourcemanager_add_alias(obj, name, allocator) use iso_c_binding, only : C_INT From ba21db30f28407ece9cff7401aa19220c3fc0273 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Mon, 6 Apr 2026 12:42:36 -0700 Subject: [PATCH 17/27] another attempt --- src/umpire/interface/umpire_shroud.yaml | 162 ++++++++---------------- 1 file changed, 52 insertions(+), 110 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 1c263d5fc..2b8405b66 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -275,116 +275,58 @@ declarations: template_suffix: _prefetcher function_suffix: "" - # Untracked pool allocators - using splicer to handle bool template parameter. - # Keep generated Fortran bufferify helper identifiers comfortably below the - # 63-character gfortran limit by using shorter impl names. - - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - format: - F_name_impl: make_alloc_dynamic_p_list_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - format: - F_name_impl: make_alloc_quick_p_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) - format: - F_name_impl: make_alloc_res_aware_p_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - format: - F_name_impl: make_alloc_fixed_p_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) - format: - F_name_impl: make_alloc_monotonic_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) - format: - F_name_impl: make_alloc_slot_p_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, object_size); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; - - - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) - format: - F_name_impl: make_alloc_mixed_p_u - splicer: - c: | - const std::string SHC_name_cxx(name); - umpire::Allocator *SHC_allocator_cxx = - static_cast(allocator.addr); - umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; - *SHC_rv_cxx = SH_this->makeAllocator( - SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, - largest_fixed_obj_size, max_initial_fixed_pool_size, - fixed_size_multiplier, quick_pool_initial_alloc_size, - quick_pool_min_alloc_size, quick_pool_align_bytes); - SHC_rv->addr = SHC_rv_cxx; - SHC_rv->idtor = 1; - return SHC_rv; + # Untracked pool allocators use the bool template instantiations directly. + # Keep the template suffixes short so generated Fortran bufferify helpers + # stay below compiler identifier limits. + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t initial_size, size_t block); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + F_name_impl_template: make_alloc_dynamic_p_list_u + template_suffix: _dynamic_p_list_u + function_suffix: "" + - instantiation: + format: + F_name_impl_template: make_alloc_quick_p_u + template_suffix: _quick_p_u + function_suffix: "" + - instantiation: + format: + F_name_impl_template: make_alloc_res_aware_p_u + template_suffix: _res_aware_p_u + function_suffix: "" + + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t object_size); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + F_name_impl_template: make_alloc_fixed_p_u + template_suffix: _fixed_p_u + function_suffix: "" + - instantiation: + format: + F_name_impl_template: make_alloc_monotonic_u + template_suffix: _monotonic_u + function_suffix: "" + - instantiation: + format: + F_name_impl_template: make_alloc_slot_p_u + template_suffix: _slot_p_u + function_suffix: "" + + - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes); + options: + F_create_generic: False + cxx_template: + - instantiation: + format: + F_name_impl_template: make_alloc_mixed_p_u + template_suffix: _mixed_p_u + function_suffix: "" - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From 89591806b9c418f9ba2bff25268f06811b243833 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Mon, 6 Apr 2026 16:36:45 -0700 Subject: [PATCH 18/27] another codex attempt --- .../interface/c_fortran/gencumpiresplicer.inc | 101 ++++++++++++++++++ src/umpire/interface/umpire_shroud.yaml | 6 +- 2 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 src/umpire/interface/c_fortran/gencumpiresplicer.inc diff --git a/src/umpire/interface/c_fortran/gencumpiresplicer.inc b/src/umpire/interface/c_fortran/gencumpiresplicer.inc new file mode 100644 index 000000000..ef07512ca --- /dev/null +++ b/src/umpire/interface/c_fortran/gencumpiresplicer.inc @@ -0,0 +1,101 @@ +////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2016-26, Lawrence Livermore National Security, LLC and Umpire +// project contributors. See the COPYRIGHT file for details. +// +// SPDX-License-Identifier: (MIT) +////////////////////////////////////////////////////////////////////////////// +// +// Shroud splicer overrides for C wrappers. +// +// These bufferify wrappers correspond to explicit non-type template +// instantiations such as makeAllocator(...). Shroud emits +// invalid member calls for these overloads in the generated bufferify helpers, +// so provide the exact wrapper bodies here. + +// splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_list_pool_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = + SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_monotonic_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked_bufferify + +// splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked_bufferify +const std::string SHCXX_name(name, Lname); +umpire::Allocator * SHCXX_allocator = + static_cast(allocator.addr); +umpire::Allocator * SHCXX_rv = new umpire::Allocator; +*SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); +SHC_rv->addr = SHCXX_rv; +SHC_rv->idtor = 1; +return SHC_rv; +// splicer end class.ResourceManager.method.make_allocator_mixed_pool_untracked_bufferify diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 2b8405b66..560825b63 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -277,7 +277,9 @@ declarations: # Untracked pool allocators use the bool template instantiations directly. # Keep the template suffixes short so generated Fortran bufferify helpers - # stay below compiler identifier limits. + # stay below compiler identifier limits. The generated C bufferify + # wrappers for these explicit non-type template instantiations are + # corrected via the C splicer file listed below. - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t initial_size, size_t block); options: F_create_generic: False @@ -393,5 +395,7 @@ declarations: - decl: void deregisterAllocation(void* ptr) splicer: + c: + - c_fortran/gencumpiresplicer.inc f: - c_fortran/genfumpiresplicer.f From 5b9efc11020cfaea5cc1eee73c8f76c26b56e5dd Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 07:24:59 -0700 Subject: [PATCH 19/27] codex might get it this time... --- src/umpire/interface/umpire_shroud.yaml | 165 ++++++++++++++++-------- 1 file changed, 111 insertions(+), 54 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 560825b63..28b51a982 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -275,60 +275,117 @@ declarations: template_suffix: _prefetcher function_suffix: "" - # Untracked pool allocators use the bool template instantiations directly. - # Keep the template suffixes short so generated Fortran bufferify helpers - # stay below compiler identifier limits. The generated C bufferify - # wrappers for these explicit non-type template instantiations are - # corrected via the C splicer file listed below. - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t initial_size, size_t block); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - F_name_impl_template: make_alloc_dynamic_p_list_u - template_suffix: _dynamic_p_list_u - function_suffix: "" - - instantiation: - format: - F_name_impl_template: make_alloc_quick_p_u - template_suffix: _quick_p_u - function_suffix: "" - - instantiation: - format: - F_name_impl_template: make_alloc_res_aware_p_u - template_suffix: _res_aware_p_u - function_suffix: "" - - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t object_size); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - F_name_impl_template: make_alloc_fixed_p_u - template_suffix: _fixed_p_u - function_suffix: "" - - instantiation: - format: - F_name_impl_template: make_alloc_monotonic_u - template_suffix: _monotonic_u - function_suffix: "" - - instantiation: - format: - F_name_impl_template: make_alloc_slot_p_u - template_suffix: _slot_p_u - function_suffix: "" - - - decl: template Allocator makeAllocator(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes); - options: - F_create_generic: False - cxx_template: - - instantiation: - format: - F_name_impl_template: make_alloc_mixed_p_u - template_suffix: _mixed_p_u - function_suffix: "" + # Untracked pool allocators need explicit names to keep the generated + # Fortran helper identifiers below compiler limits. The corresponding + # C bufferify wrappers are overridden by the C splicer include listed + # below, since Shroud emits invalid member calls for those helpers. + - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_alloc_dynamic_p_list_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_alloc_quick_p_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + format: + F_name_impl: make_alloc_res_aware_p_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, initial_size, block); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_fixed_p_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_monotonic_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + format: + F_name_impl: make_alloc_slot_p_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, object_size); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; + + - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + format: + F_name_impl: make_alloc_mixed_p_u + splicer: + c: | + const std::string SHC_name_cxx(name); + umpire::Allocator *SHC_allocator_cxx = + static_cast(allocator.addr); + umpire::Allocator *SHC_rv_cxx = new umpire::Allocator; + *SHC_rv_cxx = SH_this->makeAllocator( + SHC_name_cxx, *SHC_allocator_cxx, smallest_fixed_obj_size, + largest_fixed_obj_size, max_initial_fixed_pool_size, + fixed_size_multiplier, quick_pool_initial_alloc_size, + quick_pool_min_alloc_size, quick_pool_align_bytes); + SHC_rv->addr = SHC_rv_cxx; + SHC_rv->idtor = 1; + return SHC_rv; - decl: void addAlias(const std::string& name, Allocator allocator) - decl: void removeAlias(const std::string& name, Allocator allocator) From a6040dcaab6edf0ed83aba7ae9bc063e4ec75edb Mon Sep 17 00:00:00 2001 From: github-actions Date: Tue, 7 Apr 2026 14:26:27 +0000 Subject: [PATCH 20/27] Update C/FORTRAN interface --- .../c_fortran/wrapResourceManager.cpp | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapResourceManager.cpp b/src/umpire/interface/c_fortran/wrapResourceManager.cpp index f2d75874c..7ac5ef287 100644 --- a/src/umpire/interface/c_fortran/wrapResourceManager.cpp +++ b/src/umpire/interface/c_fortran/wrapResourceManager.cpp @@ -707,8 +707,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_list_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_list_pool_untracked(SHCXX_name, - *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -747,8 +747,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_quick_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_quick_pool_untracked(SHCXX_name, - *SHCXX_allocator, initial_size, block); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -787,7 +787,7 @@ umpire_allocator * umpire_resourcemanager_make_allocator_resource_aware_pool_unt umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_resource_aware_pool_untracked( + *SHCXX_rv = SH_this->makeAllocator( SHCXX_name, *SHCXX_allocator, initial_size, block); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; @@ -827,8 +827,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_fixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_fixed_pool_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -867,8 +867,9 @@ umpire_allocator * umpire_resourcemanager_make_allocator_monotonic_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_monotonic_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = + SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -907,8 +908,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_slot_pool_untracked_buf umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_slot_pool_untracked(SHCXX_name, - *SHCXX_allocator, object_size); + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, object_size); SHC_rv->addr = SHCXX_rv; SHC_rv->idtor = 1; return SHC_rv; @@ -956,8 +957,8 @@ umpire_allocator * umpire_resourcemanager_make_allocator_mixed_pool_untracked_bu umpire::Allocator * SHCXX_allocator = static_cast(allocator.addr); umpire::Allocator * SHCXX_rv = new umpire::Allocator; - *SHCXX_rv = SH_this->makeAllocator_mixed_pool_untracked(SHCXX_name, - *SHCXX_allocator, smallest_fixed_obj_size, + *SHCXX_rv = SH_this->makeAllocator( + SHCXX_name, *SHCXX_allocator, smallest_fixed_obj_size, largest_fixed_obj_size, max_initial_fixed_pool_size, fixed_size_multiplier, quick_pool_initial_alloc_size, quick_pool_min_alloc_size, quick_pool_align_bytes); From e012955b3a7908d65d7ccf783f79ccbd3cd39b65 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 07:33:19 -0700 Subject: [PATCH 21/27] trigger ci --- docs/sphinx/tutorial/fortran/allocators.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/sphinx/tutorial/fortran/allocators.rst b/docs/sphinx/tutorial/fortran/allocators.rst index c358ce63e..4e216dd51 100644 --- a/docs/sphinx/tutorial/fortran/allocators.rst +++ b/docs/sphinx/tutorial/fortran/allocators.rst @@ -31,3 +31,7 @@ deallocate memory: In this case, we allocate a one-dimensional array using the generic ``allocate`` function. + +.. note:: + + Umpire's FORTRAN interface is generated with the help of `Shroud `_. From e855264034be8075324b0d2dd826f022bd3faf45 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 08:15:44 -0700 Subject: [PATCH 22/27] trigger ci --- src/umpire/interface/umpire_shroud.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 28b51a982..233611200 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -1,4 +1,4 @@ -############################################################################## +################################################################################## # Copyright (c) 2018-2022, Lawrence Livermore National Security, LLC. # Produced at the Lawrence Livermore National Laboratory # @@ -11,7 +11,7 @@ # # For details, see https://github.com/LLNL/Umpire # Please also see the LICENSE file for MIT license. -############################################################################## +################################################################################## copyright: - Copyright (c) 2016-26, Lawrence Livermore National Security, LLC and Umpire From 424e5324ad213a9a165e31fd9e734eef29d94bee Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 08:16:38 -0700 Subject: [PATCH 23/27] trigger ci again --- docs/sphinx/tutorial/fortran/allocators.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/sphinx/tutorial/fortran/allocators.rst b/docs/sphinx/tutorial/fortran/allocators.rst index 4e216dd51..a9e6ddb60 100644 --- a/docs/sphinx/tutorial/fortran/allocators.rst +++ b/docs/sphinx/tutorial/fortran/allocators.rst @@ -3,7 +3,7 @@ ======================= FORTRAN API: Allocators ======================= - + The fundamental concept for accessing memory through Umpire is an :class:`umpire:Allocator`. In FORTRAN, this means using the type ``UmpireAllocator``. This type provides an ``allocate_pointer`` function to From 00a6c79c352cf24447f540576cdc1c08fe2dd8cd Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 08:50:28 -0700 Subject: [PATCH 24/27] another another another attempt --- .github/workflows/generate-shroud.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/generate-shroud.yml b/.github/workflows/generate-shroud.yml index 5bd94aa6a..db0c45868 100644 --- a/.github/workflows/generate-shroud.yml +++ b/.github/workflows/generate-shroud.yml @@ -1,8 +1,10 @@ -on: +on: + workflow_dispatch: pull_request: paths: - '**umpire_shroud.yaml' - '**genfumpiresplicer.f' + - '**gencumpiresplicer.inc' name: Generate C/FORTRAN Interface jobs: From 9f36793a57055e44927634c70be1c9fdb6e48af4 Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 09:51:13 -0700 Subject: [PATCH 25/27] trying again --- src/umpire/interface/umpire_shroud.yaml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/umpire/interface/umpire_shroud.yaml b/src/umpire/interface/umpire_shroud.yaml index 233611200..d0b7d4b60 100644 --- a/src/umpire/interface/umpire_shroud.yaml +++ b/src/umpire/interface/umpire_shroud.yaml @@ -280,6 +280,8 @@ declarations: # C bufferify wrappers are overridden by the C splicer include listed # below, since Shroud emits invalid member calls for those helpers. - decl: Allocator makeAllocator_list_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + options: + F_C_name_template: c_resourcemanager_make_alloc_dynamic_p_list_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_dynamic_p_list_u splicer: @@ -295,6 +297,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_quick_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + options: + F_C_name_template: c_resourcemanager_make_alloc_quick_p_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_quick_p_u splicer: @@ -310,6 +314,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_resource_aware_pool_untracked(const std::string& name, Allocator allocator, size_t initial_size, size_t block) + options: + F_C_name_template: c_resourcemanager_make_alloc_res_aware_p_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_res_aware_p_u splicer: @@ -325,6 +331,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_fixed_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + options: + F_C_name_template: c_resourcemanager_make_alloc_fixed_p_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_fixed_p_u splicer: @@ -340,6 +348,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_monotonic_untracked(const std::string& name, Allocator allocator, size_t object_size) + options: + F_C_name_template: c_resourcemanager_make_alloc_monotonic_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_monotonic_u splicer: @@ -355,6 +365,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_slot_pool_untracked(const std::string& name, Allocator allocator, size_t object_size) + options: + F_C_name_template: c_resourcemanager_make_alloc_slot_p_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_slot_p_u splicer: @@ -370,6 +382,8 @@ declarations: return SHC_rv; - decl: Allocator makeAllocator_mixed_pool_untracked(const std::string& name, Allocator allocator, size_t smallest_fixed_obj_size, size_t largest_fixed_obj_size, size_t max_initial_fixed_pool_size, size_t fixed_size_multiplier, size_t quick_pool_initial_alloc_size, size_t quick_pool_min_alloc_size, size_t quick_pool_align_bytes) + options: + F_C_name_template: c_resourcemanager_make_alloc_mixed_p_u{function_suffix}{template_suffix} format: F_name_impl: make_alloc_mixed_p_u splicer: From d5ec4ecc61e6b5f0f0dfdfe94971bf2bbb6a156b Mon Sep 17 00:00:00 2001 From: github-actions Date: Tue, 7 Apr 2026 16:55:10 +0000 Subject: [PATCH 26/27] Update C/FORTRAN interface --- src/umpire/interface/c_fortran/wrapfumpire.f | 93 ++++++++++---------- 1 file changed, 46 insertions(+), 47 deletions(-) diff --git a/src/umpire/interface/c_fortran/wrapfumpire.f b/src/umpire/interface/c_fortran/wrapfumpire.f index 881c88d7c..f43c8b1fb 100644 --- a/src/umpire/interface/c_fortran/wrapfumpire.f +++ b/src/umpire/interface/c_fortran/wrapfumpire.f @@ -924,8 +924,8 @@ function c_resourcemanager_make_allocator_bufferify_prefetcher( & type(C_PTR) SHT_rv end function c_resourcemanager_make_allocator_bufferify_prefetcher - function c_resourcemanager_make_allocator_list_pool_untracked( & - self, name, allocator, initial_size, block, SHT_crv) & + function c_resourcemanager_make_alloc_dynamic_p_list_u(self, & + name, allocator, initial_size, block, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_list_pool_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -938,9 +938,9 @@ function c_resourcemanager_make_allocator_list_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_list_pool_untracked + end function c_resourcemanager_make_alloc_dynamic_p_list_u - function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -956,10 +956,10 @@ function c_resourcemanager_make_allocator_list_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_list_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify - function c_resourcemanager_make_allocator_quick_pool_untracked( & - self, name, allocator, initial_size, block, SHT_crv) & + function c_resourcemanager_make_alloc_quick_p_u(self, name, & + allocator, initial_size, block, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_quick_pool_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -972,11 +972,10 @@ function c_resourcemanager_make_allocator_quick_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_quick_pool_untracked + end function c_resourcemanager_make_alloc_quick_p_u - function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & - self, name, Lname, allocator, initial_size, block, & - SHT_crv) & + function c_resourcemanager_make_alloc_quick_p_u_bufferify(self, & + name, Lname, allocator, initial_size, block, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_quick_pool_untracked_bufferify") use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T @@ -990,10 +989,10 @@ function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_quick_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_quick_p_u_bufferify - function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & - self, name, allocator, initial_size, block, SHT_crv) & + function c_resourcemanager_make_alloc_res_aware_p_u(self, name, & + allocator, initial_size, block, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_resource_aware_pool_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -1006,9 +1005,9 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_resource_aware_pool_untracked + end function c_resourcemanager_make_alloc_res_aware_p_u - function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify( & + function c_resourcemanager_make_alloc_res_aware_p_u_bufferify( & self, name, Lname, allocator, initial_size, block, & SHT_crv) & result(SHT_rv) & @@ -1024,10 +1023,10 @@ function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferif integer(C_SIZE_T), value, intent(IN) :: block type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_res_aware_p_u_bufferify - function c_resourcemanager_make_allocator_fixed_pool_untracked( & - self, name, allocator, object_size, SHT_crv) & + function c_resourcemanager_make_alloc_fixed_p_u(self, name, & + allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -1039,10 +1038,10 @@ function c_resourcemanager_make_allocator_fixed_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_fixed_pool_untracked + end function c_resourcemanager_make_alloc_fixed_p_u - function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & - self, name, Lname, allocator, object_size, SHT_crv) & + function c_resourcemanager_make_alloc_fixed_p_u_bufferify(self, & + name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_fixed_pool_untracked_bufferify") use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T @@ -1055,10 +1054,10 @@ function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_fixed_p_u_bufferify - function c_resourcemanager_make_allocator_monotonic_untracked( & - self, name, allocator, object_size, SHT_crv) & + function c_resourcemanager_make_alloc_monotonic_u(self, name, & + allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -1070,9 +1069,9 @@ function c_resourcemanager_make_allocator_monotonic_untracked( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_monotonic_untracked + end function c_resourcemanager_make_alloc_monotonic_u - function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & + function c_resourcemanager_make_alloc_monotonic_u_bufferify( & self, name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_monotonic_untracked_bufferify") @@ -1086,10 +1085,10 @@ function c_resourcemanager_make_allocator_monotonic_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_monotonic_untracked_bufferify + end function c_resourcemanager_make_alloc_monotonic_u_bufferify - function c_resourcemanager_make_allocator_slot_pool_untracked( & - self, name, allocator, object_size, SHT_crv) & + function c_resourcemanager_make_alloc_slot_p_u(self, name, & + allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked") use iso_c_binding, only : C_CHAR, C_PTR, C_SIZE_T @@ -1101,10 +1100,10 @@ function c_resourcemanager_make_allocator_slot_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_slot_pool_untracked + end function c_resourcemanager_make_alloc_slot_p_u - function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & - self, name, Lname, allocator, object_size, SHT_crv) & + function c_resourcemanager_make_alloc_slot_p_u_bufferify(self, & + name, Lname, allocator, object_size, SHT_crv) & result(SHT_rv) & bind(C, name="umpire_resourcemanager_make_allocator_slot_pool_untracked_bufferify") use iso_c_binding, only : C_CHAR, C_INT, C_PTR, C_SIZE_T @@ -1117,10 +1116,10 @@ function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: object_size type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_slot_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_slot_p_u_bufferify - function c_resourcemanager_make_allocator_mixed_pool_untracked( & - self, name, allocator, smallest_fixed_obj_size, & + function c_resourcemanager_make_alloc_mixed_p_u(self, name, & + allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & quick_pool_min_alloc_size, quick_pool_align_bytes, & @@ -1142,10 +1141,10 @@ function c_resourcemanager_make_allocator_mixed_pool_untracked( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_mixed_pool_untracked + end function c_resourcemanager_make_alloc_mixed_p_u - function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & - self, name, Lname, allocator, smallest_fixed_obj_size, & + function c_resourcemanager_make_alloc_mixed_p_u_bufferify(self, & + name, Lname, allocator, smallest_fixed_obj_size, & largest_fixed_obj_size, max_initial_fixed_pool_size, & fixed_size_multiplier, quick_pool_initial_alloc_size, & quick_pool_min_alloc_size, quick_pool_align_bytes, & @@ -1168,7 +1167,7 @@ function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify( & integer(C_SIZE_T), value, intent(IN) :: quick_pool_align_bytes type(umpire_SHROUD_allocator_capsule), intent(OUT) :: SHT_crv type(C_PTR) SHT_rv - end function c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify + end function c_resourcemanager_make_alloc_mixed_p_u_bufferify subroutine c_resourcemanager_add_alias(self, name, allocator) & bind(C, name="umpire_resourcemanager_add_alias") @@ -3429,7 +3428,7 @@ function make_alloc_dynamic_p_list_u(obj, name, allocator, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_list_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_list_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_dynamic_p_list_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_list_pool_untracked @@ -3447,7 +3446,7 @@ function make_alloc_quick_p_u(obj, name, allocator, initial_size, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_quick_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_quick_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_quick_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_quick_pool_untracked @@ -3465,7 +3464,7 @@ function make_alloc_res_aware_p_u(obj, name, allocator, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_resource_aware_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_resource_aware_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_res_aware_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & initial_size, block, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_resource_aware_pool_untracked @@ -3481,7 +3480,7 @@ function make_alloc_fixed_p_u(obj, name, allocator, object_size) & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_fixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_fixed_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_fixed_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_fixed_pool_untracked @@ -3497,7 +3496,7 @@ function make_alloc_monotonic_u(obj, name, allocator, object_size) & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_monotonic_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_monotonic_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_monotonic_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_monotonic_untracked @@ -3513,7 +3512,7 @@ function make_alloc_slot_p_u(obj, name, allocator, object_size) & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_slot_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_slot_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_slot_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & object_size, SHT_rv%cxxmem) ! splicer end class.ResourceManager.method.make_allocator_slot_pool_untracked @@ -3539,7 +3538,7 @@ function make_alloc_mixed_p_u(obj, name, allocator, & type(UmpireAllocator) :: SHT_rv ! splicer begin class.ResourceManager.method.make_allocator_mixed_pool_untracked type(C_PTR) :: SHT_prv - SHT_prv = c_resourcemanager_make_allocator_mixed_pool_untracked_bufferify(obj%cxxmem, & + SHT_prv = c_resourcemanager_make_alloc_mixed_p_u_bufferify(obj%cxxmem, & name, len_trim(name, kind=C_INT), allocator%cxxmem, & smallest_fixed_obj_size, largest_fixed_obj_size, & max_initial_fixed_pool_size, fixed_size_multiplier, & From b8464eab67f58e4d5504cc53c86057b27ec0a7cc Mon Sep 17 00:00:00 2001 From: Kristi Belcher Date: Tue, 7 Apr 2026 10:56:11 -0700 Subject: [PATCH 27/27] trigger ci --- docs/sphinx/tutorial/fortran/allocators.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/sphinx/tutorial/fortran/allocators.rst b/docs/sphinx/tutorial/fortran/allocators.rst index a9e6ddb60..34264e3b1 100644 --- a/docs/sphinx/tutorial/fortran/allocators.rst +++ b/docs/sphinx/tutorial/fortran/allocators.rst @@ -10,7 +10,7 @@ The fundamental concept for accessing memory through Umpire is an allocate raw memory, and a generic ``allocate`` procedure that takes an array pointer and an array of dimensions and will allocate the correct amount of memory. - + As with the native C++ interface, all allocators are accessed via the :class:`umpire::ResourceManager`. In the FORTRAN API, there is a corresponding ``UmpireResourceManager`` type. To get an ``UmpireAllocator``: