Initialized MiniProfiler project
- Contains the host code with a protocol implementation, data analyser and web-based visualiser
This commit is contained in:
Atharva Sawant
58
.gitignore
vendored
Normal file
58
.gitignore
vendored
Normal file
@@ -0,0 +1,58 @@
|
||||
# Python
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
*.so
|
||||
.Python
|
||||
build/
|
||||
develop-eggs/
|
||||
dist/
|
||||
downloads/
|
||||
eggs/
|
||||
.eggs/
|
||||
lib/
|
||||
lib64/
|
||||
parts/
|
||||
sdist/
|
||||
var/
|
||||
wheels/
|
||||
*.egg-info/
|
||||
.installed.cfg
|
||||
*.egg
|
||||
|
||||
# Virtual environments
|
||||
venv/
|
||||
ENV/
|
||||
env/
|
||||
|
||||
# IDE
|
||||
.vscode/
|
||||
.idea/
|
||||
*.swp
|
||||
*.swo
|
||||
*~
|
||||
|
||||
# Testing
|
||||
.pytest_cache/
|
||||
.coverage
|
||||
htmlcov/
|
||||
*.bin
|
||||
*.json
|
||||
|
||||
# OS
|
||||
.DS_Store
|
||||
Thumbs.db
|
||||
|
||||
# Embedded
|
||||
*.o
|
||||
*.elf
|
||||
*.hex
|
||||
*.bin
|
||||
*.map
|
||||
*.lst
|
||||
*.d
|
||||
*.su
|
||||
|
||||
# Build
|
||||
embedded/build/
|
||||
embedded/.build/
|
||||
208
README.md
Normal file
208
README.md
Normal file
@@ -0,0 +1,208 @@
|
||||
# MiniProfiler
|
||||
|
||||
Real-time profiling tool for embedded STM32 applications using GCC's `-finstrument-functions` feature.
|
||||
|
||||
## Features
|
||||
|
||||
- **Embedded Profiling**: Automatic function instrumentation using GCC hooks
|
||||
- **Real-time Visualization**: Live flame graphs, timelines, and statistics
|
||||
- **Low Overhead**: DMA-based UART transmission, <5% performance impact
|
||||
- **Symbol Resolution**: Automatic function name resolution from ELF/DWARF debug info
|
||||
- **Web Interface**: Modern, responsive web UI with multiple visualization modes
|
||||
|
||||
## Architecture
|
||||
|
||||
MiniProfiler consists of two main components:
|
||||
|
||||
### 1. Embedded Module (STM32)
|
||||
- Uses `__cyg_profile_func_enter/exit` hooks to capture function calls
|
||||
- Lock-free ring buffer for storing profiling data
|
||||
- UART/Serial communication with host
|
||||
- Minimal memory footprint (~2-10KB)
|
||||
|
||||
### 2. Host Application (Python)
|
||||
- Serial communication and protocol parsing
|
||||
- ELF/DWARF symbol resolution
|
||||
- Web server with real-time updates (Flask + SocketIO)
|
||||
- Three visualization modes:
|
||||
- **Flame Graph**: Aggregate CPU time by function
|
||||
- **Timeline**: Execution over time (flame chart)
|
||||
- **Statistics**: Call counts, min/max/avg durations
|
||||
|
||||
## Quick Start
|
||||
|
||||
### Installation
|
||||
|
||||
```bash
|
||||
cd host
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
Or install as a package:
|
||||
|
||||
```bash
|
||||
cd host
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
### Running the Host Application
|
||||
|
||||
```bash
|
||||
# Using the installed CLI
|
||||
miniprofiler
|
||||
|
||||
# Or directly with Python
|
||||
python -m miniprofiler.cli
|
||||
|
||||
# With custom host/port
|
||||
miniprofiler --host localhost --port 8080
|
||||
|
||||
# With verbose logging
|
||||
miniprofiler --verbose
|
||||
```
|
||||
|
||||
### Testing Without Hardware
|
||||
|
||||
Generate sample profiling data to test the visualization:
|
||||
|
||||
```bash
|
||||
cd host/tests
|
||||
python sample_data_generator.py
|
||||
```
|
||||
|
||||
This creates:
|
||||
- `sample_profile_data.bin` - Binary protocol data
|
||||
- `sample_flamegraph.json` - Flame graph data
|
||||
- `sample_statistics.json` - Statistics data
|
||||
- `sample_timeline.json` - Timeline data
|
||||
|
||||
### Using the Web Interface
|
||||
|
||||
1. Start the host application: `miniprofiler`
|
||||
2. Open browser to `http://localhost:5000`
|
||||
3. Enter serial port (e.g., `/dev/ttyUSB0` or `COM3`)
|
||||
4. Optionally provide path to `.elf` file for symbol resolution
|
||||
5. Click **Connect**
|
||||
6. Click **Start Profiling**
|
||||
7. View real-time profiling data in the three visualization tabs
|
||||
|
||||
## Protocol
|
||||
|
||||
### Command-Response Structure
|
||||
|
||||
**Commands (Host → Embedded)**
|
||||
- `START_PROFILING` (0x01)
|
||||
- `STOP_PROFILING` (0x02)
|
||||
- `GET_STATUS` (0x03)
|
||||
- `RESET_BUFFERS` (0x04)
|
||||
- `GET_METADATA` (0x05)
|
||||
|
||||
**Responses (Embedded → Host)**
|
||||
- `ACK/NACK` (0x01/0x02)
|
||||
- `METADATA` (0x03)
|
||||
- `STATUS` (0x04)
|
||||
- `PROFILE_DATA` (0x05)
|
||||
|
||||
### Profile Record Format
|
||||
|
||||
Each profiling record is 14 bytes:
|
||||
|
||||
```c
|
||||
struct ProfileRecord {
|
||||
uint32_t func_addr; // Function address
|
||||
uint32_t entry_time; // Entry timestamp (μs)
|
||||
uint32_t duration_us; // Duration (μs)
|
||||
uint16_t depth; // Call stack depth
|
||||
} __attribute__((packed));
|
||||
```
|
||||
|
||||
### Packet Format
|
||||
|
||||
```
|
||||
┌─────────┬──────────┬───────────────┬─────────┬─────┐
|
||||
│ Header │ Length │ Payload │ CRC │ End │
|
||||
│ (0xAA55)│ (2B) │ (N bytes) │ (2B) │(0x0A)│
|
||||
└─────────┴──────────┴───────────────┴─────────┴─────┘
|
||||
```
|
||||
|
||||
## Development Roadmap
|
||||
|
||||
### Phase 1: Host Application ✓
|
||||
- [x] Protocol implementation
|
||||
- [x] Serial communication
|
||||
- [x] Symbol resolution (ELF/DWARF)
|
||||
- [x] Data analysis and statistics
|
||||
- [x] Web interface with Flask + SocketIO
|
||||
- [x] Flame graph visualization (d3-flame-graph)
|
||||
- [x] Timeline visualization (Plotly.js)
|
||||
- [x] Sample data generator
|
||||
|
||||
### Phase 2: Embedded Module (Next)
|
||||
- [ ] Instrumentation hooks (`__cyg_profile_func_enter/exit`)
|
||||
- [ ] DWT/SysTick timing implementation
|
||||
- [ ] Ring buffer implementation
|
||||
- [ ] UART communication with DMA
|
||||
- [ ] Command handling
|
||||
- [ ] STM32 example project
|
||||
|
||||
### Phase 3: Integration & Testing
|
||||
- [ ] End-to-end testing with real hardware
|
||||
- [ ] Performance overhead measurement
|
||||
- [ ] Buffer overflow handling
|
||||
- [ ] Symbol resolution verification
|
||||
|
||||
### Phase 4: Renode Emulation
|
||||
- [ ] Renode platform description
|
||||
- [ ] Virtual UART setup
|
||||
- [ ] CI/CD integration
|
||||
- [ ] Automated testing
|
||||
|
||||
## Configuration
|
||||
|
||||
### GCC Compilation Flags
|
||||
|
||||
To enable instrumentation in your embedded project:
|
||||
|
||||
```makefile
|
||||
CFLAGS += -finstrument-functions
|
||||
CFLAGS += -finstrument-functions-exclude-file-list=drivers/,lib/
|
||||
```
|
||||
|
||||
### Excluding Functions
|
||||
|
||||
```c
|
||||
// Exclude specific functions
|
||||
void __attribute__((no_instrument_function)) driver_function(void);
|
||||
|
||||
// Exclude entire files
|
||||
#pragma GCC optimize ("no-instrument-functions")
|
||||
```
|
||||
|
||||
## Requirements
|
||||
|
||||
### Host Application
|
||||
- Python 3.8+
|
||||
- Flask 3.0+
|
||||
- pyserial 3.5+
|
||||
- pyelftools 0.29+
|
||||
- Modern web browser with JavaScript enabled
|
||||
|
||||
### Embedded Target
|
||||
- STM32 MCU (STM32F4/F7/H7 recommended)
|
||||
- GCC ARM toolchain with `-finstrument-functions` support
|
||||
- UART/USB-CDC peripheral
|
||||
- ~2-10KB RAM for profiling buffer
|
||||
|
||||
## License
|
||||
|
||||
MIT License - See LICENSE file for details
|
||||
|
||||
## Contributing
|
||||
|
||||
Contributions welcome! Please open an issue or submit a pull request.
|
||||
|
||||
## Acknowledgments
|
||||
|
||||
- Inspired by [Brendan Gregg's FlameGraphs](https://www.brendangregg.com/flamegraphs.html)
|
||||
- Uses [d3-flame-graph](https://github.com/spiermar/d3-flame-graph) for visualization
|
||||
- Built with Flask, SocketIO, and Plotly.js
|
||||
349
docs/GETTING_STARTED.md
Normal file
349
docs/GETTING_STARTED.md
Normal file
@@ -0,0 +1,349 @@
|
||||
# Getting Started with MiniProfiler
|
||||
|
||||
This guide will help you get started with MiniProfiler for profiling your embedded STM32 applications.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
### Host System
|
||||
- Python 3.8 or higher
|
||||
- pip package manager
|
||||
- Modern web browser (Chrome, Firefox, Edge)
|
||||
- Serial port access (USB-to-Serial adapter or built-in UART)
|
||||
|
||||
### Embedded Target (for Phase 2)
|
||||
- STM32 microcontroller (STM32F4/F7/H7 recommended)
|
||||
- GCC ARM toolchain
|
||||
- UART or USB-CDC peripheral configured
|
||||
- ST-Link or similar programmer/debugger
|
||||
|
||||
## Installation
|
||||
|
||||
### 1. Clone the Repository
|
||||
|
||||
```bash
|
||||
git clone https://github.com/yourusername/miniprofiler.git
|
||||
cd miniprofiler
|
||||
```
|
||||
|
||||
### 2. Install Python Dependencies
|
||||
|
||||
```bash
|
||||
cd host
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
Or install as a package:
|
||||
|
||||
```bash
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
### 3. Verify Installation
|
||||
|
||||
```bash
|
||||
miniprofiler --help
|
||||
```
|
||||
|
||||
You should see the help message with available options.
|
||||
|
||||
## Testing Without Hardware
|
||||
|
||||
Before connecting to real hardware, you can test the visualization with sample data.
|
||||
|
||||
### Generate Sample Data
|
||||
|
||||
```bash
|
||||
cd host/tests
|
||||
python sample_data_generator.py
|
||||
```
|
||||
|
||||
This creates several sample data files:
|
||||
- `sample_flamegraph.json` - Flame graph visualization data
|
||||
- `sample_statistics.json` - Function statistics
|
||||
- `sample_timeline.json` - Timeline data
|
||||
- `sample_profile_data.bin` - Binary protocol data
|
||||
|
||||
### View Sample Visualizations
|
||||
|
||||
You can view the sample JSON files by loading them in the web interface or by opening them directly:
|
||||
|
||||
```bash
|
||||
# View flame graph data
|
||||
cat sample_flamegraph.json | python -m json.tool
|
||||
|
||||
# View statistics
|
||||
cat sample_statistics.json | python -m json.tool
|
||||
```
|
||||
|
||||
## Running the Host Application
|
||||
|
||||
### Start the Web Server
|
||||
|
||||
```bash
|
||||
# From the host directory
|
||||
python run.py
|
||||
|
||||
# Or using the installed CLI
|
||||
miniprofiler
|
||||
```
|
||||
|
||||
The server will start on `http://localhost:5000` by default.
|
||||
|
||||
### Custom Host/Port
|
||||
|
||||
```bash
|
||||
miniprofiler --host 0.0.0.0 --port 8080
|
||||
```
|
||||
|
||||
### Enable Debug Mode
|
||||
|
||||
```bash
|
||||
miniprofiler --debug --verbose
|
||||
```
|
||||
|
||||
## Using the Web Interface
|
||||
|
||||
### 1. Open the Browser
|
||||
|
||||
Navigate to `http://localhost:5000`
|
||||
|
||||
You should see the MiniProfiler dashboard with:
|
||||
- Connection controls
|
||||
- Profiling controls (disabled until connected)
|
||||
- Status display
|
||||
- Three visualization tabs
|
||||
|
||||
### 2. Configure Connection
|
||||
|
||||
Enter your serial port details:
|
||||
- **Serial Port**: `/dev/ttyUSB0` (Linux/Mac) or `COM3` (Windows)
|
||||
- **Baud Rate**: `115200` (default)
|
||||
- **ELF Path**: Path to your `.elf` file (optional, for symbol resolution)
|
||||
|
||||
**Finding Your Serial Port:**
|
||||
|
||||
Linux/Mac:
|
||||
```bash
|
||||
ls /dev/tty* | grep -i usb
|
||||
# or
|
||||
ls /dev/tty.usb*
|
||||
```
|
||||
|
||||
Windows:
|
||||
- Open Device Manager
|
||||
- Look under "Ports (COM & LPT)"
|
||||
- Note the COM port number (e.g., COM3)
|
||||
|
||||
### 3. Connect to Device
|
||||
|
||||
Click the **Connect** button.
|
||||
|
||||
If successful, you'll see:
|
||||
- Status indicator turns green
|
||||
- "Connected to /dev/ttyUSB0" message
|
||||
- Metadata panel appears with device information
|
||||
- Profiling controls become enabled
|
||||
|
||||
### 4. Start Profiling
|
||||
|
||||
Click **Start Profiling**.
|
||||
|
||||
The device will begin sending profiling data, and you'll see:
|
||||
- Real-time updates in all three visualization tabs
|
||||
- Record count incrementing
|
||||
- Summary statistics updating
|
||||
|
||||
### 5. Explore Visualizations
|
||||
|
||||
#### Flame Graph Tab
|
||||
- Shows aggregate CPU time by function
|
||||
- Wider bars = more time spent
|
||||
- Click to zoom into specific call stacks
|
||||
- Search for functions by name
|
||||
- Hover for details
|
||||
|
||||
#### Timeline Tab
|
||||
- Shows function execution over time
|
||||
- X-axis = time in microseconds
|
||||
- Y-axis = call stack depth
|
||||
- Color = duration (darker = longer)
|
||||
- Useful for finding timing issues
|
||||
|
||||
#### Statistics Tab
|
||||
- Sortable table of function statistics
|
||||
- Columns: Function, Address, Calls, Total/Avg/Min/Max Time
|
||||
- Click column headers to sort
|
||||
- Find hot spots and outliers
|
||||
|
||||
### 6. Control Profiling
|
||||
|
||||
- **Stop Profiling**: Pause data collection
|
||||
- **Clear Data**: Reset all visualizations
|
||||
- **Reset Buffers**: Clear device-side buffers
|
||||
|
||||
### 7. Disconnect
|
||||
|
||||
Click **Disconnect** when done to close the serial connection.
|
||||
|
||||
## Understanding the Visualizations
|
||||
|
||||
### Flame Graph
|
||||
|
||||
The flame graph shows **aggregated** profiling data:
|
||||
|
||||
```
|
||||
┌─────────────────────────────────┐
|
||||
│ main (10s) │ ← Root function
|
||||
├──────────────┬──────────────────┤
|
||||
│ app_loop │ process_data │ ← Called by main
|
||||
│ (6s) │ (4s) │
|
||||
├──────┬───────┼──────────────────┤
|
||||
│ read │ write │ calculate │ ← Nested calls
|
||||
│ (3s) │ (3s) │ (4s) │
|
||||
└──────┴───────┴──────────────────┘
|
||||
```
|
||||
|
||||
**Interpretation:**
|
||||
- Width = total time (including children)
|
||||
- Read from bottom (root) to top (leaves)
|
||||
- Widest bars are hotspots to optimize
|
||||
|
||||
### Timeline
|
||||
|
||||
The timeline shows **chronological** execution:
|
||||
|
||||
```
|
||||
Time ───────────────────────►
|
||||
│ ████ func_a
|
||||
│ ██ func_b (called by func_a)
|
||||
│ ████ func_c
|
||||
│ ██ func_d
|
||||
```
|
||||
|
||||
**Interpretation:**
|
||||
- X-axis = time progression
|
||||
- Y-axis = call depth
|
||||
- Gaps = idle time or excluded functions
|
||||
- Useful for timing analysis and debugging
|
||||
|
||||
### Statistics Table
|
||||
|
||||
| Function | Calls | Total Time | Avg Time |
|
||||
|----------|-------|------------|----------|
|
||||
| main | 1 | 10000 μs | 10000 μs |
|
||||
| app_loop | 100 | 6000 μs | 60 μs |
|
||||
| calculate | 100 | 4000 μs | 40 μs |
|
||||
|
||||
**Interpretation:**
|
||||
- Calls = number of times function was called
|
||||
- Total = cumulative time across all calls
|
||||
- Avg = total / calls
|
||||
- Min/Max = shortest/longest single execution
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### "Failed to connect to /dev/ttyUSB0"
|
||||
|
||||
**Possible causes:**
|
||||
- Wrong port name
|
||||
- Port in use by another application
|
||||
- Insufficient permissions
|
||||
|
||||
**Solutions:**
|
||||
```bash
|
||||
# Linux: Check permissions
|
||||
ls -l /dev/ttyUSB0
|
||||
sudo chmod 666 /dev/ttyUSB0
|
||||
|
||||
# Or add user to dialout group
|
||||
sudo usermod -a -G dialout $USER
|
||||
# Log out and back in
|
||||
|
||||
# Check if port is in use
|
||||
lsof | grep ttyUSB0
|
||||
```
|
||||
|
||||
### No Data Appearing
|
||||
|
||||
**Check:**
|
||||
1. Is profiling started? (Click "Start Profiling")
|
||||
2. Is embedded device actually profiling?
|
||||
3. Is UART configured correctly on embedded side?
|
||||
4. Check baud rate matches on both sides
|
||||
5. Look for errors in browser console (F12)
|
||||
|
||||
### CRC Errors in Console
|
||||
|
||||
**Possible causes:**
|
||||
- Baud rate mismatch
|
||||
- Electrical noise on UART lines
|
||||
- Cable issues
|
||||
|
||||
**Solutions:**
|
||||
- Verify baud rate configuration
|
||||
- Use shielded cable
|
||||
- Add delays in embedded UART transmission
|
||||
- Reduce baud rate to 57600
|
||||
|
||||
### Buffer Overflows
|
||||
|
||||
**Symptoms:**
|
||||
- `buffer_overflows` counter > 0 in device status
|
||||
- Missing profiling data
|
||||
|
||||
**Solutions:**
|
||||
- Increase baud rate (460800 or 921600)
|
||||
- Increase embedded ring buffer size
|
||||
- Reduce instrumentation (exclude more files)
|
||||
- Use sampling mode (future feature)
|
||||
|
||||
### Symbols Not Resolved
|
||||
|
||||
**Symptoms:**
|
||||
- Function names show as `func_0x08000XXX` or `unknown_0x08000XXX`
|
||||
|
||||
**Solutions:**
|
||||
- Provide path to `.elf` file in connection settings
|
||||
- Ensure `.elf` file has debug symbols (`-g` flag)
|
||||
- Verify `.elf` file matches firmware on device
|
||||
- Check build ID in metadata matches
|
||||
|
||||
### Web Interface Not Loading
|
||||
|
||||
**Check:**
|
||||
1. Is server running? Look for "Starting web server..." message
|
||||
2. Correct URL? Should be `http://localhost:5000`
|
||||
3. Port already in use? Try different port: `miniprofiler --port 8080`
|
||||
4. Firewall blocking? Add exception for Python/Flask
|
||||
|
||||
## Next Steps
|
||||
|
||||
### For Development
|
||||
1. Read [PROTOCOL.md](PROTOCOL.md) to understand the communication protocol
|
||||
2. Review the code in `host/miniprofiler/` to customize behavior
|
||||
3. Modify visualizations in `host/web/`
|
||||
|
||||
### For Embedded Integration
|
||||
1. Wait for Phase 2 implementation of embedded module
|
||||
2. Or start implementing based on protocol specification
|
||||
3. See examples in `embedded/` directory (coming soon)
|
||||
|
||||
### For Testing
|
||||
1. Create custom sample data with `sample_data_generator.py`
|
||||
2. Test with Renode emulation (Phase 4)
|
||||
3. Benchmark overhead on real hardware
|
||||
|
||||
## Support
|
||||
|
||||
- **Documentation**: See `docs/` directory
|
||||
- **Issues**: Open an issue on GitHub
|
||||
- **Examples**: Check `examples/` directory (coming soon)
|
||||
|
||||
## What's Next?
|
||||
|
||||
After getting familiar with the host application:
|
||||
1. **Phase 2**: Implement embedded module for STM32
|
||||
2. **Phase 3**: Test on real hardware
|
||||
3. **Phase 4**: Set up Renode emulation for automated testing
|
||||
|
||||
Stay tuned for updates!
|
||||
422
docs/PROJECT_STRUCTURE.md
Normal file
422
docs/PROJECT_STRUCTURE.md
Normal file
@@ -0,0 +1,422 @@
|
||||
# MiniProfiler Project Structure
|
||||
|
||||
## Directory Layout
|
||||
|
||||
```
|
||||
MiniProfiler/
|
||||
├── docs/ # Documentation
|
||||
│ ├── GETTING_STARTED.md # Quick start guide
|
||||
│ ├── PROTOCOL.md # Communication protocol specification
|
||||
│ └── PROJECT_STRUCTURE.md # This file
|
||||
│
|
||||
├── host/ # Host application (Python)
|
||||
│ ├── miniprofiler/ # Main package
|
||||
│ │ ├── __init__.py # Package initialization
|
||||
│ │ ├── analyzer.py # Data analysis and visualization data generation
|
||||
│ │ ├── cli.py # Command-line interface
|
||||
│ │ ├── protocol.py # Binary protocol implementation
|
||||
│ │ ├── serial_reader.py # Serial communication
|
||||
│ │ ├── symbolizer.py # ELF/DWARF symbol resolution
|
||||
│ │ └── web_server.py # Flask web server with SocketIO
|
||||
│ │
|
||||
│ ├── web/ # Web interface assets
|
||||
│ │ ├── static/
|
||||
│ │ │ ├── css/
|
||||
│ │ │ │ └── style.css # Stylesheet
|
||||
│ │ │ └── js/
|
||||
│ │ │ └── app.js # JavaScript application logic
|
||||
│ │ └── templates/
|
||||
│ │ └── index.html # Main HTML template
|
||||
│ │
|
||||
│ ├── tests/ # Tests and utilities
|
||||
│ │ ├── __init__.py
|
||||
│ │ └── sample_data_generator.py # Generate mock profiling data
|
||||
│ │
|
||||
│ ├── requirements.txt # Python dependencies
|
||||
│ ├── setup.py # Package setup
|
||||
│ └── run.py # Quick start script
|
||||
│
|
||||
├── embedded/ # Embedded module (Phase 2 - TODO)
|
||||
│ ├── src/
|
||||
│ ├── inc/
|
||||
│ └── examples/
|
||||
│
|
||||
├── .gitignore # Git ignore rules
|
||||
├── CLAUDE.md # Project overview for Claude
|
||||
└── README.md # Main project README
|
||||
```
|
||||
|
||||
## Module Descriptions
|
||||
|
||||
### Host Application (`host/miniprofiler/`)
|
||||
|
||||
#### `protocol.py`
|
||||
**Purpose:** Binary protocol implementation for serial communication
|
||||
|
||||
**Key Components:**
|
||||
- `ProfileRecord`: Data class for profiling records (14 bytes)
|
||||
- `Metadata`: Device metadata (MCU clock, timer freq, etc.)
|
||||
- `StatusInfo`: Device status information
|
||||
- `CommandPacket`: Commands sent to device
|
||||
- `ResponsePacket`: Responses from device
|
||||
- CRC16 calculation and validation
|
||||
|
||||
**Used by:** `serial_reader.py`, `analyzer.py`, `sample_data_generator.py`
|
||||
|
||||
---
|
||||
|
||||
#### `serial_reader.py`
|
||||
**Purpose:** Serial port communication and packet parsing
|
||||
|
||||
**Key Components:**
|
||||
- `SerialReader`: Main class for serial I/O
|
||||
- Background thread for continuous reading
|
||||
- State machine for packet parsing
|
||||
- Callback-based event handling
|
||||
- Command sending (START, STOP, GET_STATUS, etc.)
|
||||
|
||||
**Callbacks:**
|
||||
- `on_profile_data`: Profiling records received
|
||||
- `on_metadata`: Device metadata received
|
||||
- `on_status`: Status update received
|
||||
- `on_error`: Error occurred
|
||||
|
||||
**Used by:** `web_server.py`
|
||||
|
||||
---
|
||||
|
||||
#### `symbolizer.py`
|
||||
**Purpose:** Resolve function addresses to names using ELF/DWARF debug info
|
||||
|
||||
**Key Components:**
|
||||
- `Symbolizer`: ELF file parser
|
||||
- Loads symbol table from `.elf` file
|
||||
- Parses DWARF debug info for file/line mappings
|
||||
- Address-to-name resolution
|
||||
- Handles function address ranges
|
||||
|
||||
**Dependencies:** `pyelftools`
|
||||
|
||||
**Used by:** `analyzer.py`, `web_server.py`
|
||||
|
||||
---
|
||||
|
||||
#### `analyzer.py`
|
||||
**Purpose:** Analyze profiling data and generate visualization data structures
|
||||
|
||||
**Key Components:**
|
||||
- `ProfileAnalyzer`: Main analysis engine
|
||||
- Build call tree from flat records
|
||||
- Compute statistics (call counts, durations)
|
||||
- Generate flame graph data (d3-flame-graph format)
|
||||
- Generate timeline data (Plotly format)
|
||||
- Generate statistics table data
|
||||
|
||||
**Data Structures:**
|
||||
- `CallTreeNode`: Hierarchical call tree
|
||||
- `FunctionStats`: Per-function statistics
|
||||
|
||||
**Used by:** `web_server.py`
|
||||
|
||||
---
|
||||
|
||||
#### `web_server.py`
|
||||
**Purpose:** Flask web server with SocketIO for real-time updates
|
||||
|
||||
**Key Components:**
|
||||
- `ProfilerWebServer`: Main server class
|
||||
- Flask HTTP routes (`/`, `/api/status`, `/api/flamegraph`, etc.)
|
||||
- SocketIO event handlers (connect, start_profiling, etc.)
|
||||
- Integrates `SerialReader`, `Symbolizer`, and `ProfileAnalyzer`
|
||||
- Real-time data streaming to web clients
|
||||
|
||||
**Routes:**
|
||||
- `GET /`: Main web interface
|
||||
- `GET /api/status`: Server status JSON
|
||||
- `GET /api/flamegraph`: Flame graph data JSON
|
||||
- `GET /api/timeline`: Timeline data JSON
|
||||
- `GET /api/statistics`: Statistics table JSON
|
||||
|
||||
**SocketIO Events:**
|
||||
- `connect_serial`: Connect to device
|
||||
- `start_profiling`: Start profiling
|
||||
- `stop_profiling`: Stop profiling
|
||||
- `clear_data`: Clear all data
|
||||
- Emits: `flamegraph_update`, `statistics_update`, etc.
|
||||
|
||||
**Used by:** `cli.py`
|
||||
|
||||
---
|
||||
|
||||
#### `cli.py`
|
||||
**Purpose:** Command-line interface entry point
|
||||
|
||||
**Key Components:**
|
||||
- Argument parsing (--host, --port, --debug, --verbose)
|
||||
- Logging configuration
|
||||
- Server initialization and startup
|
||||
|
||||
**Entry point:** `miniprofiler` command
|
||||
|
||||
---
|
||||
|
||||
### Web Interface (`host/web/`)
|
||||
|
||||
#### `templates/index.html`
|
||||
**Purpose:** Main HTML page structure
|
||||
|
||||
**Features:**
|
||||
- Connection controls (serial port, baud rate, ELF path)
|
||||
- Profiling controls (start, stop, clear, reset)
|
||||
- Status display
|
||||
- Metadata panel
|
||||
- Summary panel
|
||||
- Three-tab interface (Flame Graph, Timeline, Statistics)
|
||||
|
||||
**Dependencies:**
|
||||
- Socket.IO client
|
||||
- D3.js
|
||||
- d3-flame-graph
|
||||
- Plotly.js
|
||||
|
||||
---
|
||||
|
||||
#### `static/css/style.css`
|
||||
**Purpose:** Styling and layout
|
||||
|
||||
**Features:**
|
||||
- Dark theme (VSCode-inspired)
|
||||
- Responsive design
|
||||
- Flexbox layouts
|
||||
- Custom button styles
|
||||
- Table styling
|
||||
- Status indicators with animations
|
||||
|
||||
---
|
||||
|
||||
#### `static/js/app.js`
|
||||
**Purpose:** Client-side application logic
|
||||
|
||||
**Key Functions:**
|
||||
- `initializeSocket()`: Set up SocketIO connection
|
||||
- `toggleConnection()`: Connect/disconnect from device
|
||||
- `startProfiling()`, `stopProfiling()`: Control profiling
|
||||
- `updateFlameGraph()`: Render flame graph with d3-flame-graph
|
||||
- `updateTimeline()`: Render timeline with Plotly.js
|
||||
- `updateStatistics()`: Update statistics table
|
||||
- `showTab()`: Tab switching
|
||||
|
||||
**Event Handlers:**
|
||||
- Socket events (connect, disconnect, data updates)
|
||||
- Button clicks
|
||||
- Window resize
|
||||
|
||||
---
|
||||
|
||||
### Tests (`host/tests/`)
|
||||
|
||||
#### `sample_data_generator.py`
|
||||
**Purpose:** Generate realistic mock profiling data for testing
|
||||
|
||||
**Features:**
|
||||
- Simulates typical embedded application (main, init, loop, sensors, etc.)
|
||||
- Generates nested function calls with realistic timing
|
||||
- Creates binary protocol packets
|
||||
- Exports JSON files for visualization testing
|
||||
|
||||
**Outputs:**
|
||||
- `sample_profile_data.bin`: Binary protocol data
|
||||
- `sample_flamegraph.json`: Flame graph data
|
||||
- `sample_statistics.json`: Statistics data
|
||||
- `sample_timeline.json`: Timeline data
|
||||
|
||||
**Usage:**
|
||||
```bash
|
||||
cd host/tests
|
||||
python sample_data_generator.py
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Data Flow
|
||||
|
||||
### Connection and Initialization
|
||||
|
||||
```
|
||||
User Web UI Web Server Serial Reader Device
|
||||
│ │ │ │ │
|
||||
│─── Open Browser ──►│ │ │ │
|
||||
│ │ │ │ │
|
||||
│─── Enter Port ────►│ │ │ │
|
||||
│─── Click Connect ─►│─── connect_serial ──►│─── connect() ─────►│ │
|
||||
│ │ │ │─── Open ─────►│
|
||||
│ │ │ │ │
|
||||
│ │ │─── get_metadata() ►│─── CMD ──────►│
|
||||
│ │ │ │◄── METADATA ──│
|
||||
│ │◄── metadata ─────────│◄── on_metadata() ──│ │
|
||||
│◄── Display Info ───│ │ │ │
|
||||
```
|
||||
|
||||
### Profiling Session
|
||||
|
||||
```
|
||||
User Web UI Web Server Analyzer Device
|
||||
│ │ │ │ │
|
||||
│─── Start ─────────►│─── start_profiling ─►│─── start() ─────►│ │
|
||||
│ │ │ │─── CMD ────────►│
|
||||
│ │ │ │ │
|
||||
│ │ │ │◄── DATA ────────│
|
||||
│ │ │◄── on_profile ───│ │
|
||||
│ │ │ │ │
|
||||
│ │ │── add_records() ►│ │
|
||||
│ │ │ │─ Analyze │
|
||||
│ │ │ │─ Build Tree │
|
||||
│ │ │ │─ Compute Stats │
|
||||
│ │ │◄── JSON ─────────│ │
|
||||
│ │◄─ flamegraph_update ─│ │ │
|
||||
│◄── Update Viz ─────│ │ │ │
|
||||
```
|
||||
|
||||
## Technology Stack
|
||||
|
||||
### Backend
|
||||
- **Python 3.8+**: Main language
|
||||
- **Flask 3.0+**: Web framework
|
||||
- **Flask-SocketIO 5.3+**: Real-time WebSocket communication
|
||||
- **pyserial 3.5+**: Serial port communication
|
||||
- **pyelftools 0.29+**: ELF/DWARF parsing
|
||||
- **crc 6.1+**: CRC16 calculation
|
||||
- **eventlet**: Async I/O for SocketIO
|
||||
|
||||
### Frontend
|
||||
- **HTML5/CSS3**: Structure and styling
|
||||
- **JavaScript (ES6)**: Application logic
|
||||
- **Socket.IO Client**: Real-time communication
|
||||
- **D3.js v7**: Visualization library
|
||||
- **d3-flame-graph 4.1**: Flame graph component
|
||||
- **Plotly.js 2.27**: Timeline/chart visualization
|
||||
|
||||
### Development Tools
|
||||
- **setuptools**: Package management
|
||||
- **pip**: Dependency management
|
||||
- **git**: Version control
|
||||
|
||||
## Configuration Files
|
||||
|
||||
### `requirements.txt`
|
||||
Python package dependencies with minimum versions
|
||||
|
||||
### `setup.py`
|
||||
Package metadata and installation configuration
|
||||
- Entry point: `miniprofiler` CLI command
|
||||
- Package data includes web assets
|
||||
|
||||
### `.gitignore`
|
||||
Excludes:
|
||||
- Python bytecode and caches
|
||||
- Virtual environments
|
||||
- IDE configs
|
||||
- Build artifacts
|
||||
- Generated test data
|
||||
|
||||
## Key Design Decisions
|
||||
|
||||
### Why Command-Response Protocol?
|
||||
- Allows host to control profiling (start/stop)
|
||||
- Can request status and metadata
|
||||
- More flexible than auto-start mode
|
||||
- Small overhead acceptable at 115200 baud
|
||||
|
||||
### Why Entry Time + Duration?
|
||||
- Enables both flame graphs (aggregate) and timelines (chronological)
|
||||
- Only 40% more data than duration-only
|
||||
- Essential for debugging timing-sensitive embedded systems
|
||||
|
||||
### Why d3-flame-graph?
|
||||
- Industry standard for flame graph visualization
|
||||
- Interactive (zoom, search, tooltips)
|
||||
- Customizable colors and layout
|
||||
- Handles large datasets efficiently
|
||||
|
||||
### Why Separate Analyzer Module?
|
||||
- Decouples data processing from I/O
|
||||
- Easier to test in isolation
|
||||
- Can swap visualization formats without changing protocol
|
||||
- Allows offline analysis of captured data
|
||||
|
||||
## Extension Points
|
||||
|
||||
### Adding New Commands
|
||||
1. Add to `Command` enum in `protocol.py`
|
||||
2. Implement in `SerialReader.send_command()`
|
||||
3. Add handler in `web_server.py` SocketIO events
|
||||
4. Update embedded firmware to handle command
|
||||
|
||||
### Adding New Visualizations
|
||||
1. Add route in `web_server.py` (e.g., `/api/callgraph`)
|
||||
2. Implement data generation in `analyzer.py`
|
||||
3. Add HTML tab in `index.html`
|
||||
4. Add JavaScript rendering in `app.js`
|
||||
5. Update CSS as needed
|
||||
|
||||
### Supporting More Microcontrollers
|
||||
1. Ensure GCC toolchain supports `-finstrument-functions`
|
||||
2. Implement timing mechanism (DWT, SysTick, or custom timer)
|
||||
3. Port ring buffer and UART code to new MCU
|
||||
4. Test and document
|
||||
|
||||
### Adding Compression
|
||||
1. Update protocol version to 0x02
|
||||
2. Implement compression in embedded module (e.g., delta encoding)
|
||||
3. Add decompression in `protocol.py`
|
||||
4. Update `ProfileDataPayload` parsing
|
||||
|
||||
## Future Enhancements
|
||||
|
||||
### Phase 2: Embedded Module
|
||||
- [ ] STM32 HAL/LL implementation
|
||||
- [ ] FreeRTOS integration
|
||||
- [ ] Example projects for STM32F4/F7/H7
|
||||
- [ ] CMake build system
|
||||
|
||||
### Phase 3: Advanced Features
|
||||
- [ ] Statistical sampling mode
|
||||
- [ ] ISR profiling
|
||||
- [ ] Multi-core support (dual-core STM32H7)
|
||||
- [ ] Task/thread tracking for RTOS
|
||||
- [ ] Filtering and search
|
||||
|
||||
### Phase 4: Renode Integration
|
||||
- [ ] Renode platform description
|
||||
- [ ] Virtual UART setup
|
||||
- [ ] CI/CD integration
|
||||
- [ ] Automated regression tests
|
||||
|
||||
### Phase 5: Analysis Tools
|
||||
- [ ] Differential profiling (compare two runs)
|
||||
- [ ] Export to Chrome Trace Format
|
||||
- [ ] Call graph visualization
|
||||
- [ ] Performance regression detection
|
||||
- [ ] Integration with debuggers (GDB)
|
||||
|
||||
## Performance Targets
|
||||
|
||||
### Embedded Overhead
|
||||
- **Target**: <5% CPU overhead
|
||||
- **Memory**: 2-10 KB RAM for buffers
|
||||
- **Instrumentation**: 1-2 μs per function call
|
||||
|
||||
### Host Performance
|
||||
- **Latency**: <100ms from device to visualization
|
||||
- **Throughput**: Handle 500-1000 records/sec
|
||||
- **Memory**: Scale to 100K+ records in browser
|
||||
|
||||
### Bandwidth
|
||||
- **115200 baud**: ~780 records/sec
|
||||
- **460800 baud**: ~3100 records/sec
|
||||
- **921600 baud**: ~6200 records/sec
|
||||
|
||||
## Contributing
|
||||
|
||||
See individual module docstrings for implementation details.
|
||||
Follow existing code style and structure when adding features.
|
||||
300
docs/PROTOCOL.md
Normal file
300
docs/PROTOCOL.md
Normal file
@@ -0,0 +1,300 @@
|
||||
# MiniProfiler Communication Protocol
|
||||
|
||||
## Overview
|
||||
|
||||
MiniProfiler uses a binary command-response protocol over UART/Serial communication at 115200 baud (configurable).
|
||||
|
||||
- **Command packets**: Host → Embedded device
|
||||
- **Response packets**: Embedded device → Host
|
||||
|
||||
## Command Packet Format
|
||||
|
||||
Commands are sent from the host to the embedded device.
|
||||
|
||||
### Structure
|
||||
|
||||
```
|
||||
┌────────┬─────────┬─────────────┬──────────┬──────────┐
|
||||
│ Header │ Command │ Payload Len │ Payload │ Checksum │
|
||||
│ (1B) │ (1B) │ (1B) │ (8B) │ (1B) │
|
||||
└────────┴─────────┴─────────────┴──────────┴──────────┘
|
||||
Total: 12 bytes
|
||||
```
|
||||
|
||||
### Fields
|
||||
|
||||
| Field | Size | Value | Description |
|
||||
|-------|------|-------|-------------|
|
||||
| Header | 1 byte | `0x55` | Packet start marker |
|
||||
| Command | 1 byte | See table below | Command code |
|
||||
| Payload Length | 1 byte | 0-8 | Actual payload size |
|
||||
| Payload | 8 bytes | Variable | Command parameters (padded with 0x00) |
|
||||
| Checksum | 1 byte | Sum of all bytes & 0xFF | Simple checksum |
|
||||
|
||||
### Command Codes
|
||||
|
||||
| Command | Code | Description | Payload |
|
||||
|---------|------|-------------|---------|
|
||||
| START_PROFILING | `0x01` | Start profiling | None |
|
||||
| STOP_PROFILING | `0x02` | Stop profiling | None |
|
||||
| GET_STATUS | `0x03` | Request status | None |
|
||||
| RESET_BUFFERS | `0x04` | Clear profiling buffers | None |
|
||||
| GET_METADATA | `0x05` | Request device metadata | None |
|
||||
| SET_CONFIG | `0x06` | Configure profiler | Config bytes (reserved) |
|
||||
|
||||
### Example
|
||||
|
||||
Start profiling command:
|
||||
```
|
||||
55 01 00 00 00 00 00 00 00 00 00 56
|
||||
│ │ │ └─────────────────────┘ │
|
||||
│ │ │ Payload (8B) │
|
||||
│ │ └── Payload Length (0) │
|
||||
│ └── Command (START_PROFILING) │
|
||||
└── Header (0x55) └── Checksum
|
||||
```
|
||||
|
||||
## Response Packet Format
|
||||
|
||||
Responses are sent from the embedded device to the host.
|
||||
|
||||
### Structure
|
||||
|
||||
```
|
||||
┌─────────┬──────┬──────────┬──────────┬────────┬─────┐
|
||||
│ Header │ Type │ Length │ Payload │ CRC │ End │
|
||||
│ (2B) │ (1B) │ (2B) │ (N bytes)│ (2B) │(1B) │
|
||||
└─────────┴──────┴──────────┴──────────┴────────┴─────┘
|
||||
Total: 8 + N bytes
|
||||
```
|
||||
|
||||
### Fields
|
||||
|
||||
| Field | Size | Value | Description |
|
||||
|-------|------|-------|-------------|
|
||||
| Header | 2 bytes | `0xAA55` | Packet start marker (little-endian) |
|
||||
| Type | 1 byte | See table below | Response type |
|
||||
| Length | 2 bytes | 0-65535 | Payload size (little-endian) |
|
||||
| Payload | Variable | Depends on type | Response data |
|
||||
| CRC16 | 2 bytes | CRC16-CCITT | Checksum of header+type+length+payload |
|
||||
| End | 1 byte | `0x0A` | Packet end marker (newline) |
|
||||
|
||||
### Response Types
|
||||
|
||||
| Type | Code | Description | Payload Format |
|
||||
|------|------|-------------|----------------|
|
||||
| ACK | `0x01` | Command acknowledged | None |
|
||||
| NACK | `0x02` | Command failed | None |
|
||||
| METADATA | `0x03` | Device metadata | See Metadata Payload |
|
||||
| STATUS | `0x04` | Device status | See Status Payload |
|
||||
| PROFILE_DATA | `0x05` | Profiling records | See Profile Data Payload |
|
||||
|
||||
## Payload Formats
|
||||
|
||||
### Metadata Payload (28 bytes)
|
||||
|
||||
Sent in response to `GET_METADATA` command or automatically on startup.
|
||||
|
||||
```c
|
||||
struct MetadataPayload {
|
||||
uint32_t mcu_clock_hz; // MCU clock frequency in Hz
|
||||
uint32_t timer_freq; // Profiling timer frequency in Hz
|
||||
uint32_t elf_build_id; // CRC32 of .text section for version matching
|
||||
char fw_version[16]; // Firmware version string (null-terminated)
|
||||
} __attribute__((packed));
|
||||
```
|
||||
|
||||
**Example:**
|
||||
- MCU Clock: 168,000,000 Hz (168 MHz STM32F4)
|
||||
- Timer Freq: 1,000,000 Hz (1 MHz for microsecond precision)
|
||||
- Build ID: 0xDEADBEEF
|
||||
- FW Version: "v1.0.0"
|
||||
|
||||
### Status Payload (10 bytes)
|
||||
|
||||
Sent in response to `GET_STATUS` command.
|
||||
|
||||
```c
|
||||
struct StatusPayload {
|
||||
uint8_t is_profiling; // 1 if profiling active, 0 otherwise
|
||||
uint32_t buffer_overflows; // Number of buffer overflow events
|
||||
uint32_t records_captured; // Total records captured
|
||||
uint8_t buffer_usage_percent; // Current buffer usage (0-100)
|
||||
} __attribute__((packed));
|
||||
```
|
||||
|
||||
### Profile Data Payload (Variable)
|
||||
|
||||
Sent automatically during profiling or in response to data requests.
|
||||
|
||||
```c
|
||||
struct ProfileDataPayload {
|
||||
uint8_t version; // Protocol version (0x01)
|
||||
uint16_t record_count; // Number of records in this packet
|
||||
ProfileRecord records[]; // Array of profile records
|
||||
} __attribute__((packed));
|
||||
```
|
||||
|
||||
Each `ProfileRecord` is 14 bytes:
|
||||
|
||||
```c
|
||||
struct ProfileRecord {
|
||||
uint32_t func_addr; // Function address (from instrumentation)
|
||||
uint32_t entry_time; // Entry timestamp in microseconds
|
||||
uint32_t duration_us; // Function duration in microseconds
|
||||
uint16_t depth; // Call stack depth (0 = root)
|
||||
} __attribute__((packed));
|
||||
```
|
||||
|
||||
**Field Details:**
|
||||
- `func_addr`: Return address from `__builtin_return_address(0)` in instrumentation hook
|
||||
- `entry_time`: Microsecond timestamp when function was entered (wraps at ~71 minutes)
|
||||
- `duration_us`: Time spent in function including children
|
||||
- `depth`: Call stack depth (0 for main, 1 for functions called by main, etc.)
|
||||
|
||||
## Communication Flow
|
||||
|
||||
### Initial Connection
|
||||
|
||||
```
|
||||
Host Device
|
||||
| |
|
||||
|--- GET_METADATA ------>|
|
||||
|<---- METADATA ---------|
|
||||
| |
|
||||
|--- START_PROFILING --->|
|
||||
|<---- ACK --------------|
|
||||
| |
|
||||
|<---- PROFILE_DATA -----| (continuous stream)
|
||||
|<---- PROFILE_DATA -----|
|
||||
|<---- PROFILE_DATA -----|
|
||||
| ... |
|
||||
```
|
||||
|
||||
### Typical Session
|
||||
|
||||
```
|
||||
1. Host connects to serial port
|
||||
2. Host sends GET_METADATA
|
||||
3. Device responds with METADATA packet
|
||||
4. Host sends START_PROFILING
|
||||
5. Device responds with ACK
|
||||
6. Device begins streaming PROFILE_DATA packets
|
||||
7. Host processes and visualizes data in real-time
|
||||
8. Host sends STOP_PROFILING when done
|
||||
9. Device responds with ACK and stops streaming
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
### CRC Mismatch
|
||||
If the host detects a CRC mismatch:
|
||||
- Log the error
|
||||
- Discard the packet
|
||||
- Continue listening for next packet
|
||||
- No retransmission (real-time streaming)
|
||||
|
||||
### Packet Loss
|
||||
- Sequence numbers not implemented (keeps protocol simple)
|
||||
- Missing data will create gaps in visualization
|
||||
- Not critical for profiling use case
|
||||
|
||||
### Buffer Overflow
|
||||
- Device sets `buffer_overflows` counter in status
|
||||
- Host should warn user
|
||||
- Options: increase baud rate, reduce instrumentation, or use sampling
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
### Bandwidth Calculation
|
||||
|
||||
At 115200 baud:
|
||||
- Effective throughput: ~11.5 KB/s
|
||||
- Profile record size: 14 bytes
|
||||
- Packet overhead: ~8 bytes per packet
|
||||
- Records per packet (typical): 20
|
||||
- Packet size: 8 + 3 + 280 = 291 bytes
|
||||
- Packets per second: ~39
|
||||
- Records per second: ~780
|
||||
|
||||
**Recommendation:** If profiling >780 function calls/sec, increase baud rate to 460800 or 921600.
|
||||
|
||||
### Timing Overhead
|
||||
|
||||
Instrumentation overhead per function:
|
||||
- Entry hook: ~0.5-1 μs
|
||||
- Exit hook: ~0.5-1 μs
|
||||
- Total: ~1-2 μs per function call
|
||||
|
||||
Target: <5% overhead for typical applications.
|
||||
|
||||
## Protocol Versioning
|
||||
|
||||
Current version: **0x01**
|
||||
|
||||
The `version` field in `ProfileDataPayload` allows for future protocol extensions:
|
||||
- v0x01: Current format (entry_time + duration)
|
||||
- v0x02: Future - could add ISR markers, task IDs, etc.
|
||||
- v0x03: Future - compressed format, delta encoding
|
||||
|
||||
Host should check version and handle accordingly or reject unsupported versions.
|
||||
|
||||
## Example Packet Dumps
|
||||
|
||||
### GET_METADATA Command
|
||||
```
|
||||
55 05 00 00 00 00 00 00 00 00 00 5A
|
||||
```
|
||||
|
||||
### METADATA Response
|
||||
```
|
||||
AA 55 03 1C 00 // Header, Type=METADATA, Length=28
|
||||
00 09 FB 0A // mcu_clock_hz = 168000000
|
||||
40 42 0F 00 // timer_freq = 1000000
|
||||
EF BE AD DE // build_id = 0xDEADBEEF
|
||||
76 31 2E 30 2E 30 00 ... // fw_version = "v1.0.0\0..."
|
||||
XX XX // CRC16
|
||||
0A // End marker
|
||||
```
|
||||
|
||||
### PROFILE_DATA Response (2 records)
|
||||
```
|
||||
AA 55 05 1F 00 // Header, Type=PROFILE_DATA, Length=31
|
||||
01 // Version = 1
|
||||
02 00 // Record count = 2
|
||||
|
||||
// Record 1
|
||||
00 01 00 08 // func_addr = 0x08000100
|
||||
E8 03 00 00 // entry_time = 1000 μs
|
||||
D0 07 00 00 // duration = 2000 μs
|
||||
00 00 // depth = 0
|
||||
|
||||
// Record 2
|
||||
20 02 00 08 // func_addr = 0x08000220
|
||||
F4 01 00 00 // entry_time = 500 μs
|
||||
2C 01 00 00 // duration = 300 μs
|
||||
01 00 // depth = 1
|
||||
|
||||
XX XX // CRC16
|
||||
0A // End marker
|
||||
```
|
||||
|
||||
## Implementation Notes
|
||||
|
||||
### Embedded Side
|
||||
- Use DMA for UART transmission to minimize CPU overhead
|
||||
- Implement ring buffer with power-of-2 size for efficient modulo operations
|
||||
- Send packets in background task or idle hook
|
||||
- Consider double-buffering: one buffer for capturing, one for transmitting
|
||||
|
||||
### Host Side
|
||||
- Use state machine for packet parsing (don't assume atomicity)
|
||||
- Handle partial packets gracefully
|
||||
- Verify CRC before processing payload
|
||||
- Use background thread for serial reading to not block UI
|
||||
|
||||
## References
|
||||
|
||||
- CRC16-CCITT: Polynomial 0x1021, initial value 0xFFFF
|
||||
- Little-endian byte order for multi-byte integers
|
||||
- GCC instrumentation: `__cyg_profile_func_enter/exit`
|
||||
6
host/miniprofiler/__init__.py
Normal file
6
host/miniprofiler/__init__.py
Normal file
@@ -0,0 +1,6 @@
|
||||
"""MiniProfiler Host Application
|
||||
|
||||
A Python-based host application for profiling embedded STM32 applications.
|
||||
"""
|
||||
|
||||
__version__ = "0.1.0"
|
||||
314
host/miniprofiler/analyzer.py
Normal file
314
host/miniprofiler/analyzer.py
Normal file
@@ -0,0 +1,314 @@
|
||||
"""Profiling data analysis and visualization data generation.
|
||||
|
||||
This module processes raw profiling records to build call trees,
|
||||
compute statistics, and generate data structures for visualization.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import List, Dict, Optional, Any
|
||||
from collections import defaultdict
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from .protocol import ProfileRecord
|
||||
from .symbolizer import Symbolizer
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class FunctionStats:
|
||||
"""Statistics for a single function."""
|
||||
name: str
|
||||
address: int
|
||||
call_count: int = 0
|
||||
total_time_us: int = 0
|
||||
min_time_us: int = float('inf')
|
||||
max_time_us: int = 0
|
||||
self_time_us: int = 0 # Time excluding children
|
||||
|
||||
def update(self, duration_us: int):
|
||||
"""Update statistics with a new duration measurement."""
|
||||
self.call_count += 1
|
||||
self.total_time_us += duration_us
|
||||
self.min_time_us = min(self.min_time_us, duration_us)
|
||||
self.max_time_us = max(self.max_time_us, duration_us)
|
||||
|
||||
@property
|
||||
def avg_time_us(self) -> float:
|
||||
"""Average execution time in microseconds."""
|
||||
return self.total_time_us / self.call_count if self.call_count > 0 else 0
|
||||
|
||||
|
||||
@dataclass
|
||||
class CallTreeNode:
|
||||
"""Node in the call tree."""
|
||||
name: str
|
||||
address: int
|
||||
entry_time: int
|
||||
duration_us: int
|
||||
depth: int
|
||||
children: List['CallTreeNode'] = field(default_factory=list)
|
||||
|
||||
def add_child(self, node: 'CallTreeNode'):
|
||||
"""Add a child node to this node."""
|
||||
self.children.append(node)
|
||||
|
||||
def to_flamegraph_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to d3-flame-graph format.
|
||||
|
||||
Returns:
|
||||
Dictionary in the format:
|
||||
{
|
||||
"name": "function_name",
|
||||
"value": duration_in_microseconds,
|
||||
"children": [child_dicts...]
|
||||
}
|
||||
"""
|
||||
result = {
|
||||
"name": self.name,
|
||||
"value": self.duration_us
|
||||
}
|
||||
|
||||
if self.children:
|
||||
result["children"] = [child.to_flamegraph_dict() for child in self.children]
|
||||
|
||||
return result
|
||||
|
||||
def to_timeline_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to timeline/flame chart format.
|
||||
|
||||
Returns:
|
||||
Dictionary with timing information for Plotly timeline
|
||||
"""
|
||||
return {
|
||||
"name": self.name,
|
||||
"start": self.entry_time,
|
||||
"duration": self.duration_us,
|
||||
"depth": self.depth,
|
||||
"children": [child.to_timeline_dict() for child in self.children]
|
||||
}
|
||||
|
||||
|
||||
class ProfileAnalyzer:
|
||||
"""Analyzes profiling data and generates visualization data."""
|
||||
|
||||
def __init__(self, symbolizer: Optional[Symbolizer] = None):
|
||||
"""Initialize the analyzer.
|
||||
|
||||
Args:
|
||||
symbolizer: Symbolizer for resolving addresses to names
|
||||
"""
|
||||
self.symbolizer = symbolizer
|
||||
self.records: List[ProfileRecord] = []
|
||||
self.stats: Dict[int, FunctionStats] = {} # addr -> stats
|
||||
self.call_tree: Optional[CallTreeNode] = None
|
||||
self.timeline_events: List[Dict[str, Any]] = []
|
||||
|
||||
def add_records(self, records: List[ProfileRecord]):
|
||||
"""Add profiling records for analysis.
|
||||
|
||||
Args:
|
||||
records: List of ProfileRecord objects
|
||||
"""
|
||||
self.records.extend(records)
|
||||
logger.debug(f"Added {len(records)} records, total: {len(self.records)}")
|
||||
|
||||
def clear(self):
|
||||
"""Clear all recorded data."""
|
||||
self.records.clear()
|
||||
self.stats.clear()
|
||||
self.call_tree = None
|
||||
self.timeline_events.clear()
|
||||
logger.info("Cleared all profiling data")
|
||||
|
||||
def _resolve_name(self, addr: int) -> str:
|
||||
"""Resolve address to function name."""
|
||||
if self.symbolizer:
|
||||
return self.symbolizer.resolve_name(addr)
|
||||
return f"func_0x{addr:08x}"
|
||||
|
||||
def compute_statistics(self) -> Dict[int, FunctionStats]:
|
||||
"""Compute statistics for all functions.
|
||||
|
||||
Returns:
|
||||
Dictionary mapping addresses to FunctionStats
|
||||
"""
|
||||
self.stats.clear()
|
||||
|
||||
for record in self.records:
|
||||
addr = record.func_addr
|
||||
name = self._resolve_name(addr)
|
||||
|
||||
if addr not in self.stats:
|
||||
self.stats[addr] = FunctionStats(name=name, address=addr)
|
||||
|
||||
self.stats[addr].update(record.duration_us)
|
||||
|
||||
logger.info(f"Computed statistics for {len(self.stats)} functions")
|
||||
return self.stats
|
||||
|
||||
def build_call_tree(self) -> Optional[CallTreeNode]:
|
||||
"""Build call tree from profiling records.
|
||||
|
||||
The call tree is built using the depth field to determine
|
||||
parent-child relationships.
|
||||
|
||||
Returns:
|
||||
Root node of the call tree, or None if no records
|
||||
"""
|
||||
if not self.records:
|
||||
return None
|
||||
|
||||
# Sort records by entry time to process in chronological order
|
||||
sorted_records = sorted(self.records, key=lambda r: r.entry_time)
|
||||
|
||||
# Stack to track current path in the tree
|
||||
# stack[depth] = node at that depth
|
||||
stack: List[CallTreeNode] = []
|
||||
root = None
|
||||
|
||||
for record in sorted_records:
|
||||
name = self._resolve_name(record.func_addr)
|
||||
|
||||
node = CallTreeNode(
|
||||
name=name,
|
||||
address=record.func_addr,
|
||||
entry_time=record.entry_time,
|
||||
duration_us=record.duration_us,
|
||||
depth=record.depth
|
||||
)
|
||||
|
||||
# Adjust stack to current depth
|
||||
while len(stack) > record.depth:
|
||||
stack.pop()
|
||||
|
||||
# Add node to tree
|
||||
if record.depth == 0:
|
||||
# Root level function
|
||||
if root is None:
|
||||
root = node
|
||||
stack = [root]
|
||||
else:
|
||||
# Multiple root-level functions - create synthetic root
|
||||
if not isinstance(root.name, str) or not root.name.startswith("__root__"):
|
||||
synthetic_root = CallTreeNode(
|
||||
name="__root__",
|
||||
address=0,
|
||||
entry_time=0,
|
||||
duration_us=0,
|
||||
depth=-1
|
||||
)
|
||||
synthetic_root.add_child(root)
|
||||
root = synthetic_root
|
||||
stack = [root]
|
||||
|
||||
root.add_child(node)
|
||||
# Update root duration to encompass all children
|
||||
root.duration_us = max(root.duration_us,
|
||||
node.entry_time + node.duration_us)
|
||||
|
||||
else:
|
||||
# Child function
|
||||
if len(stack) >= record.depth:
|
||||
parent = stack[record.depth - 1]
|
||||
parent.add_child(node)
|
||||
else:
|
||||
logger.warning(f"Orphan node at depth {record.depth}: {name}")
|
||||
continue
|
||||
|
||||
# Push to stack if we're going deeper
|
||||
if len(stack) == record.depth:
|
||||
stack.append(node)
|
||||
elif len(stack) == record.depth + 1:
|
||||
stack[record.depth] = node
|
||||
|
||||
self.call_tree = root
|
||||
logger.info(f"Built call tree with {len(sorted_records)} nodes")
|
||||
return root
|
||||
|
||||
def to_flamegraph_json(self) -> Dict[str, Any]:
|
||||
"""Generate flame graph data in d3-flame-graph format.
|
||||
|
||||
Returns:
|
||||
Dictionary suitable for d3-flame-graph
|
||||
"""
|
||||
if self.call_tree is None:
|
||||
self.build_call_tree()
|
||||
|
||||
if self.call_tree is None:
|
||||
return {"name": "root", "value": 0, "children": []}
|
||||
|
||||
return self.call_tree.to_flamegraph_dict()
|
||||
|
||||
def to_timeline_json(self) -> List[Dict[str, Any]]:
|
||||
"""Generate timeline data for flame chart visualization.
|
||||
|
||||
Returns:
|
||||
List of events for timeline/flame chart
|
||||
"""
|
||||
events = []
|
||||
|
||||
for record in sorted(self.records, key=lambda r: r.entry_time):
|
||||
name = self._resolve_name(record.func_addr)
|
||||
|
||||
events.append({
|
||||
"name": name,
|
||||
"start": record.entry_time,
|
||||
"end": record.entry_time + record.duration_us,
|
||||
"duration": record.duration_us,
|
||||
"depth": record.depth
|
||||
})
|
||||
|
||||
return events
|
||||
|
||||
def to_statistics_json(self) -> List[Dict[str, Any]]:
|
||||
"""Generate statistics table data.
|
||||
|
||||
Returns:
|
||||
List of function statistics dictionaries
|
||||
"""
|
||||
if not self.stats:
|
||||
self.compute_statistics()
|
||||
|
||||
stats_list = []
|
||||
for func_stats in self.stats.values():
|
||||
stats_list.append({
|
||||
"name": func_stats.name,
|
||||
"address": f"0x{func_stats.address:08x}",
|
||||
"calls": func_stats.call_count,
|
||||
"total_us": func_stats.total_time_us,
|
||||
"avg_us": func_stats.avg_time_us,
|
||||
"min_us": func_stats.min_time_us,
|
||||
"max_us": func_stats.max_time_us,
|
||||
})
|
||||
|
||||
# Sort by total time (descending)
|
||||
stats_list.sort(key=lambda x: x["total_us"], reverse=True)
|
||||
|
||||
return stats_list
|
||||
|
||||
def get_summary(self) -> Dict[str, Any]:
|
||||
"""Get summary statistics.
|
||||
|
||||
Returns:
|
||||
Dictionary with summary information
|
||||
"""
|
||||
if not self.stats:
|
||||
self.compute_statistics()
|
||||
|
||||
total_records = len(self.records)
|
||||
total_functions = len(self.stats)
|
||||
total_time = sum(s.total_time_us for s in self.stats.values())
|
||||
|
||||
hottest = None
|
||||
if self.stats:
|
||||
hottest = max(self.stats.values(), key=lambda s: s.total_time_us)
|
||||
|
||||
return {
|
||||
"total_records": total_records,
|
||||
"total_functions": total_functions,
|
||||
"total_time_us": total_time,
|
||||
"hottest_function": hottest.name if hottest else None,
|
||||
"hottest_time_us": hottest.total_time_us if hottest else 0,
|
||||
}
|
||||
90
host/miniprofiler/cli.py
Normal file
90
host/miniprofiler/cli.py
Normal file
@@ -0,0 +1,90 @@
|
||||
"""Command-line interface for MiniProfiler."""
|
||||
|
||||
import argparse
|
||||
import logging
|
||||
import sys
|
||||
|
||||
from .web_server import create_app
|
||||
|
||||
|
||||
def setup_logging(verbose: bool = False):
|
||||
"""Configure logging.
|
||||
|
||||
Args:
|
||||
verbose: Enable verbose (DEBUG) logging
|
||||
"""
|
||||
level = logging.DEBUG if verbose else logging.INFO
|
||||
logging.basicConfig(
|
||||
level=level,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
datefmt='%Y-%m-%d %H:%M:%S'
|
||||
)
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point for the CLI."""
|
||||
parser = argparse.ArgumentParser(
|
||||
description='MiniProfiler - Real-time Embedded Profiling Visualization'
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
'--host',
|
||||
type=str,
|
||||
default='0.0.0.0',
|
||||
help='Host address to bind to (default: 0.0.0.0)'
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
'--port',
|
||||
type=int,
|
||||
default=5000,
|
||||
help='Port number to listen on (default: 5000)'
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
'--debug',
|
||||
action='store_true',
|
||||
help='Enable debug mode'
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
'--verbose', '-v',
|
||||
action='store_true',
|
||||
help='Enable verbose logging'
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Setup logging
|
||||
setup_logging(args.verbose)
|
||||
|
||||
# Create and run the web server
|
||||
print(f"""
|
||||
╔═══════════════════════════════════════════════════════════╗
|
||||
║ MiniProfiler ║
|
||||
║ Real-time Embedded Profiling Tool ║
|
||||
╚═══════════════════════════════════════════════════════════╝
|
||||
|
||||
Starting web server...
|
||||
Host: {args.host}
|
||||
Port: {args.port}
|
||||
|
||||
Open your browser and navigate to:
|
||||
http://localhost:{args.port}
|
||||
|
||||
Press Ctrl+C to stop the server.
|
||||
""")
|
||||
|
||||
try:
|
||||
server = create_app(args.host, args.port)
|
||||
server.run(debug=args.debug)
|
||||
except KeyboardInterrupt:
|
||||
print("\n\nShutting down gracefully...")
|
||||
sys.exit(0)
|
||||
except Exception as e:
|
||||
print(f"\nError: {e}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
280
host/miniprofiler/protocol.py
Normal file
280
host/miniprofiler/protocol.py
Normal file
@@ -0,0 +1,280 @@
|
||||
"""Protocol definitions and packet structures for MiniProfiler.
|
||||
|
||||
This module defines the binary protocol used for communication between
|
||||
the embedded device and the host application.
|
||||
"""
|
||||
|
||||
import struct
|
||||
from enum import IntEnum
|
||||
from dataclasses import dataclass
|
||||
from typing import List, Optional
|
||||
import crc
|
||||
|
||||
|
||||
class Command(IntEnum):
|
||||
"""Commands sent from host to embedded device."""
|
||||
START_PROFILING = 0x01
|
||||
STOP_PROFILING = 0x02
|
||||
GET_STATUS = 0x03
|
||||
RESET_BUFFERS = 0x04
|
||||
GET_METADATA = 0x05
|
||||
SET_CONFIG = 0x06
|
||||
|
||||
|
||||
class ResponseType(IntEnum):
|
||||
"""Response types from embedded device to host."""
|
||||
ACK = 0x01
|
||||
NACK = 0x02
|
||||
METADATA = 0x03
|
||||
STATUS = 0x04
|
||||
PROFILE_DATA = 0x05
|
||||
|
||||
|
||||
# Protocol constants
|
||||
COMMAND_HEADER = 0x55
|
||||
RESPONSE_HEADER = 0xAA55
|
||||
RESPONSE_END = 0x0A
|
||||
PROTOCOL_VERSION = 0x01
|
||||
|
||||
|
||||
@dataclass
|
||||
class ProfileRecord:
|
||||
"""A single profiling record from the embedded device.
|
||||
|
||||
Attributes:
|
||||
func_addr: Function address (from instrumentation)
|
||||
entry_time: Entry timestamp in microseconds
|
||||
duration_us: Function duration in microseconds
|
||||
depth: Call stack depth
|
||||
"""
|
||||
func_addr: int
|
||||
entry_time: int
|
||||
duration_us: int
|
||||
depth: int
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, data: bytes) -> 'ProfileRecord':
|
||||
"""Parse a ProfileRecord from binary data.
|
||||
|
||||
Format: <I (func_addr) <I (entry_time) <I (duration_us) <H (depth)
|
||||
Total: 14 bytes
|
||||
"""
|
||||
if len(data) < 14:
|
||||
raise ValueError(f"Invalid ProfileRecord size: {len(data)} bytes")
|
||||
|
||||
func_addr, entry_time, duration_us, depth = struct.unpack('<IIIH', data[:14])
|
||||
return cls(func_addr, entry_time, duration_us, depth)
|
||||
|
||||
def to_bytes(self) -> bytes:
|
||||
"""Serialize ProfileRecord to binary format."""
|
||||
return struct.pack('<IIIH', self.func_addr, self.entry_time,
|
||||
self.duration_us, self.depth)
|
||||
|
||||
|
||||
@dataclass
|
||||
class Metadata:
|
||||
"""Metadata packet sent by embedded device at startup.
|
||||
|
||||
Attributes:
|
||||
mcu_clock_hz: MCU clock frequency in Hz
|
||||
timer_freq: Timer frequency in Hz
|
||||
elf_build_id: CRC32 of .text section for version matching
|
||||
fw_version: Firmware version string
|
||||
"""
|
||||
mcu_clock_hz: int
|
||||
timer_freq: int
|
||||
elf_build_id: int
|
||||
fw_version: str
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, data: bytes) -> 'Metadata':
|
||||
"""Parse Metadata from binary data.
|
||||
|
||||
Format: <I (mcu_clock) <I (timer_freq) <I (build_id) 16s (fw_version)
|
||||
Total: 28 bytes
|
||||
"""
|
||||
if len(data) < 28:
|
||||
raise ValueError(f"Invalid Metadata size: {len(data)} bytes")
|
||||
|
||||
mcu_clock_hz, timer_freq, elf_build_id, fw_version_bytes = struct.unpack(
|
||||
'<III16s', data[:28]
|
||||
)
|
||||
fw_version = fw_version_bytes.decode('utf-8').rstrip('\x00')
|
||||
return cls(mcu_clock_hz, timer_freq, elf_build_id, fw_version)
|
||||
|
||||
def to_bytes(self) -> bytes:
|
||||
"""Serialize Metadata to binary format."""
|
||||
fw_version_bytes = self.fw_version.encode('utf-8')[:16].ljust(16, b'\x00')
|
||||
return struct.pack('<III16s', self.mcu_clock_hz, self.timer_freq,
|
||||
self.elf_build_id, fw_version_bytes)
|
||||
|
||||
|
||||
@dataclass
|
||||
class StatusInfo:
|
||||
"""Status information from embedded device.
|
||||
|
||||
Attributes:
|
||||
is_profiling: Whether profiling is currently active
|
||||
buffer_overflows: Number of buffer overflow events
|
||||
records_captured: Total number of records captured
|
||||
buffer_usage_percent: Current buffer usage percentage
|
||||
"""
|
||||
is_profiling: bool
|
||||
buffer_overflows: int
|
||||
records_captured: int
|
||||
buffer_usage_percent: int
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, data: bytes) -> 'StatusInfo':
|
||||
"""Parse StatusInfo from binary data.
|
||||
|
||||
Format: <B (is_profiling) <I (overflows) <I (records) <B (buffer_pct)
|
||||
Total: 10 bytes
|
||||
"""
|
||||
if len(data) < 10:
|
||||
raise ValueError(f"Invalid StatusInfo size: {len(data)} bytes")
|
||||
|
||||
is_profiling, buffer_overflows, records_captured, buffer_usage_percent = \
|
||||
struct.unpack('<BIIB', data[:10])
|
||||
return cls(bool(is_profiling), buffer_overflows, records_captured,
|
||||
buffer_usage_percent)
|
||||
|
||||
|
||||
class CommandPacket:
|
||||
"""Command packet sent from host to embedded device."""
|
||||
|
||||
def __init__(self, cmd: Command, payload: bytes = b''):
|
||||
"""Create a command packet.
|
||||
|
||||
Args:
|
||||
cmd: Command type
|
||||
payload: Optional payload (max 8 bytes)
|
||||
"""
|
||||
if len(payload) > 8:
|
||||
raise ValueError("Command payload cannot exceed 8 bytes")
|
||||
self.cmd = cmd
|
||||
self.payload = payload.ljust(8, b'\x00')
|
||||
|
||||
def to_bytes(self) -> bytes:
|
||||
"""Serialize command packet to binary format.
|
||||
|
||||
Format: <B (header) <B (cmd) <B (payload_len) 8s (payload) <B (checksum)
|
||||
Total: 12 bytes
|
||||
"""
|
||||
payload_len = len(self.payload.rstrip(b'\x00'))
|
||||
data = struct.pack('<BBB8s', COMMAND_HEADER, self.cmd, payload_len, self.payload)
|
||||
checksum = sum(data) & 0xFF
|
||||
return data + struct.pack('<B', checksum)
|
||||
|
||||
|
||||
class ResponsePacket:
|
||||
"""Response packet from embedded device to host."""
|
||||
|
||||
def __init__(self, response_type: ResponseType, payload: bytes):
|
||||
"""Create a response packet.
|
||||
|
||||
Args:
|
||||
response_type: Type of response
|
||||
payload: Response payload
|
||||
"""
|
||||
self.response_type = response_type
|
||||
self.payload = payload
|
||||
|
||||
@staticmethod
|
||||
def calculate_crc16(data: bytes) -> int:
|
||||
"""Calculate CRC16-CCITT for data validation."""
|
||||
calculator = crc.Calculator(crc.Crc16.CCITT)
|
||||
return calculator.checksum(data)
|
||||
|
||||
def to_bytes(self) -> bytes:
|
||||
"""Serialize response packet to binary format.
|
||||
|
||||
Format: <H (header) <B (type) <H (payload_len) payload <H (crc16) <B (end)
|
||||
"""
|
||||
payload_len = len(self.payload)
|
||||
header_data = struct.pack('<HBH', RESPONSE_HEADER, self.response_type,
|
||||
payload_len)
|
||||
data = header_data + self.payload
|
||||
crc16 = self.calculate_crc16(data)
|
||||
return data + struct.pack('<HB', crc16, RESPONSE_END)
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, data: bytes) -> Optional['ResponsePacket']:
|
||||
"""Parse response packet from binary data.
|
||||
|
||||
Returns:
|
||||
ResponsePacket if valid, None otherwise
|
||||
"""
|
||||
if len(data) < 8: # Minimum packet size
|
||||
return None
|
||||
|
||||
# Parse header
|
||||
header, response_type, payload_len = struct.unpack('<HBH', data[:5])
|
||||
|
||||
if header != RESPONSE_HEADER:
|
||||
raise ValueError(f"Invalid response header: 0x{header:04X}")
|
||||
|
||||
# Check if we have enough data
|
||||
total_len = 5 + payload_len + 3 # header + payload + crc + end
|
||||
if len(data) < total_len:
|
||||
return None
|
||||
|
||||
# Extract payload
|
||||
payload = data[5:5+payload_len]
|
||||
|
||||
# Verify CRC
|
||||
crc16_expected = struct.unpack('<H', data[5+payload_len:5+payload_len+2])[0]
|
||||
crc16_actual = cls.calculate_crc16(data[:5+payload_len])
|
||||
|
||||
if crc16_expected != crc16_actual:
|
||||
raise ValueError(f"CRC mismatch: expected 0x{crc16_expected:04X}, "
|
||||
f"got 0x{crc16_actual:04X}")
|
||||
|
||||
# Verify end marker
|
||||
end_marker = data[5+payload_len+2]
|
||||
if end_marker != RESPONSE_END:
|
||||
raise ValueError(f"Invalid end marker: 0x{end_marker:02X}")
|
||||
|
||||
return cls(ResponseType(response_type), payload)
|
||||
|
||||
def parse_payload(self) -> object:
|
||||
"""Parse the payload based on response type.
|
||||
|
||||
Returns:
|
||||
Parsed payload object (Metadata, StatusInfo, List[ProfileRecord], etc.)
|
||||
"""
|
||||
if self.response_type == ResponseType.METADATA:
|
||||
return Metadata.from_bytes(self.payload)
|
||||
|
||||
elif self.response_type == ResponseType.STATUS:
|
||||
return StatusInfo.from_bytes(self.payload)
|
||||
|
||||
elif self.response_type == ResponseType.PROFILE_DATA:
|
||||
# First byte is protocol version
|
||||
if len(self.payload) < 3:
|
||||
return []
|
||||
|
||||
version = self.payload[0]
|
||||
if version != PROTOCOL_VERSION:
|
||||
raise ValueError(f"Unsupported protocol version: {version}")
|
||||
|
||||
record_count = struct.unpack('<H', self.payload[1:3])[0]
|
||||
records = []
|
||||
|
||||
offset = 3
|
||||
for _ in range(record_count):
|
||||
if offset + 14 > len(self.payload):
|
||||
break
|
||||
record = ProfileRecord.from_bytes(self.payload[offset:offset+14])
|
||||
records.append(record)
|
||||
offset += 14
|
||||
|
||||
return records
|
||||
|
||||
elif self.response_type == ResponseType.ACK:
|
||||
return True
|
||||
|
||||
elif self.response_type == ResponseType.NACK:
|
||||
return False
|
||||
|
||||
return self.payload
|
||||
267
host/miniprofiler/serial_reader.py
Normal file
267
host/miniprofiler/serial_reader.py
Normal file
@@ -0,0 +1,267 @@
|
||||
"""Serial communication module for MiniProfiler.
|
||||
|
||||
Handles UART communication with the embedded device, including
|
||||
sending commands and receiving profiling data.
|
||||
"""
|
||||
|
||||
import serial
|
||||
import threading
|
||||
import time
|
||||
import logging
|
||||
from typing import Callable, Optional, List
|
||||
from queue import Queue
|
||||
|
||||
from .protocol import (
|
||||
Command, CommandPacket, ResponsePacket, ResponseType,
|
||||
ProfileRecord, Metadata, StatusInfo
|
||||
)
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class SerialReader:
|
||||
"""Manages serial communication with the embedded profiling device."""
|
||||
|
||||
def __init__(self, port: str, baudrate: int = 115200, timeout: float = 1.0):
|
||||
"""Initialize serial reader.
|
||||
|
||||
Args:
|
||||
port: Serial port name (e.g., '/dev/ttyUSB0', 'COM3')
|
||||
baudrate: Baud rate (default: 115200)
|
||||
timeout: Read timeout in seconds
|
||||
"""
|
||||
self.port = port
|
||||
self.baudrate = baudrate
|
||||
self.timeout = timeout
|
||||
self.serial: Optional[serial.Serial] = None
|
||||
self.running = False
|
||||
self.read_thread: Optional[threading.Thread] = None
|
||||
self.command_queue = Queue()
|
||||
|
||||
# Callbacks
|
||||
self.on_profile_data: Optional[Callable[[List[ProfileRecord]], None]] = None
|
||||
self.on_metadata: Optional[Callable[[Metadata], None]] = None
|
||||
self.on_status: Optional[Callable[[StatusInfo], None]] = None
|
||||
self.on_error: Optional[Callable[[Exception], None]] = None
|
||||
|
||||
def connect(self) -> bool:
|
||||
"""Open the serial port connection.
|
||||
|
||||
Returns:
|
||||
True if connection successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
self.serial = serial.Serial(
|
||||
port=self.port,
|
||||
baudrate=self.baudrate,
|
||||
timeout=self.timeout,
|
||||
bytesize=serial.EIGHTBITS,
|
||||
parity=serial.PARITY_NONE,
|
||||
stopbits=serial.STOPBITS_ONE
|
||||
)
|
||||
logger.info(f"Connected to {self.port} at {self.baudrate} baud")
|
||||
return True
|
||||
except serial.SerialException as e:
|
||||
logger.error(f"Failed to connect to {self.port}: {e}")
|
||||
if self.on_error:
|
||||
self.on_error(e)
|
||||
return False
|
||||
|
||||
def disconnect(self):
|
||||
"""Close the serial port connection."""
|
||||
if self.serial and self.serial.is_open:
|
||||
self.serial.close()
|
||||
logger.info(f"Disconnected from {self.port}")
|
||||
|
||||
def send_command(self, cmd: Command, payload: bytes = b'') -> bool:
|
||||
"""Send a command to the embedded device.
|
||||
|
||||
Args:
|
||||
cmd: Command to send
|
||||
payload: Optional command payload
|
||||
|
||||
Returns:
|
||||
True if command sent successfully, False otherwise
|
||||
"""
|
||||
if not self.serial or not self.serial.is_open:
|
||||
logger.error("Serial port not open")
|
||||
return False
|
||||
|
||||
try:
|
||||
packet = CommandPacket(cmd, payload)
|
||||
data = packet.to_bytes()
|
||||
self.serial.write(data)
|
||||
logger.debug(f"Sent command: {cmd.name}")
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to send command {cmd.name}: {e}")
|
||||
if self.on_error:
|
||||
self.on_error(e)
|
||||
return False
|
||||
|
||||
def start_profiling(self) -> bool:
|
||||
"""Send START_PROFILING command."""
|
||||
return self.send_command(Command.START_PROFILING)
|
||||
|
||||
def stop_profiling(self) -> bool:
|
||||
"""Send STOP_PROFILING command."""
|
||||
return self.send_command(Command.STOP_PROFILING)
|
||||
|
||||
def get_metadata(self) -> bool:
|
||||
"""Request metadata from the device."""
|
||||
return self.send_command(Command.GET_METADATA)
|
||||
|
||||
def get_status(self) -> bool:
|
||||
"""Request status from the device."""
|
||||
return self.send_command(Command.GET_STATUS)
|
||||
|
||||
def reset_buffers(self) -> bool:
|
||||
"""Send RESET_BUFFERS command."""
|
||||
return self.send_command(Command.RESET_BUFFERS)
|
||||
|
||||
def _read_packet(self) -> Optional[ResponsePacket]:
|
||||
"""Read a response packet from the serial port.
|
||||
|
||||
Returns:
|
||||
ResponsePacket if valid packet received, None otherwise
|
||||
"""
|
||||
if not self.serial or not self.serial.is_open:
|
||||
return None
|
||||
|
||||
buffer = bytearray()
|
||||
|
||||
try:
|
||||
# Search for header (0xAA55)
|
||||
while self.running:
|
||||
byte = self.serial.read(1)
|
||||
if not byte:
|
||||
continue
|
||||
|
||||
buffer.append(byte[0])
|
||||
|
||||
# Check for header
|
||||
if len(buffer) >= 2:
|
||||
header = (buffer[-2] << 8) | buffer[-1]
|
||||
if header == 0xAA55:
|
||||
# Found header, read rest of packet
|
||||
buffer = bytearray([0xAA, 0x55])
|
||||
break
|
||||
# Keep only last byte for next iteration
|
||||
if len(buffer) > 1:
|
||||
buffer = bytearray([buffer[-1]])
|
||||
|
||||
if not self.running:
|
||||
return None
|
||||
|
||||
# Read type and length (3 bytes)
|
||||
header_rest = self.serial.read(3)
|
||||
if len(header_rest) < 3:
|
||||
return None
|
||||
buffer.extend(header_rest)
|
||||
|
||||
# Extract payload length
|
||||
payload_len = (header_rest[2] << 8) | header_rest[1]
|
||||
|
||||
# Read payload + CRC (2 bytes) + end marker (1 byte)
|
||||
remaining = payload_len + 3
|
||||
remaining_data = self.serial.read(remaining)
|
||||
if len(remaining_data) < remaining:
|
||||
logger.warning(f"Incomplete packet: expected {remaining}, got {len(remaining_data)}")
|
||||
return None
|
||||
|
||||
buffer.extend(remaining_data)
|
||||
|
||||
# Parse packet
|
||||
packet = ResponsePacket.from_bytes(bytes(buffer))
|
||||
return packet
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error reading packet: {e}")
|
||||
if self.on_error:
|
||||
self.on_error(e)
|
||||
return None
|
||||
|
||||
def _reader_thread(self):
|
||||
"""Background thread for reading serial data."""
|
||||
logger.info("Serial reader thread started")
|
||||
|
||||
while self.running:
|
||||
packet = self._read_packet()
|
||||
if not packet:
|
||||
continue
|
||||
|
||||
try:
|
||||
# Parse and dispatch based on response type
|
||||
if packet.response_type == ResponseType.PROFILE_DATA:
|
||||
records = packet.parse_payload()
|
||||
if self.on_profile_data and isinstance(records, list):
|
||||
self.on_profile_data(records)
|
||||
|
||||
elif packet.response_type == ResponseType.METADATA:
|
||||
metadata = packet.parse_payload()
|
||||
if self.on_metadata and isinstance(metadata, Metadata):
|
||||
self.on_metadata(metadata)
|
||||
|
||||
elif packet.response_type == ResponseType.STATUS:
|
||||
status = packet.parse_payload()
|
||||
if self.on_status and isinstance(status, StatusInfo):
|
||||
self.on_status(status)
|
||||
|
||||
elif packet.response_type == ResponseType.ACK:
|
||||
logger.debug("Received ACK")
|
||||
|
||||
elif packet.response_type == ResponseType.NACK:
|
||||
logger.warning("Received NACK")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error processing packet: {e}")
|
||||
if self.on_error:
|
||||
self.on_error(e)
|
||||
|
||||
logger.info("Serial reader thread stopped")
|
||||
|
||||
def start_reading(self) -> bool:
|
||||
"""Start background thread to read serial data.
|
||||
|
||||
Returns:
|
||||
True if thread started successfully, False otherwise
|
||||
"""
|
||||
if self.running:
|
||||
logger.warning("Reader thread already running")
|
||||
return False
|
||||
|
||||
if not self.serial or not self.serial.is_open:
|
||||
logger.error("Serial port not open")
|
||||
return False
|
||||
|
||||
self.running = True
|
||||
self.read_thread = threading.Thread(target=self._reader_thread, daemon=True)
|
||||
self.read_thread.start()
|
||||
logger.info("Started serial reading thread")
|
||||
return True
|
||||
|
||||
def stop_reading(self):
|
||||
"""Stop the background reading thread."""
|
||||
if not self.running:
|
||||
return
|
||||
|
||||
logger.info("Stopping serial reader thread...")
|
||||
self.running = False
|
||||
|
||||
if self.read_thread:
|
||||
self.read_thread.join(timeout=2.0)
|
||||
if self.read_thread.is_alive():
|
||||
logger.warning("Reader thread did not stop cleanly")
|
||||
else:
|
||||
logger.info("Reader thread stopped")
|
||||
|
||||
def __enter__(self):
|
||||
"""Context manager entry."""
|
||||
self.connect()
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
"""Context manager exit."""
|
||||
self.stop_reading()
|
||||
self.disconnect()
|
||||
205
host/miniprofiler/symbolizer.py
Normal file
205
host/miniprofiler/symbolizer.py
Normal file
@@ -0,0 +1,205 @@
|
||||
"""Symbol resolution using ELF/DWARF debug information.
|
||||
|
||||
This module resolves function addresses to human-readable names,
|
||||
file locations, and line numbers using the ELF symbol table and
|
||||
DWARF debugging information.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Dict, Optional, Tuple
|
||||
from pathlib import Path
|
||||
from elftools.elf.elffile import ELFFile
|
||||
from elftools.dwarf.descriptions import describe_form_class
|
||||
from elftools.dwarf.die import DIE
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class SymbolInfo:
|
||||
"""Information about a symbol."""
|
||||
|
||||
def __init__(self, name: str, file: str = "", line: int = 0, size: int = 0):
|
||||
"""Initialize symbol information.
|
||||
|
||||
Args:
|
||||
name: Function or symbol name
|
||||
file: Source file path
|
||||
line: Line number in source file
|
||||
size: Symbol size in bytes
|
||||
"""
|
||||
self.name = name
|
||||
self.file = file
|
||||
self.line = line
|
||||
self.size = size
|
||||
|
||||
def __repr__(self) -> str:
|
||||
if self.file and self.line:
|
||||
return f"{self.name} ({self.file}:{self.line})"
|
||||
return self.name
|
||||
|
||||
|
||||
class Symbolizer:
|
||||
"""Resolves addresses to symbol names using ELF/DWARF information."""
|
||||
|
||||
def __init__(self, elf_path: str):
|
||||
"""Initialize symbolizer with an ELF file.
|
||||
|
||||
Args:
|
||||
elf_path: Path to the ELF file with debug symbols
|
||||
"""
|
||||
self.elf_path = Path(elf_path)
|
||||
self.symbols: Dict[int, SymbolInfo] = {}
|
||||
self.loaded = False
|
||||
|
||||
if self.elf_path.exists():
|
||||
self._load_symbols()
|
||||
else:
|
||||
logger.warning(f"ELF file not found: {elf_path}")
|
||||
|
||||
def _load_symbols(self):
|
||||
"""Load symbols from the ELF file."""
|
||||
try:
|
||||
with open(self.elf_path, 'rb') as f:
|
||||
elffile = ELFFile(f)
|
||||
|
||||
# Load symbol table
|
||||
self._load_symbol_table(elffile)
|
||||
|
||||
# Load DWARF debug info for line numbers
|
||||
if elffile.has_dwarf_info():
|
||||
self._load_dwarf_info(elffile)
|
||||
|
||||
self.loaded = True
|
||||
logger.info(f"Loaded {len(self.symbols)} symbols from {self.elf_path}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load symbols from {self.elf_path}: {e}")
|
||||
self.loaded = False
|
||||
|
||||
def _load_symbol_table(self, elffile: ELFFile):
|
||||
"""Load function symbols from the symbol table.
|
||||
|
||||
Args:
|
||||
elffile: Parsed ELF file object
|
||||
"""
|
||||
symtab = elffile.get_section_by_name('.symtab')
|
||||
if not symtab:
|
||||
logger.warning("No symbol table found in ELF file")
|
||||
return
|
||||
|
||||
for symbol in symtab.iter_symbols():
|
||||
# Only interested in function symbols
|
||||
if symbol['st_info']['type'] == 'STT_FUNC':
|
||||
addr = symbol['st_value']
|
||||
name = symbol.name
|
||||
size = symbol['st_size']
|
||||
|
||||
if addr and name:
|
||||
self.symbols[addr] = SymbolInfo(name, size=size)
|
||||
|
||||
logger.debug(f"Loaded {len(self.symbols)} function symbols from symbol table")
|
||||
|
||||
def _load_dwarf_info(self, elffile: ELFFile):
|
||||
"""Load DWARF debug information for file/line mappings.
|
||||
|
||||
Args:
|
||||
elffile: Parsed ELF file object
|
||||
"""
|
||||
dwarfinfo = elffile.get_dwarf_info()
|
||||
|
||||
# Process line number information
|
||||
for CU in dwarfinfo.iter_CUs():
|
||||
lineprog = dwarfinfo.line_program_for_CU(CU)
|
||||
if not lineprog:
|
||||
continue
|
||||
|
||||
# Get the file table
|
||||
file_entries = lineprog.header['file_entry']
|
||||
|
||||
# Process line program entries
|
||||
prevstate = None
|
||||
for entry in lineprog.get_entries():
|
||||
if entry.state is None:
|
||||
continue
|
||||
|
||||
# Look for end of sequence or new addresses
|
||||
state = entry.state
|
||||
if prevstate and state.address != prevstate.address:
|
||||
addr = prevstate.address
|
||||
file_index = prevstate.file - 1
|
||||
|
||||
if 0 <= file_index < len(file_entries):
|
||||
file_entry = file_entries[file_index]
|
||||
filename = file_entry.name.decode('utf-8') if isinstance(
|
||||
file_entry.name, bytes) else file_entry.name
|
||||
|
||||
# Update existing symbol or create new one
|
||||
if addr in self.symbols:
|
||||
self.symbols[addr].file = filename
|
||||
self.symbols[addr].line = prevstate.line
|
||||
else:
|
||||
# Create placeholder symbol for addresses without symbol table entry
|
||||
self.symbols[addr] = SymbolInfo(
|
||||
f"func_0x{addr:08x}",
|
||||
file=filename,
|
||||
line=prevstate.line
|
||||
)
|
||||
|
||||
prevstate = state
|
||||
|
||||
logger.debug("Loaded DWARF debug information")
|
||||
|
||||
def resolve(self, addr: int) -> SymbolInfo:
|
||||
"""Resolve an address to symbol information.
|
||||
|
||||
Args:
|
||||
addr: Function address to resolve
|
||||
|
||||
Returns:
|
||||
SymbolInfo object (may contain placeholder name if not found)
|
||||
"""
|
||||
# Exact match
|
||||
if addr in self.symbols:
|
||||
return self.symbols[addr]
|
||||
|
||||
# Try to find the containing function (address within function range)
|
||||
for sym_addr, sym_info in self.symbols.items():
|
||||
if sym_addr <= addr < sym_addr + sym_info.size:
|
||||
return sym_info
|
||||
|
||||
# Not found - return placeholder
|
||||
return SymbolInfo(f"unknown_0x{addr:08x}")
|
||||
|
||||
def resolve_name(self, addr: int) -> str:
|
||||
"""Resolve an address to a function name.
|
||||
|
||||
Args:
|
||||
addr: Function address
|
||||
|
||||
Returns:
|
||||
Function name string
|
||||
"""
|
||||
return self.resolve(addr).name
|
||||
|
||||
def resolve_location(self, addr: int) -> str:
|
||||
"""Resolve an address to a file:line location string.
|
||||
|
||||
Args:
|
||||
addr: Function address
|
||||
|
||||
Returns:
|
||||
Location string in format "file:line" or empty string
|
||||
"""
|
||||
info = self.resolve(addr)
|
||||
if info.file and info.line:
|
||||
return f"{info.file}:{info.line}"
|
||||
return ""
|
||||
|
||||
def get_all_symbols(self) -> Dict[int, SymbolInfo]:
|
||||
"""Get all loaded symbols.
|
||||
|
||||
Returns:
|
||||
Dictionary mapping addresses to SymbolInfo objects
|
||||
"""
|
||||
return self.symbols.copy()
|
||||
315
host/miniprofiler/web_server.py
Normal file
315
host/miniprofiler/web_server.py
Normal file
@@ -0,0 +1,315 @@
|
||||
"""Flask web server for MiniProfiler visualization.
|
||||
|
||||
Provides a web interface for real-time profiling visualization including
|
||||
flame graphs, timelines, and statistics tables.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from flask import Flask, render_template, jsonify, request
|
||||
from flask_socketio import SocketIO, emit
|
||||
from typing import Optional
|
||||
import threading
|
||||
|
||||
from .serial_reader import SerialReader
|
||||
from .analyzer import ProfileAnalyzer
|
||||
from .symbolizer import Symbolizer
|
||||
from .protocol import ProfileRecord, Metadata, StatusInfo
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class ProfilerWebServer:
|
||||
"""Web server for profiler visualization and control."""
|
||||
|
||||
def __init__(self, host: str = '0.0.0.0', port: int = 5000):
|
||||
"""Initialize the web server.
|
||||
|
||||
Args:
|
||||
host: Host address to bind to
|
||||
port: Port number to listen on
|
||||
"""
|
||||
self.host = host
|
||||
self.port = port
|
||||
|
||||
# Initialize Flask app
|
||||
self.app = Flask(__name__,
|
||||
template_folder='../web/templates',
|
||||
static_folder='../web/static')
|
||||
self.app.config['SECRET_KEY'] = 'miniprofiler-secret-key'
|
||||
|
||||
# Initialize SocketIO
|
||||
self.socketio = SocketIO(self.app, cors_allowed_origins="*")
|
||||
|
||||
# Profiler components
|
||||
self.serial_reader: Optional[SerialReader] = None
|
||||
self.analyzer = ProfileAnalyzer()
|
||||
self.symbolizer: Optional[Symbolizer] = None
|
||||
self.metadata: Optional[Metadata] = None
|
||||
|
||||
# State
|
||||
self.is_connected = False
|
||||
self.is_profiling = False
|
||||
|
||||
# Setup routes
|
||||
self._setup_routes()
|
||||
self._setup_socketio_handlers()
|
||||
|
||||
def _setup_routes(self):
|
||||
"""Setup Flask HTTP routes."""
|
||||
|
||||
@self.app.route('/')
|
||||
def index():
|
||||
"""Main page."""
|
||||
return render_template('index.html')
|
||||
|
||||
@self.app.route('/api/status')
|
||||
def status():
|
||||
"""Get server status."""
|
||||
return jsonify({
|
||||
'connected': self.is_connected,
|
||||
'profiling': self.is_profiling,
|
||||
'has_data': len(self.analyzer.records) > 0,
|
||||
'record_count': len(self.analyzer.records)
|
||||
})
|
||||
|
||||
@self.app.route('/api/summary')
|
||||
def summary():
|
||||
"""Get profiling summary statistics."""
|
||||
return jsonify(self.analyzer.get_summary())
|
||||
|
||||
@self.app.route('/api/flamegraph')
|
||||
def flamegraph():
|
||||
"""Get flame graph data."""
|
||||
return jsonify(self.analyzer.to_flamegraph_json())
|
||||
|
||||
@self.app.route('/api/timeline')
|
||||
def timeline():
|
||||
"""Get timeline data."""
|
||||
return jsonify(self.analyzer.to_timeline_json())
|
||||
|
||||
@self.app.route('/api/statistics')
|
||||
def statistics():
|
||||
"""Get statistics table data."""
|
||||
return jsonify(self.analyzer.to_statistics_json())
|
||||
|
||||
def _setup_socketio_handlers(self):
|
||||
"""Setup SocketIO event handlers."""
|
||||
|
||||
@self.socketio.on('connect')
|
||||
def handle_connect():
|
||||
"""Handle client connection."""
|
||||
logger.info("Client connected")
|
||||
emit('status', {
|
||||
'connected': self.is_connected,
|
||||
'profiling': self.is_profiling
|
||||
})
|
||||
|
||||
@self.socketio.on('disconnect')
|
||||
def handle_disconnect():
|
||||
"""Handle client disconnection."""
|
||||
logger.info("Client disconnected")
|
||||
|
||||
@self.socketio.on('connect_serial')
|
||||
def handle_connect_serial(data):
|
||||
"""Connect to serial port.
|
||||
|
||||
Args:
|
||||
data: Dict with 'port' and optional 'baudrate'
|
||||
"""
|
||||
port = data.get('port')
|
||||
baudrate = data.get('baudrate', 115200)
|
||||
elf_path = data.get('elf_path', None)
|
||||
|
||||
if not port:
|
||||
emit('error', {'message': 'No port specified'})
|
||||
return
|
||||
|
||||
try:
|
||||
# Load symbolizer if ELF path provided
|
||||
if elf_path:
|
||||
self.symbolizer = Symbolizer(elf_path)
|
||||
self.analyzer.symbolizer = self.symbolizer
|
||||
|
||||
# Create serial reader
|
||||
self.serial_reader = SerialReader(port, baudrate)
|
||||
|
||||
# Set up callbacks
|
||||
self.serial_reader.on_profile_data = self._on_profile_data
|
||||
self.serial_reader.on_metadata = self._on_metadata
|
||||
self.serial_reader.on_status = self._on_status
|
||||
self.serial_reader.on_error = self._on_error
|
||||
|
||||
# Connect
|
||||
if self.serial_reader.connect():
|
||||
self.serial_reader.start_reading()
|
||||
self.is_connected = True
|
||||
|
||||
# Request metadata
|
||||
self.serial_reader.get_metadata()
|
||||
|
||||
emit('connected', {'port': port, 'baudrate': baudrate})
|
||||
logger.info(f"Connected to {port} at {baudrate} baud")
|
||||
else:
|
||||
emit('error', {'message': f'Failed to connect to {port}'})
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error connecting to serial: {e}")
|
||||
emit('error', {'message': str(e)})
|
||||
|
||||
@self.socketio.on('disconnect_serial')
|
||||
def handle_disconnect_serial():
|
||||
"""Disconnect from serial port."""
|
||||
if self.serial_reader:
|
||||
self.serial_reader.stop_reading()
|
||||
self.serial_reader.disconnect()
|
||||
self.serial_reader = None
|
||||
self.is_connected = False
|
||||
self.is_profiling = False
|
||||
emit('disconnected', {})
|
||||
logger.info("Disconnected from serial port")
|
||||
|
||||
@self.socketio.on('start_profiling')
|
||||
def handle_start_profiling():
|
||||
"""Start profiling on the device."""
|
||||
if not self.serial_reader or not self.is_connected:
|
||||
emit('error', {'message': 'Not connected to device'})
|
||||
return
|
||||
|
||||
if self.serial_reader.start_profiling():
|
||||
self.is_profiling = True
|
||||
emit('profiling_started', {})
|
||||
logger.info("Started profiling")
|
||||
else:
|
||||
emit('error', {'message': 'Failed to start profiling'})
|
||||
|
||||
@self.socketio.on('stop_profiling')
|
||||
def handle_stop_profiling():
|
||||
"""Stop profiling on the device."""
|
||||
if not self.serial_reader or not self.is_connected:
|
||||
emit('error', {'message': 'Not connected to device'})
|
||||
return
|
||||
|
||||
if self.serial_reader.stop_profiling():
|
||||
self.is_profiling = False
|
||||
emit('profiling_stopped', {})
|
||||
logger.info("Stopped profiling")
|
||||
else:
|
||||
emit('error', {'message': 'Failed to stop profiling'})
|
||||
|
||||
@self.socketio.on('clear_data')
|
||||
def handle_clear_data():
|
||||
"""Clear all profiling data."""
|
||||
self.analyzer.clear()
|
||||
emit('data_cleared', {})
|
||||
self._emit_data_update()
|
||||
logger.info("Cleared profiling data")
|
||||
|
||||
@self.socketio.on('reset_buffers')
|
||||
def handle_reset_buffers():
|
||||
"""Reset device buffers."""
|
||||
if not self.serial_reader or not self.is_connected:
|
||||
emit('error', {'message': 'Not connected to device'})
|
||||
return
|
||||
|
||||
if self.serial_reader.reset_buffers():
|
||||
emit('buffers_reset', {})
|
||||
logger.info("Reset device buffers")
|
||||
else:
|
||||
emit('error', {'message': 'Failed to reset buffers'})
|
||||
|
||||
def _on_profile_data(self, records):
|
||||
"""Callback for receiving profile data.
|
||||
|
||||
Args:
|
||||
records: List of ProfileRecord objects
|
||||
"""
|
||||
logger.debug(f"Received {len(records)} profile records")
|
||||
self.analyzer.add_records(records)
|
||||
self._emit_data_update()
|
||||
|
||||
def _on_metadata(self, metadata: Metadata):
|
||||
"""Callback for receiving metadata.
|
||||
|
||||
Args:
|
||||
metadata: Metadata object
|
||||
"""
|
||||
logger.info(f"Received metadata: {metadata.fw_version}, "
|
||||
f"MCU: {metadata.mcu_clock_hz / 1e6:.1f} MHz")
|
||||
self.metadata = metadata
|
||||
self.socketio.emit('metadata', {
|
||||
'fw_version': metadata.fw_version,
|
||||
'mcu_clock_hz': metadata.mcu_clock_hz,
|
||||
'timer_freq': metadata.timer_freq,
|
||||
'build_id': f"0x{metadata.elf_build_id:08X}"
|
||||
})
|
||||
|
||||
def _on_status(self, status: StatusInfo):
|
||||
"""Callback for receiving status updates.
|
||||
|
||||
Args:
|
||||
status: StatusInfo object
|
||||
"""
|
||||
logger.debug(f"Device status: profiling={status.is_profiling}, "
|
||||
f"records={status.records_captured}, "
|
||||
f"overflows={status.buffer_overflows}")
|
||||
self.socketio.emit('device_status', {
|
||||
'is_profiling': status.is_profiling,
|
||||
'records_captured': status.records_captured,
|
||||
'buffer_overflows': status.buffer_overflows,
|
||||
'buffer_usage': status.buffer_usage_percent
|
||||
})
|
||||
|
||||
def _on_error(self, error: Exception):
|
||||
"""Callback for serial errors.
|
||||
|
||||
Args:
|
||||
error: Exception that occurred
|
||||
"""
|
||||
logger.error(f"Serial error: {error}")
|
||||
self.socketio.emit('error', {'message': str(error)})
|
||||
|
||||
def _emit_data_update(self):
|
||||
"""Emit updated profiling data to all clients."""
|
||||
try:
|
||||
# Send summary
|
||||
summary = self.analyzer.get_summary()
|
||||
self.socketio.emit('summary_update', summary)
|
||||
|
||||
# Send flamegraph data
|
||||
flamegraph_data = self.analyzer.to_flamegraph_json()
|
||||
self.socketio.emit('flamegraph_update', flamegraph_data)
|
||||
|
||||
# Send statistics
|
||||
stats_data = self.analyzer.to_statistics_json()
|
||||
self.socketio.emit('statistics_update', stats_data)
|
||||
|
||||
# Send timeline data (can be large, so only send periodically)
|
||||
if len(self.analyzer.records) % 50 == 0: # Every 50 records
|
||||
timeline_data = self.analyzer.to_timeline_json()
|
||||
self.socketio.emit('timeline_update', timeline_data)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error emitting data update: {e}")
|
||||
|
||||
def run(self, debug: bool = False):
|
||||
"""Run the web server.
|
||||
|
||||
Args:
|
||||
debug: Enable debug mode
|
||||
"""
|
||||
logger.info(f"Starting web server on {self.host}:{self.port}")
|
||||
self.socketio.run(self.app, host=self.host, port=self.port, debug=debug)
|
||||
|
||||
|
||||
def create_app(host: str = '0.0.0.0', port: int = 5000) -> ProfilerWebServer:
|
||||
"""Create and configure the profiler web server.
|
||||
|
||||
Args:
|
||||
host: Host address
|
||||
port: Port number
|
||||
|
||||
Returns:
|
||||
Configured ProfilerWebServer instance
|
||||
"""
|
||||
return ProfilerWebServer(host, port)
|
||||
7
host/requirements.txt
Normal file
7
host/requirements.txt
Normal file
@@ -0,0 +1,7 @@
|
||||
Flask>=3.0.0
|
||||
Flask-SocketIO>=5.3.0
|
||||
pyserial>=3.5
|
||||
pyelftools>=0.29
|
||||
crc>=6.1.1
|
||||
python-socketio>=5.10.0
|
||||
eventlet>=0.33.3
|
||||
13
host/run.py
Executable file
13
host/run.py
Executable file
@@ -0,0 +1,13 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Quick start script for MiniProfiler."""
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Add parent directory to path
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from miniprofiler.cli import main
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
51
host/setup.py
Normal file
51
host/setup.py
Normal file
@@ -0,0 +1,51 @@
|
||||
"""Setup script for MiniProfiler host application."""
|
||||
|
||||
from setuptools import setup, find_packages
|
||||
|
||||
with open("../README.md", "r", encoding="utf-8") as fh:
|
||||
long_description = fh.read()
|
||||
|
||||
setup(
|
||||
name="miniprofiler",
|
||||
version="0.1.0",
|
||||
author="MiniProfiler Contributors",
|
||||
description="Host application for embedded STM32 profiling",
|
||||
long_description=long_description,
|
||||
long_description_content_type="text/markdown",
|
||||
url="https://github.com/yourusername/miniprofiler",
|
||||
packages=find_packages(),
|
||||
classifiers=[
|
||||
"Development Status :: 3 - Alpha",
|
||||
"Intended Audience :: Developers",
|
||||
"Topic :: Software Development :: Embedded Systems",
|
||||
"License :: OSI Approved :: MIT License",
|
||||
"Programming Language :: Python :: 3",
|
||||
"Programming Language :: Python :: 3.8",
|
||||
"Programming Language :: Python :: 3.9",
|
||||
"Programming Language :: Python :: 3.10",
|
||||
"Programming Language :: Python :: 3.11",
|
||||
],
|
||||
python_requires=">=3.8",
|
||||
install_requires=[
|
||||
"Flask>=3.0.0",
|
||||
"Flask-SocketIO>=5.3.0",
|
||||
"pyserial>=3.5",
|
||||
"pyelftools>=0.29",
|
||||
"crc>=6.1.1",
|
||||
"python-socketio>=5.10.0",
|
||||
"eventlet>=0.33.3",
|
||||
],
|
||||
entry_points={
|
||||
"console_scripts": [
|
||||
"miniprofiler=miniprofiler.cli:main",
|
||||
],
|
||||
},
|
||||
include_package_data=True,
|
||||
package_data={
|
||||
"miniprofiler": [
|
||||
"../web/templates/*.html",
|
||||
"../web/static/css/*.css",
|
||||
"../web/static/js/*.js",
|
||||
],
|
||||
},
|
||||
)
|
||||
1
host/tests/__init__.py
Normal file
1
host/tests/__init__.py
Normal file
@@ -0,0 +1 @@
|
||||
"""Test utilities for MiniProfiler."""
|
||||
236
host/tests/sample_data_generator.py
Normal file
236
host/tests/sample_data_generator.py
Normal file
@@ -0,0 +1,236 @@
|
||||
"""Sample data generator for testing the profiler without hardware.
|
||||
|
||||
Generates realistic profiling data that mimics an embedded application
|
||||
with nested function calls, varying execution times, and typical patterns.
|
||||
"""
|
||||
|
||||
import random
|
||||
from typing import List
|
||||
from miniprofiler.protocol import ProfileRecord, Metadata, ResponsePacket, ResponseType
|
||||
import struct
|
||||
|
||||
|
||||
# Sample function addresses (simulating typical embedded firmware)
|
||||
FUNCTIONS = {
|
||||
0x08000100: "main",
|
||||
0x08000200: "app_init",
|
||||
0x08000220: "peripheral_init",
|
||||
0x08000240: "clock_config",
|
||||
0x08000300: "app_loop",
|
||||
0x08000320: "process_sensors",
|
||||
0x08000340: "read_temperature",
|
||||
0x08000360: "read_pressure",
|
||||
0x08000380: "process_data",
|
||||
0x080003A0: "calculate_average",
|
||||
0x080003C0: "apply_filter",
|
||||
0x08000400: "update_display",
|
||||
0x08000420: "format_string",
|
||||
0x08000440: "send_uart",
|
||||
0x08000500: "handle_interrupt",
|
||||
0x08000520: "gpio_callback",
|
||||
}
|
||||
|
||||
|
||||
def generate_metadata() -> Metadata:
|
||||
"""Generate sample metadata packet."""
|
||||
return Metadata(
|
||||
mcu_clock_hz=168_000_000, # 168 MHz (typical STM32F4)
|
||||
timer_freq=1_000_000, # 1 MHz timer
|
||||
elf_build_id=0xDEADBEEF,
|
||||
fw_version="v1.0.0-test"
|
||||
)
|
||||
|
||||
|
||||
def generate_nested_calls(
|
||||
start_time: int,
|
||||
depth: int = 0,
|
||||
max_depth: int = 5
|
||||
) -> tuple[List[ProfileRecord], int]:
|
||||
"""Generate nested function calls recursively.
|
||||
|
||||
Args:
|
||||
start_time: Starting timestamp in microseconds
|
||||
depth: Current call stack depth
|
||||
max_depth: Maximum recursion depth
|
||||
|
||||
Returns:
|
||||
Tuple of (list of ProfileRecords, end_time)
|
||||
"""
|
||||
records = []
|
||||
current_time = start_time
|
||||
|
||||
# Select random functions based on depth
|
||||
if depth == 0:
|
||||
func_addr = 0x08000300 # app_loop
|
||||
num_children = random.randint(2, 4)
|
||||
elif depth == 1:
|
||||
func_addr = random.choice([0x08000320, 0x08000380, 0x08000400])
|
||||
num_children = random.randint(1, 3)
|
||||
else:
|
||||
func_addr = random.choice(list(FUNCTIONS.keys())[depth * 2:(depth + 1) * 2 + 4])
|
||||
num_children = random.randint(0, 2) if depth < max_depth else 0
|
||||
|
||||
entry_time = current_time
|
||||
current_time += random.randint(1, 10) # Entry overhead
|
||||
|
||||
# Generate child calls
|
||||
children_records = []
|
||||
if num_children > 0 and depth < max_depth:
|
||||
for _ in range(num_children):
|
||||
child_records, current_time = generate_nested_calls(
|
||||
current_time, depth + 1, max_depth
|
||||
)
|
||||
children_records.extend(child_records)
|
||||
current_time += random.randint(5, 20) # Gap between children
|
||||
|
||||
# Add some self-time for this function
|
||||
self_time = random.randint(10, 200)
|
||||
current_time += self_time
|
||||
|
||||
exit_time = current_time
|
||||
duration = exit_time - entry_time
|
||||
|
||||
# Create record for this function
|
||||
record = ProfileRecord(
|
||||
func_addr=func_addr,
|
||||
entry_time=entry_time,
|
||||
duration_us=duration,
|
||||
depth=depth
|
||||
)
|
||||
|
||||
records.append(record)
|
||||
records.extend(children_records)
|
||||
|
||||
return records, exit_time
|
||||
|
||||
|
||||
def generate_sample_profile_data(
|
||||
num_iterations: int = 10,
|
||||
time_per_iteration: int = 10000 # 10ms per iteration
|
||||
) -> List[ProfileRecord]:
|
||||
"""Generate sample profiling data simulating multiple loop iterations.
|
||||
|
||||
Args:
|
||||
num_iterations: Number of main loop iterations
|
||||
time_per_iteration: Approximate time per iteration in microseconds
|
||||
|
||||
Returns:
|
||||
List of ProfileRecord objects
|
||||
"""
|
||||
all_records = []
|
||||
current_time = 0
|
||||
|
||||
# Generate initialization sequence (runs once)
|
||||
init_records = [
|
||||
ProfileRecord(0x08000100, current_time, 5000, 0), # main
|
||||
ProfileRecord(0x08000200, current_time + 100, 1000, 1), # app_init
|
||||
ProfileRecord(0x08000220, current_time + 150, 300, 2), # peripheral_init
|
||||
ProfileRecord(0x08000240, current_time + 500, 400, 2), # clock_config
|
||||
]
|
||||
all_records.extend(init_records)
|
||||
current_time += 5000
|
||||
|
||||
# Generate main loop iterations
|
||||
for iteration in range(num_iterations):
|
||||
records, end_time = generate_nested_calls(
|
||||
current_time,
|
||||
depth=0,
|
||||
max_depth=4
|
||||
)
|
||||
all_records.extend(records)
|
||||
current_time = end_time + random.randint(50, 200) # Idle time
|
||||
|
||||
return all_records
|
||||
|
||||
|
||||
def generate_profile_data_packet(records: List[ProfileRecord]) -> bytes:
|
||||
"""Generate a binary PROFILE_DATA response packet.
|
||||
|
||||
Args:
|
||||
records: List of ProfileRecord objects
|
||||
|
||||
Returns:
|
||||
Binary packet data
|
||||
"""
|
||||
# Build payload: version (1B) + count (2B) + records
|
||||
payload = struct.pack('<BH', 0x01, len(records))
|
||||
|
||||
for record in records:
|
||||
payload += record.to_bytes()
|
||||
|
||||
# Create response packet
|
||||
packet = ResponsePacket(ResponseType.PROFILE_DATA, payload)
|
||||
return packet.to_bytes()
|
||||
|
||||
|
||||
def generate_metadata_packet() -> bytes:
|
||||
"""Generate a binary METADATA response packet.
|
||||
|
||||
Returns:
|
||||
Binary packet data
|
||||
"""
|
||||
metadata = generate_metadata()
|
||||
packet = ResponsePacket(ResponseType.METADATA, metadata.to_bytes())
|
||||
return packet.to_bytes()
|
||||
|
||||
|
||||
def save_sample_data(filename: str, num_iterations: int = 50):
|
||||
"""Generate and save sample profiling data to a file.
|
||||
|
||||
Args:
|
||||
filename: Output filename
|
||||
num_iterations: Number of loop iterations to generate
|
||||
"""
|
||||
records = generate_sample_profile_data(num_iterations)
|
||||
|
||||
with open(filename, 'wb') as f:
|
||||
# Write metadata packet
|
||||
f.write(generate_metadata_packet())
|
||||
|
||||
# Write profile data in chunks (simulate streaming)
|
||||
chunk_size = 20
|
||||
for i in range(0, len(records), chunk_size):
|
||||
chunk = records[i:i + chunk_size]
|
||||
f.write(generate_profile_data_packet(chunk))
|
||||
|
||||
print(f"Generated {len(records)} records in {filename}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Generate sample data
|
||||
records = generate_sample_profile_data(num_iterations=20)
|
||||
|
||||
print(f"Generated {len(records)} profiling records")
|
||||
print(f"\nFirst 10 records:")
|
||||
for i, record in enumerate(records[:10]):
|
||||
func_name = FUNCTIONS.get(record.func_addr, f"0x{record.func_addr:08x}")
|
||||
print(f" [{i}] {func_name:20s} @ {record.entry_time:8d}us, "
|
||||
f"duration: {record.duration_us:6d}us, depth: {record.depth}")
|
||||
|
||||
# Save to file
|
||||
save_sample_data("sample_profile_data.bin", num_iterations=50)
|
||||
|
||||
# Also generate JSON for testing web interface
|
||||
import json
|
||||
from miniprofiler.analyzer import ProfileAnalyzer
|
||||
|
||||
analyzer = ProfileAnalyzer()
|
||||
analyzer.add_records(records)
|
||||
|
||||
# Generate flamegraph data
|
||||
flamegraph_data = analyzer.to_flamegraph_json()
|
||||
with open("sample_flamegraph.json", 'w') as f:
|
||||
json.dump(flamegraph_data, f, indent=2)
|
||||
print(f"\nGenerated sample_flamegraph.json")
|
||||
|
||||
# Generate statistics data
|
||||
stats_data = analyzer.to_statistics_json()
|
||||
with open("sample_statistics.json", 'w') as f:
|
||||
json.dump(stats_data, f, indent=2)
|
||||
print(f"Generated sample_statistics.json")
|
||||
|
||||
# Generate timeline data
|
||||
timeline_data = analyzer.to_timeline_json()
|
||||
with open("sample_timeline.json", 'w') as f:
|
||||
json.dump(timeline_data, f, indent=2)
|
||||
print(f"Generated sample_timeline.json")
|
||||
282
host/web/static/css/style.css
Normal file
282
host/web/static/css/style.css
Normal file
@@ -0,0 +1,282 @@
|
||||
/* MiniProfiler Styles */
|
||||
|
||||
* {
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
body {
|
||||
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
|
||||
background: #1e1e1e;
|
||||
color: #d4d4d4;
|
||||
line-height: 1.6;
|
||||
}
|
||||
|
||||
.container {
|
||||
max-width: 1400px;
|
||||
margin: 0 auto;
|
||||
padding: 20px;
|
||||
}
|
||||
|
||||
/* Header */
|
||||
header {
|
||||
text-align: center;
|
||||
margin-bottom: 30px;
|
||||
padding-bottom: 20px;
|
||||
border-bottom: 2px solid #3a3a3a;
|
||||
}
|
||||
|
||||
header h1 {
|
||||
font-size: 2.5em;
|
||||
color: #569cd6;
|
||||
margin-bottom: 5px;
|
||||
}
|
||||
|
||||
.subtitle {
|
||||
color: #9cdcfe;
|
||||
font-size: 0.9em;
|
||||
}
|
||||
|
||||
/* Control Panel */
|
||||
.control-panel {
|
||||
background: #252526;
|
||||
padding: 20px;
|
||||
border-radius: 8px;
|
||||
margin-bottom: 20px;
|
||||
box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
|
||||
}
|
||||
|
||||
.connection-controls, .profiling-controls {
|
||||
display: flex;
|
||||
gap: 10px;
|
||||
margin-bottom: 15px;
|
||||
flex-wrap: wrap;
|
||||
}
|
||||
|
||||
input[type="text"], input[type="number"] {
|
||||
flex: 1;
|
||||
min-width: 150px;
|
||||
padding: 10px;
|
||||
background: #3c3c3c;
|
||||
border: 1px solid #555;
|
||||
border-radius: 4px;
|
||||
color: #d4d4d4;
|
||||
font-size: 14px;
|
||||
}
|
||||
|
||||
input[type="text"]:focus, input[type="number"]:focus {
|
||||
outline: none;
|
||||
border-color: #569cd6;
|
||||
}
|
||||
|
||||
button {
|
||||
padding: 10px 20px;
|
||||
background: #0e639c;
|
||||
color: white;
|
||||
border: none;
|
||||
border-radius: 4px;
|
||||
cursor: pointer;
|
||||
font-size: 14px;
|
||||
transition: background 0.3s;
|
||||
}
|
||||
|
||||
button:hover:not(:disabled) {
|
||||
background: #1177bb;
|
||||
}
|
||||
|
||||
button:disabled {
|
||||
background: #3a3a3a;
|
||||
color: #777;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
|
||||
button#stop-btn {
|
||||
background: #d16969;
|
||||
}
|
||||
|
||||
button#stop-btn:hover:not(:disabled) {
|
||||
background: #e67373;
|
||||
}
|
||||
|
||||
button#clear-btn, button#reset-btn {
|
||||
background: #4e4e4e;
|
||||
}
|
||||
|
||||
button#clear-btn:hover:not(:disabled), button#reset-btn:hover:not(:disabled) {
|
||||
background: #5e5e5e;
|
||||
}
|
||||
|
||||
/* Status Display */
|
||||
.status-display {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 15px;
|
||||
padding-top: 10px;
|
||||
border-top: 1px solid #3a3a3a;
|
||||
}
|
||||
|
||||
.status-indicator {
|
||||
font-size: 1.5em;
|
||||
color: #6e6e6e;
|
||||
}
|
||||
|
||||
.status-indicator.connected {
|
||||
color: #4ec9b0;
|
||||
}
|
||||
|
||||
.status-indicator.profiling {
|
||||
color: #ce9178;
|
||||
animation: pulse 1.5s infinite;
|
||||
}
|
||||
|
||||
@keyframes pulse {
|
||||
0%, 100% { opacity: 1; }
|
||||
50% { opacity: 0.5; }
|
||||
}
|
||||
|
||||
/* Metadata Panel */
|
||||
.metadata-panel, .summary-panel {
|
||||
background: #252526;
|
||||
padding: 15px;
|
||||
border-radius: 8px;
|
||||
margin-bottom: 20px;
|
||||
}
|
||||
|
||||
.metadata-panel h3, .summary-panel h3 {
|
||||
color: #9cdcfe;
|
||||
margin-bottom: 10px;
|
||||
font-size: 1.1em;
|
||||
}
|
||||
|
||||
#metadata-content, #summary-content {
|
||||
display: grid;
|
||||
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
|
||||
gap: 10px;
|
||||
font-size: 0.9em;
|
||||
}
|
||||
|
||||
#summary-content p {
|
||||
margin: 5px 0;
|
||||
}
|
||||
|
||||
/* Tabs */
|
||||
.tabs {
|
||||
display: flex;
|
||||
gap: 5px;
|
||||
margin-bottom: 0;
|
||||
}
|
||||
|
||||
.tab-button {
|
||||
padding: 12px 24px;
|
||||
background: #2d2d30;
|
||||
border: none;
|
||||
border-radius: 8px 8px 0 0;
|
||||
color: #9cdcfe;
|
||||
cursor: pointer;
|
||||
transition: background 0.3s;
|
||||
}
|
||||
|
||||
.tab-button:hover {
|
||||
background: #3e3e42;
|
||||
}
|
||||
|
||||
.tab-button.active {
|
||||
background: #252526;
|
||||
color: #569cd6;
|
||||
}
|
||||
|
||||
/* Tab Content */
|
||||
.tab-content {
|
||||
display: none;
|
||||
background: #252526;
|
||||
padding: 20px;
|
||||
border-radius: 0 8px 8px 8px;
|
||||
min-height: 500px;
|
||||
}
|
||||
|
||||
.tab-content.active {
|
||||
display: block;
|
||||
}
|
||||
|
||||
/* Flame Graph */
|
||||
#flamegraph {
|
||||
width: 100%;
|
||||
min-height: 500px;
|
||||
}
|
||||
|
||||
/* Override d3-flamegraph default styles for dark theme */
|
||||
.d3-flame-graph rect {
|
||||
stroke: #1e1e1e;
|
||||
stroke-width: 1;
|
||||
}
|
||||
|
||||
.d3-flame-graph text {
|
||||
fill: #fff;
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.d3-flame-graph .label {
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
/* Timeline */
|
||||
#timeline {
|
||||
width: 100%;
|
||||
min-height: 500px;
|
||||
}
|
||||
|
||||
/* Statistics Table */
|
||||
.table-container {
|
||||
overflow-x: auto;
|
||||
}
|
||||
|
||||
table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
font-size: 0.9em;
|
||||
}
|
||||
|
||||
thead {
|
||||
background: #2d2d30;
|
||||
}
|
||||
|
||||
th {
|
||||
padding: 12px;
|
||||
text-align: left;
|
||||
color: #9cdcfe;
|
||||
font-weight: 600;
|
||||
border-bottom: 2px solid #3a3a3a;
|
||||
}
|
||||
|
||||
td {
|
||||
padding: 10px 12px;
|
||||
border-bottom: 1px solid #3a3a3a;
|
||||
}
|
||||
|
||||
tbody tr:hover {
|
||||
background: #2d2d30;
|
||||
}
|
||||
|
||||
tbody tr:nth-child(even) {
|
||||
background: #1e1e1e;
|
||||
}
|
||||
|
||||
/* Responsive */
|
||||
@media (max-width: 768px) {
|
||||
.connection-controls, .profiling-controls {
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
input[type="text"], input[type="number"], button {
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.tabs {
|
||||
flex-direction: column;
|
||||
}
|
||||
|
||||
.tab-button {
|
||||
border-radius: 4px;
|
||||
}
|
||||
}
|
||||
340
host/web/static/js/app.js
Normal file
340
host/web/static/js/app.js
Normal file
@@ -0,0 +1,340 @@
|
||||
// MiniProfiler Web Application
|
||||
|
||||
// Global state
|
||||
let socket = null;
|
||||
let isConnected = false;
|
||||
let isProfiling = false;
|
||||
let flamegraph = null;
|
||||
|
||||
// Initialize on page load
|
||||
document.addEventListener('DOMContentLoaded', function() {
|
||||
initializeSocket();
|
||||
initializeFlameGraph();
|
||||
});
|
||||
|
||||
// Socket.IO Connection
|
||||
function initializeSocket() {
|
||||
socket = io();
|
||||
|
||||
socket.on('connect', function() {
|
||||
console.log('Connected to server');
|
||||
updateStatus('Connected to server', false);
|
||||
});
|
||||
|
||||
socket.on('disconnect', function() {
|
||||
console.log('Disconnected from server');
|
||||
updateStatus('Disconnected from server', false);
|
||||
isConnected = false;
|
||||
updateControlButtons();
|
||||
});
|
||||
|
||||
socket.on('connected', function(data) {
|
||||
console.log('Connected to serial:', data);
|
||||
isConnected = true;
|
||||
updateStatus(`Connected to ${data.port}`, true);
|
||||
updateControlButtons();
|
||||
document.getElementById('metadata-panel').style.display = 'block';
|
||||
});
|
||||
|
||||
socket.on('disconnected', function() {
|
||||
console.log('Disconnected from serial');
|
||||
isConnected = false;
|
||||
isProfiling = false;
|
||||
updateStatus('Disconnected', false);
|
||||
updateControlButtons();
|
||||
document.getElementById('metadata-panel').style.display = 'none';
|
||||
});
|
||||
|
||||
socket.on('profiling_started', function() {
|
||||
console.log('Profiling started');
|
||||
isProfiling = true;
|
||||
updateStatus('Profiling active', true, true);
|
||||
updateControlButtons();
|
||||
});
|
||||
|
||||
socket.on('profiling_stopped', function() {
|
||||
console.log('Profiling stopped');
|
||||
isProfiling = false;
|
||||
updateStatus('Profiling stopped', true);
|
||||
updateControlButtons();
|
||||
});
|
||||
|
||||
socket.on('metadata', function(data) {
|
||||
console.log('Metadata received:', data);
|
||||
displayMetadata(data);
|
||||
});
|
||||
|
||||
socket.on('device_status', function(data) {
|
||||
console.log('Device status:', data);
|
||||
if (data.buffer_overflows > 0) {
|
||||
console.warn(`Buffer overflows detected: ${data.buffer_overflows}`);
|
||||
}
|
||||
});
|
||||
|
||||
socket.on('summary_update', function(data) {
|
||||
updateSummary(data);
|
||||
});
|
||||
|
||||
socket.on('flamegraph_update', function(data) {
|
||||
updateFlameGraph(data);
|
||||
});
|
||||
|
||||
socket.on('statistics_update', function(data) {
|
||||
updateStatistics(data);
|
||||
});
|
||||
|
||||
socket.on('timeline_update', function(data) {
|
||||
updateTimeline(data);
|
||||
});
|
||||
|
||||
socket.on('error', function(data) {
|
||||
console.error('Error:', data.message);
|
||||
alert('Error: ' + data.message);
|
||||
});
|
||||
}
|
||||
|
||||
// Connection Control
|
||||
function toggleConnection() {
|
||||
if (isConnected) {
|
||||
socket.emit('disconnect_serial');
|
||||
document.getElementById('connect-btn').textContent = 'Connect';
|
||||
} else {
|
||||
const port = document.getElementById('serial-port').value;
|
||||
const baudrate = parseInt(document.getElementById('baudrate').value);
|
||||
const elfPath = document.getElementById('elf-path').value;
|
||||
|
||||
if (!port) {
|
||||
alert('Please enter a serial port');
|
||||
return;
|
||||
}
|
||||
|
||||
socket.emit('connect_serial', {
|
||||
port: port,
|
||||
baudrate: baudrate,
|
||||
elf_path: elfPath || null
|
||||
});
|
||||
|
||||
document.getElementById('connect-btn').textContent = 'Disconnect';
|
||||
}
|
||||
}
|
||||
|
||||
function startProfiling() {
|
||||
socket.emit('start_profiling');
|
||||
}
|
||||
|
||||
function stopProfiling() {
|
||||
socket.emit('stop_profiling');
|
||||
}
|
||||
|
||||
function clearData() {
|
||||
if (confirm('Clear all profiling data?')) {
|
||||
socket.emit('clear_data');
|
||||
}
|
||||
}
|
||||
|
||||
function resetBuffers() {
|
||||
socket.emit('reset_buffers');
|
||||
}
|
||||
|
||||
// UI Updates
|
||||
function updateStatus(text, connected, profiling = false) {
|
||||
const statusText = document.getElementById('status-text');
|
||||
const statusIndicator = document.getElementById('connection-status');
|
||||
|
||||
statusText.textContent = text;
|
||||
|
||||
statusIndicator.classList.remove('connected', 'profiling');
|
||||
if (profiling) {
|
||||
statusIndicator.classList.add('profiling');
|
||||
} else if (connected) {
|
||||
statusIndicator.classList.add('connected');
|
||||
}
|
||||
}
|
||||
|
||||
function updateControlButtons() {
|
||||
document.getElementById('start-btn').disabled = !isConnected || isProfiling;
|
||||
document.getElementById('stop-btn').disabled = !isConnected || !isProfiling;
|
||||
document.getElementById('clear-btn').disabled = !isConnected;
|
||||
document.getElementById('reset-btn').disabled = !isConnected;
|
||||
}
|
||||
|
||||
function displayMetadata(data) {
|
||||
const content = document.getElementById('metadata-content');
|
||||
content.innerHTML = `
|
||||
<div><strong>Firmware:</strong> ${data.fw_version}</div>
|
||||
<div><strong>MCU Clock:</strong> ${(data.mcu_clock_hz / 1e6).toFixed(1)} MHz</div>
|
||||
<div><strong>Timer Freq:</strong> ${(data.timer_freq / 1e6).toFixed(1)} MHz</div>
|
||||
<div><strong>Build ID:</strong> ${data.build_id}</div>
|
||||
`;
|
||||
}
|
||||
|
||||
function updateSummary(data) {
|
||||
const content = document.getElementById('summary-content');
|
||||
|
||||
if (data.total_records === 0) {
|
||||
content.innerHTML = '<p>No profiling data available</p>';
|
||||
return;
|
||||
}
|
||||
|
||||
const totalTimeMs = (data.total_time_us / 1000).toFixed(2);
|
||||
const hottestTimeMs = (data.hottest_time_us / 1000).toFixed(2);
|
||||
|
||||
content.innerHTML = `
|
||||
<div><strong>Total Records:</strong> ${data.total_records}</div>
|
||||
<div><strong>Unique Functions:</strong> ${data.total_functions}</div>
|
||||
<div><strong>Total Time:</strong> ${totalTimeMs} ms</div>
|
||||
<div><strong>Hottest Function:</strong> ${data.hottest_function || 'N/A'}</div>
|
||||
<div><strong>Hottest Time:</strong> ${hottestTimeMs} ms</div>
|
||||
`;
|
||||
|
||||
document.getElementById('record-count').textContent = `Records: ${data.total_records}`;
|
||||
}
|
||||
|
||||
// Tab Management
|
||||
function showTab(tabName) {
|
||||
// Hide all tabs
|
||||
const tabs = document.querySelectorAll('.tab-content');
|
||||
tabs.forEach(tab => tab.classList.remove('active'));
|
||||
|
||||
const buttons = document.querySelectorAll('.tab-button');
|
||||
buttons.forEach(btn => btn.classList.remove('active'));
|
||||
|
||||
// Show selected tab
|
||||
document.getElementById(tabName + '-tab').classList.add('active');
|
||||
event.target.classList.add('active');
|
||||
}
|
||||
|
||||
// Flame Graph
|
||||
function initializeFlameGraph() {
|
||||
const width = document.getElementById('flamegraph').offsetWidth;
|
||||
|
||||
flamegraph = d3.flamegraph()
|
||||
.width(width)
|
||||
.cellHeight(18)
|
||||
.transitionDuration(750)
|
||||
.minFrameSize(5)
|
||||
.transitionEase(d3.easeCubic)
|
||||
.sort(true)
|
||||
.title("")
|
||||
.differential(false)
|
||||
.selfValue(false);
|
||||
|
||||
// Color scheme
|
||||
flamegraph.setColorMapper((d, originalColor) => {
|
||||
// Color by depth for better visualization
|
||||
const hue = (d.data.depth * 30) % 360;
|
||||
return d3.hsl(hue, 0.6, 0.5);
|
||||
});
|
||||
|
||||
d3.select("#flamegraph")
|
||||
.datum({name: "root", value: 0, children: []})
|
||||
.call(flamegraph);
|
||||
}
|
||||
|
||||
function updateFlameGraph(data) {
|
||||
if (!flamegraph) {
|
||||
initializeFlameGraph();
|
||||
}
|
||||
|
||||
// Update flame graph with new data
|
||||
d3.select("#flamegraph")
|
||||
.datum(data)
|
||||
.call(flamegraph);
|
||||
}
|
||||
|
||||
// Timeline Visualization
|
||||
function updateTimeline(data) {
|
||||
if (!data || data.length === 0) {
|
||||
document.getElementById('timeline').innerHTML = '<p>No timeline data available</p>';
|
||||
return;
|
||||
}
|
||||
|
||||
// Convert to Plotly timeline format
|
||||
const traces = [];
|
||||
|
||||
// Group by depth for better visualization
|
||||
const maxDepth = Math.max(...data.map(d => d.depth));
|
||||
|
||||
for (let depth = 0; depth <= maxDepth; depth++) {
|
||||
const depthData = data.filter(d => d.depth === depth);
|
||||
|
||||
if (depthData.length === 0) continue;
|
||||
|
||||
const trace = {
|
||||
x: depthData.map(d => d.start),
|
||||
y: depthData.map(d => depth),
|
||||
text: depthData.map(d => `${d.name}<br>Duration: ${(d.duration / 1000).toFixed(3)} ms`),
|
||||
mode: 'markers',
|
||||
marker: {
|
||||
size: depthData.map(d => Math.max(5, Math.log(d.duration + 1) * 2)),
|
||||
color: depthData.map(d => d.duration),
|
||||
colorscale: 'Viridis',
|
||||
showscale: depth === 0,
|
||||
colorbar: {
|
||||
title: 'Duration (μs)'
|
||||
}
|
||||
},
|
||||
name: `Depth ${depth}`,
|
||||
hovertemplate: '%{text}<extra></extra>'
|
||||
};
|
||||
|
||||
traces.push(trace);
|
||||
}
|
||||
|
||||
const layout = {
|
||||
title: 'Function Call Timeline',
|
||||
xaxis: {
|
||||
title: 'Time (μs)',
|
||||
gridcolor: '#444'
|
||||
},
|
||||
yaxis: {
|
||||
title: 'Call Depth',
|
||||
gridcolor: '#444'
|
||||
},
|
||||
paper_bgcolor: '#252526',
|
||||
plot_bgcolor: '#1e1e1e',
|
||||
font: {
|
||||
color: '#d4d4d4'
|
||||
},
|
||||
hovermode: 'closest',
|
||||
showlegend: false
|
||||
};
|
||||
|
||||
Plotly.newPlot('timeline', traces, layout, {responsive: true});
|
||||
}
|
||||
|
||||
// Statistics Table
|
||||
function updateStatistics(data) {
|
||||
const tbody = document.getElementById('statistics-body');
|
||||
|
||||
if (!data || data.length === 0) {
|
||||
tbody.innerHTML = '<tr><td colspan="7">No data available</td></tr>';
|
||||
return;
|
||||
}
|
||||
|
||||
let html = '';
|
||||
data.forEach(stat => {
|
||||
html += `
|
||||
<tr>
|
||||
<td>${stat.name}</td>
|
||||
<td><code>${stat.address}</code></td>
|
||||
<td>${stat.calls}</td>
|
||||
<td>${stat.total_us.toLocaleString()}</td>
|
||||
<td>${stat.avg_us.toFixed(2)}</td>
|
||||
<td>${stat.min_us}</td>
|
||||
<td>${stat.max_us}</td>
|
||||
</tr>
|
||||
`;
|
||||
});
|
||||
|
||||
tbody.innerHTML = html;
|
||||
}
|
||||
|
||||
// Handle window resize for flame graph
|
||||
window.addEventListener('resize', function() {
|
||||
if (flamegraph) {
|
||||
const width = document.getElementById('flamegraph').offsetWidth;
|
||||
flamegraph.width(width);
|
||||
flamegraph.update();
|
||||
}
|
||||
});
|
||||
101
host/web/templates/index.html
Normal file
101
host/web/templates/index.html
Normal file
@@ -0,0 +1,101 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>MiniProfiler</title>
|
||||
<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
|
||||
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/d3-flame-graph/4.1.3/d3-flamegraph.css">
|
||||
<script src="https://cdn.socket.io/4.5.4/socket.io.min.js"></script>
|
||||
<script src="https://d3js.org/d3.v7.min.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3-flame-graph/4.1.3/d3-flamegraph.min.js"></script>
|
||||
<script src="https://cdn.plot.ly/plotly-2.27.0.min.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<div class="container">
|
||||
<!-- Header -->
|
||||
<header>
|
||||
<h1>MiniProfiler</h1>
|
||||
<p class="subtitle">Real-time Embedded Profiling Visualization</p>
|
||||
</header>
|
||||
|
||||
<!-- Control Panel -->
|
||||
<div class="control-panel">
|
||||
<div class="connection-controls">
|
||||
<input type="text" id="serial-port" placeholder="/dev/ttyUSB0 or COM3" value="/dev/ttyUSB0">
|
||||
<input type="number" id="baudrate" placeholder="Baudrate" value="115200">
|
||||
<input type="text" id="elf-path" placeholder="Path to .elf file (optional)">
|
||||
<button id="connect-btn" onclick="toggleConnection()">Connect</button>
|
||||
</div>
|
||||
|
||||
<div class="profiling-controls">
|
||||
<button id="start-btn" onclick="startProfiling()" disabled>Start Profiling</button>
|
||||
<button id="stop-btn" onclick="stopProfiling()" disabled>Stop Profiling</button>
|
||||
<button id="clear-btn" onclick="clearData()" disabled>Clear Data</button>
|
||||
<button id="reset-btn" onclick="resetBuffers()" disabled>Reset Buffers</button>
|
||||
</div>
|
||||
|
||||
<div class="status-display">
|
||||
<span class="status-indicator" id="connection-status">●</span>
|
||||
<span id="status-text">Disconnected</span>
|
||||
<span id="record-count">Records: 0</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Metadata Display -->
|
||||
<div id="metadata-panel" class="metadata-panel" style="display: none;">
|
||||
<h3>Device Information</h3>
|
||||
<div id="metadata-content"></div>
|
||||
</div>
|
||||
|
||||
<!-- Summary Panel -->
|
||||
<div id="summary-panel" class="summary-panel">
|
||||
<h3>Summary</h3>
|
||||
<div id="summary-content">
|
||||
<p>No profiling data available</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Tabs -->
|
||||
<div class="tabs">
|
||||
<button class="tab-button active" onclick="showTab('flamegraph')">Flame Graph</button>
|
||||
<button class="tab-button" onclick="showTab('timeline')">Timeline</button>
|
||||
<button class="tab-button" onclick="showTab('statistics')">Statistics</button>
|
||||
</div>
|
||||
|
||||
<!-- Tab Content -->
|
||||
<div id="flamegraph-tab" class="tab-content active">
|
||||
<div id="flamegraph"></div>
|
||||
</div>
|
||||
|
||||
<div id="timeline-tab" class="tab-content">
|
||||
<div id="timeline"></div>
|
||||
</div>
|
||||
|
||||
<div id="statistics-tab" class="tab-content">
|
||||
<div class="table-container">
|
||||
<table id="statistics-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Function</th>
|
||||
<th>Address</th>
|
||||
<th>Calls</th>
|
||||
<th>Total Time (μs)</th>
|
||||
<th>Avg Time (μs)</th>
|
||||
<th>Min Time (μs)</th>
|
||||
<th>Max Time (μs)</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody id="statistics-body">
|
||||
<tr>
|
||||
<td colspan="7">No data available</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<script src="{{ url_for('static', filename='js/app.js') }}"></script>
|
||||
</body>
|
||||
</html>
|
||||
Reference in New Issue
Block a user