mirror of
https://github.com/ikawrakow/ik_llama.cpp.git
synced 2026-03-02 10:00:07 +00:00
2fe098e938
* WIP: absorb adding input into std_attn and std_ffn * WIP: NCCL infra * WIP: add reduce and fake_cpy ops * WIP * WIP: graph appears to work, layer is broken * WIP: Qwen3-MoE works with graph, layer still broken * WIP: GLM-4.5 graph works * WIP: fix sm layer (dense) * WIP: fix sm layer (MoE) * WIP: fast PP with bespoke 4-GPU NCCL I guess, I'm not using NCCL the right way as PP is very low with a single communicator group for 3 or more GPUs. But if I create 4 communicator groups for pairs of GPUs (0,1, 2,3, 0,2, 1,3) and use that, PP is fast: I'm hitting 1500 t/s for L3-70B on the 4x3090 system, which is ~20% better than the previous sm graph without NCCL. But that cannot be the solution (I cannot be creating pairwise communicators and associated logic for every possible number of GPUs). * WIP: Cohere2 * Explicitely set device * Bespoke 3-GPU case * WIP * Do not repeat get_rows multiple times * Fix 3 GPUs * OK, let's leave it in * Simple async * This sync seems enough * Only do async for 4 or more backends With 2 GPUs (so, 3 backends) not using async is slightly faster * Scheduler changes * Use OpenMP if available Surprisingly (at least to me), this is quite a bit faster than std::thread and std::barrier. GLM-4.5-AIR with 4 GPUs is now at 105 t/s at zero context! * Do not use OpenMP if there are tensor overrides * Set omp max active levels * Be more careful with having set the device before using a stream * Command line option to turn on async. Set to false by defualt for now --------- Co-authored-by: Iwan Kawrakow <iwan.kawrakow@gmail.com>
55 lines
1.4 KiB
C++
55 lines
1.4 KiB
C++
#pragma once
|
|
|
|
#include "llama-impl.h"
|
|
|
|
#include <cstdint>
|
|
|
|
struct llama_cparams {
|
|
uint32_t n_ctx; // context size used during inference
|
|
uint32_t n_batch;
|
|
uint32_t n_ubatch;
|
|
uint32_t n_seq_max;
|
|
uint32_t n_threads; // number of threads to use for generation
|
|
uint32_t n_threads_batch; // number of threads to use for batch processing
|
|
|
|
std::vector<std::string> devices;
|
|
std::vector<std::string> devices_draft;
|
|
|
|
float rope_freq_base;
|
|
float rope_freq_scale;
|
|
|
|
uint32_t n_ctx_orig_yarn;
|
|
// These hyperparameters are not exposed in GGUF, because all
|
|
// existing YaRN models use the same values for them.
|
|
float yarn_ext_factor;
|
|
float yarn_attn_factor;
|
|
float yarn_beta_fast;
|
|
float yarn_beta_slow;
|
|
float defrag_thold;
|
|
|
|
bool embeddings;
|
|
bool causal_attn;
|
|
bool offload_kqv;
|
|
bool flash_attn;
|
|
int mla_attn;
|
|
int attn_max_batch;
|
|
bool fused_moe_up_gate;
|
|
bool grouped_expert_routing;
|
|
bool fused_up_gate;
|
|
bool fused_mmad;
|
|
bool rope_cache;
|
|
bool graph_reuse;
|
|
bool k_cache_hadamard;
|
|
bool split_mode_graph_scheduling;
|
|
bool split_mode_f16;
|
|
bool scheduler_async;
|
|
int min_experts;
|
|
float thresh_experts;
|
|
|
|
enum llama_pooling_type pooling_type;
|
|
|
|
ggml_backend_sched_eval_callback cb_eval;
|
|
void * cb_eval_user_data;
|
|
void * cuda_params;
|
|
};
|