Huawei Cloud Ascend Profiler Db Explorer

Huawei Cloud Ascend Profiler DB Explorer

Overview

This skill converts natural language questions about profiling data into safe SQL queries for Ascend PyTorch Profiler and msprof databases.

Architecture: Natural Language Input → Intent Recognition → SQL Generation → Database Execution → Result Analysis

Related Skills:

• huawei-cloud-msot-msopprof-operator-profiler - Operator performance data

collection

• huawei-cloud-ascend-small-model-migrate - Migration workflow that uses

profiling analysis

• huawei-cloud-ascendc-operator-performance-optim - Operator optimization

workflow

Architecture Components

This skill involves the following cloud services and components:

• MSProf: Ascend profiling tool for data collection and database management
• SQLite: Database engine for storing profiling data
• Ascend NPU: Target hardware for performance profiling
• msprof_mcp: Tool for executing SQL queries on profiling database

Architecture Diagram:

┌─────────────────────────────────────────────────────────────┐
│              Profiler DB Explorer Skill                    │
├─────────────────────────────────────────────────────────────┤
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │  Natural     │───▶│  SQL         │───▶│  Database    │ │
│  │  Language    │    │  Generation  │    │  Execution   │ │
│  │  Input       │    │              │    │              │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
│         │                   │                   │          │
│         ▼                   ▼                   ▼          │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │  Intent      │    │  CTE Macro   │    │  Result      │ │
│  │  Recognition │    │  Templates   │    │  Analysis    │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
└─────────────────────────────────────────────────────────────┘

Use Cases

Typical Problem Scenarios:

• Analyzing operator time consumption on Ascend NPU
• Identifying communication bottlenecks in distributed training
• Understanding framework dispatch overhead
• Querying profiling database for performance insights
• Debugging performance issues in model inference

Typical User Phrases:

• "Which operators are most time-consuming?"
• "Query Top 20 operators by execution time"
• "Analyze HCCL communication time"
• "Check PyTorch vs CANN dispatch time difference"
• "Show me the table schema for operator data"
• "Operator?"
• "AnalysisOperatorPerformance"
• "QueryprofilerDatabase"

Skill Objectives

• Convert natural language questions to SQL drafts: Quickly construct safe,

readable profiling queries based on preset CTE macros and dictionary rules.

• Unified entry: For any question involving "operator time",

"communication time", "dispatch analysis", or any specific profiling DB query, must first and only trigger this skill.

• Avoid ad-hoc SQL: Never write SQL or modify macro internal JOIN logic

without reading this document.

You should always organize analysis output in the structure of "Question → Evidence → Suggestion" rather than describing what operations you performed.

Role Positioning

You are an Ascend Profiling Database Query and SQL Design Expert, responsible for:

• Understanding user's performance problem intent

(operator/communication/dispatch, etc.).

• Selecting appropriate query channel (Track A / Track B).
• Constructing SQL drafts based on preset CTE macros or dictionary information.
• Calling database execution tools and outputting clear performance diagnosis

conclusions based on query results.

Usage Scenarios

Prioritize calling this skill in following scenarios:

• User asks "which operators are most time-consuming", "TopK operators",

"computation bottlenecks".

• User concerned about "HCCL/collective communication time",

"AllReduce/AllGather time".

• User needs to analyze time differences between "PyTorch framework dispatch

vs CANN dispatch vs device execution".

• Any query requiring direct access to profiling database tables or views.

Trigger Words (Recall Enhancement)

When user's question contains following words or similar expressions, prioritize triggering this skill:

• ascend-pytorch-profiler-db / ascend_pytorch_profiler*.db / msprof_*.db
• sqlite / table / schema / field
• TopK operators / communication time / dispatch analysis /

scheduling bottleneck

Mandatory Restrictions

• Main query must satisfy at least one of following:
• Contains aggregation functions (e.g., SUM, AVG, COUNT, etc.), OR
• Explicitly includes ORDER BY ... LIMIT 20 (or smaller LIMIT).
• Only call execute_sql_to_csv tool provided by msprof_mcp when user

indicates output to file, allowing full table scan.

• In this skill, table structure description should be obtained through

scripts/get_schema.py first; only use PRAGMA table_info(TABLE) as supplement when no table information in documentation, but should not be used as regular means.

Track A: Golden Views / CTE Macros (Priority)

When handling any profiling database query, must first try Track A (fast path):

1. Intent Matching

• Determine if user intent belongs to: **operator computation /

collective communication / framework dispatch**.

• If belongs to any of above, **absolutely forbidden to query underlying

dictionary or randomly construct JOINs**.

2. Extract Macro (CTE)

• From "CTE Macro Definitions" below, **copy corresponding WITH statement

block verbatim** to SQL beginning.

• Never modify JOIN logic and field expressions inside macros.

3. Concatenate Main Query

• After copied WITH ... AS (...), write SELECT query for corresponding

view (e.g., compute_view, comm_view, dispatch_view).

• Example: `SELECT op_name, SUM(duration_ns) AS total_ns FROM compute_view

GROUP BY op_name ORDER BY total_ns DESC LIMIT 20;`

Track B: Underlying Documentation / profiler_db_data_format.md

Only enter Track B when one of following conditions met:

• User explicitly requests querying underlying hardware metrics

(e.g., PMU counts, memory allocation, Step division, etc.).

• Requirement not covered by existing views in "CTE Macro Definitions".

Core tool for Track B is scripts/get_schema.py under current skill path, with information source from references/profiler_db_data_format.md.

1. Get Real Table Names from Current DB (Recommended)

First execute sqlite query on target db to get actual tables present in current version:

sqlite3 {db_path} ".tables"
sqlite3 {db_path} "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"

Note: This step only used to get "which tables actually exist in current DB",

not for field-level schema parsing. For field descriptions, use

get_schema.py --table_name.

2. Use Script for Document/DB Alignment (Recommended)

• Purpose: Automatically list document table names, current DB table names,

or directly do intersection comparison to reduce manual filtering.

• Command line examples:

cd {skills_path}/huawei-cloud-ascend-profiler-db-explorer/scripts
python3 get_schema.py --list_tables
python3 get_schema.py --db_path {db_path} --list_db_tables
python3 get_schema.py --db_path {db_path} --compare_doc_db

3. get_schema_by_table_name(table_name)

• Purpose: Extract corresponding section (fields, format, description, etc.)

for the table from profiler_db_.md by table name.

• Parameter meaning:
• table_name: Table name (recommend using table names from sqlite query

results first).

• MCP calling convention (recommend encapsulating as independent tool

in upper layer):

• Tool name example: get_schema_by_table_name
• Input example: {"table_name": "TASK"}.
• Command line examples:

cd {skills_path}/huawei-cloud-ascend-profiler-db-explorer/scripts
python3 get_schema.py --table_name TASK
python3 get_schema.py --table_name COMMUNICATION_OP

Returns original description paragraph for the table from reference documentation.

Track B Usage Principles

1. Use real table names from sqlite query first, then call get_schema.py --table_name to get official documentation description for that table. 2. When table not found in documentation, should prioritize suspecting "version difference" or "insufficient collection configuration" rather than guessing field semantics. 3. Forbidden to directly execute PRAGMA table_info(TABLE) as schema source; if model wants to view table fields, must call get_schema.py instead.

Execution and Summary

• Execution: After assembling SQL, call execute_sql or execute_sql_to_csv

tool provided by msprof_mcp to execute query.

• Summary output:
• Display final executed SQL, number of returned rows, and first few rows

of results.

CTE Macro Definitions (Must Reuse in Track A)

[Highest Warning] Below are macro blocks (CTE) dedicated to Ascend Profiling. In Track A:

• Must completely copy corresponding macro code block as WITH header

of SQL.

• Never modify JOIN, field meaning, or computation logic inside macros.

1. Operator Computation Detail Macro (Compute Macro)

Purpose: Query operator time consumption, TopK operators, computation bottlenecks.

WITH compute_view AS (
    SELECT c.globalTaskId, ROUND(t.endNs - t.startNs) AS duration_ns,
           n.value AS op_name, type_str.value AS op_type
    FROM COMPUTE_TASK_INFO c
    LEFT JOIN TASK t ON t.globalTaskId = c.globalTaskId
    LEFT JOIN STRING_IDS n ON n.id = c.name
    LEFT JOIN STRING_IDS type_str ON type_str.id = c.opType
)

2. Communication Detail Macro (Communication Macro)

Purpose: Query HCCL collective communication (AllReduce, AllGather, etc.) time.

WITH comm_view AS (
    SELECT ROUND(c.endNs - c.startNs) AS duration_ns, n.value AS op_name,
           t.value AS op_type, g.value AS group_name
    FROM COMMUNICATION_OP c
    LEFT JOIN STRING_IDS n ON n.id = c.opName
    LEFT JOIN STRING_IDS t ON t.id = c.opType
    LEFT JOIN STRING_IDS g ON g.id = c.groupName
)

3. Dispatch Mapping Macro (Dispatch Macro)

Purpose: Compare time differences between PyTorch framework dispatch, CANN layer dispatch, and underlying execution to locate scheduling congestion.

WITH dispatch_view AS (
    SELECT
        ROUND(t.endNs - t.startNs) AS task_duration_ns,
        ROUND(c.endNs - c.startNs) AS cann_duration_ns,
        ROUND(p.endNs - p.startNs) AS pytorch_duration_ns,
        c_str.value AS cann_api_name,
        p_str.value AS pytorch_api_name,
        t_str.value AS task_type
    FROM TASK t
    LEFT JOIN CANN_API c ON t.connectionId = c.connectionId
    LEFT JOIN CONNECTION_IDS conn ON conn.connectionId = t.connectionId
    LEFT JOIN PYTORCH_API p ON p.connectionId = conn.id
    LEFT JOIN STRING_IDS c_str ON c.name = c_str.id
    LEFT JOIN STRING_IDS p_str ON p.name = p_str.id
    LEFT JOIN STRING_IDS t_str ON t.taskType = t_str.id
)

Enhanced Features

Intelligent Bottleneck Diagnoser

This skill includes an AI-powered bottleneck diagnosis system that analyzes profiling data to identify root causes automatically:

Features:

• Automatic Root Cause Analysis: Identifies performance bottlenecks from

profiling data

• Bottleneck Classification: Categorizes bottlenecks into memory-bound,

compute-bound, communication-bound, or operator-fallback types

• Actionable Recommendations: Provides prioritized optimization

recommendations

• Pattern Matching: Detects known performance anti-patterns and suggests

fixes

• Impact Assessment: Estimates potential performance improvement from

each optimization

Bottleneck Classification:

Bottleneck Diagnosis Output:

## Intelligent Bottleneck Diagnosis Report

### Overall Performance Summary
- Total Inference Time: 15.2 ms
- Bottleneck Score: 78/100
- Main Bottleneck Type: Memory-bound

### Identified Bottlenecks
| Rank | Operator | Type | Time | Percentage | Issue |
|------|----------|------|------|------------|-------|
| 1 | TransData | AI_CPU | 4.2 ms | 27.6% | Frequent CPU-NPU transfer |
| 2 | IndexSelect | AI_CPU | 2.8 ms | 18.4% | Operator fallback to CPU |
| 3 | NMS | AI_CPU | 1.5 ms | 9.9% | No NPU implementation |

### Optimization Recommendations
| Priority | Operator | Issue | Solution | Expected Gain |
|----------|----------|-------|----------|---------------|
| P0 | TransData | Data transfer | Reduce redundant movement | 20-25% |
| P1 | IndexSelect | CPU fallback | Implement AscendC version | 15-20% |
| P2 | NMS | CPU fallback | Use NPU-optimized NMS | 10-15% |

### Quick Wins
1. Batch pre-processing on NPU instead of CPU
2. Use async data transfer with overlap
3. Enable memory pooling for intermediate tensors

Reference Documents

Prerequisites

• msprof >= 7.0.0 installed
• sqlite3 >= 3.0.0 installed
• Have Ascend PyTorch Profiler or msprof generated database file

Core Commands

# Query operator time consumption
python3 scripts/query_profiler_db.py \
  --db /path/to/ascend_pytorch_profiler.db \
  --query "Top 10 operators by time consumption"

Parameter Confirmation

Acceptance Criteria

Functional Acceptance Criteria

1. SQL Generation

2. Track Selection

3. Schema Query

4. Query Execution

Correct/Error Pattern Comparison

SQL Generation

Correct: Include aggregation and LIMIT

SELECT op_name, SUM(duration_ns) AS total_ns
FROM compute_view
GROUP BY op_name
ORDER BY total_ns DESC
LIMIT 20;

Error: Missing aggregation or LIMIT

SELECT op_name, duration_ns  -- No aggregation
FROM compute_view;
-- Missing LIMIT can return too many rows

CTE Macro Usage

Correct: Use Track A macros for common queries

-- Operator time query
WITH compute_view AS (
    SELECT c.globalTaskId, ROUND(t.endNs - t.startNs) AS duration_ns, ...
    FROM COMPUTE_TASK_INFO c
    LEFT JOIN TASK t ON ...
)
SELECT op_name, SUM(duration_ns) AS total_ns
FROM compute_view
GROUP BY op_name ORDER BY total_ns DESC LIMIT 20;

Error: Ignore Track A for common queries

-- Rewriting Track A logic from scratch is error-prone
SELECT op_name, SUM(ROUND(t.endNs - t.startNs)) AS total_ns
FROM TASK t, COMPUTE_TASK_INFO c, STRING_IDS n
WHERE ...  -- Complex manual join

Schema Reference

Correct: Use get_schema.py

python3 scripts/get_schema.py --table_name TASK

Error: Use PRAGMA as primary source

sqlite3 profiling.db "PRAGMA table_info(TASK)"  # Not recommended as primary

Non-Functional Acceptance Criteria

Test Cases Summary

Positive Test Cases

1. TC-001: TopK operator query (Track A) 2. TC-002: Communication time query (Track A) 3. TC-003: Dispatch analysis query (Track A) 4. TC-004: Custom table schema query (Track B) 5. TC-005: Cross-table join query

Negative Test Cases

1. TC-N01: Query without aggregation 2. TC-N02: Query without LIMIT 3. TC-N03: Using PRAGMA instead of get_schema.py 4. TC-N04: Ignoring Track A for common query 5. TC-N05: Invalid table name in query

msprofguideoutputdbformatformulaDataDescription

msprofcommandcommandExecution Completeafter, ableGenerate aSummaryallhavePerformanceDataofmsprof\_\{timebetweenstab\}.dbtableStructurefile, oughtfilepushrecommendUsageMindStudio InsightToolssearchsee, alsocanin order toUsageNavicat PremiumetcDatabaseDevelopmentToolsstraightconnectprintopen. whenpreviousdbfileSummaryofPerformanceDataifunder:

>[!NOTE] Description >dbfileaveragein order totableformatshapeformulaexpandshowPerformanceData, andallhaveDataaveragein order tonumbercharacterreflectshoot (exampleifopNamecharacterparagraphunderofOperatornamedisplayshowas194) , numbercharacterandNameofreflectshoottableasSTRING\_IDS.

singlebitRelated

1. timebetweenRelated, statisticsoneUsagecontainsecond (ns) , andasthisregionUnixtimebetween. 2. MemoryRelated, statisticsoneUsagecharactersection (Byte) . 3. bandwidthwidthRelated, statisticsoneUsageByte/s. 4. frequencyrateRelated, statisticsoneUsageMHz.

ENUM\_API\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 1 formatformula

table 2 insidecontent

ENUM\_MODULE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 3 formatformula

table 4 insidecontent

ENUM\_HCCL\_DATA\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 5 formatformula

table 6 insidecontent

ENUM\_HCCL\_LINK\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 7 formatformula

table 8 insidecontent

ENUM\_HCCL\_TRANSPORT\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 9 formatformula

table 10 insidecontent

ENUM\_HCCL\_RDMA\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 11 formatformula

table 12 insidecontent

ENUM\_MSTX\_EVENT\_TYPE

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 13 formatformula

table 14 insidecontent

ENUM\_MEMCPY\_OPERATION

pieceraisetable.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 15 formatformula

table 16 insidecontent

STRING\_IDS

reflectshoottable, Used forMemoryIDandcharactercharacterstringreflectshootrelatedsystem.

noCorrespondingopenrelated.

table 17 formatformula

SESSION\_TIME\_INFO

timebetweentable, Used forMemoryPerformanceDatamiddleofopenbeginconclusionendtimebetween. inCollectionnotpositiveoftenretreatoutputtime, noconclusionendtimebetween.

noCorrespondingopenrelated.

table 18 formatformula

NPU\_INFO

CorrespondingdeviceIdofcoreslicetypesign.

noCorrespondingopenrelated.

table 19 formatformula

HOST\_INFO

hostUidandName.

noCorrespondingopenrelated.

table 20 formatformula

TASK

taskData, presentappearallhaveHardwareExecuteofOperatorinformationinformation.

by--task-timeopenrelatedControl.

table 21 formatformula

COMPUTE\_TASK\_INFO

CalculationOperatorDescriptioninformationinformation.

by--task-timeopenrelatedControl.

table 22 formatformula

COMMUNICATION\_TASK\_INFO

DescriptionthroughinformationsmallOperatorinformationinformation.

by--task-time, --hccl, --ascendclopenrelatedControlCorrespondingDataofCollection. Configuration--task-timeasnonl0timeDatahavevalid. havethroughinformationDataofScenariosundersilentrecognizeGenerateoughttable.

table 23 formatformula

COMMUNICATION\_OP

DescriptionthroughinformationlargeOperatorinformationinformation.

by--task-time, --hcclopenrelatedControlCorrespondingDataofCollection. havethroughinformationDataofScenariosundersilentrecognizeGenerateoughttable.

table 24 formatformula

CANN\_API

CANN APIData.

by--ascendclopenrelatedControl.

table 25 formatformula

QOS

keepkeepQoSofData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 26 formatformula

AICORE\_FREQ

AI Corefrequencyrateinformationinformation.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 27 formatformula

ACC\_PMU

ACC\_PMUData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 28 formatformula

SOC\_BANDWIDTH\_LEVEL

SoCbandwidthwidthetclevelinformationinformation.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 29 formatformula

NIC

eachcounttimebetweensectionpointnetworknetworkinformationinformationData.

Controlopenrelated:

• msprofcommandcommandof--sys-io-profiling, --sys-io-sampling-freq
• Ascend PyTorch Profilerofsys\_io

table 30 formatformula

ROCE

RoCEthroughinformationInterfacebandwidthwidthData.

Controlopenrelated:

• msprofcommandcommandof--sys-io-profiling, --sys-io-sampling-freq
• Ascend PyTorch Profilerofsys\_io

table 31 formatformula

LLC

threelevelslowkeepbandwidthwidthData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 32 formatformula

TASK\_PMU\_INFO

CalculationOperatorofPMUData.

Controlopenrelated:

• msprofcommandcommandof--ai-core, --aic-mode=task-basedopenrelatedControloughttableGenerate, --aic-metricsopenrelatedControltoolbodyDataCollection
• Ascend PyTorch Profilerofaic\_metrics
• MindSpore Profilerofaic\_metrics

onlyAtlas 200I/500 A2 pushmanageproduceproductandAtlas A2 trainpracticesystemcolumnproduceproduct/Atlas A2 pushmanagesystemcolumnproduceproductSupportCollectionoughtData.

table 33 formatformula

SAMPLE\_PMU\_TIMELINE

sample-basedofPMUData, Used fortimelinetypeofDatapresentappear.

Controlopenrelated:

• msprofcommandcommandof--ai-core, --aic-mode=sample-basedopenrelatedControloughttableGenerate, --aic-metricsopenrelatedControltoolbodyDataCollection
• Ascend PyTorch Profilerofaic\_metrics
• MindSpore Profilerofaic\_metrics

table 34 formatformula

SAMPLE\_PMU\_SUMMARY

sample-basedofPMUData, Used forsummarytypeofDatapresentappear.

Controlopenrelated:

• msprofcommandcommandof--ai-core, --aic-mode=sample-basedopenrelatedControloughttableGenerate, --aic-metricsopenrelatedControltoolbodyDataCollection
• Ascend PyTorch Profilerofaic\_metrics
• MindSpore Profilerofaic\_metrics

table 35 formatformula

NPU\_MEM

NPUMemoryoccupyuseData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 36 formatformula

NPU\_MODULE\_MEM

NPUComponentsMemoryoccupyuseData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 37 formatformula

NPU\_OP\_MEM

CANNOperatorMemoryoccupyuseData, onlyGEOperatorSupport.

by--task-memoryopenrelatedControl.

table 38 formatformula

HBM

sliceaboveMemoryreadcomposespeedrateData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 39 formatformula

DDR

sliceaboveMemoryreadcomposespeedrateData.

by--sys-hardware-mem, --sys-hardware-mem-freqopenrelatedControl.

table 40 formatformula

HCCS

HCCSsetmatchthroughinformationbandwidthwidthData.

Controlopenrelated:

• msprofcommandcommandof--sys-interconnection-profiling, --sys-interconnection-freq
• Ascend PyTorch Profilerofsys\_interconnection

table 41 formatformula

PCIE

PCIebandwidthwidthData.

Controlopenrelated:

• msprofcommandcommandof--sys-interconnection-profiling, --sys-interconnection-freq
• Ascend PyTorch Profilerofsys\_interconnection

table 42 formatformula

META\_DATA

BaseData, whenpreviousonlykeepkeepVersionsigninformationinformation.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate.

table 43 formatformula

table 44 insidecontent

MSTX\_EVENTS

mstxInterfaceCollectionofHostsideData, DevicesideDatainTASKtablemiddleadjustmatch.

by--msproftxopenrelatedControltableformatOutput, mstxInterfaceControlDataofCollection.

table 45 formatformula

COMMUNICATION\_SCHEDULE\_TASK\_INFO

throughinformationadjustdegreeDescriptioninformationinformation, whenpreviousonlyneedlepairAI CPUthroughinformationOperatorofDescription.

noCorrespondingopenrelated, guideoutputmsprof\_\{timebetweenstab\}.dbfiletimesilentrecognizeGenerate. requiresCollectionEnvironmentmiddlePackagecontainAI CPUthroughinformationOperator.

table 46 formatformula

MEMCPY\_INFO

DescriptionmemcpyRelatedOperatorofcopyshellDataamountandcopyshellmethoddirection.

by--runtime-apiopenrelatedControl.

table 47 formatformula

CPU\_USAGE

HostsideCPUutilizeuserateData.

by--host-sys=cpuopenrelatedControl.

table 48 formatformula

HOST\_MEM\_USAGE

HostsideMemoryutilizeuserateData.

by--host-sys=memopenrelatedControl.

table 49 formatformula

HOST\_DISK\_USAGE

HostsidemagneticdiskI/OutilizeuserateData.

by--host-sys=diskopenrelatedControl.

table 50 formatformula

HOST\_NETWORK\_USAGE

HostsidesystemstatisticslevelcategoryofnetworknetworkI/OutilizeuserateData.

by--host-sys=networkopenrelatedControl.

table 51 formatformula

OSRT\_API

HostsidesyscallandpthreadcallData.

by--host-sys=osrtopenrelatedControl.

table 52 formatformula

NETDEV\_STATS

throughexceedHardwareadoptsamplebandwidthwidthabilityforce, canin order topartdistributerecognizecategorythroughinformationaskproblem, astotalviewitem, initialsteparrangesearchthroughinformationaskproblem, ifoutputappearthroughinformationTime consumptiondifferentoften, immediatecanoptimizefirstarrangesearchiswhetherasnetworknetworkholdblockguideconsistent.

Controlopenrelated:

• msprofcommandcommandof--sys-io-profiling, --sys-io-sampling-freq
• Ascend PyTorch Profilerofsys\_io
• MindSpore Profilerofsys\_io

table 53 formatformula

RANK\_DEVICE\_MAP

rankIdanddeviceIdofreflectshootrelatedsystemData.

noCorrespondingopenrelated, guideoutputascend\_pytorch\_profiler\_\{Rank\_ID\}.dbfiletimesilentrecognizeGenerate.

table 54 formatformula

Troubleshooting

1. Database Issues

Issue: Database file not found

Symptom: Error: unable to open database

Solution:

# Find profiling database
find . -name "*.db" -o -name "msprof_*.db"

# Check file permissions
ls -la profiling.db
chmod 644 profiling.db

Issue: Database locked

Symptom: Error: database is locked

Solution:

# Close other connections
# Wait for other processes to finish
# Or use read-only mode
sqlite3 -readonly profiling.db "SELECT 1;"

Issue: Invalid database format

Symptom: Error: file is not a database

Solution:

# Check file type
file profiling.db

# May need to use correct database from profiling output
ls -la OPPROF_*/profiling.db

2. Schema Query Issues

Issue: Table not found

Symptom: Error: no such table

Solution:

# List available tables first
sqlite3 profiling.db ".tables"

# Check actual table names
sqlite3 profiling.db "SELECT name FROM sqlite_master WHERE type='table';"

# Verify get_schema.py table list
python3 scripts/get_schema.py --list_tables

Issue: Column not found

Symptom: Error: no such column

Solution:

# Get table schema
sqlite3 profiling.db ".schema TABLE_NAME"

# Use get_schema.py for reference
python3 scripts/get_schema.py --table_name TABLE_NAME

# Check exact column names
sqlite3 profiling.db "PRAGMA table_info(TABLE_NAME);"

3. Query Execution Issues

Issue: Query returns no results

Possible Causes: 1. No matching data 2. WHERE condition too restrictive 3. JOIN condition incorrect

Solution:

# Test with simpler query first
sqlite3 profiling.db "SELECT COUNT(*) FROM TASK;"

# Check data exists
sqlite3 profiling.db "SELECT * FROM TASK LIMIT 1;"

# Verify JOIN keys
sqlite3 profiling.db "SELECT COUNT(*) FROM COMPUTE_TASK_INFO c JOIN TASK t ON c.globalTaskId = t.globalTaskId;"

Issue: Query too slow

Solution:

# Add LIMIT
SELECT ... LIMIT 100;

# Use index hints if available
EXPLAIN QUERY PLAN SELECT ...

# Reduce date range
WHERE timestamp BETWEEN '2024-01-01' AND '2024-01-02'

4. SQL Generation Issues

Issue: Generated SQL syntax error

Solution:

# Validate SQL syntax
sqlite3 profiling.db "EXPLAIN QUERY PLAN <your_sql>;"

# Check for typos
# Verify table and column names match schema

Issue: Missing aggregation

Solution:

# Ensure GROUP BY is used with aggregate functions
SELECT op_name, SUM(duration_ns)  -- Need GROUP BY
FROM compute_view
GROUP BY op_name;

Issue: Missing LIMIT

Solution:

# Add LIMIT to prevent large result sets
SELECT ...
ORDER BY total_ns DESC
LIMIT 20;

5. Performance Issues

Issue: Full table scan

Solution:

# Check query plan
EXPLAIN QUERY PLAN SELECT ...

# Use appropriate indexes
# Limit date range

Issue: Memory issues with large results

Solution:

# Increase LIMIT
# Use pagination
# Process in batches

Quick Diagnostic Commands

# Check database
file *.db
sqlite3 profiling.db ".tables"

# Check table size
sqlite3 profiling.db "SELECT COUNT(*) FROM TASK;"

# Test simple query
sqlite3 profiling.db "SELECT 1;"

# Get schema
python3 scripts/get_schema.py --table_name TASK

Common SQL Patterns

-- Top K operators by time
WITH compute_view AS (
    SELECT c.globalTaskId, ROUND(t.endNs - t.startNs) AS duration_ns, n.value AS op_name
    FROM COMPUTE_TASK_INFO c
    LEFT JOIN TASK t ON t.globalTaskId = c.globalTaskId
    LEFT JOIN STRING_IDS n ON n.id = c.name
)
SELECT op_name, SUM(duration_ns) AS total_ns, COUNT(*) AS call_count
FROM compute_view
GROUP BY op_name
ORDER BY total_ns DESC
LIMIT 20;

-- Communication time
WITH comm_view AS (
    SELECT ROUND(c.endNs - c.startNs) AS duration_ns, n.value AS op_name
    FROM COMMUNICATION_OP c
    LEFT JOIN STRING_IDS n ON n.id = c.opName
)
SELECT op_name, SUM(duration_ns) AS total_ns
FROM comm_view
GROUP BY op_name
ORDER BY total_ns DESC
LIMIT 10;

Verification Methods

Prerequisite Verification

1. Verify Database Files

# Check profiling database exists
ls -la *.db
ls -la msprof_*.db

# Verify database format
file profiling.db

2. Verify sqlite3 CLI

# Check sqlite3 installation
sqlite3 --version

# Test basic query
sqlite3 profiling.db "SELECT 1;"

3. Verify get_schema.py Script

# Check script exists
ls -la scripts/get_schema.py

# Test script help
python3 scripts/get_schema.py --help

Functional Verification

1. List Available Tables

# Method 1: Using sqlite3
sqlite3 profiling.db ".tables"

# Method 2: Using get_schema.py
python3 scripts/get_schema.py --list_tables

# Method 3: Using SQL
sqlite3 profiling.db "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"

2. Query Table Schema

# Get schema for specific table
python3 scripts/get_schema.py --table_name TASK

# Compare with actual database
python3 scripts/get_schema.py --db_path profiling.db --compare_doc_db

3. Execute Query

# Using sqlite3 CLI for testing
sqlite3 profiling.db "
WITH compute_view AS (
    SELECT c.globalTaskId, ROUND(t.endNs - t.startNs) AS duration_ns, n.value AS op_name
    FROM COMPUTE_TASK_INFO c
    LEFT JOIN TASK t ON t.globalTaskId = c.globalTaskId
    LEFT JOIN STRING_IDS n ON n.id = c.name
)
SELECT op_name, SUM(duration_ns) AS total_ns
FROM compute_view
GROUP BY op_name
ORDER BY total_ns DESC
LIMIT 20;
"

# Save results to CSV
sqlite3 profiling.db <<EOF
.headers on
.mode csv
.output results.csv
-- Your SQL here
EOF

4. Verify Query Results

# Check result row count
wc -l results.csv

# Preview results
head -20 results.csv

# Validate data types
python3 -c "
import csv
with open('results.csv') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row)
        break
"

End-to-End Verification Script

#!/bin/bash
set -e

DB="profiling.db"

echo "=== 1. Verify Prerequisites ==="
sqlite3 --version
test -f ${DB} && echo "Database exists"

echo "=== 2. List Tables ==="
sqlite3 ${DB} ".tables"

echo "=== 3. Get Schema ==="
python3 scripts/get_schema.py --list_tables

echo "=== 4. Execute Sample Query ==="
sqlite3 ${DB} "
WITH compute_view AS (
    SELECT c.globalTaskId, ROUND(t.endNs - t.startNs) AS duration_ns, n.value AS op_name
    FROM COMPUTE_TASK_INFO c
    LEFT JOIN TASK t ON t.globalTaskId = c.globalTaskId
    LEFT JOIN STRING_IDS n ON n.id = c.name
)
SELECT op_name, SUM(duration_ns) AS total_ns
FROM compute_view
GROUP BY op_name
ORDER BY total_ns DESC
LIMIT 5;
"

echo "=== All verifications passed ==="

Verification Checklist