Funkcje Python unittest C / Fortran MPI powodujące wywołanie funkcji MPI_Init po MPI_finalize

Piszę otoki Pythona do biblioteki Fortran, która używa MPI (OpenMPI, jeśli jest to istotne). Problem, o którym tu wspominam, występuje również dokładnie w przypadku opakowań Pythona do bibliotek C. Muszę użyć wbudowanego unittestpakietu Python do testowania interfejsu Pythona.

Mam następujący MWE, który próbuje znaleźć maksymalną i minimalną liczbę całkowitą dla wszystkich procesorów. Oto plik Fortran:

! File mpitest.F90
module mpitest
    implicit none
    include "mpif.h"
    integer nranks
    integer rank

    contains

    !--------------------------------------------------!
    subroutine pympitest_init()
        implicit none
        integer ierror
        call MPI_INIT(ierror)
        call MPI_COMM_SIZE(MPI_COMM_WORLD, nranks, ierror)
        call MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierror)
    end subroutine pympitest_init

    !--------------------------------------------------!
    subroutine get_max_integer(inint, outint)
        implicit none
        integer, intent(in) :: inint
        integer, intent(out) :: outint
        integer ierror
        call mpi_allreduce(inint,outint,1,mpi_integer,mpi_max,MPI_COMM_WORLD,ierror)
    end subroutine get_max_integer

    !--------------------------------------------------!
    subroutine get_min_integer(inint, outint)
        implicit none
        integer, intent(in) :: inint
        integer, intent(out) :: outint
        integer ierror
        call mpi_allreduce(inint,outint,1,mpi_integer,mpi_min,MPI_COMM_WORLD,ierror)
    end subroutine get_min_integer

    !--------------------------------------------------!
    subroutine pympitest_final()
        integer ierror
        call mpi_finalize(ierror)
    end subroutine pympitest_final

end module mpitest

Plik testu jednostkowego Pythona jest podany poniżej, z kilkoma rzeczami, które wypróbowałem, ale nie pomogłem w umieszczaniu ich w komentarzach:

#!/usr/bin/env python3
# Python file test_pympitest.py
from __future__ import print_function
import unittest
import numpy as np

from pympitest import mpitest as pm

#--------------------------------------------------------------------#
class Test_Fortran_MPI_functions(unittest.TestCase):
    """Unit test template for testing MPI functions."""

    #----------------------------------------------------------------#
    #def __init__(self):
    #    """Try MPI_Initialize -- Does not help."""
    #    print("Initializing MPI")
    #    pm.pympitest_init()

    #----------------------------------------------------------------#
    #def tearDown(self):
    #    """Try MPI_Finalize -- Does not help."""
    #    print("Finalizing MPI")
    #    pm.pympitest_final()

    #----------------------------------------------------------------#
    def setUp(self):
        """Initialize the unit test."""
        print("Initializing MPI")
        pm.pympitest_init()

        # We'll just test min. and max. of ranks across all PEs.
        self.inint = pm.rank

    #----------------------------------------------------------------#
    def tearDown(self):
        """Finalize the unit test."""
        print("Finalizing MPI")
        pm.pympitest_final()

    #----------------------------------------------------------------#
    #----------------------------------------------------------------#
    # Two Tests. If you comment out any one of the tests, then the
    # unit test runs fine. Keeping both uncommented thorws error
    # saying MPI_Init was called after MPI_Final, obviously since
    # the setUp and tearDown functions are called every time.
    #----------------------------------------------------------------#
    def test_get_min_integer(self):
        """Test get_min_integer function."""
        minint = pm.get_min_integer(self.inint)
        print("Minimum on processor {} = {}".format(pm.rank,minint))
        self.assertEqual(minint, 0)

    #----------------------------------------------------------------#
    def test_get_max_integer(self):
        """Test get_max_integer function."""
        maxint = pm.get_max_integer(self.inint)
        print("Maximum on processor {} = {}".format(pm.rank,maxint))
        self.assertEqual(maxint, pm.nranks-1)

#--------------------------------------------------------------------#
if __name__ == "__main__":
    unittest.main()

    # Tried the following. Does not help:
    # Calls MPI_Initialize but exits without calling MPI_Finalize.
    #print("Initializing MPI")
    #pm.pympitest_init()
    #unittest.main()
    #print("Finalizing MPI")
    #pm.pympitest_final()

Kod Fortran jest owinięty w moduł Pythona o nazwie pympitestużyciu f2py, tak: f2py --f90exec="mpif90" -DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -c mpitest.F90 -m pympitest. Test jednostki jest prowadzony na 4 procesory tak: mpirun -np 4 python test_pympitest.py.

Chcę przechowywać wszystkie testy jednostkowe MPI w jednym pliku Pythona. W różnych rzeczach, które wypróbowałem (zobacz komentarze w pliku Pythona), problem, z jakim się spotkałem, polega na tym, że MPI_Initialize i MPI_Finalize są wywoływane wiele razy w jednym przebiegu lub tylko jeden z nich zostaje wywołany, z których wszystkie kończą się za pomocą błąd.

Jak to naprawić, aby testy jednostkowe przebiegały poprawnie?

Edycja (dodawanie): Umieszczenie funkcji testujących w oddzielnych Test_...(unittest.TestCase)klasach w jednym pliku Pythona również nie pomaga. Dzielenie testów jednostkowych MPI na różne pliki i próby python -m unittest discovernie działają, co jest niewygodne. Testowanie pojedynczej zawiniętej funkcji MPI na plik Pythona i indywidualne uruchamianie każdego pliku Pythona zadziałałoby, ale jest to coś, czego wolałbym unikać.

Te setUp()i tearDown()sposoby z użyciem unittest.TestCasezapewnić za prób metodą konfiguracji oraz przerwania połączenia. Należy spodziewać się, że pierwsza jest wykonywana przed każdą metodą testową, a druga po każdej.

Zamiast tego wydaje się, że chcesz, aby były one wykonywane raz dla całej kolekcji metod testowych w klasie. W tym celu potrzebujesz setUpClass () i tearDownClass () . Alternatywnie, jeśli zdefiniujesz wiele klas testowych, możesz preferować setUpModule()i tearDownModule().

Alternatywnie możesz utworzyć unittest.TestSuitepodklasę, w której będą przeprowadzane testy, i zastąpić jej run()metodę, aby przeprowadzić konfigurację i dezaktywację raz na zawsze.