Initial commit

.gitignore

+# C++ Build
+build*/
+install*/
+
+# VSCode
+.vscode
+
+# Python
+*.so
+__pycache__
+*.pyc
+*.egg-info
+
+# Mermaid
+*.mmd
+
+# Doxygen
+xml*/
+
+# ONNX
+*.onnx
\ No newline at end of file

.gitlab-ci.yml

+################################################################################
+# Pre-configured CI/CD for your Aidge module.
+#
+# Three stages are already pre-configured to run on Eclipse Aidge CI:
+# - build: ubuntu_cpp, ubuntu_python and windows_cpp;
+# - test: ubuntu_cpp, ubuntu_python and windows_cpp;
+# - coverage: ubuntu_cpp and ubuntu_python.
+#
+# If your project is pure C++ or pure Python, you can remove the "_python" or 
+# "_cpp" jobs respectively.
+# "ubuntu" jobs require an Ubuntu runner with a docker executor with tag 
+# "docker".
+# "windows" jobs require a Windows runner with a docker-windows executor with 
+# tag "windows".
+#
+# You can change the docker images in the YML scripts directly. The default 
+# images are:
+# - nvidia/cuda:12.2.0-devel-ubuntu22.04 for Ubuntu jobs;
+# - buildtools for Windows jobs, built on top of 
+#   mcr.microsoft.com/windows/servercore:ltsc2022 with Microsoft Visual Studio 
+#   2022 BuildTools installed.
+#
+# See Aidge project wiki for more details on how to setup your own docker images
+# and Gitlab runners.
+################################################################################
+
+stages:
+  # Build
+  - build
+  # Unit test stage
+  - test
+  # Code coverage
+  - coverage
+
+include:
+  - local: '/.gitlab/ci/_global.gitlab-ci.yml'
+  - local: '/.gitlab/ci/build.gitlab-ci.yml'
+  - local: '/.gitlab/ci/test.gitlab-ci.yml'
+  - local: '/.gitlab/ci/coverage.gitlab-ci.yml'

.gitlab/ci/_global.gitlab-ci.yml

+################################################################################
+# Centralized definitions of common job parameter values.                      #
+# Parameters with many optional configurations may be in separate files.       #
+#                                                                              #
+################################################################################
+variables:
+  GIT_SUBMODULE_STRATEGY: recursive
+  OMP_NUM_THREADS: 4
+  GIT_SSL_NO_VERIFY: 1
+  DEBIAN_FRONTEND: noninteractive
+
+default:
+  image: nvidia/cuda:12.2.0-devel-ubuntu22.04
+  before_script:
+    - apt update
+    - apt install -y cmake cppcheck python-is-python3 pip git gcovr unzip curl

.gitlab/ci/build.gitlab-ci.yml

+build:ubuntu_cpp:
+  stage: build
+  needs: []
+  tags:
+    - docker
+
+  script:
+    # Download dependencies
+    # aidge_core
+    - 'curl --location --output build_artifacts.zip "https://gitlab.eclipse.org/api/v4/projects/5139/jobs/artifacts/main/download?job=build:ubuntu_cpp"'
+    - unzip -o build_artifacts.zip -d .
+    - rm -rf build_cpp
+    # aidge_backend_cpu
+    - 'curl --location --output build_artifacts.zip "https://gitlab.eclipse.org/api/v4/projects/5140/jobs/artifacts/master/download?job=build:ubuntu_cpp"'
+    - unzip -o build_artifacts.zip -d .
+    - rm -rf build_cpp
+  
+    # Build current module
+    - export CMAKE_PREFIX_PATH=../install_cpp
+    - mkdir -p build_cpp
+    - cd build_cpp
+    - cmake -DCMAKE_INSTALL_PREFIX:PATH=../install_cpp -DCMAKE_BUILD_TYPE=Debug -DWERROR=ON -DCOVERAGE=ON ..
+    - make -j4 all install
+
+  artifacts:
+    paths:
+      - build_cpp/
+      - install_cpp/
+
+build:ubuntu_python:
+  stage: build
+  needs: []
+  tags:
+    - docker
+
+  script:
+    # Download dependencies
+    # aidge_core (CPP)
+    - 'curl --location --output build_artifacts.zip "https://gitlab.eclipse.org/api/v4/projects/5139/jobs/artifacts/main/download?job=build:ubuntu_cpp"'
+    - unzip -o build_artifacts.zip -d .
+    - rm -rf build_cpp
+    # aidge_backend_cpu (CPP)
+    - 'curl --location --output build_artifacts.zip "https://gitlab.eclipse.org/api/v4/projects/5140/jobs/artifacts/master/download?job=build:ubuntu_cpp"'
+    - unzip -o build_artifacts.zip -d .
+    - rm -rf build_cpp
+    # aidge_backend_cpu (Python)
+    - 'curl --location --output build_artifacts.zip "https://gitlab.eclipse.org/api/v4/projects/5140/jobs/artifacts/master/download?job=build:ubuntu_python"'
+    - unzip -o build_artifacts.zip -d .
+
+    - python3 -m pip install virtualenv
+    - virtualenv venv
+    - source venv/bin/activate
+    - export AIDGE_INSTALL=`pwd`/install
+    - export CMAKE_PREFIX_PATH=../install_cpp
+    - python3 -m pip install .
+
+  artifacts:
+    paths:
+      - venv/
+
+build:windows_cpp:
+  stage: build
+  needs: []
+  tags:
+    - windows
+
+  image: buildtools
+  before_script:
+    # Install Chocolatey
+    - Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+    # Install dependencies
+    - choco install cmake.install --installargs '"ADD_CMAKE_TO_PATH=System"' -Y
+    - choco install git -Y
+    - choco install python -Y
+    # Update PATH
+    - $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
+  script:
+    # Download dependencies
+    # aidge_core
+    - 'curl "https://gitlab.eclipse.org/api/v4/projects/5139/jobs/artifacts/main/download?job=build:windows_cpp" -o build_artifacts.zip'
+    - Expand-Archive -Path .\build_artifacts.zip -DestinationPath . -Force
+    - Remove-Item .\build_cpp\ -Recurse
+    # aidge_backend_cpu
+    - 'curl "https://gitlab.eclipse.org/api/v4/projects/5140/jobs/artifacts/master/download?job=build:windows_cpp" -o build_artifacts.zip'
+    - Expand-Archive -Path .\build_artifacts.zip -DestinationPath . -Force
+    - Remove-Item .\build_cpp\ -Recurse
+
+    - $env:CMAKE_PREFIX_PATH = '../install_cpp'
+    - mkdir -p build_cpp
+    - cd build_cpp
+    - cmake -DCMAKE_INSTALL_PREFIX:PATH=../install_cpp -DCMAKE_BUILD_TYPE=Debug ..
+    - cmake --build . -j2
+    - cmake --install . --config Debug
+
+  artifacts:
+    paths:
+      - build_cpp/
+      - install_cpp/

.gitlab/ci/coverage.gitlab-ci.yml

+coverage:ubuntu_cpp:
+  stage: coverage
+  needs: ["build:ubuntu_cpp"]
+  tags:
+    - docker
+  script:
+    - cd build_cpp
+    - ctest --output-on-failure
+    # HTML report for visualization
+    - gcovr --html-details --exclude-unreachable-branches -o coverage.html --root ${CI_PROJECT_DIR} --filter '\.\./include/' --filter '\.\./src/'
+    # Coberta XML report for Gitlab integration
+    - gcovr --xml-pretty --exclude-unreachable-branches --print-summary -o coverage.xml --root ${CI_PROJECT_DIR} --filter '\.\./include/' --filter '\.\./src/'
+  coverage: /^\s*lines:\s*\d+.\d+\%/
+  artifacts:
+    name: ${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}-${CI_COMMIT_SHA}
+    expire_in: 2 days
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: build_cpp/coverage.xml
+
+coverage:ubuntu_python:
+  stage: coverage
+  needs: ["build:ubuntu_python"]
+  tags:
+    - docker
+  script:
+    - source venv/bin/activate
+    - python3 -m pip install numpy coverage
+    - cd ${CI_PROJECT_NAME}
+    # Retrieve the installation path of the module, since it is installed with pip.
+    - export MODULE_LOCATION=`python -c "import ${CI_PROJECT_NAME} as _; print(_.__path__[0])"`
+    - python3 -m coverage run --source=$MODULE_LOCATION -m unittest discover -s unit_tests/ -v -b
+    - python3 -m coverage report
+    - python3 -m coverage xml
+  coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
+  artifacts:
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: ${CI_PROJECT_NAME}/coverage.xml

.gitlab/ci/test.gitlab-ci.yml

+test:ubuntu_cpp:
+  stage: test
+  needs: ["build:ubuntu_cpp"]
+  tags:
+    - docker
+  script:
+    - cd build_cpp
+    - ctest --output-junit ctest-results.xml --output-on-failure
+  artifacts:
+    reports:
+      junit: build_cpp/ctest-results.xml
+
+test:ubuntu_python:
+  stage: test
+  needs: ["build:ubuntu_python"]
+  tags:
+    - docker
+  script:
+    - source venv/bin/activate
+    - cd ${CI_PROJECT_NAME}
+    - python3 -m pip install unittest-xml-reporting
+    - python3 -m pip list
+    # Run on discovery all tests located in core/unit_tests/python
+    - python3 -m xmlrunner discover -s unit_tests/ -v -b --output-file xmlrunner-results.xml
+  artifacts:
+    reports:
+      junit: ${CI_PROJECT_NAME}/xmlrunner-results.xml
+
+test:windows_cpp:
+  stage: test
+  needs: ["build:windows_cpp"]
+  tags:
+    - windows
+  image: buildtools
+  before_script:
+    # Install Chocolatey
+    - Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
+    # Install dependencies
+    - choco install cmake.install --installargs '"ADD_CMAKE_TO_PATH=System"' -Y
+    - choco install python -Y
+    # Update PATH
+    - $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
+  script:
+    - cd build_cpp
+    - ctest --output-junit ctest-results.xml --output-on-failure
+  artifacts:
+    reports:
+      junit: build_cpp/ctest-results.xml

CMakeLists.txt

+cmake_minimum_required(VERSION 3.15)
+
+file(READ "${CMAKE_SOURCE_DIR}/version.txt" version)
+file(READ "${CMAKE_SOURCE_DIR}/project_name.txt" project)
+
+message(STATUS "Project name: ${project}")
+message(STATUS "Project version: ${version}")
+
+# Note : project name is {project} and python module name is also {project} 
+set(module_name _${project}) # target name
+
+
+project(${project})
+
+##############################################
+# Import utils CMakeLists
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
+include(PybindModuleCreation)
+
+##############################################
+# Define options
+option(PYBIND "python binding" ON)
+option(WERROR "Warning as error" OFF)
+option(TEST "Enable tests" ON)
+option(COVERAGE "Enable coverage" OFF)
+
+##############################################
+# Import utils CMakeLists
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake")
+include(PybindModuleCreation)
+
+if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE)
+    Include(CodeCoverage)
+endif()
+
+##############################################
+# Find system dependencies
+enable_language(CUDA)
+
+find_library(CUDART_LIBRARY cudart ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES})
+
+find_package(aidge_core REQUIRED)
+find_package(aidge_backend_cpu REQUIRED)
+# TODO: add here additional Aidge dependencies if you need to.
+
+##############################################
+# Create target and set properties
+
+file(GLOB_RECURSE src_files "src/*.cpp")
+file(GLOB_RECURSE inc_files "include/*.hpp")
+
+add_library(${module_name} ${src_files} ${inc_files})
+target_link_libraries(${module_name}
+    PUBLIC
+        _aidge_core # _ is added because we link the target not the project
+        _aidge_backend_cpu # _ is added because we link the target not the project
+        # TODO: add here additional Aidge dependencies if you need to.
+)
+
+#Set target properties
+set_property(TARGET ${module_name} PROPERTY POSITION_INDEPENDENT_CODE ON)
+target_include_directories(${module_name}
+    PUBLIC
+        $<INSTALL_INTERFACE:include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
+# PYTHON BINDING
+generate_python_binding(${project} ${module_name})
+
+if (PYBIND)
+    # Handles Python + pybind11 headers dependencies
+    target_link_libraries(${module_name}
+        PUBLIC 
+            pybind11::pybind11
+        PRIVATE
+            Python::Python
+        )
+endif()
+
+target_compile_features(${module_name} PRIVATE cxx_std_14)
+
+
+if(WERROR)
+    target_compile_options(${module_name} PRIVATE
+    $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
+    -Wall -Wextra -fPIC -Wold-style-cast -Winline -pedantic -Werror=narrowing -Wshadow -Werror>)
+    target_compile_options(${module_name} PRIVATE
+    $<$<CXX_COMPILER_ID:MSVC>:
+    /W4>)
+else()
+    target_compile_options(${module_name} PRIVATE
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
+        -Wall -Wextra -fPIC -Wold-style-cast -Winline -pedantic -Werror=narrowing -Wshadow -Wpedantic>)
+        target_compile_options(${module_name} PRIVATE
+        $<$<CXX_COMPILER_ID:MSVC>:
+        /W4>)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE)
+    append_coverage_compiler_flags()
+endif()
+
+# We need to explicitly state that we need all CUDA files in the 
+# ${module_name} library to be built with -dc as the member functions 
+# could be called by other libraries and executables
+set_target_properties(${module_name}
+                       PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+##############################################
+# Installation instructions
+
+include(GNUInstallDirs)
+set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${project})
+
+install(TARGETS ${module_name} EXPORT ${project}-targets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+#Export the targets to a script
+
+install(EXPORT ${project}-targets
+ FILE "${project}-targets.cmake"
+ DESTINATION ${INSTALL_CONFIGDIR}
+#  COMPONENT ${module_name} 
+)  
+
+#Create a ConfigVersion.cmake file
+include(CMakePackageConfigHelpers)
+
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/${project}-config-version.cmake"
+    VERSION ${version}
+    COMPATIBILITY AnyNewerVersion
+)
+
+configure_package_config_file("${project}-config.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/${project}-config.cmake"
+    INSTALL_DESTINATION ${INSTALL_CONFIGDIR}
+)
+
+#Install the config, configversion and custom find modules
+install(FILES
+    "${CMAKE_CURRENT_BINARY_DIR}/${project}-config.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/${project}-config-version.cmake"
+    DESTINATION ${INSTALL_CONFIGDIR}
+)
+
+##############################################
+## Exporting from the build tree
+export(EXPORT ${project}-targets
+    FILE "${CMAKE_CURRENT_BINARY_DIR}/${project}-targets.cmake")
+
+
+##############################################
+## Add test
+if(TEST)
+    enable_testing()
+    add_subdirectory(unit_tests)
+endif()

LICENSE

+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.
\ No newline at end of file

README.md

+![Pipeline status](https://gitlab.eclipse.org/eclipse/aidge/aidge_backend_cuda/badges/master/pipeline.svg?ignore_skipped=true) ![C++ coverage](https://gitlab.eclipse.org/eclipse/aidge/aidge_backend_cuda/badges/master/coverage.svg?job=coverage:ubuntu_cpp&key_text=C%2B%2B+coverage&key_width=90) ![Python coverage](https://gitlab.eclipse.org/eclipse/aidge/aidge_backend_cuda/badges/master/coverage.svg?job=coverage:ubuntu_python&key_text=Python+coverage&key_width=100)
+
+# Aidge CUDA library
+
+You can find in this folder the library that implements the CUDA operators.
+
+## Pip installation
+
+You will need to install first the aidge_core library before installing aidge_backend_cuda.
+Also, make sure that the install path was set before installing aidge_core library.
+Then run in your python environnement : 
+``` bash
+pip install . -v
+```
+
+## Standard C++ Compilation
+
+You will need to compile first the Core library before compiling the CUDA one.
+The makefile is designed to do it for you.

aidge_backend_cuda-config.cmake.in

+@PACKAGE_INIT@
+
+include(${CMAKE_CURRENT_LIST_DIR}/aidge_backend_cuda-config-version.cmake)
+
+include(${CMAKE_CURRENT_LIST_DIR}/aidge_backend_cuda-targets.cmake)

aidge_backend_cuda/__init__.py

+# Example 1: import .so generated by PyBind
+from aidge_backend_cuda.aidge_backend_cuda import *
+
+# Example 3: pure Python function equivalent to example 1 (example_func)
+from .example import *

aidge_backend_cuda/unit_tests/test_tensor.py

+import unittest
+import aidge_core
+import aidge_backend_cuda
+import numpy as np
+
+
+class test_tensor(unittest.TestCase):
+    """Test tensor binding
+    """
+    def setUp(self):
+        pass
+    def tearDown(self):
+        pass
+
+    def test_getavailable_backends(self):
+        self.assertTrue("cuda" in aidge_core.Tensor.get_available_backends())
+
+    def test_numpy_int_to_tensor(self):
+        np_array = np.arange(9).reshape(1,1,3,3)
+        # Numpy -> Tensor
+        t = aidge_core.Tensor(np_array)
+        self.assertEqual(t.dtype(), aidge_core.DataType.Int32)
+        for i_t, i_n in zip(t, np_array.flatten()):
+            self.assertTrue(i_t == i_n)
+        for i,j in zip(t.dims(), np_array.shape):
+            self.assertEqual(i,j)
+    def test_tensor_int_to_numpy(self):
+        np_array = np.arange(9).reshape(1,1,3,3)
+        # Numpy -> Tensor
+        t = aidge_core.Tensor(np_array)
+        # Tensor -> Numpy
+        nnarray = np.array(t)
+        for i_nn, i_n in zip(nnarray.flatten(), np_array.flatten()):
+            self.assertTrue(i_nn == i_n)
+        for i,j in zip(t.dims(), nnarray.shape):
+            self.assertEqual(i,j)
+
+    def test_numpy_float_to_tensor(self):
+        t = aidge_core.Tensor()
+        np_array = np.random.rand(1, 1, 3, 3).astype(np.float32)
+        # Numpy -> Tensor
+        t = aidge_core.Tensor(np_array)
+        self.assertEqual(t.dtype(), aidge_core.DataType.Float32)
+        for i_t, i_n in zip(t, np_array.flatten()):
+            self.assertTrue(i_t == i_n) # TODO : May need to change this to a difference
+        for i,j in zip(t.dims(), np_array.shape):
+            self.assertEqual(i,j)
+if __name__ == '__main__':
+    unittest.main()

cmake/PybindModuleCreation.cmake

+function(generate_python_binding name target_to_bind) 
+    if (PYBIND)
+        add_definitions(-DPYBIND)
+        Include(FetchContent)
+
+        FetchContent_Declare(
+        PyBind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+        GIT_TAG        v2.10.4 # or a later release
+        )
+
+        # Use the New FindPython mode, recommanded. Requires CMake 3.15+
+        find_package(Python COMPONENTS Interpreter Development)
+        FetchContent_MakeAvailable(PyBind11)
+
+        message(STATUS "Creating binding for module ${name}")
+        file(GLOB_RECURSE pybind_src_files "python_binding/*.cpp")
+
+        pybind11_add_module(${name} MODULE ${pybind_src_files} "NO_EXTRAS") # NO EXTRA recquired for pip install
+        target_include_directories(${name} PUBLIC "python_binding")
+        target_link_libraries(${name} PUBLIC ${target_to_bind})        
+    endif()
+endfunction()

include/aidge/aidge_backend_cpu.hpp

+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_BACKEND_CUDA_IMPORTS_H_
+#define AIDGE_BACKEND_CUDA_IMPORTS_H_
+
+#include "aidge/data/TensorImpl.hpp"
+
+#endif /* AIDGE_BACKEND_CUDA_IMPORTS_H_ */
\ No newline at end of file

include/aidge/data/TensorImpl.hpp

+#ifndef AIDGE_BACKEND_CUDA_DATA_TENSORIMPL_H_
+#define AIDGE_BACKEND_CUDA_DATA_TENSORIMPL_H_
+
+#include "aidge/backend/TensorImpl.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+#include "aidge/utils/CudaUtils.hpp"
+
+namespace Aidge {
+template <class T>
+class TensorImpl_cuda : public TensorImpl {
+   private:
+    const Tensor &mTensor;  // Impl needs to access Tensor information, but is not
+                            // supposed to change it!
+    T* mData = nullptr;
+
+   public:
+    static constexpr const char *Backend = "cuda";
+
+    TensorImpl_cuda(const Tensor &tensor) : TensorImpl(Backend), mTensor(tensor) {}
+
+    bool operator==(const TensorImpl &otherImpl) const override final {
+        printf("Not implemented yet.");
+        return false;
+    }
+
+    static std::unique_ptr<TensorImpl_cuda> create(const Tensor &tensor) {
+        return std::make_unique<TensorImpl_cuda<T>>(tensor);
+    }
+
+    // native interface
+    const T* data() const { return mData; }
+
+    std::size_t scalarSize() const override { return sizeof(T); }
+
+    void copy(const void *src, NbElts_t length) override {
+        CHECK_CUDA_STATUS(cudaMemcpy(rawPtr(), src, length * sizeof(T), cudaMemcpyHostToDevice));
+    }
+
+    void *rawPtr() override {
+        lazyInit(reinterpret_cast<void**>(&mData));
+        return mData;
+    };
+
+    virtual ~TensorImpl_cuda() {
+        if (mData != nullptr)
+            cudaFree(mData);
+    }
+
+    void setRawPtr(void *ptr) override final {
+        printf("Not implemented yet.");
+        return false;
+    };
+
+   private:
+    void lazyInit(void** data) {
+        if (*data == nullptr)
+            CHECK_CUDA_STATUS(cudaMalloc(data, mTensor.size() * sizeof(T)));
+    }
+};
+
+namespace {
+static Registrar<Tensor> registrarTensorImpl_cuda_Float64(
+        {"cuda", DataType::Float64}, Aidge::TensorImpl_cuda<double>::create);
+static Registrar<Tensor> registrarTensorImpl_cuda_Float32(
+        {"cuda", DataType::Float32}, Aidge::TensorImpl_cuda<float>::create);
+static Registrar<Tensor> registrarTensorImpl_cuda_Int32(
+        {"cuda", DataType::Int32}, Aidge::TensorImpl_cuda<int>::create);
+}  // namespace
+}  // namespace Aidge
+
+#endif /* AIDGE_BACKEND_CUDA_DATA_TENSORIMPL_H_ */

include/aidge/utils/CudaUtils.hpp

+#ifndef CudaUtils_cuda_H_
+#define CudaUtils_cuda_H_
+
+#include <string>
+
+#include <cuda.h>
+
+#define CHECK_CUDA_STATUS(status)                                              \
+    do {                                                                       \
+        const cudaError_t e = (status);                                        \
+        if ((e) != cudaSuccess) {                                              \
+            printf("Cuda failure: %s in %s:%d", cudaGetErrorString(e), __FILE__, __LINE__);                            \
+            int dev;                                                           \
+            if (cudaGetDevice(&dev) == cudaSuccess)                            \
+                printf(" on device #%d", dev); \
+            printf("\n"); \
+            cudaDeviceReset();                                                 \
+            assert(false && "Cuda failure");                             \
+        }                                                                      \
+    } while(0)
+
+#endif // CudaUtils_cuda_H_
\ No newline at end of file

project_name.txt

+aidge_backend_cuda
\ No newline at end of file

python_binding/pybind_backend_cuda.cpp

+#include <pybind11/pybind11.h>
+// Need to call this header to register every impl
+#include "aidge/aidge_backend_cuda.hpp"
+
+namespace py = pybind11;
+
+namespace Aidge {
+
+void init_Aidge(py::module& /*m*/){
+
+}
+
+PYBIND11_MODULE(aidge_backend_cuda, m) {
+    init_Aidge(m);
+}
+}

setup.py

+#!/usr/bin/env python3
+""" Aidge
+
+#TODO To change
+POC of the next framework named Aidge
+"""
+
+DOCLINES = (__doc__ or '').split("\n")
+
+import sys
+import os
+
+# Python supported version checks
+if sys.version_info[:2] < (3, 7):
+    raise RuntimeError("Python version >= 3.7 required.")
+
+
+CLASSIFIERS = """\
+Development Status :: 2 - Pre-Alpha
+"""
+
+import shutil
+import pathlib
+import subprocess
+import multiprocessing
+
+from math import ceil
+
+from setuptools import setup, Extension
+from setuptools import find_packages
+from setuptools.command.build_ext import build_ext
+
+def get_project_name() -> str:
+    return open(pathlib.Path().absolute() / "project_name.txt", "r").read()
+
+def get_project_version() -> str:
+    aidge_root = pathlib.Path().absolute()
+    version = open(aidge_root / "version.txt", "r").read().strip()
+    return version
+
+
+class CMakeExtension(Extension):
+    def __init__(self, name):
+        super().__init__(name, sources=[])
+
+class CMakeBuild(build_ext):
+
+    def run(self):
+        # This lists the number of processors available on the machine
+        # The compilation will use half of them
+        max_jobs = str(ceil(multiprocessing.cpu_count() / 2))
+
+        cwd = pathlib.Path().absolute()
+
+        build_temp = cwd / "build"
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True, exist_ok=True)
+
+        build_lib = pathlib.Path(self.build_lib)
+        if not build_lib.exists():
+            build_lib.mkdir(parents=True, exist_ok=True)
+
+        os.chdir(str(build_temp))
+
+        # Impose to use the executable of the python 
+        # used to launch setup.py to setup PythonInterp
+        param_py = "-DPYTHON_EXECUTABLE=" + sys.executable
+        
+        install_path = f"{build_temp}/install" if "AIDGE_INSTALL" not in os.environ else os.environ["AIDGE_INSTALL"]
+
+        self.spawn(['cmake', str(cwd), param_py, '-DTEST=OFF', f'-DCMAKE_INSTALL_PREFIX:PATH={install_path}'])
+        if not self.dry_run:
+            self.spawn(['make', 'all', 'install', '-j', max_jobs])
+        os.chdir(str(cwd))
+
+        aidge_package = build_lib / (get_project_name())
+
+        # Get "aidge core" package
+        # ext_lib = build_temp
+        print(build_temp.absolute())
+        # Copy all shared object files from build_temp/lib to aidge_package
+        for root, _, files in os.walk(build_temp.absolute()):
+            for file in files:
+                if file.endswith('.so') and (root != str(aidge_package.absolute())):
+                    currentFile=os.path.join(root, file)
+                    shutil.copy(currentFile, str(aidge_package.absolute())) 
+
+        # Copy version.txt in aidge_package
+        os.chdir(os.path.dirname(__file__))
+        shutil.copy("version.txt", str(aidge_package.absolute()))    
+
+
+if __name__ == '__main__':
+
+    setup(
+        name=get_project_name(),
+        version=get_project_version(),
+        python_requires='>=3.7',
+        description=DOCLINES[0],
+        long_description_content_type="text/markdown",
+        long_description="\n".join(DOCLINES[2:]),
+        classifiers=[c for c in CLASSIFIERS.split('\n') if c],
+        platforms=["Linux"],
+        packages=find_packages(where="."),
+        include_package_data=True,
+        ext_modules=[CMakeExtension(get_project_name())],
+        cmdclass={
+            'build_ext': CMakeBuild,
+        },
+        zip_safe=False,
+
+    )