Fixing nrnivmodl-core: Avoid redefined symbols + script startup fixes (#133)

* Fixing nrnivmodl-core: dir creation, shbang
* Remove unnecessary mkdir step, create core sub-directory under x86_64
* Avoiding duplicate symbols when using nrnivmodl-core
* Generating libcorenrnmech featuring solve_core()
* Create an intermediate library (corenrnmech, similar to the process of nrnivmodl-core) which
contains the extra mechanisms and a solve_core() launcher, besides all
dependent registration/hook routines (mod_func.cpp and dimplic.cpp)
* Recompile kinderiv dependencies
* Install libcudacoreneuron; link missing
* Set rpath on libcorenrnmech
* Fix for GPU. Simplified build and fixed link flag
* Fixing rpath Origin in Mac and added deploy script
* Remove Wall flags from default compilation
* Cleanup debug messages in GPU implementation

Author: ferdonline

CMake/config/ReleaseDebugAutoFlags.cmake

@@ -47,15 +47,15 @@ endif()
 include(CompilerFlagsHelpers)
 
 
-set(CMAKE_C_FLAGS_RELEASE  "${CMAKE_C_WARNING_ALL} ${CMAKE_C_OPT_NORMAL}")
-set(CMAKE_C_FLAGS_DEBUG  "${CMAKE_C_DEBUGINFO_FLAGS} ${CMAKE_C_WARNING_ALL} ${CMAKE_C_OPT_NONE} ${CMAKE_C_STACK_PROTECTION}")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_DEBUGINFO_FLAGS} ${CMAKE_C_WARNING_ALL} ${CMAKE_C_OPT_NORMAL}")
-set(CMAKE_C_FLAGS_FAST "${CMAKE_C_WARNING_ALL} ${CMAKE_C_OPT_FASTEST} ${CMAKE_C_LINK_TIME_OPT} ${CMAKE_C_GEN_NATIVE}")
+set(CMAKE_C_FLAGS_RELEASE  "${CMAKE_C_OPT_NORMAL}")
+set(CMAKE_C_FLAGS_DEBUG  "${CMAKE_C_DEBUGINFO_FLAGS}  ${CMAKE_C_OPT_NONE} ${CMAKE_C_STACK_PROTECTION}")
+set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_DEBUGINFO_FLAGS}  ${CMAKE_C_OPT_NORMAL}")
+set(CMAKE_C_FLAGS_FAST " ${CMAKE_C_OPT_FASTEST} ${CMAKE_C_LINK_TIME_OPT} ${CMAKE_C_GEN_NATIVE}")
 
 
 
-set(CMAKE_CXX_FLAGS_RELEASE  "${CMAKE_CXX_WARNING_ALL} ${CMAKE_CXX_OPT_NORMAL}")
-set(CMAKE_CXX_FLAGS_DEBUG  "${CMAKE_CXX_DEBUGINFO_FLAGS} ${CMAKE_CXX_WARNING_ALL} ${CMAKE_CXX_OPT_NONE} ${CMAKE_CXX_STACK_PROTECTION}")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_DEBUGINFO_FLAGS} ${CMAKE_CXX_WARNING_ALL} ${CMAKE_CXX_OPT_NORMAL}")
-set(CMAKE_CXX_FLAGS_FAST "${CMAKE_CXX_WARNING_ALL} ${CMAKE_CXX_OPT_FASTEST} ${CMAKE_CXX_LINK_TIME_OPT} ${CMAKE_CXX_GEN_NATIVE}")
+set(CMAKE_CXX_FLAGS_RELEASE  "${CMAKE_CXX_OPT_NORMAL}")
+set(CMAKE_CXX_FLAGS_DEBUG  "${CMAKE_CXX_DEBUGINFO_FLAGS}  ${CMAKE_CXX_OPT_NONE} ${CMAKE_CXX_STACK_PROTECTION}")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_DEBUGINFO_FLAGS}  ${CMAKE_CXX_OPT_NORMAL}")
+set(CMAKE_CXX_FLAGS_FAST " ${CMAKE_CXX_OPT_FASTEST} ${CMAKE_CXX_LINK_TIME_OPT} ${CMAKE_CXX_GEN_NATIVE}")
 

CMake/config/SetRpath.cmake

@@ -14,6 +14,8 @@ IF( NOT BLUEGENE AND NOT CRAY_SYSTEM)
     # which point to directories outside the build tree to the install RPATH
     SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 
+    set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+
     # the RPATH to be used when installing, but only if it's not a system directory
     LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${LIB_INSTALL_DIR}" isSystemDir)
     IF("${isSystemDir}" STREQUAL "-1")

CMakeLists.txt

@@ -216,6 +216,7 @@ if(${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
 endif()
 
 if(ENABLE_OPENACC)
+    set(COMPILE_LIBRARY_TYPE "STATIC")
     if(${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
         add_definitions( -DPG_ACC_BUGS)
         set(ACC_FLAGS "-acc -Minline=size:200,levels:10")
@@ -232,7 +233,6 @@ if(ENABLE_OPENACC)
     if(ENABLE_CUDA_MODULES)
         find_package(CUDA 5.0)
         SET(CUDA_SEPARABLE_COMPILATION ON)
-
         if(CUDA_FOUND)
             if(ENABLE_SELECTIVE_GPU_PROFILING)
                 add_definitions( -DCUDA_PROFILING)
@@ -253,6 +253,7 @@ ELSE(ENABLE_OPENACC)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${IGNORE_UNKNOWN_PRAGMA_FLAGS}")
 endif(ENABLE_OPENACC)
 
+
 if(DISABLE_NRN_TIMEOUT)
     add_definitions("-DDISABLE_TIMEOUT")
 endif()

apps/CMakeLists.txt

@@ -27,21 +27,15 @@
 
 include_directories(${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/coreneuron ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_BINARY_DIR}/coreneuron)
 
-# The mechanism registration function will be always defined from extra mechanisms in test directory
-add_definitions(-DADDITIONAL_MECHS)
-
-# LIbrary required for special
-add_library(coreneuron_main STATIC "coreneuron.cpp")
-
 add_executable(coreneuron_exec "${CMAKE_CURRENT_SOURCE_DIR}/coreneuron.cpp")
 
-set_target_properties(coreneuron_exec PROPERTIES
-                      OUTPUT_NAME "coreneuron_exec")
-
-target_link_libraries(coreneuron_exec coreneuron ${MPI_C_LIBRARIES} ${MPI_CXX_LIBRARIES} ${reportinglib_LIBRARY})
+target_link_libraries(coreneuron_exec corenrnmech
+                      ${MPI_C_LIBRARIES} ${MPI_CXX_LIBRARIES} ${reportinglib_LIBRARY})
 
 install(TARGETS coreneuron_exec
         DESTINATION "${CMAKE_INSTALL_BINDIR}")
 
-install(TARGETS coreneuron_main
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+
+# Install main to recompile for special-core
+install(FILES coreneuron.cpp
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/coreneuron)

apps/coreneuron.cpp

@@ -26,14 +26,8 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include <coreneuron/engine.h>
-extern "C" {extern void modl_reg(void);}
+#include <coreneuron/enginemech.h>
 
 int main(int argc, char** argv) {
-  return solve_core(argc, argv);
+    return solve_core(argc, argv);
 }
-
-/// Declare an empty function if Neurodamus mechanisms are not used, otherwise register them in mechs/cfile/mod_func.c
-#ifndef ADDITIONAL_MECHS
-void modl_reg() {}
-#endif

coreneuron/CMakeLists.txt

@@ -29,10 +29,14 @@ include_directories(utils/randoms)
 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${MPI_INCLUDE_PATH})
 
-FILE(GLOB_RECURSE coreneuron_all_headers "*.h*")
-FILE(GLOB_RECURSE coreneuron_all_templates "*.ipp")
-FILE(GLOB_RECURSE coreneuron_all_c_files "*.c*")
+file(GLOB_RECURSE coreneuron_all_headers "*.h*")
+file(GLOB_RECURSE coreneuron_all_templates "*.ipp")
 file(GLOB_RECURSE coreneuron_cuda_files "*.cu")
+file(GLOB_RECURSE coreneuron_all_c_files "nrniv/*.c*" "nrnmpi/*.c*" "nrnoc/*.c*"
+                                         "nrnomp/*.c*" "utils/*.c*")
+set(DIMPLIC_C "mech/dimplic.cpp")
+file(GLOB_RECURSE scopmath_c_files "scopmath_core/*.c*")
+
 
 # Compile and include MOD files
 
@@ -228,6 +232,7 @@ add_custom_command(OUTPUT "${KINDERIV_H}"
     DEPENDS ${MOD2C_OPTMECH_OUTPUTS} ${MOD2C_STDMECH_OUTPUTS} "${KINDERIV_PY}"
     COMMAND python "${KINDERIV_PY}"
     WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+add_custom_target(kinderiv DEPENDS "${KINDERIV_H}")
 
 if (EXPORT_MECHS_FUNCTIONS)
   # Create C file with all "get function pointers" methods
@@ -242,7 +247,8 @@ if (EXPORT_MECHS_FUNCTIONS)
 endif()
 
 # Add generated sources from MOD files
-set(GENERATED_MECH_C_FILES ${MOD_FUNC_C} ${MOD_FUNC_PTRS_C} ${MOD2C_STDMECH_OUTPUTS} ${MOD2C_OPTMECH_OUTPUTS})
+set(ADDITIONAL_MECH_C_FILES ${MOD_FUNC_C} ${MOD_FUNC_PTRS_C} ${DIMPLIC_C} ${MOD2C_OPTMECH_OUTPUTS})
+set(GENERATED_MECH_C_FILES ${ADDITIONAL_MECH_C_FILES}  ${MOD2C_STDMECH_OUTPUTS})
 
 # artificial cells must be on cpu, defaul nrnran123.c is for cpu, nrn_setup.cpp uses nrnran123 for only memory calculation purpose which should use cpu version of nrnran123
 set(NOACC_MECH_C_FILES
@@ -261,8 +267,6 @@ if(ENABLE_OPENACC)
     endif()
 endif()
 
-set(coreneuron_all_c_files ${coreneuron_all_c_files} ${GENERATED_MECH_C_FILES})
-
 #to indent generated c/cpp files
 if(CLANG_FORMAT_FOUND)
     add_custom_target(formatbuild
@@ -275,8 +279,6 @@ if(CLANG_FORMAT_FOUND)
 endif()
 
 
-add_library(coreneuron ${COMPILE_LIBRARY_TYPE} ${coreneuron_all_headers} ${coreneuron_all_templates} ${coreneuron_all_c_files} ${KINDERIV_H})
-
 set(link_cudacoreneuron)
 set(link_reportinglib)
 
@@ -288,6 +290,7 @@ if(ENABLE_OPENACC AND ENABLE_CUDA_MODULES)
         -gencode=arch=compute_50,code=sm_50
         -gencode=arch=compute_52,code=sm_52
         -gencode=arch=compute_52,code=compute_52
+        -Xcompiler -fPIC
     )
     set(link_cudacoreneuron cudacoreneuron)
 endif()
@@ -297,8 +300,20 @@ if(ENABLE_REPORTINGLIB)
 endif()
 
 
+
+############################################################
+# Target libs
+############################################################
+
+#
+# The coreneuron lib (only internal mechanisms)
+#
+add_library(coreneuron ${COMPILE_LIBRARY_TYPE} ${coreneuron_all_headers} ${coreneuron_all_templates}
+                       ${coreneuron_all_c_files} ${cudacorenrn_objs} ${MOD2C_STDMECH_OUTPUTS})
+add_dependencies(coreneuron kinderiv)
+
 target_link_libraries(coreneuron ${MPI_CXX_LIBRARIES}
-                      ${link_reportinglib} ${link_cudacoreneuron} ${CUDA_LIBRARIES} )
+                      ${link_reportinglib} ${link_cudacoreneuron} ${CUDA_LIBRARIES})
 
 set_target_properties(coreneuron PROPERTIES
                       VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}
@@ -315,31 +330,53 @@ set(CORENRN_LINK_LIBS ${CORENRN_LINK_LIBS} PARENT_SCOPE)
 set(CORENRN_OPTMECH_MODS "${MOD2C_OPTMECH_MODS}" PARENT_SCOPE)
 
 
-install(TARGETS coreneuron
+# The scopmath lib - should not contain dimplic
+add_library(scopmath STATIC ${coreneuron_all_headers} ${scopmath_c_files})
+set_target_properties(scopmath PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+#
+# The "complete" lib (coreneuron + opt mechs)
+#
+set(ENGINEMECH_C "mech/enginemech.cpp")
+add_library(corenrnmech ${COMPILE_LIBRARY_TYPE} ${coreneuron_all_headers} ${ENGINEMECH_C} ${ADDITIONAL_MECH_C_FILES})
+add_dependencies(corenrnmech kinderiv)
+
+# The mechanism registration function will be always defined (at least for halfgap)
+target_compile_definitions(corenrnmech PUBLIC -DADDITIONAL_MECHS)
+
+# Public link interface (default), so that end binary links with all, even if they'r static
+target_link_libraries(corenrnmech scopmath coreneuron)
+
+
+#########################################################
+# INSTALL
+#########################################################
+
+install(TARGETS coreneuron corenrnmech ${link_cudacoreneuron}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
-install(FILES "engine.h"
+install(FILES "engine.h" "enginemech.h"
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/coreneuron)
 
+install(PROGRAMS ${MOD2C_BINARY}
+        DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+install(FILES ${MOD2C_UNITS}
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/mod2c)
+
+
 if(ENABLE_HEADER_INSTALL)
     install(DIRECTORY .
             DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/coreneuron
             FILES_MATCHING PATTERN "*.h*" PATTERN "*.ipp")
 
-    install(FILES ${KINDERIV_PY}
+    install(FILES ${KINDERIV_PY} ${MOD_FUNC_C_PL} ${DIMPLIC_C} ${ENGINEMECH_C}
             DESTINATION ${CMAKE_INSTALL_DATADIR}/coreneuron)
 
-    install(FILES ${MOD_FUNC_C_PL}
+    install(TARGETS scopmath
             DESTINATION ${CMAKE_INSTALL_DATADIR}/coreneuron)
 
-    install(DIRECTORY "scopmath_core"
-            DESTINATION ${CMAKE_INSTALL_DATADIR}/coreneuron
-            FILES_MATCHING PATTERN "dimplic.cpp")
+    install(FILES ${MOD2C_OPTMECH_OUTPUTS}
+            DESTINATION ${CMAKE_INSTALL_DATADIR}/mod2c)
 endif()
-
-install(PROGRAMS ${MOD2C_BINARY}
-        DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-install(FILES ${MOD2C_UNITS}
-        DESTINATION ${CMAKE_INSTALL_DATADIR}/mod2c)

coreneuron/engine.h

@@ -4,7 +4,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern int solve_core(int argc, char** argv);
+
+extern void mk_mech_init(int argc, char** argv);
+extern int run_solve_core(int argc, char** argv);
+
 #ifdef __cplusplus
 }
 #endif

coreneuron/enginemech.h

@@ -0,0 +1,14 @@
+#ifndef CORENEURON_ENGINEMECH_H
+#define CORENEURON_ENGINEMECH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int solve_core(int argc, char** argv);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

coreneuron/scopmath_core/dimplic.cpp coreneuron/mech/dimplic.cppcoreneuron/scopmath_core/dimplic.cpp renamed to coreneuron/mech/dimplic.cpp

@@ -0,0 +1,21 @@
+/// Corenrnmech is a wrapper lib providing a single solve_core function
+/// which initializes the solver, loads the external mechanisms and launches the simulation
+
+#include <coreneuron/enginemech.h>
+#include <coreneuron/engine.h>
+
+#ifdef ADDITIONAL_MECHS
+namespace coreneuron{ extern void modl_reg(); }
+#endif
+
+int solve_core(int argc, char** argv) {
+
+    mk_mech_init(argc, argv);
+
+#ifdef ADDITIONAL_MECHS
+    /// Initializing additional Neurodamus mechanisms (in mod_func.c, built by mech/mod_func.c.pl)
+    coreneuron::modl_reg();
+#endif
+
+    return run_solve_core(argc, argv);
+}