Use new dag_m library (currently tracking dag HEAD)

Author: hsnyder

fpm.toml

@@ -7,7 +7,7 @@ copyright = "2021 Sourcery Institute"
 
 [dependencies]
 sourcery = {git = "https://github.com/sourceryinstitute/sourcery", tag = "21.02.24"}
-dag = {git = "https://github.com/sourceryinstitute/dag", tag = "21.04.20"}
+dag = {git = "https://github.com/sourceryinstitute/dag"}
 
 [dev-dependencies]
 vegetables = {git = "https://gitlab.com/everythingfunctional/vegetables", tag = "v7.0.2"}

src/application_m.f90

@@ -1,5 +1,5 @@
 module application_m
-  use dag_interface, only : dag_t
+  use dag_m, only : dag_t
   use task_item_m, only : task_item_t
   implicit none
 

src/application_s.f90

@@ -5,7 +5,7 @@
 contains
 
   module procedure construct
-    call assert(size(tasks)==dag%get_num_vertices(), "application(construct): size(tasks)==dag%get_num_vertices()")
+    call assert(size(tasks)==dag%num_vertices(), "application(construct): size(tasks)==dag%num_vertices()")
     application%dag_ = dag
     application%tasks_ = tasks
   end procedure

src/image_s.f90

@@ -1,5 +1,5 @@
 submodule(image_m) image_s
-    use dag_interface, only: dag_t
+    use dag_m, only: dag_t
     use iso_fortran_env, only: event_type
     use final_task_m, only: final_task_t
     use mailbox_m, only: mailbox, mailbox_entry_can_be_freed
@@ -84,7 +84,7 @@ function do_work(tasks, dag) result(tasks_left)
                     integer, allocatable :: upstream_task_imagenums(:)
 
                     ! figure out which images have our input data
-                    upstream_task_nums      = dag%get_edges(task_identifier)
+                    upstream_task_nums      = dag%dependencies_for(task_identifier)
                     upstream_task_imagenums = task_assignment_history(upstream_task_nums)[scheduler_image]
 
                     ! execute task, store result
@@ -138,10 +138,10 @@ function assign_task(dag) result(tasks_left)
                         ! check which task the image just finished, that's task A
                         ! for each task B upstream of A, walk through that task's downstream dependencies
                         ! if they're all completed, the output data from B can be freed.
-                        upstream_tasks       = dag%get_edges(task_identifier[next_image])
+                        upstream_tasks       = dag%dependencies_for(task_identifier[next_image])
                         upstream_task_images = task_assignment_history(upstream_tasks)
                         do i = 1, size(upstream_tasks)
-                            if (all(task_done(dag%get_dependencies(upstream_tasks(i))))) then
+                            if (all(task_done(dag%depends_on(upstream_tasks(i))))) then
                                 mailbox_entry_can_be_freed(upstream_tasks(i))[upstream_task_images(i)] = .true.        
                             end if
                         end do
@@ -176,7 +176,8 @@ subroutine assign_completed_to_images()
     end subroutine
 
     pure function find_next_task ( dag ) Result ( next_task_to_run )
-!! find_next_task: search through the dag to find the next task where its dependents are complete
+!! find_next_task: search through the dag to find the next task where its 
+!! dependencies are complete
 !!
 !! possible outputs for next_task_to_run
 !!     - a positive integer signals the next task to run
@@ -189,7 +190,7 @@ pure function find_next_task ( dag ) Result ( next_task_to_run )
       integer :: next_task_to_run
 
       integer :: task, depends
-      integer, allocatable, dimension(:) :: dependents
+      integer, allocatable, dimension(:) :: dependencies
       logical :: done, all_done
 
       all_done = .true.
@@ -200,10 +201,10 @@ pure function find_next_task ( dag ) Result ( next_task_to_run )
             cycle
          else
             all_done = .false.
-            dependents = dag%get_dependencies ( task )
+            dependencies = dag%dependencies_for ( task )
             done = .true.
-            do depends = 1, size(dependents)
-               done = done .and. task_done(depends)
+            do depends = 1, size(dependencies)
+               done = done .and. task_done(dependencies(depends))
             end do
             if ( done ) then
                next_task_to_run = task