My 8 GB GPU Wasn't the Only Bottleneck. System RAM Mattered Too.
I expected the 8 GB GPU in my laptop to be the main constraint when I experimented with local image generation. Instead, the system's 16 GB of RAM became a practical limit on heavier workflows.
The report associated some slow runs with Windows paging, though the evidence available here does not establish that paging caused the delays. A graph using two ControlNets crashed.
The rule I took from that experiment was specific to this laptop: use at most one ControlNet per graph, leave RAM headroom, and watch system memory as well as VRAM.
The experiment
I tested local image-generation workflows in ComfyUI on a laptop with an RTX 4060 GPU (8 GB VRAM) and 16 GB of system RAM. The workflows used SDXL with a pixel-art LoRA; some also used IPAdapter for reference guidance or ControlNet OpenPose for pose guidance.
The report covers 126 generations, including 13 with errors. Those errors were not all memory failures.
What the measurements showed
The report recorded these values for the SDXL workflows:
| Workflow | Median time | Peak VRAM | Peak system RAM reading* |
|---|---|---|---|
| Base SDXL + pixel-art LoRA | 28 s | 7.7 GB | 15.5 GB |
| Portrait with IPAdapter | 33 s | 7.6 GB | 14.6 GB |
| Pose with IPAdapter + OpenPose | 51 s | 7.7 GB | 16.0 GB |
| Seamless terrain | 36 s text-to-image; 132 s image-to-image | 7.8 GB | 15.3 GB |
*The system RAM metric, its units and rounding still need verification; it cannot yet be interpreted as physical RAM in use or as committed memory. The figures are transcribed report values, not a controlled hardware comparison.
The report associates the slower terrain image-to-image run with paging; it also notes that paging stretched some runs from about 35 seconds to 10 minutes. Those timings are observations across runs, not a measured speedup from changing one setting.
Dedicated VRAM is GPU memory; physical system RAM is a separate pool shared with Windows and applications. A graph can execute within VRAM while its surrounding workload places pressure on system RAM: model loading or offloading, CPU-side preprocessing, image buffers, drivers, and other applications can all contribute. Their individual contributions were not measured here.
GPU utilization and available VRAM alone cannot show whether the rest of the machine has sufficient memory. The troubleshooting notes record one slow run with an editor and a download open alongside the workload.
When physical memory is scarce, Windows can move infrequently used memory pages to a pagefile; retrieving needed data from storage can be much slower than reading RAM. Hard faults and disk activity can also have other causes. The available record does not establish how paging was identified or whether it caused these slow runs.
How I recorded runs
The generation script saved a manifest with the workflow identity and hash, graph, seed, model information, settings, duration, and resource readings. Its sampler took a baseline and then sampled GPU-wide VRAM and machine-wide system RAM at 0.5-second intervals during generation.
Those readings include other activity on the machine; they are not memory used by the generation process alone. Sampling can also miss short peaks.
There was a reproducibility gap: the manifest's dedicated ControlNet list was empty in the implementation I reviewed. The graph is saved, but I would not assume the manifest fully identifies every ControlNet model without checking the relevant graph and registry.
For each ControlNet I would record:
- model filename and hash
- version if available
- preprocessor settings
- strength
- start and end percentages
- relevant node configuration
A seed alone cannot reproduce a generation without the same models, graph, settings, software, and execution conditions.
The decision
The immediate constraint was one ControlNet per graph at most. That was a practical operating rule from this experiment, not a claim that two ControlNets cannot work on other machines. Closing heavy applications before batches was another way to preserve headroom.
If I repeated the test, I would capture the machine state, distinguish cold and warm runs, repeat each workflow, and record ControlNet model identity explicitly. I would also record available physical memory, committed memory, page reads and disk activity alongside process memory, and separate memory failures from other errors rather than treating the error count as a RAM metric.
The cause and repeatability of the two-ControlNet crash still need checking.
The useful lesson for me was to ask two questions: can this machine generate an image, and can it run this particular graph at a tolerable, repeatable speed? The first answer was yes. The second depended on the whole machine and the workload, not just the number printed on the GPU.
Comments
No comments yet. Start the discussion.