Overview#
This guide covers performance optimization strategies for ComfyUI workflows on the Lilith platform, including GPU selection, workflow design, caching, and monitoring.
GPU Selection#
Available GPU Types#
| GPU | VRAM | Best For | Cost |
|---|---|---|---|
| A4000 | 16GB | Simple workflows, low-res images | $ |
| A5000 | 24GB | Standard SDXL, medium complexity | $$ |
| A6000 | 48GB | High-res, complex workflows | $$$ |
| A100 | 80GB | Video, extreme complexity | $$$$ |
| H100 | 80GB | Maximum performance | $$$$$ |
GPU Selection Guidelines#
typescript
function selectGPU(workflow: WorkflowRequirements): GPUType {
const { resolution, complexity, outputType } = workflow;
// Video always needs A100+
if (outputType === OutputType.VIDEO) {
return 'A100';
}
// High resolution needs more VRAM
if (resolution.width >= 2048 || resolution.height >= 2048) {
return 'A6000';
}
// Complex workflows need more compute
if (complexity === ComplexityLevel.HIGH) {
return 'A5000';
}
// Standard SDXL
if (resolution.width >= 1024 && complexity === ComplexityLevel.MEDIUM) {
return 'A5000';
}
// Simple workflows
return 'A4000';
}
VRAM Requirements#
| Resolution | Model | Approx VRAM |
|---|---|---|
| 512x512 | SD 1.5 | 4-6 GB |
| 768x768 | SD 1.5 | 6-8 GB |
| 1024x1024 | SDXL | 10-14 GB |
| 1536x1536 | SDXL | 16-24 GB |
| 2048x2048 | SDXL | 32-48 GB |
Workflow Optimization#
1. Reduce Sampling Steps#
Higher step counts improve quality but increase processing time linearly.
typescript
// Quality vs Speed tradeoffs
const STEP_PRESETS = {
draft: 15, // Fast preview
standard: 25, // Good balance
quality: 35, // High quality
maximum: 50, // Maximum quality
};
// Most workflows don't need more than 30 steps
builder.setSamplerParams('3', {
steps: STEP_PRESETS.standard,
cfg: 7.5,
sampler: 'euler_ancestral', // Fast sampler
});
2. Optimize Resolution#
Process at minimum needed resolution, then upscale:
typescript
// Instead of generating at 2048x2048
// Generate at 1024x1024 and upscale
const generateWithUpscale = async (prompt: string) => {
// Step 1: Generate at lower resolution
const baseResult = await client.runInference('sd-base', {
'5': { inputs: { width: 1024, height: 1024 } },
'6': { inputs: { text: prompt } },
});
// Step 2: Upscale 2x
const upscaledResult = await client.runInference('upscale-4x', {
'14': { inputs: { image: baseResult.outputs[0].url } },
});
return upscaledResult;
};
// Processing time: ~30s + ~15s = 45s
// vs Direct 2048x2048: ~120s
// Quality: Often comparable or better
3. Choose Fast Samplers#
Sampler performance comparison:
| Sampler | Speed | Quality | Best For |
|---|---|---|---|
| euler | Fast | Good | Quick previews |
| euler_ancestral | Fast | Good | Creative variety |
| dpm++ 2m | Medium | Very Good | General use |
| dpm++ 2m karras | Medium | Excellent | Quality outputs |
| ddim | Fast | Moderate | img2img |
| UniPC | Fast | Very Good | Time-sensitive |
typescript
// Fast sampler for previews
builder.setSamplerParams('3', {
sampler: 'euler',
scheduler: 'normal',
steps: 15,
});
// Quality sampler for final output
builder.setSamplerParams('3', {
sampler: 'dpmpp_2m_karras',
scheduler: 'karras',
steps: 30,
});
4. Use Efficient Model Loading#
Cache model loads across jobs:
typescript
// Configure deployment with model preloading
const deployment: DeploymentConfiguration = {
// ...
lilithMetadata: {
preloadModels: [
'sd_xl_base_1.0.safetensors',
'spiritual_art_v2.safetensors',
],
},
};
5. Optimize LoRA Usage#
Limit LoRA count and strength:
typescript
// Single LoRA is faster than stacking
builder.setLora('10', 'spiritual_art_v2.safetensors', 0.7);
// If multiple needed, reduce strengths
// This is slower but sometimes necessary
builder.node('10').setInputs({
lora_name: 'lora1.safetensors',
strength_model: 0.5,
strength_clip: 0.5,
});
builder.node('11').setInputs({
lora_name: 'lora2.safetensors',
strength_model: 0.4,
strength_clip: 0.4,
});
Batch Processing#
Optimal Batch Sizes#
typescript
// Batch size depends on VRAM and resolution
const getOptimalBatchSize = (resolution: number, gpuType: GPUType): number => {
const vramGB = {
A4000: 16,
A5000: 24,
A6000: 48,
A100: 80,
H100: 80,
}[gpuType];
// Rough estimates for SDXL
if (resolution >= 2048) return 1;
if (resolution >= 1536) return Math.min(2, Math.floor(vramGB / 32));
if (resolution >= 1024) return Math.min(4, Math.floor(vramGB / 14));
if (resolution >= 768) return Math.min(8, Math.floor(vramGB / 8));
return Math.min(16, Math.floor(vramGB / 6));
};
// Use optimal batch
const batchSize = getOptimalBatchSize(1024, 'A5000'); // Returns 4
builder.setBatchSize('5', batchSize);
Parallel Job Processing#
typescript
// Process multiple prompts in parallel
async function generateBatch(prompts: string[]): Promise<JobResult[]> {
const CONCURRENT_LIMIT = 5;
const results: JobResult[] = [];
for (let i = 0; i < prompts.length; i += CONCURRENT_LIMIT) {
const batch = prompts.slice(i, i + CONCURRENT_LIMIT);
const batchPromises = batch.map((prompt) =>
client.runInference('deployment-id', {
'6': { inputs: { text: prompt } },
'3': { inputs: { seed: Math.floor(Math.random() * 2147483647) } },
})
);
const batchResults = await Promise.all(batchPromises);
results.push(...batchResults);
}
return results;
}
Caching Strategies#
Result Caching#
typescript
import { createHash } from 'crypto';
class ResultCache {
private cache: Map<string, CachedResult> = new Map();
private redis: RedisClient;
private generateCacheKey(
deploymentId: string,
overrides: WorkflowOverrides
): string {
const hash = createHash('sha256');
hash.update(deploymentId);
hash.update(JSON.stringify(overrides));
return hash.digest('hex').substring(0, 32);
}
async getCached(
deploymentId: string,
overrides: WorkflowOverrides
): Promise<JobResult | null> {
const key = this.generateCacheKey(deploymentId, overrides);
// Check memory cache first
const memCached = this.cache.get(key);
if (memCached && Date.now() < memCached.expiresAt) {
return memCached.result;
}
// Check Redis
const redisCached = await this.redis.get(`comfyui:${key}`);
if (redisCached) {
return JSON.parse(redisCached);
}
return null;
}
async setCached(
deploymentId: string,
overrides: WorkflowOverrides,
result: JobResult,
ttlSeconds: number = 86400
): Promise<void> {
const key = this.generateCacheKey(deploymentId, overrides);
// Memory cache (short TTL)
this.cache.set(key, {
result,
expiresAt: Date.now() + 300000, // 5 minutes
});
// Redis cache (long TTL)
await this.redis.setex(
`comfyui:${key}`,
ttlSeconds,
JSON.stringify(result)
);
}
}
// Usage
const cache = new ResultCache(redisClient);
async function generateWithCache(
deploymentId: string,
overrides: WorkflowOverrides
): Promise<JobResult> {
// Check cache first
const cached = await cache.getCached(deploymentId, overrides);
if (cached) {
return cached;
}
// Generate
const result = await client.runInference(deploymentId, overrides);
// Cache result (only cache successful jobs)
if (result.status === JobStatus.COMPLETED) {
await cache.setCached(deploymentId, overrides, result);
}
return result;
}
Prompt Template Caching#
typescript
// Pre-compile frequently used prompt templates
const COMPILED_TEMPLATES = new Map<
string,
(vars: Record<string, string>) => string
>();
function compileTemplate(
template: string
): (vars: Record<string, string>) => string {
const placeholders = template.match(/\{(\w+)\}/g) || [];
return (vars: Record<string, string>) => {
let result = template;
for (const placeholder of placeholders) {
const key = placeholder.slice(1, -1);
result = result.replace(placeholder, vars[key] || '');
}
return result;
};
}
// Compile at startup
for (const [id, template] of Object.entries(LILITH_PROMPT_TEMPLATES)) {
COMPILED_TEMPLATES.set(id, compileTemplate(template.template));
}
// Use compiled template
function applyFastTemplate(
templateId: string,
vars: Record<string, string>
): string {
const compiled = COMPILED_TEMPLATES.get(templateId);
if (!compiled) throw new Error(`Unknown template: ${templateId}`);
return compiled(vars);
}
Monitoring & Profiling#
Track Processing Times#
typescript
interface PerformanceMetrics {
deploymentId: string;
queueWaitMs: number;
processingMs: number;
totalMs: number;
timestamp: string;
}
class PerformanceTracker {
private metrics: PerformanceMetrics[] = [];
async trackJob(
deploymentId: string,
runJob: () => Promise<JobResult>
): Promise<JobResult> {
const startTime = Date.now();
const result = await runJob();
const metrics: PerformanceMetrics = {
deploymentId,
queueWaitMs: result.startedAt
? new Date(result.startedAt).getTime() -
new Date(result.queuedAt).getTime()
: 0,
processingMs: result.processingTimeMs || 0,
totalMs: Date.now() - startTime,
timestamp: new Date().toISOString(),
};
this.metrics.push(metrics);
this.emitMetrics(metrics);
return result;
}
getAverages(
deploymentId: string,
windowMinutes: number = 60
): {
avgQueueWait: number;
avgProcessing: number;
avgTotal: number;
count: number;
} {
const cutoff = Date.now() - windowMinutes * 60 * 1000;
const recent = this.metrics.filter(
(m) =>
m.deploymentId === deploymentId &&
new Date(m.timestamp).getTime() > cutoff
);
if (recent.length === 0) {
return { avgQueueWait: 0, avgProcessing: 0, avgTotal: 0, count: 0 };
}
return {
avgQueueWait:
recent.reduce((s, m) => s + m.queueWaitMs, 0) / recent.length,
avgProcessing:
recent.reduce((s, m) => s + m.processingMs, 0) / recent.length,
avgTotal: recent.reduce((s, m) => s + m.totalMs, 0) / recent.length,
count: recent.length,
};
}
}
Prometheus Metrics#
typescript
import { Counter, Histogram, Gauge } from 'prom-client';
// Job metrics
const jobDuration = new Histogram({
name: 'comfyui_job_duration_seconds',
help: 'Duration of ComfyUI jobs',
labelNames: ['deployment', 'status'],
buckets: [5, 15, 30, 60, 120, 300, 600],
});
const jobsTotal = new Counter({
name: 'comfyui_jobs_total',
help: 'Total number of ComfyUI jobs',
labelNames: ['deployment', 'status'],
});
const queueWait = new Histogram({
name: 'comfyui_queue_wait_seconds',
help: 'Queue wait time for jobs',
labelNames: ['deployment'],
buckets: [1, 5, 10, 30, 60, 120],
});
const activeJobs = new Gauge({
name: 'comfyui_active_jobs',
help: 'Currently active jobs',
labelNames: ['deployment'],
});
// Record metrics
function recordJobMetrics(result: JobResult): void {
const labels = { deployment: result.deploymentId, status: result.status };
jobsTotal.inc(labels);
if (result.processingTimeMs) {
jobDuration.observe(labels, result.processingTimeMs / 1000);
}
if (result.startedAt && result.queuedAt) {
const wait =
new Date(result.startedAt).getTime() -
new Date(result.queuedAt).getTime();
queueWait.observe({ deployment: result.deploymentId }, wait / 1000);
}
}
Cost Optimization#
Estimate Costs Before Running#
typescript
function estimateCost(
deploymentId: string,
quantity: number = 1
): { credits: number; estimatedTimeSeconds: number } {
const deployment = registry.getDeployment(deploymentId);
if (!deployment) {
throw new Error(`Unknown deployment: ${deploymentId}`);
}
return {
credits: deployment.costPerRun * quantity,
estimatedTimeSeconds: deployment.estimatedProcessingTime * quantity,
};
}
// Check before batch processing
const estimate = estimateCost('sacred-mandala-v1', 100);
console.log(`This will cost ${estimate.credits} credits`);
console.log(`Estimated time: ${estimate.estimatedTimeSeconds / 60} minutes`);
if (estimate.credits > user.creditBalance) {
throw new Error('Insufficient credits');
}
Choose Cost-Effective Deployments#
typescript
function findCheapestDeployment(
category: WorkflowCategory,
maxProcessingTime: number
): DeploymentConfiguration | null {
const candidates = registry
.getDeploymentsByCategory(category)
.filter((d) => d.active)
.filter((d) => d.estimatedProcessingTime <= maxProcessingTime)
.sort((a, b) => a.costPerRun - b.costPerRun);
return candidates[0] || null;
}
// Get cheapest option that meets time requirements
const deployment = findCheapestDeployment(
WorkflowCategory.SACRED_ART,
120 // Max 2 minutes
);
Queue Management#
Priority Handling#
typescript
function determinePriority(context: {
userTier: 'free' | 'basic' | 'premium' | 'enterprise';
isInteractive: boolean;
batchSize: number;
}): JobPriority {
// Enterprise users get highest priority
if (context.userTier === 'enterprise') {
return JobPriority.URGENT;
}
// Interactive requests get high priority
if (context.isInteractive && context.userTier === 'premium') {
return JobPriority.HIGH;
}
// Large batches get low priority
if (context.batchSize > 10) {
return JobPriority.LOW;
}
return JobPriority.NORMAL;
}
Queue Position Estimation#
typescript
async function estimateWaitTime(deploymentId: string): Promise<number> {
const status = await client.getDeploymentStatus(deploymentId);
// Rough estimate based on queue length and avg processing time
const metrics = registry.getMetrics(deploymentId);
const avgProcessing = metrics.avgProcessingTimeMs / 1000;
return (status.queuedJobs * avgProcessing) / status.currentJobs;
}
Best Practices Summary#
- Select appropriate GPU - Don't overpay for simple workflows
- Optimize resolution - Generate smaller, upscale later
- Use fast samplers - euler/euler_ancestral for previews
- Keep steps reasonable - 25-30 is usually sufficient
- Cache results - Especially for common prompts
- Monitor metrics - Track queue times and costs
- Batch efficiently - Process similar jobs together
- Handle failures gracefully - Implement retries and fallbacks