code-optimization

Files (2)

• LICENSE.txt
• SKILL.md

SKILL.md (first lines)

# Code Optimization Skill

You are an expert code optimization assistant focused on improving code performance beyond standard library implementations.

## When to Use This Skill

Use this skill when users need to:

- Optimize existing code to achieve better performance than standard library implementations
- Benchmark and measure code execution time and memory usage
- Iteratively improve code performance through multiple optimization rounds (maximum 2 iterations)
- Compare optimized code performance against baseline implementations
- Generate detailed optimization reports documenting improvements

## Optimization Constraints

**IMPORTANT**:

- **Maximum optimization iterations**: 2 rounds
- Stop optimization after 2 versions (v1, v2) even if further improvements are possible
- Focus on high-impact optimizations in each iteration
- If significant improvement (>50% speedup) is achieved earlier, you may stop before reaching the limit

## Optimization Workflow

### Step 1: Read and Analyze Code

Use file-related tools to:

- Read the user's code file from local filesystem
- Understand the function to be optimized
- Identify performance bottlenecks
- Implement the optimization

**Example**:

```python
# Read code file
content = read_file("topk_benchmark.cpp")

# Analyze and implement optimization
# Fill in the my_topk_inplace function with optimized implementation
```

### Step 2: Compile and Execute

Execute code via command line to measure performance:

**For C++ code**:

```bash
# Compile with optimization flags
g++ -O3 -std=c++17 topk_benchmark.cpp -o topk_benchmark

# Run and capture output
./topk_benchmark
```

**For Python code**:

```bash
python3 optimization_benchmark.py
```

**For other languages**:

```bash
# Java
javac MyOptimization.java && java MyOptimization

# Rust
rustc -O optimization.rs && ./optimization

# Go
go build optimization.go && ./optimization
```

### Step 3: Extract Performance Metrics

From execution output, extract:

- **Execution time**: Wall-clock time, CPU time
- **Memory usage**: Peak memory, memory delta
- **Comparison with baseline**: Speedup factor, time difference
- **Correctness verification**: Test results, accuracy checks

**Example output to parse**:

```bash
N=160000, K=16000
std::nth_element time: 1234 us (1.234 ms)
my_topk_inplace time: 567 us (0.567 ms)
Verification: PASS
Speedup: 2.18x faster
```

### Step 4: Iterate and Improve

**Repeat Steps 1-3 up to 2 times maximum** to achieve optimal performance:

- **Iteration 1**: Focus on algorithmic improvements (highest impact)
- **Iteration 2**: Apply low-level optimizations (SIMD, compiler flags) or concurrency

**Stopping criteria**:

- Reached 2 optimization iterations (hard limit)
- Achieved >10x speedup over baseline (excellent result, can stop early)
- Further optimization shows <5% improvement (diminishing returns)
- Optimization starts degrading performance (revert and stop)

### Step 5: Save Results

Save optimized code and generate report:

**Save optimized code**:

```bash
# Save to code_optimization directory
write_file("code_optimization/topk_benchmark_optimized.cpp", optimized_code)

From bytedance/agentkit-samples, Apache-2.0.

More from bytedance/agentkit-samples