MAking implementation choices real dependencies

nasa · Feb 8, 2024 · dc89f87 · dc89f87
1 parent ee2afd9
commit dc89f87
Show file tree

Hide file tree

Showing 9 changed files with 79 additions and 81 deletions.
diff --git a/Fw/SerializableFile/CMakeLists.txt b/Fw/SerializableFile/CMakeLists.txt
@@ -12,13 +12,10 @@ set(SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/SerializableFile.cpp"
 )
 set(MOD_DEPS
-  Fw/Cfg
-  Fw/Types
+    Fw/Cfg
+    Fw/Types
+    Os
 )
-# For shared libraries, Os must exist in the module list
-if (BUILD_SHARED_LIBS)
-    list(APPEND MOD_DEPS "Os")
-endif()
 register_fprime_module()
 ### UTs ###
 set(UT_SOURCE_FILES

diff --git a/Os/CMakeLists.txt b/Os/CMakeLists.txt
@@ -81,7 +81,7 @@ elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
       list(APPEND MOD_DEPS "-lrt")
   endif()
 endif()
-require_fprime_implementation(Os/File)
+
 
 # If baremetal scheduler is set, remove the previous task files and add in the Baremetal variant
 if (FPRIME_USE_BAREMETAL_SCHEDULER)
@@ -100,6 +100,7 @@ if (FPRIME_USE_BAREMETAL_SCHEDULER)
     list(APPEND SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/Baremetal/Task.cpp")
 endif()
 register_fprime_module()
+require_fprime_implementation(Os/File)
 
 ### UTS ### Note: 3 separate UTs registered here.
 set(UT_SOURCE_FILES

diff --git a/Os/Stub/CMakeLists.txt b/Os/Stub/CMakeLists.txt
@@ -8,45 +8,33 @@
 add_custom_target("${FPRIME_CURRENT_MODULE}")
 set(SOURCE_FILES
     "${CMAKE_CURRENT_LIST_DIR}/File.cpp"
-)
-register_fprime_module(Os_File_Stub_Implementation)
-
-set(SOURCE_FILES
     "${CMAKE_CURRENT_LIST_DIR}/DefaultFile.cpp"
 )
-set(MOD_DEPS
-    Os_File_Stub_Implementation
-)
 register_fprime_module(Os_File_Stub)
 register_fprime_implementation(Os/File Os_File_Stub)
 
-if (BUILD_TESTING)
-    set(SOURCE_FILES
-        "${CMAKE_CURRENT_LIST_DIR}/test/File.cpp"
-    )
-    register_fprime_module(Os_File_Test_Stub_Implementation)
-
-    set(SOURCE_FILES
-            "${CMAKE_CURRENT_LIST_DIR}/test/DefaultFile.cpp"
-    )
-    set(MOD_DEPS
-            Os_File_Test_Stub_Implementation
-    )
-    register_fprime_module(Os_File_Test_Stub)
+# Remainder of file is specific to UTs
+if (NOT BUILD_TESTING)
+    return()
+endif ()
 
-    register_fprime_implementation(Os/File Os_File_Test_Stub)
+set(SOURCE_FILES
+    "${CMAKE_CURRENT_LIST_DIR}/test/File.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/test/DefaultFile.cpp"
+)
+register_fprime_module(Os_File_Test_Stub)
+register_fprime_implementation(Os/File Os_File_Test_Stub)
 
-    set(UT_SOURCE_FILES
-        "${CMAKE_CURRENT_LIST_DIR}/test/ut/StubFileTests.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/../test/ut/file/CommonTests.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/../test/ut/file/MyRules.cpp"
-    )
-    set(UT_MOD_DEPS
-        Os
-        Os_Test_File_SyntheticFileSystem
-        Os_Models
-        STest
-    )
-    choose_fprime_implementation(Os/File Os_File_Test_Stub)
-    register_fprime_ut(StubFileTest)
-endif()
+set(UT_SOURCE_FILES
+    "${CMAKE_CURRENT_LIST_DIR}/test/ut/StubFileTests.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/../test/ut/file/CommonTests.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/../test/ut/file/MyRules.cpp"
+)
+set(UT_MOD_DEPS
+    Os
+    Os_Models
+    Os_Test_File_SyntheticFileSystem
+    STest
+)
+choose_fprime_implementation(Os/File Os_File_Test_Stub)
+register_fprime_ut(StubFileTest)
diff --git a/Svc/CmdSequencer/CMakeLists.txt b/Svc/CmdSequencer/CMakeLists.txt
@@ -60,10 +60,7 @@ set(UT_SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/CmdSequencerTester.cpp"
 )
 
-# Choose stub as the implementation of file as we'll link over it
-choose_fprime_implementation(Os/File Os_File_Stub)
 set(UT_MOD_DEPS
-    Os_File_Test_Stub_Implementation
-    Os_File_Posix_Implementation
+    Os_File_Posix
 )
 register_fprime_ut()
diff --git a/Svc/PrmDb/CMakeLists.txt b/Svc/PrmDb/CMakeLists.txt
@@ -19,10 +19,9 @@ set(UT_SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/PrmDbTester.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/PrmDbImplTester.cpp"
 )
-# Choose stub as the implementation of file as we'll link over it
-choose_fprime_implementation(Os/File Os_File_Stub)
+
 set(UT_MOD_DEPS
-    Os_File_Test_Stub_Implementation
+    Os_File_Test_Stub
 )
 register_fprime_ut()
 
diff --git a/cmake/API.cmake b/cmake/API.cmake
@@ -560,6 +560,20 @@ macro(register_fprime_build_autocoder TARGET_FILE_PATH)
     register_fprime_list_helper("${TARGET_FILE_PATH}" FPRIME_AUTOCODER_TARGET_LIST)
 endmacro(register_fprime_build_autocoder)
 
+####
+# Function `create_implementation_interface`:
+#
+# Helper function to create implementation interface library once and only once to ensure it exists.
+#
+# **IMPLEMENTATION**: implementation library name (resolved)
+####
+function (create_implementation_interface IMPLEMENTATION)
+    if (TARGET "${IMPLEMENTATION}")
+        return()
+    endif()
+    add_library("${IMPLEMENTATION}" INTERFACE)
+endfunction()
+
 
 ####
 # Function `require_fprime_implementation`:
@@ -569,16 +583,23 @@ endmacro(register_fprime_build_autocoder)
 # `choose_fprime_implementation` in the platform and may be overridden in in the executable/deployment.
 #
 # **IMPLEMENTATION:** implementation module name that must be covered
+# **REQUESTER:** (optional) the requester of the implementation. Default: ${FPRIME_CURRENT_MODULE}
 ####
 function(require_fprime_implementation IMPLEMENTATION)
-    resolve_dependencies(IMPLEMENTATION "${IMPLEMENTATION}")
-    # Create interface target if necessary
-    if (NOT TARGET "${IMPLEMENTATION}")
-        add_custom_target("${IMPLEMENTATION}" INTERFACE)
+    if (ARGC EQUAL 2)
+        set(REQUESTER "${ARGV1}")
+    elseif (FPRIME_CURRENT_MODULE)
+        set(REQUESTER "${FPRIME_CURRENT_MODULE}")
+    else ()
+        message(FATAL_ERROR "Cannot determine current module, please supply as second argument")
     endif()
+    resolve_dependencies(IMPLEMENTATION "${IMPLEMENTATION}")
+    resolve_dependencies(REQUESTER "${REQUESTER}")
+
+    create_implementation_interface("${IMPLEMENTATION}")
     append_list_property("${IMPLEMENTATION}" GLOBAL PROPERTY "REQUIRED_IMPLEMENTATIONS")
     append_list_property("${FPRIME_CURRENT_MODULE}" TARGET "${IMPLEMENTATION}" PROPERTY "REQUESTERS")
-    get_property(VAR123 TARGET "${IMPLEMENTATION}" PROPERTY "REQUESTERS")
+    add_dependencies("${REQUESTER}" "${IMPLEMENTATION}")
 endfunction()
 
 ####
@@ -594,12 +615,11 @@ endfunction()
 function(register_fprime_implementation IMPLEMENTATION IMPLEMENTOR)
     resolve_dependencies(IMPLEMENTATION "${IMPLEMENTATION}")
     resolve_dependencies(IMPLEMENTOR "${IMPLEMENTOR}")
-    # Create interface target if necessary
-    if (NOT TARGET "${IMPLEMENTATION}")
-        add_custom_target("${IMPLEMENTATION}" INTERFACE)
-    endif()
+    create_implementation_interface("${IMPLEMENTATION}")
     append_list_property("${IMPLEMENTOR}" TARGET "${IMPLEMENTATION}" PROPERTY "IMPLEMENTORS")
+    add_dependencies("${IMPLEMENTATION}" "${IMPLEMENTOR}")
 endfunction()
+
 ####
 # Function `choose_fprime_implementation`:
 #
@@ -623,11 +643,10 @@ function(choose_fprime_implementation IMPLEMENTATION IMPLEMENTOR)
     else()
         message(FATAL_ERROR "Cannot call 'choose_fprime_implementation' outside an fprime module or platform CMake file")
     endif()
-    # Create interface target if necessary
-    if (NOT TARGET "${IMPLEMENTATION}")
-        add_custom_target("${IMPLEMENTATION}" INTERFACE)
-    endif()
-    set_property(GLOBAL PROPERTY "${IMPLEMENTATION}_${ACTIVE_MODULE}" "${IMPLEMENTOR}")
+    create_implementation_interface("${IMPLEMENTATION}")
+    # Add this implementation in the case it has not been added
+    append_list_property("${IMPLEMENTATION}" GLOBAL PROPERTY "REQUIRED_IMPLEMENTATIONS")
+    set_property(GLOBAL PROPERTY "${ACTIVE_MODULE}_${IMPLEMENTATION}" "${IMPLEMENTOR}")
 endfunction()
 
 #### Documentation links

diff --git a/cmake/implementation.cmake b/cmake/implementation.cmake
@@ -35,12 +35,12 @@ include_guard()
 ####
 function(remap_implementation_choices INFERRED DECLARED)
     # Check and setup implementors
-    get_property(LOCAL_REQUIRED GLOBAL PROPERTY "REQUIRED_IMPLEMENTATIONS")
-    if (LOCAL_REQUIRED)
-        foreach (IMPLEMENTATION IN LISTS LOCAL_REQUIRED)
-            get_property(IMPLEMENTOR GLOBAL PROPERTY "${IMPLEMENTATION}_${INFERRED}")
+    get_property(GLOBAL_REQUIRED GLOBAL PROPERTY "REQUIRED_IMPLEMENTATIONS")
+    if (GLOBAL_REQUIRED)
+        foreach (IMPLEMENTATION IN LISTS GLOBAL_REQUIRED)
+            get_property(IMPLEMENTOR GLOBAL PROPERTY "${INFERRED}_${IMPLEMENTATION}")
             if (IMPLEMENTOR)
-                set_property(GLOBAL PROPERTY "${IMPLEMENTATION}_${DECLARED}" "${IMPLEMENTOR}")
+                set_property(GLOBAL PROPERTY "${DECLARED}_${IMPLEMENTATION}" "${IMPLEMENTOR}")
             endif()
         endforeach()
     endif ()
@@ -76,9 +76,9 @@ endfunction()
 #####
 function(setup_executable_implementation IMPLEMENTATION MODULE)
     # Get the chosen implementor and fallback to the platform choice
-    get_property(IMPLEMENTOR GLOBAL PROPERTY "${IMPLEMENTATION}_${MODULE}")
+    get_property(IMPLEMENTOR GLOBAL PROPERTY "${MODULE}_${IMPLEMENTATION}")
     if (NOT IMPLEMENTOR)
-        get_property(IMPLEMENTOR GLOBAL PROPERTY "${IMPLEMENTATION}_${FPRIME_PLATFORM}")
+        get_property(IMPLEMENTOR GLOBAL PROPERTY "${FPRIME_PLATFORM}_${IMPLEMENTATION}")
     endif()
     # Handle a failure to choose anything
     if (NOT IMPLEMENTOR)
@@ -90,10 +90,8 @@ function(setup_executable_implementation IMPLEMENTATION MODULE)
         message(FATAL_ERROR "An implementation of ${IMPLEMENTATION} is required.  Choose from: ${POSSIBLE}")
     endif ()
     if (CMAKE_DEBUG_OUTPUT)
-        message(STATUS "Using Implementation: ${IMPLEMENTOR} for ${IMPLEMENTATION}")
+        message(STATUS "[${MODULE}] Using Implementation: ${IMPLEMENTOR} for ${IMPLEMENTATION}")
     endif()
-    # Replicated order to solve the circular dependency issue without causing a hard-dependency
-    target_link_libraries("${MODULE}" PUBLIC "$<TARGET_PROPERTY:${IMPLEMENTATION},REQUESTERS>" "${IMPLEMENTOR}"
-            "$<TARGET_PROPERTY:${IMPLEMENTATION},REQUESTERS>")
-    add_dependencies("${MODULE}" "${IMPLEMENTOR}")
+    add_dependencies("${MODULE}" ${IMPLEMENTATION} ${IMPLEMENTOR})
+    target_link_libraries("${MODULE}" PUBLIC ${IMPLEMENTATION} ${IMPLEMENTOR})
 endfunction()
diff --git a/cmake/module.cmake b/cmake/module.cmake
@@ -35,12 +35,6 @@ function(generate_base_module_properties TARGET_TYPE TARGET_NAME SOURCE_FILES DE
         message(FATAL_ERROR "Module ${FPRIME_CURRENT_MODULE} cannot register object of type ${TARGET_TYPE}")
     endif()
 
-    # Handle updates when the types have diverged
-    if (NOT TARGET_NAME STREQUAL "${FPRIME_CURRENT_MODULE}")
-        # Update implementation choices
-        remap_implementation_choices("${FPRIME_CURRENT_MODULE}" "${TARGET_NAME}")
-    endif()
-
     # Modules properties for posterity
     set_target_properties("${TARGET_NAME}" PROPERTIES FP_TYPE "${TARGET_TYPE}")
     set_property(GLOBAL APPEND PROPERTY FPRIME_MODULES "${TARGET_NAME}")

diff --git a/cmake/target/build.cmake b/cmake/target/build.cmake
@@ -69,6 +69,11 @@ function(build_setup_build_module MODULE SOURCES GENERATED DEPENDENCIES)
     # Handle executable items' need for determined package implementation choices
     is_target_library(IS_LIB "${MODULE}")
     if (NOT IS_LIB)
+        # Handle updates when the types have diverged
+        if (NOT MODULE STREQUAL "${FPRIME_CURRENT_MODULE}")
+            # Update implementation choices
+            remap_implementation_choices("${FPRIME_CURRENT_MODULE}" "${MODULE}")
+        endif()
         setup_executable_implementations("${MODULE}")
     endif ()