In Ollama, what does the PROCESSOR column of `ollama ps` tell you, and what does a 48%/52% CPU/GPU reading mean?
answer
- loaded models, not pulled ones
- memory placement, not utilisation
- size against size_vram
- some layers left in system RAM
- CONTEXT column sits beside it
basics
~20 sollama ps lists the models currently loaded, and PROCESSOR says where each one's memory sits: 100% GPU is fully in VRAM, while 48%/52% CPU/GPU means about half stayed in system RAM, so those layers run on the CPU and generation slows sharply.
solid answer
~50 s`ollama ps` shows the models loaded in memory right now — not everything pulled, which is `ollama ls` — with NAME, ID, SIZE, PROCESSOR, CONTEXT and UNTIL. PROCESSOR comes from two numbers in `/api/ps`: the loaded model's `size` and the part in GPU memory, `size_vram`. `100% GPU` means everything is in VRAM, `100% CPU` means nothing is, and `48%/52% CPU/GPU` means 48% of the loaded size sits in system RAM. That size includes the memory reserved for the context, not just the weights. A split is a big slowdown, because the layers left on the CPU run at system-memory speed and every token passes through them. The fix is to make the load fit — a smaller context, fewer parallel slots, another loaded model stopped, or a smaller tag — and then check that it reads `100% GPU`.
code
console · 4 lines$ ollama ps
NAME ID SIZE PROCESSOR CONTEXT UNTIL
your-model:14b 1a2b3c4d5e6f 15 GB 41%/59% CPU/GPU 32768 4 minutes from now
your-embedder 6f5e4d3c2b1a 849 MB 100% GPU 8192 2 minutes from nowgo deeper
Know that ollama ps shows loaded models, that PROCESSOR is where their memory sits, and that 100% GPU is the reading you want.
Explain how the split is derived from size and size_vram, that the size includes context memory, and which settings make a model fit again.
Diagnose a split from the whole row: compare CONTEXT with what clients need, count other loaded models, and confirm 100% GPU after each change rather than guessing.
Treat 100% GPU as a service-level condition on shared boxes: decide which models and contexts a machine is sized for, and monitor size against size_vram instead of waiting for complaints.
## What `ollama ps` lists `ollama ps` asks the running Ollama server which models are **loaded in memory right now** — not which models are on disk. Pulled models are listed by `ollama ls`; a model only appears in `ollama ps` after a request (or a preload) has loaded it, and it disappears again when it is unloaded. The same data is available over HTTP from `GET /api/ps`, which is what the command calls. Each row has six columns: - **NAME** and **ID** — the model tag and the first characters of its digest. - **SIZE** — how much memory the loaded model occupies. This is the size of the *running* model, not of the file: it covers the weights plus the memory reserved for the context, so it grows when the context length or the number of parallel request slots grows. - **PROCESSOR** — where that memory sits: in GPU memory (VRAM), in system RAM, or split across both. - **CONTEXT** — the context length, in tokens, that the model was actually loaded with. - **UNTIL** — when the model will be unloaded if no further request arrives (driven by `keep_alive`). ## How the PROCESSOR column is computed `/api/ps` reports two numbers per model: `size` (everything the loaded model uses) and `size_vram` (the part placed in GPU memory). The CLI turns them into text: | PROCESSOR reads | What it means | |---|---| | `100% GPU` | `size_vram` equals `size`: the whole loaded model is in VRAM | | `100% CPU` | `size_vram` is zero: nothing is on the GPU, the model runs from system RAM | | `48%/52% CPU/GPU` | 48% of the loaded size is in system RAM and 52% in VRAM | | `Unknown` | the two numbers are inconsistent (VRAM larger than the total) | The CPU share is simply `(size - size_vram) / size`, rounded. Two points trip people up: 1. **It is a memory placement, not a utilisation figure.** `100% CPU` does not mean the processor is pegged; it means no part of the model was placed on a GPU — because there is none Ollama can use, because the request asked for zero GPU layers, or because nothing fit. 2. **It describes the whole loaded model, context included.** A model whose weights would fit can still show a split once a large context or several parallel slots are added on top. ## Why a split is slow A model is a stack of layers, and every generated token passes through every layer in order. When Ollama cannot fit everything in VRAM, it places as many layers as fit on the GPU and leaves the rest in system memory, where the CPU computes them. The CPU-side layers are processed at system-memory speed, so they set the pace for every token: a model reading `100% GPU` at dozens of tokens per second can fall to a handful once a large share of it lands on the CPU. The reason decoding is bound by memory bandwidth belongs to the inference foundations; the operational point is that a split is a large slowdown, not a small one. ## What to do when you see a split Make the loaded model fit, then confirm with `ollama ps` that it reads `100% GPU`: 1. **Check the CONTEXT column first.** A context larger than the application needs is the most common cause; lower it with `num_ctx` or `OLLAMA_CONTEXT_LENGTH`. 2. **Check parallelism.** `OLLAMA_NUM_PARALLEL` multiplies the context the model is loaded with. 3. **Look for other loaded models.** Another row in `ollama ps` holds VRAM too; `ollama stop <model>` frees it. 4. **Consider the cache type or a smaller tag.** `OLLAMA_KV_CACHE_TYPE=q8_0` shrinks the context's memory; a smaller model shrinks the weights. `100% CPU` on a machine that has a GPU is a different problem: usually a driver or discovery issue, or a request that set `num_gpu` to 0, and the server log is where to look. ## Reading the rest of the row The **CONTEXT** column is the quickest way to learn what Ollama chose when nobody set a context, and the **UNTIL** column shows whether a model will stay warm (a time such as "4 minutes from now", or "Forever" when it was loaded with a negative `keep_alive`). Reading the whole row — size, placement, context and expiry — answers most "why is it slow" questions before any benchmarking starts.
- How would a monitoring script detect a split without parsing the CLI table?Call `GET /api/ps` on the Ollama server. Each loaded model carries `size` and `size_vram`; when `size_vram` is less than `size`, part of the model is in system RAM. The CLI's percentage is just `(size - size_vram) / size`, so a script can alert on any model where the two differ.
- Why is SIZE in `ollama ps` larger than the model file on disk?SIZE is the loaded runner's memory: the weights plus what is reserved for the context and its buffers. It therefore rises with the context length and with the number of parallel slots, and a model whose file would fit in VRAM can still show a CPU/GPU split once that context is added.
- 100% CPU means the processor is fully utilised by the model
- ollama ps lists every model pulled to the machine
- A 48%/52% split only costs a few percent of speed
- SIZE in ollama ps is the size of the model file on disk
- The CPU/GPU split is fixed by the model and cannot be changed