Optymalizacja wydajności: szybkość na dużą skalę

Optymalizacja wydajności: szybkość na dużą skalę

W miarę wzrostu twojej bazy kodu i skalowania zespołu, utrzymanie wydajności Cursor staje się krytyczne. Ten przewodnik obejmuje zaawansowane techniki optymalizacji, które utrzymują responsywność Cursor nawet pod dużym obciążeniem.

Zrozumienie wąskich gardeł wydajności

Obciążenie indeksowania

Indeksowanie początkowe i przyrostowe może zużywać znaczące CPU/pamięć

Rozmiar okna kontekstu

Duże okna kontekstu spowalniają odpowiedzi AI wykładniczo

Konflikty rozszerzeń

Rozszerzenia mogą interferować z funkcjami AI Cursor

Opóźnienie sieci

Wywołania API do modeli AI mogą być ograniczane przez szybkość sieci

Optymalizacje na poziomie systemu

Zalecenia sprzętowe

Komponent	Minimum	Zalecane	Optymalne
RAM	8GB	16GB	32GB+
CPU	4 rdzenie	8 rdzeni	12+ rdzeni
Pamięć masowa	SSD 256GB	NVMe 512GB	NVMe 1TB+
Sieć	10 Mbps	50 Mbps	100+ Mbps

Dostrajanie systemu operacyjnego

macOS

# Zwiększ limity deskryptorów plików
sudo launchctl limit maxfiles 65536 200000

# Wyłącz indeksowanie Spotlight dla katalogów kodu
sudo mdutil -i off /path/to/code

# Zwiększ pamięć współdzieloną
sudo sysctl -w kern.sysv.shmmax=2147483648
sudo sysctl -w kern.sysv.shmall=524288

# Dodaj do /etc/sysctl.conf dla trwałości
echo "kern.sysv.shmmax=2147483648" | sudo tee -a /etc/sysctl.conf
echo "kern.sysv.shmall=524288" | sudo tee -a /etc/sysctl.conf

Linux

# Zwiększ limity deskryptorów plików
echo "* soft nofile 65536" | sudo tee -a /etc/security/limits.conf
echo "* hard nofile 65536" | sudo tee -a /etc/security/limits.conf

# Zwiększ obserwatorów inotify
echo "fs.inotify.max_user_watches=524288" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Optymalizuj swappiness dla rozwoju
echo "vm.swappiness=10" | sudo tee -a /etc/sysctl.conf

# Włącz transparent huge pages
echo "always" | sudo tee /sys/kernel/mm/transparent_hugepage/enabled

Windows

# Uruchom jako administrator

# Zwiększ pamięć wirtualną
wmic computersystem set AutomaticManagedPagefile=False
wmic pagefileset set InitialSize=16384,MaximumSize=32768

# Wyłącz wyszukiwanie Windows dla katalogów kodu
Set-Service WSearch -StartupType Disabled

# Optymalizuj dla wydajności
powercfg -setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

# Wyłącz niepotrzebne usługi
Set-Service "SysMain" -StartupType Disabled
Set-Service "Windows Search" -StartupType Disabled

Optymalizacja konfiguracji Cursor

Ustawienia pamięci i cache

// Konfiguracja wydajności Cursor
{
  "cursor.performance.memoryLimit": "8GB",
  "cursor.performance.maxWorkers": 6,
  "cursor.performance.cacheSize": "2GB",
  "cursor.performance.enableLazyLoading": true,
  "cursor.performance.garbageCollection": "aggressive",
  "cursor.performance.indexingThreads": 4,
  "cursor.performance.searchCacheEnabled": true,
  "cursor.performance.searchCacheSize": "1GB",
  "cursor.performance.incrementalIndexing": true,
  "cursor.performance.indexingBatchSize": 100
}

Optymalizacja indeksowania

Stwórz zoptymalizowany plik .cursorignore:

# .cursorignore - maksymalizuj wydajność indeksowania

# Zależności i pakiety
node_modules/
vendor/
packages/*/node_modules/
**/bower_components/
.pnpm-store/
.yarn/

# Wyjścia budowy
dist/
build/
out/
target/
*.min.js
*.min.css
*.map

# Duże wygenerowane pliki
coverage/
*.generated.*
*.pb.go
*.pb.js
schema.graphql
package-lock.json
yarn.lock
pnpm-lock.yaml

# Media i binaria
*.jpg
*.jpeg
*.png
*.gif
*.mp4
*.pdf
*.zip
*.tar.gz

# Logi i bazy danych
*.log
*.sqlite
*.db

# Pliki IDE i systemu
.idea/
.vscode/
.DS_Store
Thumbs.db

# Fixtures testów i dane
fixtures/
__fixtures__/
testdata/
*.snapshot
__snapshots__/

Wskazówka

Wskazówka: Uruchom find . -size +10M -type f, aby zidentyfikować duże pliki, które powinny zostać dodane do .cursorignore.

Strategie zarządzania kontekstem

Inteligentny wybór kontekstu

// Wzorce optymalizacji kontekstu

// 1. Podejście warstwowego kontekstu
class ContextOptimizer {
  // Zacznij od minimalnego kontekstu
  async getMinimalContext(task: string) {
    return {
      currentFile: this.getCurrentFile(),
      directImports: await this.getDirectImports(),
      recentChanges: this.getRecentChanges(5)
    };
  }

  // Rozwijaj w miarę potrzeb
  async expandContext(feedback: string) {
    const additionalContext = await this.analyzeNeeds(feedback);
    return this.addContext(additionalContext);
  }

  // Nigdy nie przekraczaj limitów
  async pruneContext(context: Context) {
    const tokenCount = await this.countTokens(context);
    if (tokenCount > this.maxTokens) {
      return this.intelligentPrune(context);
    }
    return context;
  }
}

Optymalizacja okna kontekstu

// Monitoruj i optymalizuj użycie kontekstu
class ContextMonitor {
  private contextHistory: ContextUsage[] = [];

  async analyzeUsage() {
    const stats = {
      averageTokens: this.calculateAverage(),
      peakUsage: this.findPeak(),
      wastedTokens: this.identifyWaste(),
      optimalSize: this.calculateOptimal()
    };

    return {
      stats,
      recommendations: this.generateRecommendations(stats)
    };
  }

  private identifyWaste() {
    // Znajdź uwzględnione pliki, które nigdy nie były referencowane
    return this.contextHistory
      .flatMap(usage => usage.includedFiles)
      .filter(file => !this.wasReferenced(file));
  }
}

Wybór modelu dla wydajności

Wybór modelu oparty na zadaniu

// Inteligentny wybór modelu
class ModelSelector {
  selectModel(task: TaskType): Model {
    switch (task.complexity) {
      case 'simple':
        // Szybki, lekki model
        return {
          model: 'claude-4-sonnet',
          temperature: 0.3,
          maxTokens: 2000
        };

      case 'medium':
        // Zrównoważony model
        return {
          model: 'claude-4-sonnet',
          temperature: 0.5,
          maxTokens: 4000
        };

      case 'complex':
        // Potężny ale wolniejszy
        return {
          model: 'claude-4.1-opus',
          temperature: 0.7,
          maxTokens: 8000
        };

      case 'analysis':
        // Model długiego kontekstu
        return {
          model: 'gemini-2.5-pro',
          temperature: 0.4,
          maxTokens: 100000
        };
    }
  }
}

Kompromisy wydajność vs jakość

Typ zadania	Wybór modelu	Czas odpowiedzi	Jakość	Koszt tokenów
Szybkie poprawki	Sonnet 4	poniżej 2s	Dobra	Niski
Rozwój funkcji	Sonnet 4	2-5s	Bardzo dobra	Średni
Złożona refaktoryzacja	Opus 4	5-10s	Doskonała	Wysoki
Analiza bazy kodu	Gemini 2.5	3-8s	Bardzo dobra	Średni
Głębokie debugowanie	o3	10-20s	Doskonała	Bardzo wysoki

Zarządzanie rozszerzeniami

Identyfikacja rozszerzeń wpływających na wydajność

# Debuguj problemy wydajności rozszerzeń
cursor --inspect-brk-extensions 9229

# Uruchom w trybie bezpiecznym (bez rozszerzeń)
cursor --disable-extensions

# Aby znaleźć problematyczne rozszerzenia:
# 1. Wyłącz wszystkie rozszerzenia przez UI
# 2. Włączaj je po jednym, aby wyizolować problemy

Lista kontrolna optymalizacji rozszerzeń

• Wyłącz nieużywane rozszerzenia
• Sprawdź konflikty rozszerzeń z funkcjami AI
• Zaktualizuj wszystkie rozszerzenia do najnowszych wersji
• Usuń rozszerzenia z duplikującą funkcjonalnością
• Skonfiguruj rozszerzenia do lazy-load

Zalecana konfiguracja rozszerzeń

{
  // Wyłącz rozszerzenia konfliktujące z Cursor AI
  "extensions.disabled": [
    "github.copilot",
    "tabnine.tabnine-vscode",
    "visualstudioexptteam.vscodeintellicode"
  ],

  // Lazy load ciężkich rozszerzeń
  "extensions.experimental.affinity": {
    "vscodevim.vim": 1,
    "dbaeumer.vscode-eslint": 2,
    "esbenp.prettier-vscode": 2
  }
}

Optymalizacja sieci

Buforowanie odpowiedzi API

// Implementuj inteligentne buforowanie
class ResponseCache {
  private cache = new Map<string, CachedResponse>();
  private readonly TTL = 5 * 60 * 1000; // 5 minut

  async getCachedOrFetch(
    prompt: string,
    fetcher: () => Promise<Response>
  ): Promise<Response> {
    const key = this.hashPrompt(prompt);
    const cached = this.cache.get(key);

    if (cached && !this.isExpired(cached)) {
      return cached.response;
    }

    const response = await fetcher();
    this.cache.set(key, {
      response,
      timestamp: Date.now()
    });

    return response;
  }
}

Pooling połączeń

{
  "cursor.network.connectionPool": {
    "maxSockets": 10,
    "maxFreeSockets": 5,
    "timeout": 60000,
    "keepAlive": true,
    "keepAliveMsecs": 30000
  },

  "cursor.network.http2": {
    "enabled": true,
    "maxConcurrentStreams": 100
  }
}

Monitorowanie i profilowanie

Dashboard metryk wydajności

// Monitorowanie wydajności w czasie rzeczywistym
class PerformanceMonitor {
  private metrics = {
    indexingTime: new MetricCollector('indexing'),
    searchLatency: new MetricCollector('search'),
    aiResponseTime: new MetricCollector('ai_response'),
    memoryUsage: new MetricCollector('memory'),
    cpuUsage: new MetricCollector('cpu')
  };

  startMonitoring() {
    // Zbieraj metryki co 30 sekund
    setInterval(() => {
      this.collectMetrics();
      this.analyzeThresholds();
      this.generateAlerts();
    }, 30000);
  }

  private analyzeThresholds() {
    const alerts = [];

    if (this.metrics.memoryUsage.current > 0.9) {
      alerts.push('Wykryto wysokie użycie pamięci');
    }

    if (this.metrics.aiResponseTime.p95 > 10000) {
      alerts.push('Wykryto wolne odpowiedzi AI');
    }

    return alerts;
  }
}

Logowanie wydajności

// Włącz logowanie wydajności
{
  "cursor.telemetry.performanceLogging": true,
  "cursor.telemetry.logLevel": "verbose",
  "cursor.telemetry.logPath": "~/.cursor/performance.log",
  "cursor.telemetry.metrics": [
    "indexing",
    "search",
    "completion",
    "memory",
    "network"
  ]
}

Scenariusze wydajności z prawdziwego świata

Scenariusz 1: monorepo z 5M+ LOC

Zespół zoptymalizował swoje masywne monorepo:

1. Podzielenie bazy kodu

   • Podzielone na 12 logicznych workspace
   • Tylko 2-3 aktywne jednocześnie
   • Wynik: 75% redukcja użycia pamięci

2. Optymalizacja indeksowania

   • Agresywne reguły .cursorignore
   • Indeksowanie przyrostowe co 5 minut
   • Wynik: początkowy indeks z 45min do 8min

3. Strategia kontekstu

   • Podejście warstwowego kontekstu
   • Inteligentne włączanie plików
   • Wynik: 60% szybsze odpowiedzi AI

4. Wybór modelu

   • Sonnet do 90% zadań
   • Opus tylko do architektury
   • Wynik: 40% redukcja kosztów

Scenariusz 2: system high-frequency trading

Optymalizacje środowiska krytycznego dla wydajności:

// Konfiguracja ultra-niskich opóźnień
{
  "cursor.performance": {
    "mode": "performance",
    "disableAnimations": true,
    "disableTelemetry": true,
    "minimalUI": true,
    "aggressiveCaching": true,
    "preloadModels": ["claude-4-sonnet"],
    "dedicatedWorkers": 8
  }
}

// Wyniki:
// - Uzupełnianie tabulatora: poniżej 50ms
// - Edycje inline: poniżej 100ms
// - Odpowiedzi agenta: poniżej 2s średnio

Rozwiązywanie problemów wydajności

Lista kontrolna diagnostyczna

Wysokie użycie CPU

1. Sprawdź status indeksowania
2. Przejrzyj aktywność rozszerzeń
3. Monitoruj procesy w tle
4. Zweryfikuj brak nieskończonych pętli w regułach

Wolne odpowiedzi

1. Przetestuj szybkość sieci
2. Sprawdź rozmiar kontekstu
3. Zweryfikuj dostępność modelu
4. Przejrzyj limity API

Wycieki pamięci

1. Regularnie restartuj Cursor
2. Wyczyść katalogi cache
3. Zaktualizuj do najnowszej wersji
4. Zgłoś uporczywe problemy

Zawieszanie indeksowania

1. Sprawdź .cursorignore
2. Usuń problematyczne pliki
3. Zresetuj bazę danych indeksu
4. Zwiększ ustawienia timeout

Procedura resetowania wydajności

#!/bin/bash
# Pełny reset wydajności

# 1. Zamknij Cursor
killall Cursor

# 2. Wyczyść cache
rm -rf ~/.cursor/Cache
rm -rf ~/.cursor/CachedData
rm -rf ~/.cursor/GPUCache

# 3. Zresetuj indeksy
rm -rf ~/.cursor/IndexedDB

# 4. Wyczyść pamięć workspace
rm -rf ~/.cursor/workspaceStorage

# 5. Uruchom ponownie ze świeżym profilem
cursor --user-data-dir ~/.cursor-fresh

Podsumowanie najlepszych praktyk

1. Profiluj przed optymalizacją

   • Zmierz rzeczywiste wąskie gardła
   • Nie optymalizuj przedwcześnie
   • Skup się na obszarach największego wpływu

2. Stopniowe ulepszenia

   • Wprowadzaj po jednej zmianie naraz
   • Mierz wpływ każdej zmiany
   • Dokumentuj co działa

3. Standardy zespołowe

   • Udostępniaj konfiguracje wydajności
   • Ustal limity rozmiaru kontekstu
   • Monitoruj metryki agregowane

4. Regularna konserwacja

   • Cotygodniowe czyszczenie cache
   • Miesięczny przegląd rozszerzeń
   • Kwartalny audyt konfiguracji

Uwaga

Ostrzeżenie: Nadmierna optymalizacja może zmniejszyć funkcjonalność. Zawsze równoważ wydajność z funkcjami produktywności, których rzeczywiście potrzebujesz.

Następne kroki

1. Uruchom audyt wydajności - użyj listy kontrolnej diagnostycznej
2. Zaimplementuj szybkie wygrane - zacznij od optymalizacji .cursorignore
3. Monitoruj metryki - ustaw śledzenie wydajności
4. Kontynuuj do prywatności i bezpieczeństwa - upewnij się, że optymalizacje nie naruszają bezpieczeństwa

Pamiętaj: najszybszy Cursor to ten skonfigurowany dla twojego konkretnego przepływu pracy. Nie ma rozwiązania uniwersalnego—eksperymentuj i mierz, aby znaleźć swoją optymalną konfigurację.