Przejdź do treści
Biblioteka skilli
Programowanie · Analiza

interval-profiling-performance-analyzer

/interval-profiling-performance-analyzer

Profiluje programy na poziomie funkcji i metod, by wskazać wąskie gardła wydajności: czas wykonania, zużycie pamięci i częstość wywołań, z rekomendacjami dla Pythona, Javy i C/C++.

Repozytorium
Skills-4-SE ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
21.08.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
8
Skrypty
4
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.08.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co sprawdzić przed instalacją
  • 4 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/generate_visualization.py, scripts/profile_cpp.py, scripts/profile_java.py, scripts/profile_python.py

Co robi i kiedy

Profiluje programy na poziomie funkcji i metod, by wskazać wąskie gardła wydajności: czas wykonania, zużycie pamięci i częstość wywołań, z rekomendacjami dla Pythona, Javy i C/C++.

Oryginalny opis (EN)

Profile programs at the function/method level to identify performance hotspots, bottlenecks, and optimization opportunities. Records execution time, memory usage, and call frequency for each interval. Generates actionable recommendations and visualizations. Use when users need to (1) analyze program performance, (2) identify slow functions or bottlenecks, (3) optimize execution time or memory usage, (4) profile Python, Java, or C/C++ programs with test cases or workload scenarios, or (5) generate performance reports with flame graphs and recommendations.

Jak działa

  1. Workflow
  2. Common Patterns
  3. Important Notes
  4. Troubleshooting
  5. Resources
Sekcje z nagłówków SKILL.md, w oryginale · 193 linii, 783 słów
Podgląd SKILL.md
---
name: interval-profiling-performance-analyzer
description: Profile programs at the function/method level to identify performance hotspots, bottlenecks, and optimization opportunities. Records execution time, memory usage, and call frequency for each interval. Generates actionable recommendations and visualizations. Use when users need to (1) analyze program performance, (2) identify slow functions or bottlenecks, (3) optimize execution time or memory usage, (4) profile Python, Java, or C/C++ programs with test cases or workload scenarios, or (5) generate performance reports with flame graphs and recommendations.
---

# Interval Profiling & Performance Analyzer

Profile programs to identify performance bottlenecks and generate optimization recommendations with visualizations.

## Workflow

### 1. Understand Requirements

Clarify the profiling task:
- **Target program:** Which file/executable to profile?
- **Language:** Python, Java, or C/C++?
- **Test scenarios:** What workload or test cases to run?
- **Focus area:** CPU time, memory usage, or both?

### 2. Select Profiling Tool

Choose based on language and environment:

**Python:**
- Use `scripts/profile_python.py` (cProfile + tracemalloc)
- Captures function-level timing and memory usage
- No code modification required

**Java:**
- Use `scripts/profile_java.py` (Java Flight Recorder)
- Requires JDK 11+ with JFR support
- Low overhead, production-safe

**C/C++:**
- Use `scripts/profile_cpp.py` (perf or gprof)
- `perf`: Linux only, no recompilation needed
- `gprof`: Cross-platform, requires `-pg` compilation flag

For detailed tool information, see [references/profiling-tools.md](references/profiling-tools.md).

### 3. Run Profiling

Execute the appropriate profiling script:

**Python example:**
```bash
python scripts/profile_python.py target_script.py
```

**Java example:**
```bash
python scripts/profile_java.py MainClass ./bin 30
# Arguments: MainClass, classpath, duration_seconds
```

**C/C++ example:**
```bash
python scripts/profile_cpp.py ./program --tool perf
# Or use gprof (requires compilation with -pg):
python scripts/profile_cpp.py ./program --tool gprof
```

All scripts generate `profile_results.json` containing:
- **intervals:** All profiled functions with metrics
- **hotspots:** Functions exceeding 5% of execution time
- **recommendations:** Actionable optimization suggestions
- **summary:** Overall statistics

### 4. Generate Visualizations

Create interactive HTML report and flame graph data:

```bash
python scripts/generate_visualization.py profile_results.json profile_report.html
```

Outputs:
- `profile_report.html`: Interactive report with charts and recommendations
- `flamegraph.txt`: Data for flame graph generation (use flamegraph.pl if available)

### 5. Analyze Results

Review the generated report:

**Hotspots section:** Functions consuming the most time
- Focus optimization efforts here (80/20 rule)
- Look for high call counts or slow per-call times

**Recommendations section:** Specific suggestions for each hotspot
- Language-specific patterns (e.g., use StringBuilder in Java)
- Algorithm improvements (e.g., reduce call frequency)
- Data structure optimizations

**Memory usage:** Identify memory-intensive operations
- Large allocations or many small objects
- Potential memory leaks

### 6. Provide Recommendations

Summarize findings for the user:

1. **Top 3-5 hotspots** with their impact (% of total time)
2. **Specific optimization suggestions** from the recommendations
3. **Quick wins:** Easy changes with high impact
4. **Deeper optimizations:** Algorithm or architecture changes

Reference [references/optimization-patterns.md](references/optimization-patterns.md) for detailed optimization techniques.

## Common Patterns

### Pattern 1: Quick Performance Check
User wants to know "why is my program slow?"

1. Run profiling script on the program
2. Generate HTML report
3. Identify top 3 hotspots
4. Provide specific recommendations for each

### Pattern 2: Before/After Comparison
User wants to verify optimization effectiveness.

1. Profile original version → save as `before.json`
2. User applies optimizations
3. Profile optimized version → save as `after.json`
4. Compare hotspots and total execution time
5. Quantify improvement

### Pattern 3: Memory Leak Investigation
User suspects memory issues.

1. Run Python profiling (includes memory tracking)
2. Review memory_usage section in results
3. Identify functions with high memory allocation
4. Suggest using generators, object pooling, or cleanup

### Pattern 4: Multi-Scenario Profiling
User wants to profile different workloads.

1. Create test scripts for each scenario
2. Profile each scenario separately
3. Compare hotspots across scenarios
4. Identify common bottlenecks vs scenario-specific issues

## Important Notes

### Python Profiling
- Profiling adds ~10-30% overhead
- Memory tracking (tracemalloc) adds additional overhead
- Results are deterministic (not sampling-based)

### Java Profiling
- Requires JDK 11+ for JFR
- JFR has <1% overhead, safe for production
- May need to adjust duration for long-running programs
- Alternative: Use VisualVM for GUI-based profiling

### C/C++ Profiling
- **perf:** Linux only, requires debug symbols for readable output
  - Compile with `-g` flag for function names
  - May need `sudo` for system-wide profiling
- **gprof:** Requires recompilation with `-pg` flag
  - Not suitable for multithreaded programs
  - Higher overhead than perf

### Optimization Guidelines
- **Profile first, optimize second:** Don't guess where the bottleneck is
- **Focus on hotspots:** Optimizing cold code wastes time
- **Measure impact:** Verify optimizations actually help
- **Consider readability:** Don't sacrifice maintainability for minor gains
- **Algorithm > micro-optimizations:** O(n²) → O(n log n) beats loop tweaks

## Troubleshooting

**"perf not found" (C/C++):**
```bash
sudo apt-get install linux-tools-generic
```

**"JFR file not created" (Java):**
- Ensure JDK 11+ is installed
- Check program actually runs and completes
- Try increasing duration parameter

**"No profiling data" (any language):**
- Verify program actually executes (doesn't exit immediately)
- Check for errors in program output
- Ensure test scenarios exercise the code

**"Flame graph not generating":**
- Install flamegraph.pl from github.com/brendangregg/FlameGraph
- Or use the HTML report which includes bar charts

## Resources

- **[references/profiling-tools.md](references/profiling-tools.md):** Detailed tool documentation and selection guide
- **[references/optimization-patterns.md](references/optimization-patterns.md):** Language-specific optimization patterns and best practices
Pliki w paczce (8)
  • SKILL.md 7 KB
  • USAGE.txt 1 KB
  • references/optimization-patterns.md 8 KB
  • references/profiling-tools.md 4 KB
  • scripts/generate_visualization.py 9 KB
  • scripts/profile_cpp.py 8 KB
  • scripts/profile_java.py 6 KB
  • scripts/profile_python.py 5 KB

Wersje

W bazie nie ma innych skilli o nazwie interval-profiling-performance-analyzer.

Migawka bazy z 13.11.2026 · wersja paczki d1805f8fb13c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100profiling-application-performance
    Profiluje wydajność aplikacji: zużycie CPU i pamięci oraz czas wykonania, wskazując wąskie gardła i rekomendacje optymalizacji.
  • 100profiling-application-performance
    Profiluje wydajność aplikacji: zużycie CPU i pamięci oraz czas wykonania, wskazując wąskie gardła i rekomendacje optymalizacji.
  • 100perf-profile
    Wskazuje wąskie gardła wydajności, mierzy je względem budżetów i przygotowuje uporządkowane rekomendacje optymalizacji.
  • 100python-performance-optimization
    Mierzy najpierw wąskie gardła kodu Pythona przez cProfile lub py-spy, a potem ogranicza zużycie pamięci i czas działania aplikacji.
  • 100python-performance
    Profiluje kod Python pod kątem wąskich gardeł wydajności i problemów z pamięcią, np. przed wydaniem.
  • 95python-performance-optimization
    Profiluje i optymalizuje kod Pythona z cProfile i profilerami pamięci, gdy trzeba znaleźć wąskie gardła i przyspieszyć wolny kod.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.