knexus 0.0.1__tar.gz

knexus-0.0.1/CMakeLists.txt

@@ -0,0 +1,221 @@
+cmake_minimum_required(VERSION 3.18)
+
+if(POLICY CMP0116)
+# Introduced in cmake 3.20
+# https://cmake.org/cmake/help/latest/policy/CMP0116.html
+  cmake_policy(SET CMP0116 OLD)
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+
+    set(CMAKE_CXX_FLAGS_INIT "-stdlib=libc++")
+    set(CMAKE_EXE_LINKER_FLAGS_INIT "-stdlib=libc++")
+
+endif()
+
+project(nexus CXX C)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+
+    set(LINUX TRUE)
+    set(ENV{PLATFORM_OS} "Linux")
+    message(STATUS "Target system: Linux")
+
+elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+
+    set(MACOS TRUE)
+    set(ENV{PLATFORM_OS} "MacOS")
+    message(STATUS "Target system: MacOS")
+
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# Options
+option(NEXUS_BUILD_PYTHON_MODULE "Build Python Nexus bindings" ON)
+option(NEXUS_ENABLE_LOGGING "Enable Nexus Logging" ON)
+option(NEXUS_BUILD_PLUGINS "Build the runtime plugins" ON)
+
+# Ensure Python3 vars are set correctly
+# used conditionally in this file and by lit tests
+
+# Customized release build type with assertions: NEXUSRelBuildWithAsserts
+if(NOT MSVC)
+  set(CMAKE_C_FLAGS_NEXUSRELBUILDWITHASSERTS "-O2 -g")
+  set(CMAKE_CXX_FLAGS_NEXUSRELBUILDWITHASSERTS "-O2 -g")
+  set(CMAKE_C_FLAGS_NEXUSBUILDWITHO1 "-O1")
+  set(CMAKE_CXX_FLAGS_NEXUSBUILDWITHO1 "-O1")
+else()
+  set(CMAKE_C_FLAGS_NEXUSRELBUILDWITHASSERTS "/Zi /RTC1 /bigobj /Zc:preprocessor /permissive-")
+  set(CMAKE_CXX_FLAGS_NEXUSRELBUILDWITHASSERTS "/Zi /RTC1 /bigobj /Zc:preprocessor /permissive-")
+  set(CMAKE_EXE_LINKER_FLAGS_NEXUSRELBUILDWITHASSERTS "/debug:fastlink /INCREMENTAL")
+  set(CMAKE_MODULE_LINKER_FLAGS_NEXUSRELBUILDWITHASSERTS "/debug:fastlink /INCREMENTAL")
+  set(CMAKE_SHARED_LINKER_FLAGS_NEXUSRELBUILDWITHASSERTS "/debug:fastlink /INCREMENTAL")
+endif()
+
+# Default build type
+if(NOT CMAKE_BUILD_TYPE)
+  message(STATUS "Default build type: Debug")
+  set(CMAKE_BUILD_TYPE "Debug")
+endif()
+
+if(NOT WIN32)
+  find_library(TERMINFO_LIBRARY tinfo)
+endif()
+
+#if(NEXUS_BUILD_UT)
+#  # This is an aggregate target for all unit tests.
+#  add_custom_target(NEXUSUnitTests)
+#  set_target_properties(NEXUSUnitTests PROPERTIES FOLDER "NEXUS/Tests")
+#  include(AddNEXUSUnitTest)
+#endif()
+
+# Compiler flags
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+if(NOT MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__STDC_FORMAT_MACROS  -fPIC -std=gnu++17")
+else()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__STDC_FORMAT_MACROS")
+endif()
+
+
+# Disable warnings that show up in external code (gtest;pybind11)
+if(NOT MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-covered-switch-default -fvisibility=hidden")
+else()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244 /wd4624 /wd4715 /wd4530")
+endif()
+
+if(NEXUS_ENABLE_LOGGING)
+  add_compile_definitions(NEXUS_LOGGING)
+endif()
+
+file(COPY ${CMAKE_SOURCE_DIR}/device_lib/
+     DESTINATION ${CMAKE_BINARY_DIR}/device_lib
+     FILES_MATCHING PATTERN "*")
+
+include_directories(${PROJECT_SOURCE_DIR}/include)
+include_directories(${PROJECT_SOURCE_DIR}/third_party/magic_enum/include)
+
+# -----
+add_subdirectory(third_party/json json)
+
+# ------
+# Core API source directory
+add_subdirectory(src)
+
+# ------
+if(NEXUS_BUILD_PYTHON_MODULE)
+  message(STATUS "Adding Python module")
+  set(PYTHON_SRC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/python/src)
+  include_directories(${PYTHON_SRC_PATH})
+
+  # Python Interpreter is used to run lit tests
+  find_package(Python3 REQUIRED COMPONENTS Development.Module Interpreter)
+  find_package(pybind11 CONFIG REQUIRED HINTS "${Python3_SITELIB}")
+
+  set(NEXUS_LIBRARIES
+    nexus-api
+
+    Python3::Module
+    pybind11::headers
+
+  )
+
+  add_library(nexus SHARED
+      ${PYTHON_SRC_PATH}/main.cc
+      ${PYTHON_SRC_PATH}/system.cc
+  )
+
+  # EXAMPLE_VERSION_INFO is defined by setup.py and passed into the C++ code as a
+  # define (VERSION_INFO) here.
+  target_compile_definitions(nexus
+        PRIVATE VERSION_INFO=${EXAMPLE_VERSION_INFO})
+
+  ## Link nexus with its dependencies
+  target_link_libraries(nexus PRIVATE ${NEXUS_LIBRARIES})
+  target_link_libraries(nexus PRIVATE pybind11::module)
+
+  set_target_properties(nexus PROPERTIES
+    BUILD_RPATH_USE_ORIGIN TRUE
+    INSTALL_RPATH "$ORIGIN"
+    BUILD_RPATH "$ORIGIN"
+  )
+
+  set_target_properties(nexus PROPERTIES PREFIX "lib" SUFFIX ".so")
+  #install(TARGETS nexus DESTINATION nexus)
+
+  if(WIN32)
+    target_link_libraries(nexus PRIVATE ${CMAKE_DL_LIBS})
+    set_target_properties(nexus PROPERTIES SUFFIX ".pyd")
+  else()
+    # Check if the platform is MacOS
+    if(APPLE)
+      #set(PYTHON_LDFLAGS "-undefined dynamic_lookup")
+    endif()
+
+    target_link_options(nexus PRIVATE ${PYTHON_LDFLAGS})
+
+    #target_link_libraries(nexus PRIVATE z)
+  endif()
+endif()
+
+if (UNIX AND NOT APPLE)
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--exclude-libs,ALL")
+endif()
+
+if(NEXUS_BUILD_PLUGINS)
+  add_subdirectory(plugins)
+endif()
+
+# Google Test
+include_directories(third_party/googletest)
+add_subdirectory(third_party/googletest)
+
+enable_testing()
+include(GoogleTest)
+add_custom_target(NexusIntegrationTest)
+set_target_properties(NexusIntegrationTest PROPERTIES FOLDER "Tests")
+
+function(add_nexus_it)
+  set(options)
+  set(oneValueArgs NAME)
+  set(multiValueArgs SRCS LIBS DEFS)
+  cmake_parse_arguments(_ "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  get_property(nexus_libs GLOBAL PROPERTY NEXUS_LIBRARIES)
+
+  add_test(NAME ${__NAME}
+          COMMAND ${__NAME})
+  add_executable(
+          ${__NAME}
+          ${__SRCS})
+  target_link_libraries(
+          ${__NAME}
+          PRIVATE
+          GTest::gtest_main
+          ${nexus_libs}
+          gmock
+          ${__LIBS})
+
+  if(NOT MSVC)
+    target_compile_options(${__NAME} PRIVATE -fno-rtti)
+  endif()
+
+  target_compile_definitions(${__NAME} PRIVATE ${__DEFS})
+
+  # Without the TEST_DISCOVERY_TIMEOUT, the tests randomly time out on my mac
+  # laptop.  I think the issue may be that the very first time you run a program
+  # it's a bit slow.
+  gtest_discover_tests(${__NAME} DISCOVERY_TIMEOUT 60)
+
+  # Add the unit test to the top-level unit test target.
+  add_dependencies(NexusIntegrationTest ${__NAME})
+endfunction()
+
+add_subdirectory(test)

knexus-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kernelize.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

knexus-0.0.1/MANIFEST.in

@@ -0,0 +1,16 @@
+graft device_lib
+include CMakeLists.txt
+include *.md *.txt *.cfg *.ini
+recursive-include cmake *.cmake *.in
+recursive-include src *.cpp *.cc *.h *.hpp CMakeLists.txt
+recursive-include api-src *.cpp *.cc *.h *.hpp
+recursive-include python *.py 
+recursive-include python/src *.cpp *.cc *.h *.hpp
+recursive-include include *.h *.hpp
+recursive-include third_party *.h *.hpp *.cpp *.cc *.json CMakeLists.txt *.cmake *.in
+recursive-include plugins *.cpp *.cc *.h *.hpp CMakeLists.txt
+recursive-include test *.cpp *.cc *.h *.hpp CMakeLists.txt
+recursive-include third_party/cpuinfo/include *.h
+recursive-include third_party/cpuinfo/src *.c
+recursive-include third_party/cpuinfo/deps *.c *.h
+include third_party/cpuinfo/CMakeLists.txt

knexus-0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: knexus
+Version: 0.0.1
+Home-page: https://github.com/kernelize-ai/nexus/
+Author: Simon Waters
+Author-email: simon@kernelize.ai
+Keywords: Runtime,Triton
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9,<3.14
+License-File: LICENSE
+Requires-Dist: setuptools>=40.8.0
+Requires-Dist: importlib-metadata; python_version < "3.10"
+Provides-Extra: test
+Requires-Dist: pytest>=6.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python

knexus-0.0.1/README.md

@@ -0,0 +1,160 @@
+# Nexus Device API
+
+The Nexus Device API provides a clean, standardized Interface to Device Discovery, Characterization and Kernel Deployment.
+
+## Interfaces
+
+There are 4 interfaces in Nexus, 2 User APIs and 2 Vendor APIs.
+
+User APIs:
+* Python API
+* C++ Source API
+
+Vendor APIs:
+* JSON DB
+* Runtime Plugin C-API
+
+### Python API
+
+The Python API is designed to be intuitive with full device discovery, characterization and kernel execution.
+
+```python
+import nexus
+
+runtimes = nexus.get_runtimes()
+rt0 = runtimes.get(0)
+rt0_name = rt0.get_property_str('Name')
+
+dev0 = rt0.get_device(0)
+dev0_arch = dev0.get_property_str('Architecture')
+
+buf0 = dev0.create_buffer(tensor0)
+buf1 = dev0.create_buffer((1024,1024), dtype='fp16')
+
+# Create event for synchronization
+event = dev0.create_event(nexus.event_type.Shared)
+
+sched0 = dev0.create_schedule()
+
+cmd0 = sched0.create_command(kernel)
+signal_cmd = sched0.create_signal_command(event, 1)
+
+sched0.run(blocking=False)
+event.wait(1)  # Wait for completion
+```
+
+### C++ Source API
+
+The C++ Source API provides direct access to all API objects with clean interface and garbage collection.
+
+```
+// insert test/cpp/main.cpp
+```
+
+### JSON DB
+
+The JSON DB interface provides deep device/system characteristics to improve compilation and runtime distribution. There should be a device_lib.json for each architecture. 
+The file name follows the convention `<vendor_name>-<device_type>-<architecture>.json`. This should correlate with querying the device:
+
+```c++
+auto vendor = device.getProperty<std::string>("Vendor");
+auto type = device.getProperty<std::string>("Type");
+auto arch = device.getProperty<std::string>("Architecture");
+```
+
+// see schema/gpu_architecture_schema.json
+
+
+### Runtime Plugin C-API
+
+The Runtime Plugin C-API is a thin wrapper for clean dynamic library loading to call into vendor specific runtimes.
+
+// See plugins/metal/metal_runtime.cpp for example
+
+
+## Building Nexus
+
+### Quick Start
+
+For a quick setup, see the [Quick Start Guide](docs/Quick_Start.md).
+
+### Detailed Build Instructions
+
+First clone the repo with submodules:
+
+```shell
+git clone --recursive https://github.com/kernelize-ai/nexus.git
+cd nexus
+```
+
+Then build with CMake:
+
+```shell
+mkdir build && cd build
+cmake .. -DCMAKE_BUILD_TYPE=Release -DNEXUS_BUILD_PYTHON_MODULE=ON -DNEXUS_BUILD_PLUGINS=ON
+make -j$(nproc)  # Linux/macOS
+# or
+cmake --build . --config Release --parallel  # Windows
+```
+
+For detailed build instructions, dependencies, and troubleshooting, see the [Build and CI Documentation](docs/Build_and_CI.md).
+
+### Building the python packages
+
+For building the development package in a virtual environment:
+
+```shell
+python3 -m venv .venv --prompt nexus
+source .venv/bin/activate  # Linux/macOS
+# or
+.venv\Scripts\activate  # Windows
+pip install -r requirements.txt
+
+pip install -e .
+```
+
+For building and installing the release package in a virtual environment:
+
+```shell
+python -m build
+
+python3 -m venv .venv --prompt nexus
+source .venv/bin/activate  # Linux/macOS
+# or
+.venv\Scripts\activate  # Windows
+pip install -r requirements.txt
+
+pip install dist/nexus-*.whl
+```
+
+## Testing
+
+Run the test suite:
+
+```shell
+cd build
+ctest --output-on-failure
+```
+
+For Python-specific tests:
+
+```shell
+python test/pynexus/test.py
+```
+
+## Continuous Integration
+
+The project uses GitHub Actions for continuous integration, building on:
+- **Linux** (Ubuntu): GCC compiler, Debug and Release builds
+- **macOS**: Clang compiler, Debug and Release builds
+
+See the [Build and CI Documentation](docs/Build_and_CI.md) for details on the CI setup and how to run builds locally.
+
+## Documentation
+
+- [Quick Start Guide](docs/Quick_Start.md) - Get up and running quickly
+- [Core API](docs/Core_API.md) - C++ API documentation
+- [Python API](docs/Python_API.md) - Python bindings documentation
+- [Plugin API](docs/Plugin_API.md) - Plugin development guide
+- [JSON API](docs/JSON_API.md) - JSON interface documentation
+- [Build and CI](docs/Build_and_CI.md) - Build instructions and CI setup

knexus-0.0.1/api-src/nxs_api.cpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2023 The Khronos Group Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * OpenCL is a trademark of Apple Inc. used under license by Khronos.
+ */
+
+
+#include <nexus-api.h>
+#include <magic_enum/magic_enum.hpp>
+
+const char *nxsGetFuncName(nxs_int funcEnum) {
+    auto fenum = magic_enum::enum_cast<nxs_function>(funcEnum);
+    if (fenum)
+        return magic_enum::enum_name(*fenum).data() + NXS_FUNCTION_PREFIX_LEN;
+    return "";
+}
+
+nxs_function nxsGetFuncEnum(const char *funcName) {
+    std::string fname = std::string("NF_") + funcName;
+    if (auto val = magic_enum::enum_cast<nxs_function>(fname))
+        return *val;
+    return NXS_FUNCTION_INVALID;
+}
+
+
+const char *nxsGetPropName(nxs_int propEnum) {
+    auto penum = magic_enum::enum_cast<nxs_property>(propEnum);
+    if (penum)
+        return magic_enum::enum_name(*penum).data() + NXS_PROPERTY_PREFIX_LEN;
+    return "";
+}
+
+nxs_property nxsGetPropEnum(const char *propName) {
+    std::string pname = std::string("NP_") + propName;
+    if (auto val = magic_enum::enum_cast<nxs_property>(pname))
+        return *val;
+    return NXS_PROPERTY_INVALID;
+}
+
+const char *nxsGetStatusName(nxs_int statusEnum) {
+    auto senum = magic_enum::enum_cast<nxs_status>(statusEnum);
+    if (senum)
+        return magic_enum::enum_name(*senum).data() + NXS_STATUS_PREFIX_LEN;
+    return "";
+}
+
+nxs_status nxsGetStatusEnum(const char *statusName) {
+    std::string sname = std::string("NXS_") + statusName;
+    return *magic_enum::enum_cast<nxs_status>(sname);
+}

knexus-0.0.1/cmake/FindCPUINFO.cmake

@@ -0,0 +1,39 @@
+
+if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "^(s390x|ppc64le)$")
+  # ---[ Nexus uses cpuinfo library in the thread pool
+  # ---[ But it doesn't support s390x/powerpc and thus not used on s390x/powerpc
+  if(NOT TARGET cpuinfo AND USE_SYSTEM_CPUINFO)
+    add_library(cpuinfo SHARED IMPORTED)
+    find_library(CPUINFO_LIBRARY cpuinfo)
+    if(NOT CPUINFO_LIBRARY)
+      message(FATAL_ERROR "Cannot find cpuinfo")
+    endif()
+    message("Found cpuinfo: ${CPUINFO_LIBRARY}")
+    set_target_properties(cpuinfo PROPERTIES IMPORTED_LOCATION "${CPUINFO_LIBRARY}")
+  elseif(NOT TARGET cpuinfo)
+    if(NOT DEFINED CPUINFO_SOURCE_DIR)
+      set(CPUINFO_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/../third_party/cpuinfo" CACHE STRING "cpuinfo source directory")
+    endif()
+
+    set(CPUINFO_BUILD_TOOLS OFF CACHE BOOL "")
+    set(CPUINFO_BUILD_UNIT_TESTS OFF CACHE BOOL "")
+    set(CPUINFO_BUILD_MOCK_TESTS OFF CACHE BOOL "")
+    set(CPUINFO_BUILD_BENCHMARKS OFF CACHE BOOL "")
+    set(CPUINFO_LIBRARY_TYPE "static" CACHE STRING "")
+    set(CPUINFO_LOG_LEVEL "error" CACHE STRING "")
+    if(MSVC)
+      if(NEXUS_USE_MSVC_STATIC_RUNTIME)
+        set(CPUINFO_RUNTIME_TYPE "static" CACHE STRING "")
+      else()
+        set(CPUINFO_RUNTIME_TYPE "shared" CACHE STRING "")
+      endif()
+    endif()
+    add_subdirectory(
+      "${CPUINFO_SOURCE_DIR}"
+      "${CMAKE_CURRENT_BINARY_DIR}/cpuinfo")
+    # We build static version of cpuinfo but link
+    # them into a shared library for Nexus, so they need PIC.
+    set_property(TARGET cpuinfo PROPERTY POSITION_INDEPENDENT_CODE ON)
+  endif()
+endif()
+