Function passesJitHeuristics

src/backend/oneapi/Array.cpp:320–414

///    limitation on the platform. For NVIDIA this is 4096 bytes. The
template<typename T>
kJITHeuristics passesJitHeuristics(span<Node *> root_nodes) {
    if (!evalFlag()) { return kJITHeuristics::Pass; }
    static auto getLogger = [&] { return common::loggerFactory("jit"); };
    for (const Node *n : root_nodes) {
        if (n->getHeight() > static_cast<int>(getMaxJitSize())) {
            AF_TRACE(
                "JIT tree evaluated because of tree height exceeds limit: {} > "
                "{}",
                n->getHeight(), getMaxJitSize());
            return kJITHeuristics::TreeHeight;
        }
    }

    // TODO(umar): add memory based checks for JIT kernel generation
    bool isBufferLimit =
        false;  // getMemoryPressure() >= getMemoryPressureThreshold();
    // auto platform      = getActivePlatform();

    // The Apple platform can have the nvidia card or the AMD card
    // bool isIntel = platform == AFCL_PLATFORM_INTEL;

    /// Intels param_size limit is much smaller than the other platforms
    /// so we need to start checking earlier with smaller trees
    int heightCheckLimit = 3;

    // A lightweight check based on the height of the node. This is
    // an inexpensive operation and does not traverse the JIT tree.
    bool atHeightLimit =
        std::any_of(std::begin(root_nodes), std::end(root_nodes),
                    [heightCheckLimit](Node *n) {
                        return (n->getHeight() + 1 >= heightCheckLimit);
                    });

    if (atHeightLimit || isBufferLimit) {
        // This is the base parameter size if the kernel had no
        // arguments
        size_t base_param_size =
            (sizeof(T *) + sizeof(Param<T>)) * root_nodes.size() +
            (3 * sizeof(uint));

        const sycl::device &device = getDevice();
        size_t max_param_size =
            device.get_info<sycl::info::device::max_parameter_size>();
        // typical values:
        //   NVIDIA     = 4096
        //   AMD        = 3520  (AMD A10 iGPU = 1024)
        //   Intel iGPU = 1024
        max_param_size -= base_param_size;

        struct tree_info {
            size_t total_buffer_size;
            size_t num_buffers;
            size_t param_scalar_size;
        };

        tree_info info{0, 0, 0};
        for (Node *n : root_nodes) {
            NodeIterator<> it(n);