Profilage de DataStore

Mesurez les performances de DataStore avec le profileur intégré

Le profileur de DataStore vous aide à mesurer le temps d’exécution et à identifier les goulots d’étranglement en matière de performances.

​

Démarrage rapide

from chdb import datastore as pd
from chdb.datastore.config import config, get_profiler

# Enable profiling
config.enable_profiling()

# Run your operations
ds = pd.read_csv("large_data.csv")
result = (ds
    .filter(ds['amount'] > 100)
    .groupby('category')
    .agg({'amount': 'sum'})
    .sort('sum', ascending=False)
    .head(10)
    .to_df()
)

# View report
profiler = get_profiler()
print(profiler.report())

​

Activer le profilage

from chdb.datastore.config import config

# Enable profiling
config.enable_profiling()

# Disable profiling
config.disable_profiling()

# Check if profiling is enabled
print(config.profiling_enabled)  # True or False

---

​

API du profileur

​

Obtenir le profileur

from chdb.datastore.config import get_profiler

profiler = get_profiler()

​

report()

Affiche un rapport de performances.

profiler.report(min_duration_ms=0.1)

Paramètres :

Paramètre	Type	Défaut	Description
min_duration_ms	float	0.1	Affiche uniquement les étapes d’une durée >= à cette valeur

Exemple de sortie :

======================================================================
EXECUTION PROFILE
======================================================================
   45.79ms (100.0%) Total Execution
     23.25ms ( 50.8%) Query Planning [ops_count=2]
     22.29ms ( 48.7%) SQL Segment 1 [ops=2]
       20.48ms ( 91.9%) SQL Execution
        1.74ms (  7.8%) Result to DataFrame
----------------------------------------------------------------------
      TOTAL:    45.79ms
======================================================================

Le rapport affiche :

• La durée en millisecondes pour chaque étape
• Le pourcentage du temps du parent par rapport au temps total
• L’imbrication hiérarchique des opérations
• Les métadonnées de chaque étape (par exemple, ops_count, ops)

​

step()

Mesurez manuellement le temps d’exécution d’un bloc de code.

with profiler.step("custom_operation"):
    # Your code here
    expensive_operation()

​

clear()

Supprime toutes les données de profilage.

profiler.clear()

​

summary()

Renvoie un dictionnaire associant les noms des étapes à leur durée (ms).

summary = profiler.summary()
for name, duration in summary.items():
    print(f"{name}: {duration:.2f}ms")

Exemple de sortie :

Total Execution: 45.79ms
Total Execution.Cache Check: 0.00ms
Total Execution.Query Planning: 23.25ms
Total Execution.SQL Segment 1: 22.29ms
Total Execution.SQL Segment 1.SQL Execution: 20.48ms
Total Execution.SQL Segment 1.Result to DataFrame: 1.74ms

---

​

Comprendre le rapport

​

Nom des étapes

Nom de l’étape	Description
Total Execution	Temps d’exécution total
Query Planning	Temps consacré à la planification de la requête
SQL Segment N	Exécution du segment SQL N
SQL Execution	Exécution réelle de la requête SQL
Result to DataFrame	Conversion des résultats en DataFrame pandas
Cache Check	Vérification du cache de requêtes
Cache Write	Écriture des résultats dans le cache

​

Durée

• Étapes de planification (Planification de la requête) : généralement rapides
• Étapes d’exécution (Exécution SQL) : c’est là que s’effectue le travail réel
• Étapes de transfert (Résultat vers un DataFrame) : conversion des données en DataFrame pandas

​

Identifier les goulots d’étranglement

======================================================================
EXECUTION PROFILE
======================================================================
  200.50ms (100.0%) Total Execution
    10.25ms (  5.1%) Query Planning [ops_count=4]
   190.00ms ( 94.8%) SQL Segment 1 [ops=4]
     185.00ms ( 97.4%) SQL Execution    <- Main bottleneck
       5.00ms (  2.6%) Result to DataFrame
----------------------------------------------------------------------
      TOTAL:   200.50ms
======================================================================

---

​

Modèles de profilage

​

Profiler une seule requête

config.enable_profiling()
profiler = get_profiler()
profiler.clear()  # Clear previous data

# Run query
result = ds.filter(...).groupby(...).agg(...).to_df()

# View this query's profile
print(profiler.report())

​

Profiler plusieurs requêtes

config.enable_profiling()
profiler = get_profiler()
profiler.clear()

# Query 1
with profiler.step("Query 1"):
    result1 = query1.to_df()

# Query 2
with profiler.step("Query 2"):
    result2 = query2.to_df()

print(profiler.report())

​

Comparer les approches

profiler = get_profiler()

# Approach 1: Filter then groupby
profiler.clear()
with profiler.step("filter_then_groupby"):
    result1 = ds.filter(ds['x'] > 10).groupby('y').sum().to_df()
summary1 = profiler.summary()
time1 = summary1.get('filter_then_groupby', 0)

# Approach 2: Groupby then filter
profiler.clear()
with profiler.step("groupby_then_filter"):
    result2 = ds.groupby('y').sum().filter(ds['x'] > 10).to_df()
summary2 = profiler.summary()
time2 = summary2.get('groupby_then_filter', 0)

print(f"Approach 1: {time1:.2f}ms")
print(f"Approach 2: {time2:.2f}ms")
print(f"Winner: {'Approach 1' if time1 < time2 else 'Approach 2'}")

---

​

Conseils d’optimisation

​

1. Vérifiez le temps d’exécution SQL

Si SQL execution est le goulot d’étranglement :

• Ajoutez davantage de filtres pour réduire le volume de données
• Utilisez Parquet plutôt que CSV
• Vérifiez la présence d’index adaptés (pour les sources de type base de données)

​

2. Vérifiez le temps d’E/S

Si read_csv ou read_parquet constitue le goulot d’étranglement :

• Utilisez Parquet (format colonnaire, compressé)
• Lisez uniquement les colonnes nécessaires
• Filtrez à la source si possible

​

3. Vérifier le transfert des données

Si to_df est lent :

• Le jeu de résultats est peut-être trop volumineux
• Ajoutez davantage de filtres ou réduisez la limite
• Utilisez head() pour un aperçu

​

4. Comparer les moteurs

from chdb.datastore.config import config

# Profile with chdb
config.use_chdb()
profiler.clear()
result_chdb = query.to_df()
time_chdb = profiler.total_duration_ms

# Profile with pandas
config.use_pandas()
profiler.clear()
result_pandas = query.to_df()
time_pandas = profiler.total_duration_ms

print(f"chdb: {time_chdb:.2f}ms")
print(f"pandas: {time_pandas:.2f}ms")

---

​

Bonnes pratiques

​

1. Profiler avant d’optimiser

# Don't guess - measure!
config.enable_profiling()
result = your_query.to_df()
print(get_profiler().report())

​

2. Nettoyer entre les tests

profiler.clear()  # Clear previous data
# Run test
print(profiler.report())

​

3. Utilisez min_duration_ms pour mieux cibler

# Only show operations >= 100ms
profiler.report(min_duration_ms=100)

​

4. Profilez des données représentatives

# Profile with real-world data sizes
# Small test data may not show real bottlenecks

​

5. Désactiver en production

# Development
config.enable_profiling()

# Production
config.set_profiling_enabled(False)  # Avoid overhead

---

​

Exemple : session de profilage complète

from chdb import datastore as pd
from chdb.datastore.config import config, get_profiler

# Setup
config.enable_profiling()
config.enable_debug()  # Also see what's happening
profiler = get_profiler()

# Load data
profiler.clear()
print("=== Loading Data ===")
ds = pd.read_csv("sales_2024.csv")  # 10M rows
print(profiler.report())

# Query 1: Simple filter
profiler.clear()
print("\n=== Query 1: Simple Filter ===")
result1 = ds.filter(ds['amount'] > 1000).to_df()
print(profiler.report())

# Query 2: Complex aggregation
profiler.clear()
print("\n=== Query 2: Complex Aggregation ===")
result2 = (ds
    .filter(ds['amount'] > 100)
    .groupby('region', 'category')
    .agg({
        'amount': ['sum', 'mean', 'count'],
        'quantity': 'sum'
    })
    .sort('sum', ascending=False)
    .head(20)
    .to_df()
)
print(profiler.report())

# Summary
print("\n=== Summary ===")
print(f"Query 1: {len(result1)} rows")
print(f"Query 2: {len(result2)} rows")