Skip to content

Latest commit

 

History

History
327 lines (259 loc) · 16.1 KB

BENCHMARK.en.md

File metadata and controls

327 lines (259 loc) · 16.1 KB

Carbon Performance Analysis Report

Overview

This report provides a comprehensive performance analysis of the Carbon date and time library. The testing uses Go's standard benchmarking framework, including sequential, concurrent, and parallel execution modes.

Test Environment

  • Operating System: macOS 14.5.0
  • Go Version: 1.22+
  • CPU: Apple Silicon M1
  • Testing Framework: Go testing package
  • Test Modes: Sequential, Concurrent, Parallel
  • Testing Tools: go test -bench
  • Test Data: 10,000 operations
  • Memory Analysis: go test -bench -benchmem

Overall Performance Overview

Performance Rating Statistics

Performance Level Module Count Percentage Key Features
⭐⭐⭐⭐⭐ (Excellent) 16 70% Zero allocation, < 100ns
⭐⭐⭐⭐ (Good) 5 22% Low allocation, 100-1000ns
⭐⭐⭐ (Fair) 1 4% Medium allocation, > 1000ns

Core Module Performance

Ultra-High Performance Modules (⭐⭐⭐⭐⭐)

Module Average Time Memory Allocation Core Advantages
carbon.go 1.3-50ns 0-1 B/op Core operations, zero allocation
comparer.go 1-25ns 0 B/op Comparison operations, zero allocation
boundary.go 12.5-15.2ns 0 B/op Boundary checking, zero allocation
creator.go 50-80ns 0 B/op Creation operations, zero allocation
default.go 5-10ns 0 B/op Default values, zero allocation
difference.go 4.2-18.5ns 0 B/op Difference calculation, zero allocation
extremum.go 80-120ns 0 B/op Extremum calculation, zero allocation
frozen.go 15-20ns 0 B/op Freeze operations, zero allocation
getter.go 5-8ns 0 B/op Getter operations, zero allocation
language.go 1.4-19.7ns 0-5 B/op Language operations, early return optimization performance improvement 60-90x, achieved zero allocation
season.go 30-50ns 0 B/op Season operations, zero allocation
setter.go 20-25ns 0 B/op Setter operations, zero allocation
traveler.go 25-60ns 0 B/op Time travel, zero allocation
type_builtin.go 8-12ns 0 B/op Built-in types, zero allocation
type_carbon.go 70-85ns 0 B/op Type conversion, zero allocation

High Performance Modules (⭐⭐⭐⭐)

Module Average Time Memory Allocation Core Advantages
outputer.go 6.5-103.8ns 0-88 B/op Format output, low allocation
parser.go 372-2718ns 459-4904 B/op String parsing, ParseByFormats optimization performance improvement 7.5%
calendar.go 13-298.1ns 4-88 B/op Calendar conversion, low allocation
type_format.go 8-12ns 0 B/op Format types, zero allocation
type_layout.md 8-95ns 0 B/op Layout types, zero allocation
type_timestamp.go 8-12ns 0 B/op Timestamp types, zero allocation

Ultra-High Performance Modules (⭐⭐⭐⭐⭐)

Module Average Time Memory Allocation Core Advantages
helper.go 2-15ns 0 B/op sync.Map optimization, zero allocation

Good Performance Modules (⭐⭐⭐)

Module Average Time Memory Allocation Optimization Space
constellation.go Estimated 200-500ns Estimated 0-50 B/op Constellation calculation, good performance

Lock Optimization Analysis

Comprehensive Lock Optimization Results

Through systematic lock usage optimization, multiple modules have achieved significant performance improvements and concurrency safety enhancements:

1. Language Module Early Return Optimization Results

Before and After Comparison

Method Before Optimization After Optimization Performance Improvement Optimization Strategy
Copy 7.6-108.5ns 7.7-21.2ns 30-40% Minimize lock holding time
SetLocale 870-1271ns 1.4-19.7ns 60-90x Early return optimization, same locale repeated setting
SetResources 6.8-157.3ns 6.7-29.0ns 35-40% Validation logic outside lock
translate 7.6-165.2ns 7.3-21.5ns 40-45% Avoid deadlock, optimize read lock usage

2. Concurrency Safety Lock Optimization Results

By fixing potential race conditions and null pointer dereference issues, multiple modules have significantly improved concurrency safety:

Fixed Modules and Methods

Module Fixed Method Issue Type Fix Strategy Safety Improvement
outputer.go ToMonthString Null pointer dereference Local variable protection Eliminate race conditions
outputer.go ToShortMonthString Null pointer dereference Local variable protection Eliminate race conditions
outputer.go ToWeekString Null pointer dereference Local variable protection Eliminate race conditions
outputer.go ToShortWeekString Null pointer dereference Local variable protection Eliminate race conditions
constellation.go Constellation Null pointer dereference Local variable protection Eliminate race conditions
season.go Season Null pointer dereference Local variable protection Eliminate race conditions
language.go translate Race condition Re-acquire lock Avoid data race

Fix Effects

  • ✅ Eliminate race conditions: Avoided data races in concurrent environments
  • ✅ Prevent null pointer dereference: Avoided potential panic risks
  • ✅ Improve concurrency safety: Code is more stable in high-concurrency environments
  • ✅ Maintain performance: Fixes introduced no additional performance overhead

3. Early Return Optimization Results

SetLocale Method Early Return Optimization

Through implementing intelligent early return mechanism, the SetLocale method achieved significant performance improvement when setting the same locale repeatedly:

Scenario Before Optimization After Optimization Performance Improvement Memory Allocation
Same locale repeated setting 870-1271ns 14.2-14.3ns 60-90x 0 B/op, 0 allocs/op
Different locale setting 870-1271ns 870-1271ns No change 1352 B/op, 9 allocs/op
Mixed scenarios 870-1271ns 653-655ns 30-40% 1014 B/op, 6 allocs/op

Optimization Mechanism:

  • Smart Detection: Check if locale has changed and resources are already loaded
  • Zero Allocation Optimization: Avoid resource copying when setting same locale repeatedly
  • Cache Utilization: Fully utilize loaded language resource cache
  • Concurrency Safety: Use read-write locks to protect early return checks

Technical Optimization Points

  1. Minimize lock holding time: Heavy operations (file I/O, JSON parsing, map copying) executed outside locks
  2. Read-write separation: Read operations use read locks, write operations use write locks
  3. Avoid deadlocks: Don't call write operations while holding read locks
  4. Error handling: Error checking performed outside locks
  5. Atomic operations: Use defer to ensure proper lock release
  6. Early return: Direct return when setting same locale repeatedly, avoid duplicate operations

Performance Bottleneck Analysis

Major Performance Bottlenecks

1. parseDuration Function (helper.go) ✅ Optimized

  • Performance Level: ⭐⭐⭐⭐⭐
  • Average Time: 2-15ns (after sync.Map optimization)
  • Memory Allocation: 0 B/op, 0 allocs/op
  • Optimization Results:
    • Used sync.Map for high-performance concurrent caching
    • Concurrent performance improvement 35-38 times
    • Achieved zero allocation, excellent performance
  • Technical Features:
    • Read operations almost lock-free
    • Write operations atomized
    • Excellent high-concurrency performance

2. Complex Parsing Operations (parser.go)

  • Performance Level: ⭐⭐⭐⭐
  • Average Time: 372-2718ns
  • Memory Allocation: 459-4904 B/op
  • Bottleneck Causes:
    • Multiple layout matching attempts
    • Timezone parsing overhead
    • Frequent string operations
  • Optimization Suggestions:
    • Optimize layout matching algorithms
    • Enhance timezone caching mechanisms
    • Reduce unnecessary string allocations

3. Calendar Creation Operations (calendar.go)

  • Performance Level: ⭐⭐⭐⭐
  • Average Time: 401-2735ns
  • Memory Allocation: 467-4688 B/op
  • Bottleneck Causes:
    • Complex calendar conversion algorithms
    • Multiple object creations
    • Timezone processing overhead
  • Optimization Suggestions:
    • Optimize calendar conversion algorithms
    • Implement object pool reuse
    • Enhance timezone caching

Resolved Performance Bottlenecks

1. Copy Method Optimization ✅

  • Before: 141ns, 233 B/op, 1 alloc
  • After: 1.3ns, 1 B/op, 0 allocs
  • Performance Improvement: 108 times
  • Optimization Measures: Direct field copying, avoid time reconstruction

2. Comparison Method Optimization ✅

  • Before: String formatting comparison
  • After: Direct numerical comparison
  • Performance Improvement: Achieved zero allocation
  • Optimization Measures: IsAM/IsPM/IsSameHour and other methods

3. Helper Function Optimization ✅

  • parseTimezone: Achieved zero allocation, optimized with sync.Map
  • format2layout: Achieved zero allocation, 15ns
  • parseDuration: Achieved zero allocation, 2-15ns (sync.Map optimization), concurrent performance improvement 35-38 times

Optimization Space Analysis

High Priority Optimization

1. parseDuration Function Refactoring ✅ Resolved

  • Before: 2871ns, 1856 B/op, 78 allocs/op
  • After: 2-15ns (sync.Map optimization), 0 B/op
  • Performance Improvement: 130-160 times, concurrent performance improvement 35-38 times
  • Optimization Measures:
    • Use sync.Map instead of regular map + mutex
    • Predefine error instances, avoid fmt.Errorf overhead
    • Implement pre-caching mechanism, cache common durations at startup
    • Optimize error handling, reduce string formatting
    • Smart caching strategy, auto-cache short durations

2. Parser Performance Enhancement

  • Current State: 372-2718ns
  • Target State: < 200ns (simple parsing)
  • Optimization Strategy:
    • Optimize layout matching order
    • Implement smart caching
    • Reduce timezone parsing overhead
    • Pre-compile common layouts

3. Calendar Conversion Optimization

  • Current State: 401-2735ns
  • Target State: < 300ns (creation operations)
  • Optimization Strategy:
    • Optimize calendar conversion algorithms
    • Implement object pools
    • Enhance caching mechanisms
    • Reduce memory allocation

Medium Priority Optimization

1. Format Output Optimization

  • Current State: 6.5-103.8ns
  • Target State: Maintain current performance
  • Optimization Strategy:
    • Further reduce memory allocation
    • Optimize string building
    • Implement format caching

2. Concurrency Performance Optimization

  • Current State: Good concurrency performance
  • Target State: Further improve concurrency performance
  • Optimization Strategy:
    • Reduce lock contention
    • Optimize memory allocation patterns
    • Implement lock-free data structures

Low Priority Optimization

1. Constellation Calculation Optimization

  • Current State: Estimated 200-500ns
  • Target State: < 200ns
  • Optimization Strategy:
    • Optimize calculation algorithms
    • Implement result caching
    • Reduce mathematical operations

2. Type Conversion Optimization

  • Current State: Performance already excellent
  • Target State: Maintain current performance
  • Optimization Strategy:
    • Fine-tune implementation details
    • Reduce function call overhead

Performance Test Summary

Overall Assessment

Performance Dimension Rating Evaluation
Execution Efficiency ⭐⭐⭐⭐⭐ Excellent core operation performance
Memory Efficiency ⭐⭐⭐⭐⭐ Most operations zero allocation
Concurrency Performance ⭐⭐⭐⭐⭐ Good concurrency safety
Feature Completeness ⭐⭐⭐⭐⭐ Rich and complete features
Usability ⭐⭐⭐⭐⭐ User-friendly API design

Performance Highlights

  1. Zero allocation design: 65% of modules achieve zero allocation
  2. Excellent base performance: Core operations < 100ns
  3. Early return optimization: SetLocale method same locale repeated setting performance improvement 60-90x
  4. Lock optimization results: Language module performance improvement 30-45%
  5. Excellent concurrency performance: Stable performance under high concurrency
  6. Rich feature support: Supports multiple calendars and formats
  7. Good extensibility: Supports custom formats and types
  8. Concurrency safety optimization: Systematically fixed race conditions and null pointer dereference issues
  9. Parser optimization: ParseByFormats performance improvement 7.5%
  10. Comprehensive lock optimization: 7 modules' lock usage strategies optimized
  11. Smart caching mechanism: Language resource caching and early return optimization

Optimization Results

2025-10-15 Optimization Results

  • Early return optimization: SetLocale method implemented intelligent early return, same locale repeated setting performance improvement 60-90x
  • Zero allocation optimization: Achieved zero allocation when setting same locale repeatedly, significantly improved memory efficiency
  • Caching mechanism optimization: Fully utilized language resource cache, reduced duplicate loading overhead

2025-09-16 Optimization Results

  • Concurrency safety optimization: Fixed race conditions and null pointer dereference issues in 7 modules
  • Lock usage optimization: Comprehensively optimized lock usage strategies, improved concurrency safety

2025-09-15 Optimization Results

  • Language module lock optimization: Performance improvement 30-45%
  • Copy method: Performance improvement 108 times
  • Comparison methods: Achieved zero allocation optimization

2025-09-13 Optimization Results

  • sync.Map caching: Timezone, duration, and format conversion caching, concurrent performance improvement 23-38 times
  • parseDuration: Performance improvement 130-160 times, concurrent performance improvement 35-38 times, achieved zero allocation
  • format2layout: Concurrent performance improvement 23 times, achieved zero allocation
  • Helper functions: Multiple functions achieved zero allocation

Improvement Directions

  1. Parser performance enhancement: Target < 200ns
  2. Calendar conversion optimization: Target < 300ns
  3. Format output optimization: Target < 500ns
  4. Caching mechanism enhancement: Implement more caching
  5. Object pool implementation: Reduce memory allocation

Conclusion

The Carbon library demonstrates excellent overall performance, particularly outstanding in core functionality and calendar conversion. Through continuous optimization, performance has been significantly improved. The parseDuration function has been successfully optimized, using sync.Map to achieve concurrent performance improvement of 35-38 times, overall performance improvement of 130-160 times, and achieved zero allocation. The format2layout function has also been optimized, using sync.Map to achieve concurrent performance improvement of 23 times. The ParseByFormats method in parser.go achieved 7.5% performance improvement through algorithm optimization. The latest SetLocale method early return optimization achieved 60-90x performance improvement when setting the same locale repeatedly and achieved zero allocation, further enhancing the overall performance of the language module.