modify to be able to compile with OpenCoarrays

Author: everythingfunctional

example/lu_decomp/main.f90

@@ -26,6 +26,7 @@ program main
       close(f_unit)
     end if
     open(file=timing_file, newunit = f_unit, status="old", position = "append")
-    write(f_unit, '(I0, ",", I0, ",", I0, ",", G0)') matrix_size, size(tasks%vertices), num_images(), real(finish-start)/real(count_rate)
+    write(f_unit, '(I0, ",", I0, ",", I0, ",", G0)') &
+        matrix_size, size(tasks%vertices), num_images(), real(finish-start)/real(count_rate)
   end if
 end program

src/payload_m.f90

@@ -3,6 +3,8 @@ module payload_m
     private
     public :: payload_t, empty_payload
 
+    integer, parameter :: MAX_PAYLOAD_SIZE = 20002
+
     type :: payload_t
         !! A raw buffer to facilitate data transfer between  images
         !!
@@ -11,7 +13,8 @@ module payload_m
         !! * produce a string representation of the data, and then parse that string to recover the original data
         !! * use the `transfer` function to copy the raw bytes of the data
         private
-        integer, public, allocatable :: payload_(:)
+        integer, public :: payload_(MAX_PAYLOAD_SIZE)
+        integer :: payload_size = 0
     contains
         private
         procedure, public :: raw_payload
@@ -29,42 +32,58 @@ pure function from_raw(payload) result(new_payload)
         integer, intent(in) :: payload(:)
         type(payload_t) :: new_payload
 
-        allocate(new_payload%payload_, source = payload)
+        integer :: incoming_payload_size
+
+        incoming_payload_size = size(payload)
+        if (incoming_payload_size > MAX_PAYLOAD_SIZE) then
+            new_payload%payload_size = MAX_PAYLOAD_SIZE
+            new_payload%payload_ = payload(1:MAX_PAYLOAD_SIZE)
+        else
+            new_payload%payload_size = incoming_payload_size
+            new_payload%payload_(1:incoming_payload_size) = payload
+        end if
     end function
 
     pure function from_string(payload) result(new_payload)
         implicit none
         character(len=*), intent(in) :: payload
         type(payload_t) :: new_payload
 
-        new_payload = payload_t([len(payload), transfer(payload, new_payload%payload_)])
+        new_payload%payload_(1) = len(payload)
+        associate(string_as_integers => transfer(payload, new_payload%payload_))
+            if (size(string_as_integers) > MAX_PAYLOAD_SIZE-1) then
+                new_payload%payload_size = MAX_PAYLOAD_SIZE
+                new_payload%payload_(2:MAX_PAYLOAD_SIZE) = string_as_integers(1:MAX_PAYLOAD_SIZE-1)
+            else
+                new_payload%payload_size = size(string_as_integers) + 1
+                new_payload%payload_(2:new_payload%payload_size) = string_as_integers
+            end if
+        end associate
     end function
 
     pure function empty_payload()
         implicit none
         type(payload_t) :: empty_payload
-
-        allocate(empty_payload%payload_(0))
     end function
 
     pure function raw_payload(self)
         implicit none
         class(payload_t), intent(in) :: self
         integer, allocatable :: raw_payload(:)
 
-        raw_payload = self%payload_
+        raw_payload = self%payload_(1:self%payload_size)
     end function
 
     pure function string_payload(self)
         implicit none
         class(payload_t), intent(in) :: self
         character(len=:), allocatable :: string_payload
 
-        if (size(self%payload_) > 0) then
+        if (self%payload_size > 0) then
             allocate(character(len=self%payload_(1)) :: string_payload)
             if (self%payload_(1) > 0) &
                     string_payload = transfer( &
-                            self%payload_(2:), string_payload)
+                            self%payload_(2:self%payload_size), string_payload)
         else
             allocate(character(len=0) :: string_payload)
         end if

src/vertex_m.f90

@@ -15,4 +15,17 @@ module vertex_m
       integer, allocatable :: edges(:)
       class(task_t), allocatable :: task
     end type
+
+    interface vertex_t
+      module procedure construct
+    end interface
+contains
+    function construct(edges, task) result(vertex)
+      integer, intent(in) :: edges(:)
+      class(task_t), intent(in) :: task
+      type(vertex_t) :: vertex
+
+      vertex%edges = edges
+      vertex%task = task
+    end function
 end module vertex_m