[Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Andre Vehreschild]

[-- Attachment #1: Type: text/plain, Size: 365 bytes --]

Hi all,

attached patch fixes a memory leak when a user-defined function returns a
polymorphic type/class. The issue was, that the polymorphic type was not
detected correctly and therefore the len-field was not transferred correctly.

Regtests ok x86_64-linux/Fedora 39. Ok for master?

Regards,
	Andre
--
Andre Vehreschild * Email: vehre ad gmx dot de

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: pr90072_1.patch --]
[-- Type: text/x-patch, Size: 6735 bytes --]

From e79072de7279cc6863914588e4a0457f0c3493fd Mon Sep 17 00:00:00 2001
From: Andre Vehreschild <vehre@gcc.gnu.org>
Date: Wed, 19 Jul 2023 11:57:43 +0200
Subject: [PATCH] Fix returned type to be allocatable for user-functions.

The returned type of user-defined function returning a
class object was not detected and handled correctly, which
lead to memory leaks.

	PR fortran/90072

gcc/fortran/ChangeLog:

	* expr.cc (gfc_is_alloc_class_scalar_function): Detect
	allocatable class return types also for user-defined
	functions.
	* trans-expr.cc (gfc_conv_procedure_call): Same.
	(trans_class_vptr_len_assignment): Compute vptr len
	assignment correctly for user-defined functions.

gcc/testsuite/ChangeLog:

	* gfortran.dg/class_77.f90: New test.
---
 gcc/fortran/expr.cc                    | 13 ++--
 gcc/fortran/trans-expr.cc              | 35 +++++------
 gcc/testsuite/gfortran.dg/class_77.f90 | 83 ++++++++++++++++++++++++++
 3 files changed, 109 insertions(+), 22 deletions(-)
 create mode 100644 gcc/testsuite/gfortran.dg/class_77.f90

diff --git a/gcc/fortran/expr.cc b/gcc/fortran/expr.cc
index a162744c719..be138d196a2 100644
--- a/gcc/fortran/expr.cc
+++ b/gcc/fortran/expr.cc
@@ -5573,11 +5573,14 @@ bool
 gfc_is_alloc_class_scalar_function (gfc_expr *expr)
 {
   if (expr->expr_type == EXPR_FUNCTION
-      && expr->value.function.esym
-      && expr->value.function.esym->result
-      && expr->value.function.esym->result->ts.type == BT_CLASS
-      && !CLASS_DATA (expr->value.function.esym->result)->attr.dimension
-      && CLASS_DATA (expr->value.function.esym->result)->attr.allocatable)
+      && ((expr->value.function.esym
+	   && expr->value.function.esym->result
+	   && expr->value.function.esym->result->ts.type == BT_CLASS
+	   && !CLASS_DATA (expr->value.function.esym->result)->attr.dimension
+	   && CLASS_DATA (expr->value.function.esym->result)->attr.allocatable)
+	  || (expr->ts.type == BT_CLASS
+	      && CLASS_DATA (expr)->attr.allocatable
+	      && !CLASS_DATA (expr)->attr.dimension)))
     return true;

   return false;
diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc
index 9f6cc8f871e..d6f4d6bfe45 100644
--- a/gcc/fortran/trans-expr.cc
+++ b/gcc/fortran/trans-expr.cc
@@ -8301,7 +8301,9 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym,
 	    }

 	  /* Finalize the result, if necessary.  */
-	  attr = CLASS_DATA (expr->value.function.esym->result)->attr;
+	  attr = expr->value.function.esym
+		 ? CLASS_DATA (expr->value.function.esym->result)->attr
+		 : CLASS_DATA (expr)->attr;
 	  if (!((gfc_is_class_array_function (expr)
 		 || gfc_is_alloc_class_scalar_function (expr))
 		&& attr.pointer))
@@ -10085,27 +10087,26 @@ trans_class_vptr_len_assignment (stmtblock_t *block, gfc_expr * le,
   if (re->expr_type != EXPR_VARIABLE && re->expr_type != EXPR_NULL
       && rse->expr != NULL_TREE)
     {
-      if (re->ts.type == BT_CLASS && !GFC_CLASS_TYPE_P (TREE_TYPE (rse->expr)))
-	class_expr = gfc_get_class_from_expr (rse->expr);
+      if (!DECL_P (rse->expr))
+	{
+	  if (re->ts.type == BT_CLASS && !GFC_CLASS_TYPE_P (TREE_TYPE (rse->expr)))
+	    class_expr = gfc_get_class_from_expr (rse->expr);

-      if (rse->loop)
-	pre = &rse->loop->pre;
-      else
-	pre = &rse->pre;
+	  if (rse->loop)
+	    pre = &rse->loop->pre;
+	  else
+	    pre = &rse->pre;

-      if (class_expr != NULL_TREE && UNLIMITED_POLY (re))
-	{
-	  tmp = TREE_OPERAND (rse->expr, 0);
-	  tmp = gfc_create_var (TREE_TYPE (tmp), "rhs");
-	  gfc_add_modify (&rse->pre, tmp, TREE_OPERAND (rse->expr, 0));
+	  if (class_expr != NULL_TREE && UNLIMITED_POLY (re))
+	      tmp = gfc_evaluate_now (TREE_OPERAND (rse->expr, 0), &rse->pre);
+	  else
+	      tmp = gfc_evaluate_now (rse->expr, &rse->pre);
+
+	  rse->expr = tmp;
 	}
       else
-	{
-	  tmp = gfc_create_var (TREE_TYPE (rse->expr), "rhs");
-	  gfc_add_modify (&rse->pre, tmp, rse->expr);
-	}
+	pre = &rse->pre;

-      rse->expr = tmp;
       temp_rhs = true;
     }

diff --git a/gcc/testsuite/gfortran.dg/class_77.f90 b/gcc/testsuite/gfortran.dg/class_77.f90
new file mode 100644
index 00000000000..ef38dd67743
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/class_77.f90
@@ -0,0 +1,83 @@
+! { dg-do compile }
+! { dg-additional-options "-fdump-tree-original" }
+!
+! PR fortran/90072
+!
+! Contributed by Brad Richardson  <everythingfunctional@protonmail.com>
+!
+
+module types
+    implicit none
+
+    type, abstract :: base_returned
+    end type base_returned
+
+    type, extends(base_returned) :: first_returned
+    end type first_returned
+
+    type, extends(base_returned) :: second_returned
+    end type second_returned
+
+    type, abstract :: base_called
+    contains
+        procedure(get_), deferred :: get
+    end type base_called
+
+    type, extends(base_called) :: first_extended
+    contains
+        procedure :: get => getFirst
+    end type first_extended
+
+    type, extends(base_called) :: second_extended
+    contains
+        procedure :: get => getSecond
+    end type second_extended
+
+    abstract interface
+        function get_(self) result(returned)
+            import base_called
+            import base_returned
+            class(base_called), intent(in) :: self
+            class(base_returned), allocatable :: returned
+        end function get_
+    end interface
+contains
+    function getFirst(self) result(returned)
+        class(first_extended), intent(in) :: self
+        class(base_returned), allocatable :: returned
+
+        allocate(returned, source = first_returned())
+    end function getFirst
+
+    function getSecond(self) result(returned)
+        class(second_extended), intent(in) :: self
+        class(base_returned), allocatable :: returned
+
+        allocate(returned, source = second_returned())
+    end function getSecond
+end module types
+
+program dispatch_memory_leak
+    implicit none
+
+    call run()
+contains
+    subroutine run()
+        use types, only: base_returned, base_called, first_extended
+
+        class(base_called), allocatable :: to_call
+        class(base_returned), allocatable :: to_get
+
+        allocate(to_call, source = first_extended())
+        allocate(to_get, source = to_call%get())
+
+        deallocate(to_get)
+        select type(to_call)
+        type is (first_extended)
+            allocate(to_get, source = to_call%get())
+        end select
+    end subroutine run
+end program dispatch_memory_leak
+
+! { dg-final { scan-tree-dump-times "__builtin_free" 5 "original" } }
+
--
2.45.1

Re: [Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Paul Richard Thomas]

[-- Attachment #1: Type: text/plain, Size: 675 bytes --]

Hi Andre,

I apologise for the slow response. It's been something of a heavy week...

This is good for mainline.

Thanks

Paul

PS That's good news about the funding. Maybe we will get to see "built in"
coarrays soon?


On Tue, 4 Jun 2024 at 11:25, Andre Vehreschild <vehre@gmx.de> wrote:

> Hi all,
>
> attached patch fixes a memory leak when a user-defined function returns a
> polymorphic type/class. The issue was, that the polymorphic type was not
> detected correctly and therefore the len-field was not transferred
> correctly.
>
> Regtests ok x86_64-linux/Fedora 39. Ok for master?
>
> Regards,
>         Andre
> --
> Andre Vehreschild * Email: vehre ad gmx dot de
>

Re: [Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Andre Vehreschild]

Hi Paul,

thank you for the review. No need to apologize. I am happily working on and will
ping if I get no reviews.

Btw, Mikael, Nikolas and I are covered by the same funding and agreed to not
review each others work to prevent any "smells", like "they follow there own
agenda". We can of course be triggered by the community to do a second review
of each others work, when no one has enough expertise in the area worked on.

The patch has been commited to master as gcc-15-1090-g51046e46ae6

> PS That's good news about the funding. Maybe we will get to see "built in"
> coarrays soon?

You hopefully will see Nikolas work on the shared memory coarray support, if
that is what you mean by "built in" coarrays. I will be working on the
distributed memory coarray support esp. fixing the module issues and some other
team related things.

Thanks again for the review.

Regards,
	Andre
--
Andre Vehreschild * Email: vehre ad gmx dot de

Re: [Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Tobias Burnus]

[-- Attachment #1.1: Type: text/plain, Size: 1420 bytes --]

Andre Vehreschild wrote:
>> PS That's good news about the funding. Maybe we will get to see "built in"
>> coarrays soon?
> You hopefully will see Nikolas work on the shared memory coarray support, if
> that is what you mean by "built in" coarrays. I will be working on the
> distributed memory coarray support esp. fixing the module issues and some other
> team related things.

Cool! (Both of it.)

I assume "distributed memory coarray support" is still based on Open
Coarrays?

* * *

I am asking because there is coarray API being defined: Parallel Runtime
Interface for Fortran (PRIF), https://go.lbl.gov/prif

with an implementation called Caffeine – CoArray Fortran Framework of
Efficient Interfaces to Network Environments,
https://crd.lbl.gov/caffeine which uses GASNet or POSIX processes.

Well, the among the implementers is (unsurprising?) Damian – and the
idea seems to be that LLVM's FLANG will use the API.

Tobias

PS: I think it might be useful in the long run to support both
PRIF/Caffeine and OpenCoarrays.

I have attached my hello-world patch for -fcoarray=prif that I wrote
after ISC-HPC; it only handles this_image() / num_images() + init/stop.
I got confirmation by the PRIF developers that the next revision will
permit calling __prif_MOD_prif_init multiple times such that one can use
it in the constructor for static coarrays, which won't work otherwise.

[-- Attachment #2: prif.diff --]
[-- Type: text/x-patch, Size: 10099 bytes --]

gcc/ChangeLog:

	* flag-types.h (enum gfc_fcoarray):

gcc/fortran/ChangeLog:

	* invoke.texi:
	* lang.opt:
	* trans-decl.cc (gfc_build_builtin_function_decls):
	(create_main_function):
	* trans-intrinsic.cc (trans_this_image):
	(trans_num_images):
	* trans.h (GTY):

 gcc/flag-types.h               |  3 ++-
 gcc/fortran/invoke.texi        |  7 +++++-
 gcc/fortran/lang.opt           |  5 +++-
 gcc/fortran/trans-decl.cc      | 56 ++++++++++++++++++++++++++++++++++++++++--
 gcc/fortran/trans-intrinsic.cc | 42 +++++++++++++++++++++++++++----
 gcc/fortran/trans.h            |  5 ++++
 6 files changed, 108 insertions(+), 10 deletions(-)

diff --git a/gcc/flag-types.h b/gcc/flag-types.h
index 5a2b461fa75..babd747c01d 100644
--- a/gcc/flag-types.h
+++ b/gcc/flag-types.h
@@ -427,7 +427,8 @@ enum gfc_fcoarray
 {
   GFC_FCOARRAY_NONE = 0,
   GFC_FCOARRAY_SINGLE,
-  GFC_FCOARRAY_LIB
+  GFC_FCOARRAY_LIB,
+  GFC_FCOARRAY_PRIF
 };
 
 
diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi
index 40e8e4a7cdd..331a40d31db 100644
--- a/gcc/fortran/invoke.texi
+++ b/gcc/fortran/invoke.texi
@@ -1753,7 +1753,12 @@ Single-image mode, i.e. @code{num_images()} is always one.
 
 @item @samp{lib}
 Library-based coarray parallelization; a suitable GNU Fortran coarray
-library needs to be linked.
+library needs to be linked such as @url{http://opencoarrays.org}.
+
+@item @samp{prif}
+Using the Parallel Runtime Interface for Fortran (PRIF),
+@url{https://go.lbl.gov/@/prif}; for instance, via Caffeine,
+@url{https://go.lbl.gov/@/caffeine}.
 @end table
 
 
diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt
index 5efd4a0129a..9ba957d5571 100644
--- a/gcc/fortran/lang.opt
+++ b/gcc/fortran/lang.opt
@@ -786,7 +786,7 @@ Copy array sections into a contiguous block on procedure entry.
 
 fcoarray=
 Fortran RejectNegative Joined Enum(gfc_fcoarray) Var(flag_coarray) Init(GFC_FCOARRAY_NONE)
--fcoarray=<none|single|lib>	Specify which coarray parallelization should be used.
+-fcoarray=<none|single|lib|prif>	Specify which coarray parallelization should be used.
 
 Enum
 Name(gfc_fcoarray) Type(enum gfc_fcoarray) UnknownError(Unrecognized option: %qs)
@@ -800,6 +800,9 @@ Enum(gfc_fcoarray) String(single) Value(GFC_FCOARRAY_SINGLE)
 EnumValue
 Enum(gfc_fcoarray) String(lib) Value(GFC_FCOARRAY_LIB)
 
+EnumValue
+Enum(gfc_fcoarray) String(prif) Value(GFC_FCOARRAY_PRIF)
+
 fcheck=
 Fortran RejectNegative JoinedOrMissing
 -fcheck=[...]	Specify which runtime checks are to be performed.
diff --git a/gcc/fortran/trans-decl.cc b/gcc/fortran/trans-decl.cc
index dca7779528b..d1c0e2ee997 100644
--- a/gcc/fortran/trans-decl.cc
+++ b/gcc/fortran/trans-decl.cc
@@ -170,6 +170,10 @@ tree gfor_fndecl_co_sum;
 tree gfor_fndecl_caf_is_present;
 tree gfor_fndecl_caf_random_init;
 
+tree gfor_fndecl_prif_init;
+tree gfor_fndecl_prif_stop;
+tree gfor_fndecl_prif_this_image_no_coarray;
+tree gfor_fndecl_prif_num_images;
 
 /* Math functions.  Many other math functions are handled in
    trans-intrinsic.cc.  */
@@ -4147,6 +4151,31 @@ gfc_build_builtin_function_decls (void)
 	    get_identifier (PREFIX("caf_random_init")),
 	    void_type_node, 2, logical_type_node, logical_type_node);
     }
+  else if (flag_coarray == GFC_FCOARRAY_PRIF)
+    {
+      tree pint_type = build_pointer_type (integer_type_node);
+      tree pbool_type = build_pointer_type (boolean_type_node);
+      tree pintmax_type_node = get_typenode_from_name (INTMAX_TYPE);
+      pintmax_type_node = build_pointer_type (pintmax_type_node);
+
+      gfor_fndecl_prif_init = gfc_build_library_function_decl_with_spec (
+	get_identifier ("__prif_MOD_prif_init"), ". W ",
+	void_type_node, 1, pint_type);
+
+      gfor_fndecl_prif_stop = gfc_build_library_function_decl_with_spec (
+	get_identifier ("__prif_MOD_prif_stop"), ". R R R ", void_type_node,
+	4, pbool_type, pint_type, pchar_type_node, gfc_charlen_type_node);
+
+      gfor_fndecl_prif_this_image_no_coarray =
+	gfc_build_library_function_decl_with_spec (
+	  get_identifier ("__prif_MOD_prif_this_image_no_coarray"), ". R W ",
+	void_type_node, 2, pvoid_type_node, pint_type);
+
+      gfor_fndecl_prif_num_images = gfc_build_library_function_decl_with_spec (
+	get_identifier ("__prif_MOD_prif_num_images"), ". R W ", void_type_node,
+	3, pvoid_type_node, pintmax_type_node,
+	pint_type);
+    }
 
   gfc_build_intrinsic_function_decls ();
   gfc_build_intrinsic_lib_fndecls ();
@@ -6507,9 +6536,9 @@ create_main_function (tree fndecl)
 
   /* Call some libgfortran initialization routines, call then MAIN__().  */
 
-  /* Call _gfortran_caf_init (*argc, ***argv).  */
   if (flag_coarray == GFC_FCOARRAY_LIB)
     {
+      /* Call _gfortran_caf_init (*argc, ***argv).  */
       tree pint_type, pppchar_type;
       pint_type = build_pointer_type (integer_type_node);
       pppchar_type
@@ -6520,6 +6549,16 @@ create_main_function (tree fndecl)
 		gfc_build_addr_expr (pppchar_type, argv));
       gfc_add_expr_to_block (&body, tmp);
     }
+  else if (flag_coarray == GFC_FCOARRAY_PRIF)
+    {
+      /* Call prif_init (*exit_code).  */
+      tree exit_code = create_tmp_var_raw (integer_type_node, "exit_code");
+      pushdecl (exit_code);
+      tmp = build_call_expr_loc (input_location, gfor_fndecl_prif_init, 1,
+				 gfc_build_addr_expr (NULL, exit_code));
+      gfc_add_expr_to_block (&body, tmp);
+// FIXME: Handle exit code?
+    }
 
   /* Call _gfortran_set_args (argc, argv).  */
   TREE_USED (argc) = 1;
@@ -6634,12 +6673,25 @@ create_main_function (tree fndecl)
   /* Mark MAIN__ as used.  */
   TREE_USED (fndecl) = 1;
 
-  /* Coarray: Call _gfortran_caf_finalize(void).  */
   if (flag_coarray == GFC_FCOARRAY_LIB)
     {
+      /* Call _gfortran_caf_finalize(void).  */
       tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_finalize, 0);
       gfc_add_expr_to_block (&body, tmp);
     }
+  else if (flag_coarray == GFC_FCOARRAY_PRIF)
+    {
+      /* Call prif_stop(*quiet, *stop_code_int, *stop_code_char, _stop_code_char)
+	 as prif_stop(&true, NULL, NULL, 0).  */
+      tree quiet = create_tmp_var_raw (boolean_type_node, "quiet");
+      pushdecl (quiet);
+      gfc_add_modify (&body, quiet, boolean_true_node);
+      tmp = build_call_expr_loc (input_location, gfor_fndecl_prif_stop, 4,
+				 gfc_build_addr_expr (NULL, quiet), null_pointer_node,
+				 null_pointer_node,
+				 build_zero_cst (gfc_charlen_type_node));
+      gfc_add_expr_to_block (&body, tmp);
+    }
 
   /* "return 0".  */
   tmp = fold_build2_loc (input_location, MODIFY_EXPR, integer_type_node,
diff --git a/gcc/fortran/trans-intrinsic.cc b/gcc/fortran/trans-intrinsic.cc
index 80dc3426ab0..a34d6a57688 100644
--- a/gcc/fortran/trans-intrinsic.cc
+++ b/gcc/fortran/trans-intrinsic.cc
@@ -27,6 +27,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "memmodel.h"
 #include "tm.h"		/* For UNITS_PER_WORD.  */
 #include "tree.h"
+#include "gimple-expr.h"  /* For create_tmp_var_name.  */
 #include "gfortran.h"
 #include "trans.h"
 #include "stringpool.h"
@@ -2386,6 +2387,7 @@ trans_this_image (gfc_se * se, gfc_expr *expr)
   /* Argument-free version: THIS_IMAGE().  */
   if (distance || expr->value.function.actual->expr == NULL)
     {
+// FIXME: Update comment; handle distance (== 'team' arg?)
       if (distance)
 	{
 	  gfc_init_se (&argse, NULL);
@@ -2396,8 +2398,23 @@ trans_this_image (gfc_se * se, gfc_expr *expr)
 	}
       else
 	tmp = integer_zero_node;
-      tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_this_image, 1,
-				 tmp);
+      if (flag_coarray == GFC_FCOARRAY_LIB)
+	tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_this_image,
+				   1, tmp);
+      else if (flag_coarray == GFC_FCOARRAY_PRIF)
+	{
+	  tree image_index = create_tmp_var_raw (integer_type_node,
+						 "image_index");
+	  gfc_add_decl_to_function (image_index);
+	  tmp = build_call_expr_loc (input_location,
+				     gfor_fndecl_prif_this_image_no_coarray, 2,
+				     null_pointer_node, /* FIXME: team. */
+				     gfc_build_addr_expr (NULL, image_index));
+	  gfc_add_expr_to_block (&se->pre, tmp);
+	  tmp = image_index;
+	}
+      else
+	gcc_unreachable ();
       se->expr = fold_convert (gfc_get_int_type (gfc_default_integer_kind),
 			       tmp);
       return;
@@ -2799,7 +2816,7 @@ trans_num_images (gfc_se * se, gfc_expr *expr)
 {
   tree tmp, distance, failed;
   gfc_se argse;
-
+// FIXME: Handle team / team-numbe argument
   if (expr->value.function.actual->expr)
     {
       gfc_init_se (&argse, NULL);
@@ -2821,8 +2838,23 @@ trans_num_images (gfc_se * se, gfc_expr *expr)
     }
   else
     failed = build_int_cst (integer_type_node, -1);
-  tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_num_images, 2,
-			     distance, failed);
+  if (flag_coarray == GFC_FCOARRAY_LIB)
+    tmp = build_call_expr_loc (input_location, gfor_fndecl_caf_num_images, 2,
+			       distance, failed);
+  else if (flag_coarray == GFC_FCOARRAY_PRIF)
+    {
+      tree image_count = create_tmp_var_raw (integer_type_node, "image_count");
+      gfc_add_decl_to_function (image_count);
+      tmp = build_call_expr_loc (input_location, gfor_fndecl_prif_num_images, 3,
+				 null_pointer_node, /* FIXME: team. */
+				 null_pointer_node, /* FIXME: team_number. */
+				 gfc_build_addr_expr (NULL, image_count));
+      gfc_add_expr_to_block (&se->pre, tmp);
+      tmp = image_count;
+    }
+  else
+    gcc_unreachable ();
+
   se->expr = fold_convert (gfc_get_int_type (gfc_default_integer_kind), tmp);
 }
 
diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h
index f94fa601400..adf4d406bba 100644
--- a/gcc/fortran/trans.h
+++ b/gcc/fortran/trans.h
@@ -920,6 +920,11 @@ extern GTY(()) tree gfor_fndecl_co_reduce;
 extern GTY(()) tree gfor_fndecl_co_sum;
 extern GTY(()) tree gfor_fndecl_caf_is_present;
 
+extern GTY(()) tree gfor_fndecl_prif_init;
+extern GTY(()) tree gfor_fndecl_prif_stop;
+extern GTY(()) tree gfor_fndecl_prif_this_image_no_coarray;
+extern GTY(()) tree gfor_fndecl_prif_num_images;
+
 /* Math functions.  Many other math functions are handled in
    trans-intrinsic.cc.  */
 

Re: [Patch, PR Fortran/90072] Polymorphic Dispatch to Polymophic Return Type Memory Leak

[Andre Vehreschild]

Hi Tobias,

I know about PRIF and was involved in the design of Caffeine. Unfortunately did
this intersect with the funding proposal and we did not want to overload the
proposal more. At the moment adding module support to dist. mem. coarrays means
OpenCoarrays patching, yes. In the unlikely event, that this should proceed
faster than expected we might look into PRIF/Caffeine and work on an
alternative implementation. But I expect that besides a proof of concept not
much will come of that, because one needs to implement a rather different
interface for each API call. 

Anyway, did you see my question about me issue with doing gomp-fortran tests: 
https://gcc.gnu.org/pipermail/fortran/2024-June/060542.html

Do you have any insight of what I am doing wrong? 

Regards,
	Andre

On Sat, 8 Jun 2024 21:52:42 +0200
Tobias Burnus <burnus@net-b.de> wrote:

> Andre Vehreschild wrote:
> >> PS That's good news about the funding. Maybe we will get to see "built in"
> >> coarrays soon?  
> > You hopefully will see Nikolas work on the shared memory coarray support, if
> > that is what you mean by "built in" coarrays. I will be working on the
> > distributed memory coarray support esp. fixing the module issues and some
> > other team related things.  
> 
> Cool! (Both of it.)
> 
> I assume "distributed memory coarray support" is still based on Open
> Coarrays?
> 
> * * *
> 
> I am asking because there is coarray API being defined: Parallel Runtime
> Interface for Fortran (PRIF), https://go.lbl.gov/prif
> 
> with an implementation called Caffeine – CoArray Fortran Framework of
> Efficient Interfaces to Network Environments,
> https://crd.lbl.gov/caffeine which uses GASNet or POSIX processes.
> 
> Well, the among the implementers is (unsurprising?) Damian – and the
> idea seems to be that LLVM's FLANG will use the API.
> 
> Tobias
> 
> PS: I think it might be useful in the long run to support both
> PRIF/Caffeine and OpenCoarrays.
> 
> I have attached my hello-world patch for -fcoarray=prif that I wrote
> after ISC-HPC; it only handles this_image() / num_images() + init/stop.
> I got confirmation by the PRIF developers that the next revision will
> permit calling __prif_MOD_prif_init multiple times such that one can use
> it in the constructor for static coarrays, which won't work otherwise.


-- 
Andre Vehreschild * Email: vehre ad gmx dot de