Identify computational bottlenecks, analyze parallel scaling, estimate memory requirements, and generate optimization recommendations for materials simulations — parse timing logs to find dominant phases (solver, assembly, I/O), evaluate strong and weak scaling efficiency, profile memory from mesh and field parameters, and detect bottlenecks with actionable fix suggestions. Use when a simulation is running slower than expected, investigating MPI scaling efficiency, planning HPC resource allocation, deciding whether to tune the preconditioner or reduce I/O frequency, or estimating if a problem fits in available RAM, even if the user only says "my simulation is too slow" or "how many nodes do I need."
Provide tools to analyze simulation performance, identify bottlenecks, and recommend optimization strategies for computational materials science simulations.
Requirements
Python 3.10+
No external dependencies (uses Python standard library only)
Works on Linux, macOS, and Windows
Inputs to Gather
Before running profiling scripts, collect from the user:
Input
Description
Example
Simulation log
Log file with timing information
simulation.log
Scaling data
JSON with multi-run performance data
scaling_data.json
Simulation parameters
JSON with mesh, fields, solver config
params.json
Available memory
System memory in GB (optional)
16.0
Decision Guidance
When to Use Each Script
Need to identify slow phases?
├── YES → Use timing_analyzer.py
│ └── Parse simulation logs for timing data
│
Need to understand parallel performance?
├── YES → Use scaling_analyzer.py
│ └── Analyze strong or weak scaling efficiency
│
Need to estimate memory requirements?
├── YES → Use memory_profiler.py
│ └── Estimate memory from problem parameters
│
Need optimization recommendations?
└── YES → Use bottleneck_detector.py
└── Combine analyses and get actionable advice
Choosing Analysis Thresholds
Metric
Good
Acceptable
Poor
Phase dominance
<30%
30-50%
>50%
Parallel efficiency
>0.80
0.70-0.80
<0.70
Memory usage
<60%
60-80%
>80%
Script Outputs (JSON Fields)
All scripts wrap their payload in a top-level object with two keys: inputs and results. The fields below live under results.
The detector applies per-type dominance thresholds: solver/assembly/general phases are flagged above 50% of runtime; I/O phases above 30%. Any flagged phase above 70% is reported as high severity.
Scenario
Meaning
Action
Solver >50% (high >70%)
Solver-dominated
Tune preconditioner, check tolerance
Assembly >50%
Assembly-dominated
Cache matrices, vectorize, parallelize
I/O >30%
I/O-dominated
Reduce frequency, use parallel I/O
Balanced (below thresholds)
Well-balanced
Look for algorithmic improvements
Scaling Analysis
Efficiency
Meaning
Action
>0.80
Excellent scaling
Continue scaling up
0.70-0.80
Good scaling
Monitor at larger scales
0.50-0.70
Poor scaling
Investigate communication/load balance
<0.50
Very poor scaling
Reduce processor count or redesign
Memory Profile
Usage
Meaning
Action
<60% available
Safe
No action needed
60-80% available
Moderate
Monitor, consider optimization
>80% available
High
Reduce resolution or increase processors
>100% available
Exceeds capacity
Must reduce problem size
The estimate follows the three-term formula Total = Field + Solver Workspace + Matrix Storage (see references/profiling_guide.md). Matrix storage and solver workspace depend on solver.type:
iterative (default): sparse matrix (default 7-point stencil, override via solver.stencil_nnz) plus workspace vectors.
direct: sparse matrix scaled by a conservative fill-in factor (solver.fillin_factor, default 10) to reflect factorization fill-in — a direct solver estimates far more memory than an iterative one for the same mesh.
matrix-free: no assembled matrix; workspace vectors only.
The estimate is intentionally conservative so a "will it fit in RAM?" decision does not silently under-estimate.
Error Handling
Error
Cause
Resolution
Log file not found
Invalid path
Verify log file path
No timing data found
Pattern mismatch
Provide custom pattern with --pattern
At least 2 runs required
Insufficient data
Provide more scaling runs
Missing required parameters
Incomplete params
Add mesh and fields to params file
Optimization Strategies by Bottleneck Type
Solver Bottlenecks
Use algebraic multigrid (AMG) preconditioner
Tighten solver tolerance if over-solving
Consider direct solver for small problems
Profile matrix assembly vs solve time
Assembly Bottlenecks
Cache element matrices if geometry is static
Use vectorized assembly routines
Consider matrix-free methods
Parallelize assembly with coloring
I/O Bottlenecks
Reduce output frequency
Use parallel I/O (HDF5, MPI-IO)
Write to fast scratch storage
Compress output data
Scaling Bottlenecks
Investigate communication overhead
Check for load imbalance
Reduce synchronization points
Use asynchronous communication
Consider hybrid MPI+OpenMP
Memory Bottlenecks
Reduce mesh resolution
Use iterative solver (lower memory than direct)
Enable out-of-core computation
Increase number of processors
Use single precision where appropriate
Verification checklist
Before trusting a profiling result or acting on a recommendation, record the concrete evidence below:
Confirmed timing_analyzer.py actually matched entries — results.phases is non-empty and results.total_time > 0; if a custom --pattern was used and results.message/suggested_patterns appeared, the pattern was fixed and re-run (an empty phases list silently looks like a fast simulation).
Cross-checked that the sum of phases[].percentage is ~100% and that named phases cover the wall-clock time — unaccounted-for time means missing log lines, not a balanced run.
For scaling claims, used >=2 runs spanning a real processor range and recorded results.average_efficiency and results.efficiency_threshold_processors from scaling_analyzer.py; verified the --type (strong vs weak) matches how the runs were generated (fixed total size vs fixed work-per-rank).
Recorded the memory breakdown from memory_profiler.py (field_memory_gb, solver_workspace_gb, matrix_storage_gb, total_memory_gb) and confirmed solver.type (iterative / direct / matrix-free) matches the real solver — a direct solve carries the ~10x fill-in factor and a wrong type makes the "fits in RAM?" answer unsafe.
Checked results.warnings and compared total_memory_gb (and per_process_gb) against the actual --available-gb; treated >80% as the documented "high" band, not a pass.
For each bottleneck_detector.py recommendation, confirmed the driving bottleneck (its category, value, and threshold) is consistent with the timing/scaling/memory inputs that were actually supplied — recommendations only reflect the JSON files passed via --timing/--scaling/--memory.
After implementing an optimization, re-ran the relevant analyzer and recorded the before/after value to confirm the bottleneck actually moved (re-profile step of the workflow).
Common pitfalls & rationalizations
Tempting shortcut
Why it's wrong / what to do
"timing_analyzer.py returned no bottlenecks, so the run is balanced."
An empty/low result is often a pattern mismatch — phases may be empty or partial. Verify total_time matches wall-clock and that phase percentages sum to ~100% before concluding "balanced".
"Two runs scaled fine, so it scales."
Two points only give an average efficiency; they cannot reveal where efficiency falls off. Add more processor counts and check efficiency_threshold_processors, and confirm you used the correct --type (strong vs weak).
"Iterative vs direct is just a flag; memory is about the same."
memory_profiler.py applies a conservative ~10x fill-in factor for direct and stores no matrix for matrix-free. Setting the wrong solver.type can under-estimate RAM by an order of magnitude — set it to the real solver.
"It fits in --available-gb total, so we're fine."
The relevant number for an MPI run is per_process_gb against per-node/per-rank RAM, and >80% of total already triggers a warning. Check the per-process figure and the warnings list, not just the total.
"I/O is under 50%, so I/O isn't the bottleneck."
I/O is flagged at the lower 30% threshold, not 50%. A 30-50% I/O phase is a real bottleneck the detector reports — reduce output frequency or use parallel I/O.
"The recommendation says tune the preconditioner, so the solver is the problem."
Recommendations are only as complete as the JSON you passed in. If --scaling/--memory were omitted, those bottlenecks are simply invisible — feed all available analyses before trusting the priority ranking.
Security
Input Validation
User-supplied --pattern regex values are validated for length (500 chars max) and rejected if they contain constructs prone to catastrophic backtracking (ReDoS)
Scaling data entries are validated for finite time values, integer processor counts, and bounded run count (10,000 max)
available_gb is validated as a positive finite number; mesh dimensions and field parameters are validated as positive integers
--type (scaling type) is validated against a fixed allowlist (strong, weak)
All loaded JSON files must have an object (dict) as root element
File Access
timing_analyzer.py reads a single log file specified by --log; log files are capped at 500 MB and rejected before parsing
scaling_analyzer.py, memory_profiler.py, and bottleneck_detector.py read JSON files capped at 100 MB
Phase names extracted from log files are truncated to 200 characters and stripped of control characters to prevent prompt-injection payloads from propagating into agent context
No scripts write to the filesystem; all output goes to stdout
Tool Restrictions
Read: Used to inspect script source, references, simulation logs, and result files
Write: Used to save profiling reports or optimization recommendations; writes are scoped to the user's working directory
Grep/Glob: Used to locate log files, result files, and search references
The skill's allowed-tools excludes Bash to prevent the agent from executing arbitrary commands when processing untrusted simulation logs or result files
Safety Measures
No eval(), exec(), or dynamic code generation
All subprocess calls use explicit argument lists (no shell=True)
Reduced tool surface (no Bash) limits the agent to read/write operations only
Phase names and diagnostic strings are sanitized before inclusion in output to prevent injection
Limitations
Log parsing: Depends on pattern matching; may miss unusual formats
Scaling analysis: Requires at least 2 runs for meaningful results
Memory estimation: Approximate; actual usage may vary
Recommendations: General guidance; may need domain-specific tuning
References
references/profiling_guide.md - Profiling concepts and interpretation
See CHANGELOG.md for the authoritative, dated release history.
1---2name: performance-profiling3description: >4 Identify computational bottlenecks, analyze parallel scaling, estimate memory5 requirements, and generate optimization recommendations for materials6 simulations — parse timing logs to find dominant phases (solver, assembly,7 I/O), evaluate strong and weak scaling efficiency, profile memory from mesh8 and field parameters, and detect bottlenecks with actionable fix suggestions.9 Use when a simulation is running slower than expected, investigating MPI10 scaling efficiency, planning HPC resource allocation, deciding whether to11 tune the preconditioner or reduce I/O frequency, or estimating if a problem12 fits in available RAM, even if the user only says "my simulation is too13 slow" or "how many nodes do I need."14allowed-tools: Read, Write, Grep, Glob15metadata:16 source: https://skillmd.com/skills/heshamfs/performance-profiling17 author: HeshamFS18 version: "1.2.2"19 security_tier: medium20 security_reviewed: true21 tested_with:22 - claude-code23 last_evaluated: "2026-06-24"24 eval_cases: 525 last_reviewed: "2026-06-23"26 standards:27 - "Amdahl (1967), serial-fraction speedup law S(N)=1/(f+(1-f)/N)"28 - "Gustafson (1988), scaled speedup law S(N)=N-f(N-1)"29 - "Gropp, Lusk & Skjellum (1999), Using MPI (parallel scaling and communication)"30 - "Saad (2003), Iterative Methods for Sparse Linear Systems (solver/preconditioner choice)"31 - "Karypis & Kumar (1998), METIS multilevel graph partitioning (load balancing)"32---3334# Performance Profiling3536## Goal3738Provide tools to analyze simulation performance, identify bottlenecks, and recommend optimization strategies for computational materials science simulations.3940## Requirements4142- Python 3.10+43- No external dependencies (uses Python standard library only)44- Works on Linux, macOS, and Windows4546## Inputs to Gather4748Before running profiling scripts, collect from the user:4950| Input | Description | Example |51|-------|-------------|---------|52| Simulation log | Log file with timing information | `simulation.log` |53| Scaling data | JSON with multi-run performance data | `scaling_data.json` |54| Simulation parameters | JSON with mesh, fields, solver config | `params.json` |55| Available memory | System memory in GB (optional) | `16.0` |5657## Decision Guidance5859### When to Use Each Script6061```62Need to identify slow phases?63├── YES → Use timing_analyzer.py64│ └── Parse simulation logs for timing data65│66Need to understand parallel performance?67├── YES → Use scaling_analyzer.py68│ └── Analyze strong or weak scaling efficiency69│70Need to estimate memory requirements?71├── YES → Use memory_profiler.py72│ └── Estimate memory from problem parameters73│74Need optimization recommendations?75└── YES → Use bottleneck_detector.py76 └── Combine analyses and get actionable advice77```7879### Choosing Analysis Thresholds8081| Metric | Good | Acceptable | Poor |82|--------|------|------------|------|83| Phase dominance | <30% | 30-50% | >50% |84| Parallel efficiency | >0.80 | 0.70-0.80 | <0.70 |85| Memory usage | <60% | 60-80% | >80% |8687## Script Outputs (JSON Fields)8889All scripts wrap their payload in a top-level object with two keys: `inputs` and `results`. The fields below live under `results`.9091| Script | Key Outputs (under `results`) |92|--------|-------------|93| `timing_analyzer.py` | `results.phases`, `results.slowest_phase`, `results.total_time` |94| `scaling_analyzer.py` | `results.results`, `results.efficiency_threshold_processors`, `results.average_efficiency`, `results.baseline` |95| `memory_profiler.py` | `results.total_memory_gb`, `results.per_process_gb`, `results.field_memory_gb`, `results.solver_workspace_gb`, `results.matrix_storage_gb`, `results.warnings` |96| `bottleneck_detector.py` | `results.bottlenecks`, `results.recommendations` |9798## Workflow99100### Complete Profiling Workflow1011021. **Analyze timing** from simulation logs1032. **Analyze scaling** from multi-run data (if available)1043. **Profile memory** from simulation parameters1054. **Detect bottlenecks** and get recommendations1065. **Implement optimizations** based on recommendations1076. **Re-profile** to verify improvements108109### Quick Profiling (Timing Only)1101111. **Run timing analyzer** on simulation log1122. **Identify dominant phases** (>50% of runtime)1133. **Apply targeted optimizations** to dominant phases114115## CLI Examples116117### Timing Analysis118119```bash120# Basic timing analysis121python3 scripts/timing_analyzer.py \122 --log simulation.log \123 --json124125# Custom timing pattern126python3 scripts/timing_analyzer.py \127 --log simulation.log \128 --pattern 'Step\s+(\w+)\s+took\s+([\d.]+)s' \129 --json130```131132### Scaling Analysis133134```bash135# Strong scaling (fixed problem size)136python3 scripts/scaling_analyzer.py \137 --data scaling_data.json \138 --type strong \139 --json140141# Weak scaling (constant work per processor)142python3 scripts/scaling_analyzer.py \143 --data scaling_data.json \144 --type weak \145 --json146```147148### Memory Profiling149150```bash151# Estimate memory requirements152python3 scripts/memory_profiler.py \153 --params simulation_params.json \154 --available-gb 16.0 \155 --json156```157158### Bottleneck Detection159160```bash161# Detect bottlenecks from timing only162python3 scripts/bottleneck_detector.py \163 --timing timing_results.json \164 --json165166# Comprehensive analysis with all inputs167python3 scripts/bottleneck_detector.py \168 --timing timing_results.json \169 --scaling scaling_results.json \170 --memory memory_results.json \171 --json172```173174## Conversational Workflow Example175176**User**: My simulation is taking too long. Can you help me identify what's slow?177178**Agent workflow**:1791. Ask for simulation log file1802. Run timing analyzer:181 ```bash182 python3 scripts/timing_analyzer.py --log simulation.log --json183 ```1843. Interpret results (the detector flags solver/assembly phases above 50% and I/O phases above 30%; >70% is high severity):185 - If solver dominates (>50%, high above 70%): Recommend preconditioner tuning186 - If assembly dominates (>50%): Recommend caching or vectorization187 - If I/O dominates (>30%): Recommend reducing output frequency1884. If user has multi-run data, analyze scaling:189 ```bash190 python3 scripts/scaling_analyzer.py --data scaling.json --type strong --json191 ```1925. Generate comprehensive recommendations:193 ```bash194 python3 scripts/bottleneck_detector.py --timing timing.json --scaling scaling.json --json195 ```196197## Interpretation Guidance198199### Timing Analysis200201The detector applies per-type dominance thresholds: solver/assembly/general phases are flagged above **50%** of runtime; I/O phases above **30%**. Any flagged phase above **70%** is reported as high severity.202203| Scenario | Meaning | Action |204|----------|---------|--------|205| Solver >50% (high >70%) | Solver-dominated | Tune preconditioner, check tolerance |206| Assembly >50% | Assembly-dominated | Cache matrices, vectorize, parallelize |207| I/O >30% | I/O-dominated | Reduce frequency, use parallel I/O |208| Balanced (below thresholds) | Well-balanced | Look for algorithmic improvements |209210### Scaling Analysis211212| Efficiency | Meaning | Action |213|------------|---------|--------|214| >0.80 | Excellent scaling | Continue scaling up |215| 0.70-0.80 | Good scaling | Monitor at larger scales |216| 0.50-0.70 | Poor scaling | Investigate communication/load balance |217| <0.50 | Very poor scaling | Reduce processor count or redesign |218219### Memory Profile220221| Usage | Meaning | Action |222|-------|---------|--------|223| <60% available | Safe | No action needed |224| 60-80% available | Moderate | Monitor, consider optimization |225| >80% available | High | Reduce resolution or increase processors |226| >100% available | Exceeds capacity | Must reduce problem size |227228The estimate follows the three-term formula `Total = Field + Solver Workspace + Matrix Storage` (see `references/profiling_guide.md`). Matrix storage and solver workspace depend on `solver.type`:229230- `iterative` (default): sparse matrix (default 7-point stencil, override via `solver.stencil_nnz`) plus workspace vectors.231- `direct`: sparse matrix scaled by a conservative fill-in factor (`solver.fillin_factor`, default 10) to reflect factorization fill-in — a direct solver estimates far more memory than an iterative one for the same mesh.232- `matrix-free`: no assembled matrix; workspace vectors only.233234The estimate is intentionally conservative so a "will it fit in RAM?" decision does not silently under-estimate.235236## Error Handling237238| Error | Cause | Resolution |239|-------|-------|------------|240| `Log file not found` | Invalid path | Verify log file path |241| `No timing data found` | Pattern mismatch | Provide custom pattern with --pattern |242| `At least 2 runs required` | Insufficient data | Provide more scaling runs |243| `Missing required parameters` | Incomplete params | Add mesh and fields to params file |244245## Optimization Strategies by Bottleneck Type246247### Solver Bottlenecks248- Use algebraic multigrid (AMG) preconditioner249- Tighten solver tolerance if over-solving250- Consider direct solver for small problems251- Profile matrix assembly vs solve time252253### Assembly Bottlenecks254- Cache element matrices if geometry is static255- Use vectorized assembly routines256- Consider matrix-free methods257- Parallelize assembly with coloring258259### I/O Bottlenecks260- Reduce output frequency261- Use parallel I/O (HDF5, MPI-IO)262- Write to fast scratch storage263- Compress output data264265### Scaling Bottlenecks266- Investigate communication overhead267- Check for load imbalance268- Reduce synchronization points269- Use asynchronous communication270- Consider hybrid MPI+OpenMP271272### Memory Bottlenecks273- Reduce mesh resolution274- Use iterative solver (lower memory than direct)275- Enable out-of-core computation276- Increase number of processors277- Use single precision where appropriate278279## Verification checklist280281Before trusting a profiling result or acting on a recommendation, record the concrete evidence below:282283- [ ] Confirmed `timing_analyzer.py` actually matched entries — `results.phases` is non-empty and `results.total_time` > 0; if a custom `--pattern` was used and `results.message`/`suggested_patterns` appeared, the pattern was fixed and re-run (an empty `phases` list silently looks like a fast simulation).284- [ ] Cross-checked that the sum of `phases[].percentage` is ~100% and that named phases cover the wall-clock time — unaccounted-for time means missing log lines, not a balanced run.285- [ ] For scaling claims, used >=2 runs spanning a real processor range and recorded `results.average_efficiency` and `results.efficiency_threshold_processors` from `scaling_analyzer.py`; verified the `--type` (strong vs weak) matches how the runs were generated (fixed total size vs fixed work-per-rank).286- [ ] Recorded the memory breakdown from `memory_profiler.py` (`field_memory_gb`, `solver_workspace_gb`, `matrix_storage_gb`, `total_memory_gb`) and confirmed `solver.type` (iterative / direct / matrix-free) matches the real solver — a direct solve carries the ~10x fill-in factor and a wrong type makes the "fits in RAM?" answer unsafe.287- [ ] Checked `results.warnings` and compared `total_memory_gb` (and `per_process_gb`) against the actual `--available-gb`; treated >80% as the documented "high" band, not a pass.288- [ ] For each `bottleneck_detector.py` recommendation, confirmed the driving `bottleneck` (its `category`, `value`, and `threshold`) is consistent with the timing/scaling/memory inputs that were actually supplied — recommendations only reflect the JSON files passed via `--timing`/`--scaling`/`--memory`.289- [ ] After implementing an optimization, re-ran the relevant analyzer and recorded the before/after `value` to confirm the bottleneck actually moved (re-profile step of the workflow).290291## Common pitfalls & rationalizations292293| Tempting shortcut | Why it's wrong / what to do |294|-------------------|------------------------------|295| "`timing_analyzer.py` returned no bottlenecks, so the run is balanced." | An empty/low result is often a pattern mismatch — `phases` may be empty or partial. Verify `total_time` matches wall-clock and that phase percentages sum to ~100% before concluding "balanced". |296| "Two runs scaled fine, so it scales." | Two points only give an average efficiency; they cannot reveal where efficiency falls off. Add more processor counts and check `efficiency_threshold_processors`, and confirm you used the correct `--type` (strong vs weak). |297| "Iterative vs direct is just a flag; memory is about the same." | `memory_profiler.py` applies a conservative ~10x fill-in factor for `direct` and stores no matrix for `matrix-free`. Setting the wrong `solver.type` can under-estimate RAM by an order of magnitude — set it to the real solver. |298| "It fits in `--available-gb` total, so we're fine." | The relevant number for an MPI run is `per_process_gb` against per-node/per-rank RAM, and >80% of total already triggers a warning. Check the per-process figure and the `warnings` list, not just the total. |299| "I/O is under 50%, so I/O isn't the bottleneck." | I/O is flagged at the lower **30%** threshold, not 50%. A 30-50% I/O phase is a real bottleneck the detector reports — reduce output frequency or use parallel I/O. |300| "The recommendation says tune the preconditioner, so the solver is the problem." | Recommendations are only as complete as the JSON you passed in. If `--scaling`/`--memory` were omitted, those bottlenecks are simply invisible — feed all available analyses before trusting the priority ranking. |301302## Security303304### Input Validation305- User-supplied `--pattern` regex values are validated for length (500 chars max) and rejected if they contain constructs prone to catastrophic backtracking (ReDoS)306- Scaling data entries are validated for finite time values, integer processor counts, and bounded run count (10,000 max)307- `available_gb` is validated as a positive finite number; mesh dimensions and field parameters are validated as positive integers308- `--type` (scaling type) is validated against a fixed allowlist (`strong`, `weak`)309- All loaded JSON files must have an object (dict) as root element310311### File Access312- `timing_analyzer.py` reads a single log file specified by `--log`; log files are capped at 500 MB and rejected before parsing313- `scaling_analyzer.py`, `memory_profiler.py`, and `bottleneck_detector.py` read JSON files capped at 100 MB314- Phase names extracted from log files are truncated to 200 characters and stripped of control characters to prevent prompt-injection payloads from propagating into agent context315- No scripts write to the filesystem; all output goes to stdout316317### Tool Restrictions318- **Read**: Used to inspect script source, references, simulation logs, and result files319- **Write**: Used to save profiling reports or optimization recommendations; writes are scoped to the user's working directory320- **Grep/Glob**: Used to locate log files, result files, and search references321- The skill's `allowed-tools` excludes `Bash` to prevent the agent from executing arbitrary commands when processing untrusted simulation logs or result files322323### Safety Measures324- No `eval()`, `exec()`, or dynamic code generation325- All subprocess calls use explicit argument lists (no `shell=True`)326- Reduced tool surface (no Bash) limits the agent to read/write operations only327- Phase names and diagnostic strings are sanitized before inclusion in output to prevent injection328329## Limitations330331- **Log parsing**: Depends on pattern matching; may miss unusual formats332- **Scaling analysis**: Requires at least 2 runs for meaningful results333- **Memory estimation**: Approximate; actual usage may vary334- **Recommendations**: General guidance; may need domain-specific tuning335336## References337338- `references/profiling_guide.md` - Profiling concepts and interpretation339- `references/optimization_strategies.md` - Detailed optimization approaches340341## Version History342343See `CHANGELOG.md` for the authoritative, dated release history.
Run npx get-skill add heshamfs/performance-profiling in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
Identify computational bottlenecks, analyze parallel scaling, estimate memory requirements, and generate optimization recommendations for materials simulations — parse timing logs to find dominant phases (solver, assembly, I/O), evaluate strong and weak scaling efficiency, profile memory from mesh and field parameters, and detect bottlenecks with actionable fix suggestions. Use when a simulation is running slower than expected, investigating MPI scaling efficiency, planning HPC resource allocation, deciding whether to tune the preconditioner or reduce I/O frequency, or estimating if a problem fits in available RAM, even if the user only says "my simulation is too slow" or "how many nodes do I need." It is listed under Productivity on SkillMD.
This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. Capability flags: executes scripts. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
HeshamFS (@heshamfs) published this skill. Their other Agent Skills are listed on their SkillMD profile.