build: 添加 llm 子项目用于前端大模型自定义算子

Signed-off-by: YdrMaster <[email protected]>

Author: YdrMaster

CMakeLists.txt

@@ -72,4 +72,5 @@ add_subdirectory(src/05computation)
 add_subdirectory(src/06frontend)
 add_subdirectory(src/07onnx)
 add_subdirectory(src/08communication)
+add_subdirectory(src/08-01llm)
 add_subdirectory(src/09python_ffi)

src/08-01llm/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
+project(llm VERSION 0.0.0 LANGUAGES CXX)
+message(STATUS "Project " ${PROJECT_NAME} " version " ${PROJECT_VERSION})
+
+file(GLOB_RECURSE LLM_SRC src/*.cc src/*.cpp)
+add_library(llm STATIC ${LLM_SRC})
+target_link_libraries(llm PUBLIC frontend)
+target_include_directories(llm PUBLIC include)
+
+file(GLOB_RECURSE LLM_TEST test/*.cpp)
+if(LLM_TEST)
+    add_executable(llm_test ${LLM_TEST})
+    add_test(llm_test llm_test)
+    target_link_libraries(llm_test llm GTest::gtest_main ${BACKWARD_ENABLE})
+    add_backward(llm_test)
+endif()

src/08-01llm/include/llm/operators.h

@@ -0,0 +1,10 @@
+#ifndef LLM_OPERATORS_H
+#define LLM_OPERATORS_H
+
+namespace refactor::llm {
+
+    void register_();
+
+}// namespace refactor::llm
+
+#endif// LLM_OPERATORS_H

src/08-01llm/src/operators.cpp

@@ -0,0 +1,14 @@
+#include "llm/operators.h"
+#include "operators/rms_normalization.hh"
+
+namespace refactor::llm {
+    using namespace frontend;
+
+    void register_() {
+        // clang-format off
+        #define REGISTER(NAME, CLASS) Operator::register_<CLASS>("llm::" #NAME)
+        #undef REGISTER
+        // clang-format on
+    }
+
+}// namespace refactor::llm

src/08-01llm/src/operators/common.h

@@ -0,0 +1,19 @@
+#ifndef LLM_COMMON_H
+#define LLM_COMMON_H
+
+#include "common.h"
+
+#define EXPECT_SIZE(N)                                         \
+    if (inputs.size() != (N)) {                                \
+        return Err(InferError(ERROR_MSG("Input size error"))); \
+    }
+
+#define EXPECT_VAL(DIM, VAL)                                             \
+    int64_t VAL;                                                         \
+    if ((DIM).hasValue()) {                                              \
+        VAL = (DIM).value();                                             \
+    } else {                                                             \
+        return Err(InferError(UnknownVariable{(DIM.variable()->name)})); \
+    }
+
+#endif// LLM_COMMON_H

src/08-01llm/src/operators/rms_normalization.cc

@@ -0,0 +1,24 @@
+#include "rms_normalization.hh"
+#include "common.h"
+
+namespace refactor::llm {
+    using Op = RmsNormalization;
+
+    auto Op::build(ModelContext const &, std::string_view, Attributes) -> OpBox {
+        return OpBox(std::make_unique<Op>());
+    }
+    auto Op::typeId() -> size_t {
+        static uint8_t ID = 1;
+        return reinterpret_cast<size_t>(&ID);
+    }
+
+    auto Op::opTypeId() const -> size_t { return typeId(); }
+    auto Op::opTypeName() const -> std::string_view { return "llm::RmsNormalization"; }
+
+    auto Op::infer(TensorRefs inputs, InferOptions const &) const -> InferResult {
+        EXPECT_SIZE(2)
+
+        TODO("");
+    }
+
+}// namespace refactor::llm

src/08-01llm/src/operators/rms_normalization.hh

@@ -0,0 +1,23 @@
+#ifndef LLM_RMS_NORMALIZATION_HH
+#define LLM_RMS_NORMALIZATION_HH
+
+#include "frontend/operator.h"
+
+namespace refactor::llm {
+    using namespace frontend;
+
+    struct RmsNormalization final : public Operator {
+
+        constexpr RmsNormalization() noexcept = default;
+
+        static OpBox build(ModelContext const &, std::string_view, Attributes);
+        static size_t typeId();
+
+        size_t opTypeId() const final;
+        std::string_view opTypeName() const final;
+        InferResult infer(TensorRefs, InferOptions const &) const final;
+    };
+
+}// namespace refactor::llm
+
+#endif// LLM_RMS_NORMALIZATION_HH