@fugood/llama.node 0.6.3 → 1.0.0-beta.1

package/src/llama.cpp/ggml/src/ggml-sycl/common.hpp

@@ -1,493 +0,0 @@
-//
-// MIT license
-// Copyright (C) 2024 Intel Corporation
-// SPDX-License-Identifier: MIT
-//
-
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-
-#ifndef GGML_SYCL_COMMON_HPP
-#define GGML_SYCL_COMMON_HPP
-
-#include <fstream>
-#include <iostream>
-
-#include "dpct/helper.hpp"
-#include "ggml-sycl.h"
-#include "presets.hpp"
-#include "sycl_hw.hpp"
-
-
-#if GGML_SYCL_DNNL
-#include "dnnl.hpp"
-#include "dnnl_sycl.hpp"
-#endif
-
-#define GGML_COMMON_DECL_SYCL
-#define GGML_COMMON_IMPL_SYCL
-/* suppress warning spam */
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wnested-anon-types"
-#include "ggml-common.h"
-#pragma clang diagnostic pop
-#include "ggml-impl.h"
-
-void* ggml_sycl_host_malloc(size_t size);
-void ggml_sycl_host_free(void* ptr);
-
-
-extern int g_ggml_sycl_debug;
-extern int g_ggml_sycl_disable_optimize;
-extern int g_ggml_sycl_prioritize_dmmv;
-
-#define GGML_SYCL_DEBUG(...)        \
-  do {                              \
-    if (g_ggml_sycl_debug)          \
-      fprintf(stderr, __VA_ARGS__); \
-  } while (0)
-
-#define CHECK_TRY_ERROR(expr)                                            \
-  [&]() {                                                                \
-    try {                                                                \
-      expr;                                                              \
-      return dpct::success;                                              \
-    } catch (std::exception const& e) {                                  \
-      std::cerr << e.what() << "\nException caught at file:" << __FILE__ \
-                << ", line:" << __LINE__ << ", func:" << __func__        \
-                << std::endl;                                            \
-      return dpct::default_error;                                        \
-    }                                                                    \
-  }()
-
-
-#define __SYCL_ARCH__ DPCT_COMPATIBILITY_TEMP
-#define VER_4VEC 610 // todo for hardward optimize.
-#define VER_GEN9 700 // todo for hardward optimize.
-#define VER_GEN12 1000000 // todo for hardward optimize.
-#define VER_GEN13 (VER_GEN12 + 1030) // todo for hardward optimize.
-
-#define GGML_SYCL_MAX_NODES 8192 // TODO: adapt to hardwares
-
-// define for XMX in Intel GPU
-// TODO: currently, it's not used for XMX really.
-#if !defined(GGML_SYCL_FORCE_MMQ)
-    #define SYCL_USE_XMX
-#endif
-
-// max batch size to use MMQ kernels when tensor cores are available
-#define MMQ_MAX_BATCH_SIZE 32
-
-// dmmv = dequantize_mul_mat_vec
-#ifndef GGML_SYCL_DMMV_X
-#define GGML_SYCL_DMMV_X 32
-#endif
-#ifndef GGML_SYCL_MMV_Y
-#define GGML_SYCL_MMV_Y 1
-#endif
-
-typedef sycl::queue *queue_ptr;
-
-enum ggml_sycl_backend_gpu_mode {
-  SYCL_UNSET_GPU_MODE = -1,
-  SYCL_SINGLE_GPU_MODE = 0,
-  SYCL_MUL_GPU_MODE
-};
-
-static_assert(sizeof(sycl::half) == sizeof(ggml_fp16_t), "wrong fp16 size");
-
-static void crash() {
-  int* ptr = NULL;
-  *ptr = 0;
-}
-
-[[noreturn]] static void ggml_sycl_error(
-    const char* stmt,
-    const char* func,
-    const char* file,
-    const int line,
-    const char* msg) {
-  fprintf(stderr, "SYCL error: %s: %s\n", stmt, msg);
-  fprintf(stderr, "  in function %s at %s:%d\n", func, file, line);
-  GGML_ABORT("SYCL error");
-}
-
-#define SYCL_CHECK(err)                                                                                    \
-    do {                                                                                                   \
-        auto err_ = (err);                                                                                 \
-        if (err_ != 0)                                                                                     \
-            ggml_sycl_error(#err, __func__, __FILE__, __LINE__, "Exception caught in this line of code."); \
-    } while (0)
-
-#if DPCT_COMPAT_RT_VERSION >= 11100
-#define GGML_SYCL_ASSUME(x) __builtin_assume(x)
-#else
-#define GGML_SYCL_ASSUME(x)
-#endif // DPCT_COMPAT_RT_VERSION >= 11100
-
-#ifdef GGML_SYCL_F16
-typedef sycl::half dfloat; // dequantize float
-typedef sycl::half2 dfloat2;
-#else
-typedef float dfloat; // dequantize float
-typedef sycl::float2 dfloat2;
-#endif // GGML_SYCL_F16
-
-#define MMVQ_MAX_BATCH_SIZE  8
-
-static const int8_t kvalues_iq4nl[16]={-127, -104, -83, -65, -49, -35, -22, -10, 1, 13, 25, 38, 53, 69, 89, 113};
-
-static int g_all_sycl_device_count = -1;
-static bool g_ggml_backend_sycl_buffer_type_initialized = false;
-
-static ggml_sycl_backend_gpu_mode g_ggml_sycl_backend_gpu_mode =
-    SYCL_UNSET_GPU_MODE;
-
-static void* g_scratch_buffer = nullptr;
-static size_t g_scratch_size = 0; // disabled by default
-static size_t g_scratch_offset = 0;
-
-[[noreturn]] static inline void bad_arch(const sycl::stream& stream_ct1) {
-  stream_ct1 << "ERROR: ggml-sycl was compiled without support for the "
-                "current GPU architecture.\n";
-  // __trap();
-  std::exit(1);
-
-  (void)bad_arch; // suppress unused function warning
-}
-
-int get_current_device_id();
-
-inline dpct::err0 ggml_sycl_set_device(const int device) try {
-  int current_device_id;
-  SYCL_CHECK(CHECK_TRY_ERROR(current_device_id = get_current_device_id()));
-
-  // GGML_SYCL_DEBUG("ggml_sycl_set_device device_id=%d,
-  // current_device_id=%d\n", device, current_device);
-  if (device == current_device_id) {
-    return 0;
-  }
-
-  return CHECK_TRY_ERROR(dpct::select_device(device));
-} catch (sycl::exception const& exc) {
-  std::cerr << exc.what() << "Exception caught at file:" << __FILE__
-            << ", line:" << __LINE__ << std::endl;
-  crash();
-  std::exit(1);
-}
-
-//////////////////////
-struct optimize_feature {
-    bool reorder=false;
-};
-
-struct sycl_device_info {
-    int     cc;                 // compute capability
-    // int     nsm;                // number of streaming multiprocessors
-    // size_t  smpb;               // max. shared memory per block
-    bool    vmm;                // virtual memory support
-    size_t  total_vram;
-    sycl_hw_info hw_info;
-    optimize_feature opt_feature;
-};
-
-
-struct ggml_sycl_device_info {
-    int device_count;
-
-    sycl_device_info devices[GGML_SYCL_MAX_DEVICES] = {};
-
-    std::array<float, GGML_SYCL_MAX_DEVICES> default_tensor_split = {};
-
-    int max_work_group_sizes[GGML_SYCL_MAX_DEVICES] = {0};
-};
-
-const ggml_sycl_device_info & ggml_sycl_info();
-
-struct ggml_sycl_pool {
-    virtual ~ggml_sycl_pool() = default;
-
-    virtual void * alloc(size_t size, size_t * actual_size) = 0;
-    virtual void free(void * ptr, size_t size) = 0;
-};
-
-template<typename T>
-struct ggml_sycl_pool_alloc {
-    ggml_sycl_pool * pool = nullptr;
-    T * ptr = nullptr;
-    size_t actual_size = 0;
-
-    explicit ggml_sycl_pool_alloc(ggml_sycl_pool & pool) : pool(&pool) {
-    }
-
-    ggml_sycl_pool_alloc(ggml_sycl_pool & pool, size_t size) : pool(&pool) {
-        alloc(size);
-    }
-
-    ~ggml_sycl_pool_alloc() {
-        if (ptr != nullptr) {
-            pool->free(ptr, actual_size);
-        }
-    }
-
-    T * realloc(size_t size) {
-        GGML_ASSERT(pool != nullptr);
-        if (ptr)
-            pool->free(ptr, actual_size);
-        ptr = (T *) pool->alloc(size * sizeof(T), &this->actual_size);
-        return ptr;
-    }
-
-    // size is in number of elements
-    T * alloc(size_t size) {
-        GGML_ASSERT(pool != nullptr);
-        GGML_ASSERT(ptr == nullptr);
-        ptr = (T *) pool->alloc(size * sizeof(T), &this->actual_size);
-        return ptr;
-    }
-
-    T * alloc(ggml_sycl_pool & pool, size_t size) {
-        this->pool = &pool;
-        return alloc(size);
-    }
-
-    T * get() {
-        return ptr;
-    }
-
-    ggml_sycl_pool_alloc() = default;
-    ggml_sycl_pool_alloc(const ggml_sycl_pool_alloc &) = delete;
-    ggml_sycl_pool_alloc(ggml_sycl_pool_alloc &&) = delete;
-    ggml_sycl_pool_alloc& operator=(const ggml_sycl_pool_alloc &) = delete;
-    ggml_sycl_pool_alloc& operator=(ggml_sycl_pool_alloc &&) = delete;
-};
-
-// backend interface
-
-struct ggml_tensor_extra_gpu {
-  void* data_device[GGML_SYCL_MAX_DEVICES]; // 1 pointer for each device for split
-                                       // tensors
-  dpct::event_ptr events[GGML_SYCL_MAX_DEVICES]
-                        [GGML_SYCL_MAX_STREAMS]; // events for synchronizing multiple GPUs
-  optimize_feature optimized_feature;
-};
-
-void release_extra_gpu(ggml_tensor_extra_gpu * extra, std::vector<queue_ptr> streams={});
-
-inline optimize_feature check_gpu_optimize_feature(syclex::architecture &arch) {
-    optimize_feature opt;
-
-    opt.reorder =
-        (arch == syclex::architecture::intel_gpu_dg1 ||
-         arch == syclex::architecture::intel_gpu_acm_g10 ||
-         arch == syclex::architecture::intel_gpu_acm_g11 ||
-         arch == syclex::architecture::intel_gpu_acm_g12 ||
-         arch == syclex::architecture::intel_gpu_pvc ||
-         arch == syclex::architecture::intel_gpu_pvc_vg ||
-         arch == syclex::architecture::intel_gpu_mtl_u ||
-         arch == syclex::architecture::intel_gpu_mtl_s ||
-         arch == syclex::architecture::intel_gpu_mtl_h ||
-         arch == syclex::architecture::intel_gpu_arl_u ||
-         arch == syclex::architecture::intel_gpu_arl_s ||
-         arch == syclex::architecture::intel_gpu_arl_h ||
-         arch == syclex::architecture::intel_gpu_bmg_g21 ||
-         arch == syclex::architecture::intel_gpu_lnl_m
-        );
-
-    return opt;
-}
-
-namespace sycl_ex = sycl::ext::oneapi::experimental;
-struct ggml_backend_sycl_context {
-    int device;
-    std::string name;
-    optimize_feature opt_feature;
-
-    queue_ptr qptrs[GGML_SYCL_MAX_DEVICES][GGML_SYCL_MAX_STREAMS] = { { nullptr } };
-
-    explicit ggml_backend_sycl_context(int device) :
-        device(device),
-        name(GGML_SYCL_NAME + std::to_string(device)) {
-        opt_feature = ggml_sycl_info().devices[device].opt_feature;
-    }
-
-    queue_ptr stream(int device, int stream) {
-        if (qptrs[device][stream] == nullptr) {
-            qptrs[device][stream] = &(dpct::get_device(device).default_queue());
-        }
-        return qptrs[device][stream];
-    }
-
-    queue_ptr stream() {
-        return stream(device, 0);
-    }
-
-#if GGML_SYCL_DNNL
-    dnnl::engine make_engine(sycl::queue* q) {
-        // Get the device associated with the queue
-        sycl::device dev = q->get_device();
-        // Get the context associated with the queue
-        sycl::context ctx = q->get_context();
-        const dnnl::engine eng = dnnl::sycl_interop::make_engine(dev, ctx);
-        return eng;
-    }
-
-    std::unordered_map<sycl::queue*, dnnl::stream> stream_map;
-    std::unordered_map<sycl::queue*, dnnl::engine> engine_map;
-    dnnl::stream stream_dnnl(int device, int _stream) {
-        auto q = stream(device, _stream);
-        return stream_dnnl(q);
-    }
-    dnnl::engine engine_dnnl(sycl::queue* qptr) {
-        auto it = engine_map.find(qptr);
-        if (it == engine_map.end()) {
-            auto eng = make_engine(qptr);
-            engine_map[qptr] = eng;
-            return eng;
-        }
-        else
-        {
-            return it->second;
-        }
-    }
-    dnnl::stream stream_dnnl(sycl::queue* qptr) {
-        auto it = stream_map.find(qptr);
-        if (it == stream_map.end()) {
-            auto eng = engine_dnnl(qptr);
-            auto stream = dnnl::sycl_interop::make_stream(eng, *qptr);
-            stream_map[qptr] = stream;
-            return stream;
-        }
-        else
-        {
-            return it->second;
-        }
-    }
-    dnnl::stream stream_dnnl() {
-        return stream_dnnl(device, 0);
-    }
-    dnnl::memory get_scratchpad_mem(const dnnl::memory::desc & scratchpad_md,
-                                    const dnnl::engine & eng, const queue_ptr q) {
-        ggml_sycl_pool_alloc<uint8_t> * pool;
-        auto it = scratchpad_map.find(q);
-        if (it == scratchpad_map.end()) {
-            scratchpad_map[q] = std::make_unique<ggml_sycl_pool_alloc<uint8_t>>(this->pool());
-            pool = scratchpad_map[q].get();
-        } else {
-            pool = it->second.get();
-        }
-
-        size_t scratchpad_size = scratchpad_md.get_size();
-        if (scratchpad_size > pool->actual_size) {
-            pool->realloc(scratchpad_size);
-        }
-        void * mem_ptr = pool->get();
-        return dnnl::memory(scratchpad_md, eng, mem_ptr);
-    }
-#endif
-
-    // pool
-    std::unique_ptr<ggml_sycl_pool> pools[GGML_SYCL_MAX_DEVICES];
-    std::unordered_map<sycl::queue *, std::unique_ptr<ggml_sycl_pool_alloc<uint8_t>>> scratchpad_map;
-
-    std::unique_ptr<ggml_sycl_pool> host_pools[GGML_SYCL_MAX_DEVICES];
-
-    static std::unique_ptr<ggml_sycl_pool> new_pool_for_device(queue_ptr qptr, int device);
-
-    static std::unique_ptr<ggml_sycl_pool> new_pool_for_host(queue_ptr qptr, int device);
-
-    ggml_sycl_pool & pool(int device) {
-        if (pools[device] == nullptr) {
-            pools[device] = new_pool_for_device(stream(device,0), device);
-        }
-        return *pools[device];
-    }
-
-    ggml_sycl_pool & pool() {
-        return pool(device);
-    }
-
-#ifdef GGML_SYCL_GRAPH
-    std::unique_ptr<sycl_ex::command_graph<sycl_ex::graph_state::executable>> exec_graph = nullptr;
-#endif
-
-    ggml_sycl_pool & host_pool(int device) {
-        if (host_pools[device] == nullptr) {
-            host_pools[device] = new_pool_for_host(stream(device, 0), device);
-        }
-        return *host_pools[device];
-    }
-
-    ggml_sycl_pool & host_pool() { return host_pool(device); }
-};
-
-// common device functions
-
-static __dpct_inline__ float warp_reduce_sum(float x,
-    const sycl::nd_item<3>& item_ct1) {
-#pragma unroll
-    for (int mask = WARP_SIZE / 2; mask > 0; mask >>= 1) {
-        /*
-        DPCT1096:98: The right-most dimension of the work-group used in the SYCL
-        kernel that calls this function may be less than "32". The function
-        "dpct::permute_sub_group_by_xor" may return an unexpected result on the
-        CPU device. Modify the size of the work-group to ensure that the value
-        of the right-most dimension is a multiple of "32".
-        */
-        x += dpct::permute_sub_group_by_xor(item_ct1.get_sub_group(), x, mask);
-    }
-    return x;
-}
-
-static __dpct_inline__ sycl::float2
-warp_reduce_sum(sycl::float2 a, const sycl::nd_item<3>& item_ct1) {
-#pragma unroll
-    for (int mask = WARP_SIZE / 2; mask > 0; mask >>= 1) {
-        a.x() += dpct::permute_sub_group_by_xor(item_ct1.get_sub_group(), a.x(),
-            mask);
-        a.y() += dpct::permute_sub_group_by_xor(item_ct1.get_sub_group(), a.y(),
-            mask);
-    }
-    return a;
-}
-
-static __dpct_inline__ float warp_reduce_max(float x,
-    const sycl::nd_item<3>& item_ct1) {
-#pragma unroll
-    for (int mask = WARP_SIZE / 2; mask > 0; mask >>= 1) {
-        /*
-        DPCT1096:97: The right-most dimension of the work-group used in the SYCL
-        kernel that calls this function may be less than "32". The function
-        "dpct::permute_sub_group_by_xor" may return an unexpected result on the
-        CPU device. Modify the size of the work-group to ensure that the value
-        of the right-most dimension is a multiple of "32".
-        */
-        x = sycl::fmax(x, dpct::permute_sub_group_by_xor(
-            item_ct1.get_sub_group(), x, mask));
-    }
-    return x;
-}
-
-// Helper for vec loading aligned data
-template <typename Tp, int n>
-inline sycl::vec<Tp, n> vec_aligned_load(const Tp* aligned_ptr) {
-    return *reinterpret_cast<const sycl::vec<Tp, n>*>(aligned_ptr);
-}
-
-// Helper for accessing pointers with no warnings
-template <typename Tp, int dim>
-static __dpct_inline__ Tp* get_pointer(sycl::local_accessor<Tp, dim> acc) {
-    return acc.template get_multi_ptr<sycl::access::decorated::no>().get();
-}
-
-int64_t downsample_sycl_global_range(int64_t accumulate_block_num, int64_t block_size);
-
-constexpr size_t ceil_div(const size_t m, const size_t n) {
-    return (m + n - 1) / n;
-}
-
-bool gpu_has_xmx(sycl::device &dev);
-#endif // GGML_SYCL_COMMON_HPP

package/src/llama.cpp/ggml/src/ggml-sycl/concat.cpp

@@ -1,197 +0,0 @@
-//
-// MIT license
-// Copyright (C) 2024 Intel Corporation
-// SPDX-License-Identifier: MIT
-//
-
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-
-#include "concat.hpp"
-#include "common.hpp"
-
-static void concat_f32_dim0(const float *x, const float *y, float *dst,
-                            const int ne0, const int ne00,
-                            const sycl::nd_item<3> &item_ct1) {
-  int nidx = item_ct1.get_local_id(2) +
-             item_ct1.get_group(2) * item_ct1.get_local_range(2);
-  if (nidx >= ne0) {
-    return;
-  }
-  // operation
-  int offset_dst = nidx + item_ct1.get_group(1) * ne0 +
-                   item_ct1.get_group(0) * ne0 * item_ct1.get_group_range(1);
-  if (nidx < ne00) { // src0
-    int offset_src = nidx + item_ct1.get_group(1) * ne00 +
-                     item_ct1.get_group(0) * ne00 * item_ct1.get_group_range(1);
-    dst[offset_dst] = x[offset_src];
-  } else {
-    int offset_src =
-        nidx - ne00 + item_ct1.get_group(1) * (ne0 - ne00) +
-        item_ct1.get_group(0) * (ne0 - ne00) * item_ct1.get_group_range(1);
-    dst[offset_dst] = y[offset_src];
-  }
-}
-
-static void concat_f32_dim1(const float *x, const float *y, float *dst,
-                            const int ne0, const int ne01,
-                            const sycl::nd_item<3> &item_ct1) {
-  int nidx = item_ct1.get_local_id(2) +
-             item_ct1.get_group(2) * item_ct1.get_local_range(2);
-  if (nidx >= ne0) {
-    return;
-  }
-  // operation
-  int offset_dst = nidx + item_ct1.get_group(1) * ne0 +
-                   item_ct1.get_group(0) * ne0 * item_ct1.get_group_range(1);
-  if (item_ct1.get_group(1) < (size_t) ne01) { // src0
-    int offset_src =
-        nidx + item_ct1.get_group(1) * ne0 + item_ct1.get_group(0) * ne0 * ne01;
-    dst[offset_dst] = x[offset_src];
-  } else {
-    int offset_src =
-        nidx + (item_ct1.get_group(1) - ne01) * ne0 +
-        item_ct1.get_group(0) * ne0 * (item_ct1.get_group_range(1) - ne01);
-    dst[offset_dst] = y[offset_src];
-  }
-}
-
-static void concat_f32_dim2(const float *x, const float *y, float *dst,
-                            const int ne0, const int ne02,
-                            const sycl::nd_item<3> &item_ct1) {
-  int nidx = item_ct1.get_local_id(2) +
-             item_ct1.get_group(2) * item_ct1.get_local_range(2);
-  if (nidx >= ne0) {
-    return;
-  }
-  // operation
-  int offset_dst = nidx + item_ct1.get_group(1) * ne0 +
-                   item_ct1.get_group(0) * ne0 * item_ct1.get_group_range(1);
-  if (item_ct1.get_group(0) < (size_t) ne02) { // src0
-    int offset_src = nidx + item_ct1.get_group(1) * ne0 +
-                     item_ct1.get_group(0) * ne0 * item_ct1.get_group_range(1);
-    dst[offset_dst] = x[offset_src];
-  } else {
-    int offset_src =
-        nidx + item_ct1.get_group(1) * ne0 +
-        (item_ct1.get_group(0) - ne02) * ne0 * item_ct1.get_group_range(1);
-    dst[offset_dst] = y[offset_src];
-  }
-}
-
-static void concat_f32_sycl(const float *x, const float *y, float *dst,
-                            int ne00, int ne01, int ne02, int ne0, int ne1,
-                            int ne2, int dim, queue_ptr stream) {
-  int num_blocks = (ne0 + SYCL_CONCAT_BLOCK_SIZE - 1) / SYCL_CONCAT_BLOCK_SIZE;
-  sycl::range<3> gridDim(ne2, ne1, num_blocks);
-  switch (dim) {
-  case 0:
-    stream->parallel_for(
-        sycl::nd_range<3>(gridDim *
-                              sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE),
-                          sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE)),
-        [=](sycl::nd_item<3> item_ct1) {
-          concat_f32_dim0(x, y, dst, ne0, ne00, item_ct1);
-        });
-    break;
-  case 1:
-    stream->parallel_for(
-        sycl::nd_range<3>(gridDim *
-                              sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE),
-                          sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE)),
-        [=](sycl::nd_item<3> item_ct1) {
-          concat_f32_dim1(x, y, dst, ne0, ne01, item_ct1);
-        });
-    break;
-  // dim >=2 will be dispatched to the default path
-  default:
-    stream->parallel_for(
-        sycl::nd_range<3>(gridDim *
-                              sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE),
-                          sycl::range<3>(1, 1, SYCL_CONCAT_BLOCK_SIZE)),
-        [=](sycl::nd_item<3> item_ct1) {
-          concat_f32_dim2(x, y, dst, ne0, ne02, item_ct1);
-        });
-    break;
-  }
-}
-
-// non-contiguous kernel (slow)
-static void concat_f32_sycl_non_cont(
-    queue_ptr stream, const char *src0, const char *src1, char *dst,
-    int64_t ne00, int64_t ne01, int64_t ne02, int64_t ne03, uint64_t nb00,
-    uint64_t nb01, uint64_t nb02, uint64_t nb03, int64_t /*ne10*/,
-    int64_t /*ne11*/, int64_t /*ne12*/, int64_t /*ne13*/, uint64_t nb10,
-    uint64_t nb11, uint64_t nb12, uint64_t nb13, int64_t ne0, int64_t ne1,
-    int64_t ne2, int64_t ne3, uint64_t nb0, uint64_t nb1, uint64_t nb2,
-    uint64_t nb3, int32_t dim) {
-  sycl::range<3> gridDim(ne3, ne2, ne1);
-  stream->parallel_for(
-      sycl::nd_range<3>(gridDim, sycl::range<3>(1, 1, 1)),
-      [=](sycl::nd_item<3> item_ct1) {
-        int64_t i3 = item_ct1.get_group(0);
-        int64_t i2 = item_ct1.get_group(1);
-        int64_t i1 = item_ct1.get_group(2);
-
-        int64_t o[4] = {0, 0, 0, 0};
-        o[dim] = dim == 0 ? ne00 : (dim == 1 ? ne01 : (dim == 2 ? ne02 : ne03));
-
-        const float *x;
-
-        for (int i0 = item_ct1.get_local_id(2); i0 < ne0;
-             i0 += item_ct1.get_local_range(2)) {
-          if (i0 < ne00 && i1 < ne01 && i2 < ne02 && i3 < ne03) {
-            x = (const float *)(src0 + (i3)*nb03 + (i2)*nb02 + (i1)*nb01 +
-                                (i0)*nb00);
-          } else {
-            x = (const float *)(src1 + (i3 - o[3]) * nb13 + (i2 - o[2]) * nb12 +
-                                (i1 - o[1]) * nb11 + (i0 - o[0]) * nb10);
-          }
-
-          float *y = (float *)(dst + i3 * nb3 + i2 * nb2 + i1 * nb1 + i0 * nb0);
-
-          *y = *x;
-        }
-      });
-}
-
-void ggml_sycl_op_concat(ggml_backend_sycl_context & ctx, ggml_tensor *dst) {
-  const ggml_tensor *src0 = dst->src[0];
-  const ggml_tensor *src1 = dst->src[1];
-  queue_ptr stream = ctx.stream();
-
-  const int32_t dim = ((int32_t *)dst->op_params)[0];
-
-  if (ggml_is_contiguous(src0) && ggml_is_contiguous(src1)) {
-    const float *src0_d = (const float *)src0->data;
-    const float *src1_d = (const float *)src1->data;
-
-    float *dst_d = (float *)dst->data;
-
-    if (dim != 3) {
-      for (int i3 = 0; i3 < dst->ne[3]; i3++) {
-        concat_f32_sycl(
-            src0_d + i3 * (src0->nb[3] / 4), src1_d + i3 * (src1->nb[3] / 4),
-            dst_d + i3 * (dst->nb[3] / 4), src0->ne[0], src0->ne[1],
-            src0->ne[2], dst->ne[0], dst->ne[1], dst->ne[2], dim, stream);
-      }
-    } else {
-      const size_t size0 = ggml_nbytes(src0);
-      const size_t size1 = ggml_nbytes(src1);
-
-      SYCL_CHECK(CHECK_TRY_ERROR(stream->memcpy(dst_d, src0_d, size0).wait()));
-      SYCL_CHECK(CHECK_TRY_ERROR(
-          stream->memcpy(dst_d + size0 / 4, src1_d, size1).wait()));
-    }
-  } else
-    concat_f32_sycl_non_cont(
-        stream, (const char *)src0->data, (const char *)src1->data,
-        (char *)dst->data, src0->ne[0], src0->ne[1], src0->ne[2], src0->ne[3],
-        src0->nb[0], src0->nb[1], src0->nb[2], src0->nb[3], src1->ne[0],
-        src1->ne[1], src1->ne[2], src1->ne[3], src1->nb[0], src1->nb[1],
-        src1->nb[2], src1->nb[3], dst->ne[0], dst->ne[1], dst->ne[2],
-        dst->ne[3], dst->nb[0], dst->nb[1], dst->nb[2], dst->nb[3], dim);
-}

package/src/llama.cpp/ggml/src/ggml-sycl/concat.hpp

@@ -1,20 +0,0 @@
-//
-// MIT license
-// Copyright (C) 2024 Intel Corporation
-// SPDX-License-Identifier: MIT
-//
-
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-
-#ifndef GGML_SYCL_CONCAT_HPP
-#define GGML_SYCL_CONCAT_HPP
-
-#include "common.hpp"
-
-void ggml_sycl_op_concat(ggml_backend_sycl_context & ctx, ggml_tensor *dst);
-
-#endif // GGML_SYCL_CONCAT_HPP