Add dispatch test script

Update testing script

Update script

Remove testing script

Update rust build

Update tests so that it passes in wasm

Add testing script

Fix script

Fix indentation

Fix script

Fix indentation

Fix script

Add CI workflow for simsimd dispatch test

Move job to build and deploy workflow

Fix yaml

Add test trigger

Add dependency on build job

Move CI job to separate workflow

Author: andyfengHKU

.github/workflows/simsimd-dispatch-test.yml

@@ -0,0 +1,40 @@
+name: SimSIMD Dispatch Test
+on:
+  # TODO(Royi) remove once done testing
+  pull_request:
+    branches:
+      - master
+  schedule:
+    - cron: "0 5 * * *"
+
+  workflow_dispatch:
+
+jobs:
+  build-precompiled-bin-linux:
+    if: ${{ github.event_name == 'schedule' || github.event.inputs.skipBinaries != 'true' }}
+    uses: ./.github/workflows/linux-precompiled-bin-workflow.yml
+    with:
+      isNightly: true
+    secrets: inherit
+
+  simsimd-dispatch-test:
+    name: simsimd-dispatch-test
+    needs: build-precompiled-bin-linux
+    runs-on: kuzu-self-hosted-testing
+    env:
+      NUM_THREADS: 32
+      GEN: Ninja
+      CC: gcc
+      CXX: g++
+    steps:
+      - name: Download nightly build
+        uses: actions/download-artifact@v4
+        with:
+          name: kuzu_cli-linux-x86_64
+
+      - name: Extract kuzu shell
+        run: |
+          tar xf kuzu_cli-linux-x86_64.tar.gz
+
+      - name: Test
+        run: gdb --batch -x scripts/test-simsimd-dispatch.py --args ./kuzu

scripts/simd-dispatch-test.cypher

@@ -0,0 +1,4 @@
+CREATE NODE TABLE embeddings (id int64, vec FLOAT[8], PRIMARY KEY (id));
+COPY embeddings FROM "dataset/embeddings/embeddings-8-1k.csv" (deLim=',');
+CALL CREATE_HNSW_INDEX('e_hnsw_index', 'embeddings', 'vec', distFunc := 'l2');
+CALL QUERY_HNSW_INDEX('e_hnsw_index', 'embeddings', CAST([0.1521,0.3021,0.5366,0.2774,0.5593,0.5589,0.1365,0.8557],'FLOAT[8]'), 3) RETURN nn.id ORDER BY _distance;

scripts/test-simsimd-dispatch.py

@@ -0,0 +1,45 @@
+import gdb
+import subprocess
+
+
+def get_machine_architecture():
+    output = subprocess.check_output(["cat", "/proc/cpuinfo"])
+    flags_str = ""
+    for line in output.decode("utf-8").split("\n"):
+        line = line.strip()
+        if line.startswith("flags"):
+            flags_str = line
+            break
+    assert len(line) > 0
+
+    # Uses the same way as _simsimd_capabilities_x86() in simsimd.h to detect supported features
+    # The only simsimd functions we use in the vector index are cos/l2/l2_sq/dot which only branch for the targets 'skylake', 'haswell', and 'serial' so we only test for those
+    if "avx512f" in flags_str:
+        return "skylake"
+    elif "avx2" in flags_str and "f16c" in flags_str and "fma" in flags_str:
+        return "haswell"
+    else:
+        return "serial"
+
+
+bp = gdb.Breakpoint(f"simsimd_l2_f32_{get_machine_architecture()}")
+
+gdb.execute("run < scripts/simd-dispatch-test.cypher")
+
+try:
+    gdb.execute("continue")
+    # we only care if the breakpoint is hit at all
+    # disable it now to prevent the test from needing to execute 'continue' many times to reach completion
+    bp.enabled = False
+except gdb.error:
+    # the program has terminated
+    pass
+
+# Check if the breakpoint was hit
+if bp.hit_count == 0:
+    print(
+        f"Error: did not hit the expected simsimd function for machine architecture '{get_machine_architecture()}'"
+    )
+    gdb.execute("quit 1")
+
+gdb.execute("quit")

src/function/sequence/sequence_functions.cpp

@@ -45,10 +45,12 @@ function_set CurrValFunction::getFunctionSet() {
 
 function_set NextValFunction::getFunctionSet() {
     function_set functionSet;
-    functionSet.push_back(make_unique<ScalarFunction>(name,
-        std::vector<LogicalTypeID>{LogicalTypeID::STRING}, LogicalTypeID::INT64,
+    auto func = make_unique<ScalarFunction>(name, std::vector<LogicalTypeID>{LogicalTypeID::STRING},
+        LogicalTypeID::INT64,
         ScalarFunction::UnarySequenceExecFunction<common::ku_string_t, common::ValueVector,
-            NextVal>));
+            NextVal>);
+    func->isReadOnly = false;
+    functionSet.push_back(std::move(func));
     return functionSet;
 }
 

src/include/function/function.h

@@ -63,10 +63,12 @@ struct KUZU_API Function {
     std::vector<common::LogicalTypeID> parameterTypeIDs;
     // Currently we only one variable-length function which is list creation. The expectation is
     // that all parameters must have the same type as parameterTypes[0].
-    bool isVarLength;
-    bool isListLambda;
+    // For variable length function. A
+    bool isVarLength = false;
+    bool isListLambda = false;
+    bool isReadOnly = true;
 
-    Function() : isVarLength{false}, isListLambda{false} {};
+    Function() : isVarLength{false}, isListLambda{false}, isReadOnly{true} {};
     Function(std::string name, std::vector<common::LogicalTypeID> parameterTypeIDs)
         : name{std::move(name)}, parameterTypeIDs{std::move(parameterTypeIDs)}, isVarLength{false},
           isListLambda{false} {}

src/include/parser/expression/parsed_expression_visitor.h

@@ -46,13 +46,17 @@ class ParsedParamExprCollector : public ParsedExpressionVisitor {
     std::vector<const ParsedExpression*> paramExprs;
 };
 
-class ParsedSequenceFunctionCollector : public ParsedExpressionVisitor {
+class ReadWriteExprAnalyzer : public ParsedExpressionVisitor {
 public:
-    bool hasSeqUpdate() const { return hasSeqUpdate_; }
+    explicit ReadWriteExprAnalyzer(main::ClientContext* context)
+        : ParsedExpressionVisitor{}, context{context} {}
+
+    bool isReadOnly() const { return readOnly; }
     void visitFunctionExpr(const ParsedExpression* expr) override;
 
 private:
-    bool hasSeqUpdate_ = false;
+    main::ClientContext* context;
+    bool readOnly = true;
 };
 
 class MacroParameterReplacer : public ParsedExpressionVisitor {

src/include/parser/visitor/statement_read_write_analyzer.h

@@ -1,15 +1,17 @@
 #pragma once
 
+#include "parser/expression/parsed_expression.h"
 #include "parser/parsed_statement_visitor.h"
 
 namespace kuzu {
 namespace parser {
 
 class StatementReadWriteAnalyzer final : public StatementVisitor {
 public:
-    StatementReadWriteAnalyzer() : StatementVisitor{}, readOnly{true} {}
+    explicit StatementReadWriteAnalyzer(main::ClientContext* context)
+        : StatementVisitor{}, readOnly{true}, context{context} {}
 
-    bool isReadOnly(const Statement& statement);
+    bool isReadOnly() const { return readOnly; }
 
 private:
     void visitCreateSequence(const Statement& /*statement*/) override { readOnly = false; }
@@ -31,8 +33,11 @@ class StatementReadWriteAnalyzer final : public StatementVisitor {
         readOnly = false;
     }
 
+    bool isExprReadOnly(const ParsedExpression* expr);
+
 private:
     bool readOnly;
+    main::ClientContext* context;
 };
 
 } // namespace parser

src/main/client_context.cpp

@@ -462,7 +462,12 @@ std::unique_ptr<PreparedStatement> ClientContext::prepareNoLock(
     prepareTimer.start();
     try {
         preparedStatement->preparedSummary.statementType = parsedStatement->getStatementType();
-        preparedStatement->readOnly = StatementReadWriteAnalyzer().isReadOnly(*parsedStatement);
+        auto readWriteAnalyzer = StatementReadWriteAnalyzer(this);
+        TransactionHelper::runFuncInTransaction(
+            *transactionContext, [&]() -> void { readWriteAnalyzer.visit(*parsedStatement); },
+            true /* readOnly */, false /* */,
+            TransactionHelper::TransactionCommitAction::COMMIT_IF_NEW);
+        preparedStatement->readOnly = readWriteAnalyzer.isReadOnly();
         preparedStatement->parsedStatement = std::move(parsedStatement);
         validateTransaction(*preparedStatement);
 

src/parser/expression/parsed_expression_visitor.cpp

@@ -1,12 +1,15 @@
 #include "parser/expression/parsed_expression_visitor.h"
 
+#include "catalog/catalog.h"
+#include "catalog/catalog_entry/function_catalog_entry.h"
 #include "common/exception/not_implemented.h"
-#include "function/sequence/sequence_functions.h"
+#include "main/client_context.h"
 #include "parser/expression/parsed_case_expression.h"
 #include "parser/expression/parsed_function_expression.h"
 #include "parser/expression/parsed_lambda_expression.h"
 
 using namespace kuzu::common;
+using namespace kuzu::catalog;
 
 namespace kuzu {
 namespace parser {
@@ -141,13 +144,28 @@ void ParsedExpressionVisitor::visitCaseChildrenUnsafe(ParsedExpression& expr) {
     }
 }
 
-void ParsedSequenceFunctionCollector::visitFunctionExpr(const ParsedExpression* expr) {
+void ReadWriteExprAnalyzer::visitFunctionExpr(const ParsedExpression* expr) {
     if (expr->getExpressionType() != ExpressionType::FUNCTION) {
+        // Can be AND/OR/... which guarantees to be readonly.
         return;
     }
-    auto funName = expr->constCast<ParsedFunctionExpression>().getFunctionName();
-    if (StringUtils::getUpper(funName) == function::NextValFunction::name) {
-        hasSeqUpdate_ = true;
+    auto funcName = expr->constCast<ParsedFunctionExpression>().getFunctionName();
+    auto catalog = context->getCatalog();
+    // Assume user cannot add function with sideeffect, i.e. all non-readonly function is
+    // registered when database starts.
+    auto transaction = &transaction::DUMMY_TRANSACTION;
+    if (!catalog->containsFunction(transaction, funcName)) {
+        return;
+    }
+    auto entry = catalog->getFunctionEntry(transaction, funcName);
+    if (entry->getType() != CatalogEntryType::SCALAR_FUNCTION_ENTRY) {
+        // Can be macro function which guarantees to be readonly.
+        return;
+    }
+    auto& funcSet = entry->constPtrCast<FunctionCatalogEntry>()->getFunctionSet();
+    KU_ASSERT(!funcSet.empty());
+    if (!funcSet[0]->isReadOnly) {
+        readOnly = false;
     }
 }
 

src/parser/visitor/statement_read_write_analyzer.cpp

@@ -7,28 +7,17 @@
 namespace kuzu {
 namespace parser {
 
-bool StatementReadWriteAnalyzer::isReadOnly(const Statement& statement) {
-    visit(statement);
-    return readOnly;
-}
-
-static bool hasSequenceUpdate(const ParsedExpression* expr) {
-    auto collector = ParsedSequenceFunctionCollector();
-    collector.visit(expr);
-    return collector.hasSeqUpdate();
-}
-
 void StatementReadWriteAnalyzer::visitReadingClause(const ReadingClause* readingClause) {
     if (readingClause->hasWherePredicate()) {
-        if (hasSequenceUpdate(readingClause->getWherePredicate())) {
+        if (!isExprReadOnly(readingClause->getWherePredicate())) {
             readOnly = false;
         }
     }
 }
 
 void StatementReadWriteAnalyzer::visitWithClause(const WithClause* withClause) {
     for (auto& expr : withClause->getProjectionBody()->getProjectionExpressions()) {
-        if (hasSequenceUpdate(expr.get())) {
+        if (!isExprReadOnly(expr.get())) {
             readOnly = false;
             return;
         }
@@ -37,12 +26,18 @@ void StatementReadWriteAnalyzer::visitWithClause(const WithClause* withClause) {
 
 void StatementReadWriteAnalyzer::visitReturnClause(const ReturnClause* returnClause) {
     for (auto& expr : returnClause->getProjectionBody()->getProjectionExpressions()) {
-        if (hasSequenceUpdate(expr.get())) {
+        if (!isExprReadOnly(expr.get())) {
             readOnly = false;
             return;
         }
     }
 }
 
+bool StatementReadWriteAnalyzer::isExprReadOnly(const ParsedExpression* expr) {
+    auto analyzer = ReadWriteExprAnalyzer(context);
+    analyzer.visit(expr);
+    return analyzer.isReadOnly();
+}
+
 } // namespace parser
 } // namespace kuzu