Skip to main content

Performance Optimization

Optimize your InForm models for fast, responsive user experiences. This guide covers techniques for improving execution speed, reducing memory usage, and enhancing overall performance.

Performance Overview​

Key Performance Metrics​

  • Parameter update time: <3 seconds for typical changes
  • Initial load time: <10 seconds for model and UI
  • Memory usage: <500MB per user session
  • Concurrent users: Support 10+ simultaneous users
  • Complex analysis: <15 seconds for heavy calculations

Performance Factors​

  • Model complexity: Number of operations and geometric detail
  • Algorithm efficiency: Choice of computational methods
  • Data transfer: Size of geometry and results data
  • Caching strategies: Reuse of previously calculated results
  • Server resources: Available CPU, memory, and network

Grasshopper Optimization​

Algorithmic Efficiency​

Choose Efficient Components​

Replace slow operations with faster alternatives:

Geometry Operations:

// Slow: Multiple individual operations
- Create individual surfaces
- Join surfaces one by one
- Perform individual intersections

// Fast: Batch operations
- Create surface list and join all at once
- Use bulk intersection operations
- Utilize vectorized operations

Mathematical Operations:

// Slow: Iterative calculations
- Loop through each item
- Individual trigonometric calculations
- Repeated similar computations

// Fast: Vectorized operations
- Process entire lists at once
- Use lookup tables for complex functions
- Cache repeated calculations

Optimize Data Structures​

Use appropriate data organization:

Tree Structures:

  • Use flat lists when possible (faster than trees)
  • Minimize tree complexity and depth
  • Avoid unnecessary tree operations

Data Types:

  • Use appropriate precision (float vs double)
  • Minimize string operations
  • Use integers for discrete values

Geometry Optimization​

Mesh Complexity Management​

Balance detail with performance:

Adaptive Detail:

// Use different detail levels based on viewing distance
- High detail for close-up elements
- Medium detail for mid-range
- Low detail for distant or background elements

// Example mesh settings
Close_Detail: 0.1 meters
Medium_Detail: 0.5 meters
Far_Detail: 2.0 meters

Efficient Meshing:

  • Use appropriate mesh settings for each geometry type
  • Avoid over-meshing curved surfaces
  • Remove duplicate vertices and degenerate faces
  • Use welded meshes where possible

NURBS vs Mesh Strategy​

Choose appropriate geometry representation:

NURBS Surfaces:

  • Use for parametric surfaces that change significantly
  • Good for mathematical precision
  • Avoid for complex multi-patch surfaces

Meshes:

  • Use for display and visualization
  • Better for complex geometry
  • More efficient for large models

Caching and Data Management​

Strategic Caching​

Implement caching for expensive operations:

Parameter Caching:

// Cache expensive calculations that don't change often
- Material property lookups
- Complex geometric calculations
- Analysis results for fixed inputs

Data Parameters:

  • Use Data parameters to store computed values
  • Prevent recalculation of unchanged data
  • Share data between different parts of definition

Memory Management​

Minimize memory usage:

Data Cleanup:

  • Remove unused geometry at each step
  • Clear temporary variables
  • Avoid accumulating large datasets

Efficient Data Flow:

  • Process data in chunks rather than all at once
  • Use streaming for large datasets
  • Minimize data copying between components

Server-Side Optimization​

RhinoCompute Efficiency​

Optimal Compute Settings​

Configure RhinoCompute for best performance:

Parallel Processing:

  • Enable multi-threading where safe
  • Use parallel loops for independent operations
  • Balance thread count with memory usage

Resource Allocation:

{
  "compute_settings": {
    "max_memory": "2GB",
    "timeout": "30s",
    "parallel_threads": 4,
    "cache_size": "100MB"
  }
}

Error Handling​

Implement robust error handling:

Graceful Degradation:

  • Provide fallback calculations for complex operations
  • Handle invalid parameter combinations
  • Return partial results when possible

Timeout Management:

  • Set appropriate timeouts for different operation types
  • Provide progress indicators for long operations
  • Allow cancellation of running operations

Data Transfer Optimization​

Geometry Compression​

Minimize data transfer size:

Mesh Compression:

  • Use appropriate compression algorithms
  • Remove unnecessary precision
  • Optimize vertex ordering

Selective Transfer:

  • Only send changed geometry
  • Use incremental updates
  • Implement level-of-detail streaming

Result Optimization​

Optimize analysis results transfer:

Data Aggregation:

  • Summarize large datasets before transfer
  • Use statistical summaries where appropriate
  • Provide different detail levels on demand

Format Optimization:

{
  "geometry": {
    "format": "compressed_mesh",
    "precision": 0.01,
    "include_normals": true,
    "include_colors": false
  },
  "data": {
    "format": "json",
    "compression": "gzip",
    "precision": 3
  }
}

Client-Side Optimization​

Unity WebGL Performance​

Rendering Optimization​

Optimize 3D visualization performance:

Level of Detail (LOD):

  • Implement distance-based LOD
  • Use occlusion culling
  • Reduce polygon count for distant objects

Material Optimization:

  • Use efficient shaders
  • Minimize texture size and count
  • Use texture atlasing where possible

Lighting and Shadows:

  • Use baked lighting for static elements
  • Minimize real-time shadow casting
  • Use efficient shadow algorithms

Memory Management​

Manage WebGL memory efficiently:

Texture Management:

  • Use appropriate texture formats
  • Implement texture streaming
  • Release unused textures

Geometry Batching:

  • Combine similar objects into batches
  • Use instancing for repeated elements
  • Minimize draw calls

User Interface Optimization​

Responsive Design​

Ensure UI remains responsive:

Asynchronous Operations:

  • Use web workers for heavy calculations
  • Implement progressive loading
  • Provide immediate feedback for user actions

Efficient Rendering:

  • Minimize DOM updates
  • Use virtual scrolling for large lists
  • Implement efficient change detection

Network Optimization​

Optimize network usage:

Request Batching:

  • Combine multiple parameter changes
  • Use debouncing for rapid changes
  • Implement request queuing

Caching Strategy:

// Example caching configuration
const cacheConfig = {
  parameterResults: {
    maxAge: 300000, // 5 minutes
    maxSize: 100    // 100 cached results
  },
  geometryData: {
    maxAge: 600000, // 10 minutes
    maxSize: 50     // 50 cached geometries
  }
};

Monitoring and Profiling​

Performance Monitoring​

Key Metrics to Track​

Monitor these performance indicators:

Execution Metrics:

  • Parameter update response time
  • Model calculation time
  • Geometry generation time
  • Data transfer time

Resource Metrics:

  • CPU usage per request
  • Memory consumption
  • Network bandwidth usage
  • Cache hit rates

User Experience Metrics:

  • Time to first interaction
  • Interface responsiveness
  • Error rates
  • User satisfaction scores

Monitoring Implementation​

Set up comprehensive monitoring:

// Example performance monitoring
const performanceMonitor = {
  startTimer: (operation) => {
    performance.mark(`${operation}-start`);
  },
  
  endTimer: (operation) => {
    performance.mark(`${operation}-end`);
    performance.measure(operation, 
      `${operation}-start`, 
      `${operation}-end`);
  },
  
  reportMetrics: () => {
    const measures = performance.getEntriesByType('measure');
    // Send metrics to monitoring service
  }
};

Profiling Tools​

Grasshopper Profiling​

Use Grasshopper's built-in profiler:

  1. Enable profiling in Grasshopper preferences
  2. Run your definition with typical parameter values
  3. Analyze results to identify bottlenecks
  4. Focus optimization on slowest components
  5. Validate improvements with before/after comparisons

Browser Profiling​

Use browser developer tools:

Performance Tab:

  • Record performance during parameter changes
  • Identify rendering bottlenecks
  • Analyze memory allocation patterns
  • Check for memory leaks

Network Tab:

  • Monitor request/response times
  • Identify large data transfers
  • Check for redundant requests
  • Validate caching effectiveness

Optimization Strategies​

Systematic Optimization Process​

1. Baseline Measurement​

Establish current performance:

  • Measure key metrics with typical usage patterns
  • Document current user experience
  • Identify most common performance complaints
  • Set specific improvement targets

2. Bottleneck Identification​

Find the biggest performance issues:

  • Use profiling tools to identify slow operations
  • Analyze user workflows to find pain points
  • Review error logs for common failures
  • Survey users about performance concerns

3. Prioritized Optimization​

Focus on highest-impact improvements:

  • Address bottlenecks with biggest user impact
  • Consider development effort vs. performance gain
  • Implement quick wins first
  • Plan complex optimizations as separate projects

4. Validation and Monitoring​

Verify improvements and track ongoing performance:

  • Measure performance improvements
  • Validate user experience improvements
  • Monitor for performance regressions
  • Continue iterative optimization

Common Optimization Patterns​

Lazy Loading​

Load data only when needed:

// Load complex geometry only when visible
- Check if element is in current view
- Load detailed geometry on demand
- Use placeholder geometry for distant elements

Progressive Enhancement​

Build up complexity gradually:

  1. Basic geometry: Fast loading, low detail
  2. Enhanced detail: Add complexity as needed
  3. Full analysis: Complete calculations on demand
  4. Interactive features: Enable advanced functionality

Precomputation​

Calculate results in advance:

Design Space Sampling:

  • Pre-calculate common parameter combinations
  • Store results for instant retrieval
  • Use interpolation for intermediate values

Analysis Caching:

  • Cache analysis results for stable configurations
  • Update cache when underlying models change
  • Provide cached results while calculating updates

Troubleshooting Performance Issues​

Common Performance Problems​

Slow Parameter Updates​

Symptoms: Long delays when changing parameters

Diagnosis:

  • Use Grasshopper profiler to identify slow components
  • Check for inefficient algorithms or excessive detail
  • Look for unnecessary recalculations

Solutions:

  • Optimize slow components
  • Implement selective updates
  • Add caching for expensive operations
  • Reduce geometric complexity

Memory Issues​

Symptoms: Browser crashes, out of memory errors

Diagnosis:

  • Monitor memory usage in browser developer tools
  • Check for memory leaks in JavaScript
  • Analyze geometry data size and complexity

Solutions:

  • Implement proper memory cleanup
  • Reduce geometry complexity
  • Use streaming for large datasets
  • Optimize texture and material usage

Network Bottlenecks​

Symptoms: Slow loading, timeouts, poor responsiveness

Diagnosis:

  • Use browser network tab to analyze requests
  • Check server response times
  • Monitor bandwidth usage

Solutions:

  • Implement data compression
  • Optimize request batching
  • Use CDN for static assets
  • Improve caching strategies

Performance Testing​

Load Testing​

Test performance under realistic usage:

Single User Testing:

  • Test with typical parameter changes
  • Measure response times for all operations
  • Test with complex model configurations
  • Validate on different devices and browsers

Multi-User Testing:

  • Simulate concurrent users
  • Test resource sharing and contention
  • Validate server performance under load
  • Check for degradation with increased users

Stress Testing​

Test performance limits:

Resource Limits:

  • Test with maximum geometry complexity
  • Push parameter ranges to extremes
  • Test with maximum number of concurrent users
  • Validate error handling under stress

Recovery Testing:

  • Test recovery from failures
  • Validate system stability after stress
  • Check for resource leaks
  • Ensure graceful degradation

Next Steps​

After optimizing performance:

  1. Implement monitoring: Track ongoing performance
  2. User training: Help users use the system efficiently
  3. Continuous improvement: Regular optimization reviews
  4. Scale planning: Prepare for increased usage

Additional Resources​