Hubbry Logo
search
logo
Instruments (software) avatar
Instruments (software)
Instruments (software)
current hub
I

Instruments (software)

logo
Community Hub0 Subscribers
Read side by side
Instruments (software)
View on Wikipedia
from Wikipedia

Instruments
DeveloperApple Inc
Stable release
26.0 / September 15, 2025
Operating systemmacOS
TypeTracing & Profiling
LicenseProprietary freeware
Websitehelp.apple.com/instruments

Instruments (formerly Xray) is an application performance analyzer and visualizer by Apple Inc., integrated in Xcode 3.0 and later versions of Xcode. It is built on top of the DTrace tracing framework from OpenSolaris, which was ported to Mac OS X v10.5 and which is available in all following versions of macOS.

Instruments shows a time line displaying any event occurring in the application, such as CPU activity variation, memory allocation, and network and file activity, together with graphs and statistics. Group of events are monitored via customizable "instruments", which have the ability to record user generated events and replay (emulate) them exactly as many times as needed, so a developer can see the effect of code changes without actually doing the repetitive work. The Instrument Builder feature allows the creation of custom analysis instruments.[1]

Features

[edit]

Built-in instruments can track

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Instruments (software)

View on Grokipedia
from Grokipedia
Instruments is a performance analysis and visualization tool developed by Apple Inc. for profiling and debugging applications across its platforms.[1] Integrated into the Xcode integrated development environment since version 3.0, released in 2007 with Mac OS X Leopard, Instruments enables developers to monitor and optimize app behavior in real time.[1] It supports analysis on iOS, iPadOS, macOS, tvOS, watchOS, and visionOS, providing insights into CPU usage, memory allocation, energy consumption, and graphical rendering.[2] Originally codenamed Xray, Instruments evolved from earlier debugging utilities like Shark into a comprehensive suite of instruments, each targeting specific performance metrics such as allocations, leaks, zombies, and thread activity. Key features include time-based tracing, which captures data over app execution to identify bottlenecks, and integration with DTrace for low-level system probing without significant overhead.[3] Developers use its graphical interface to visualize timelines, stack traces, and resource graphs, facilitating targeted optimizations like reducing main thread blocks to prevent hangs or minimizing energy impact for battery-powered devices.[4] The tool's extensibility allows custom instrument creation via the Instruments package format and SDK, using languages like C and DTrace for data providers.[5] Recent updates, such as those in Xcode 15 and later, incorporate hardware-assisted profiling for Apple silicon, enhancing accuracy in CPU and GPU optimization on M-series chips.[6] By providing actionable data on app responsiveness, resource efficiency, and stability, Instruments remains essential for creating high-performance software in the Apple ecosystem.[7]

Overview

Development and Release History

Instruments originated as a tool named Xray in early betas of Xcode during 2006, serving as a performance analysis utility for developers. It was rebranded to Instruments and officially integrated into Xcode 3.0, which Apple released on October 22, 2007, coinciding with the launch of Mac OS X 10.5 Leopard.[8] This rebranding reflected Apple's intent to consolidate various standalone profiling tools into a unified interface for tracing application behavior. A key milestone came with its alignment to DTrace, the dynamic tracing framework made available in macOS 10.5 Leopard, enabling Instruments to leverage kernel-level instrumentation for real-time performance monitoring without requiring code modifications. This integration marked Instruments as a core component of Apple's developer ecosystem, replacing fragmented tools like Shark for sampling-based profiling and MallocDebug for memory leak detection, which were deprecated around the same period to streamline developer workflows.[9] Subsequent updates expanded Instruments' capabilities across Xcode versions. Xcode 4, released in March 2011, introduced full support for iOS device profiling, allowing developers to analyze mobile app performance directly on hardware.[8] Xcode 5 in September 2013 enhanced memory debugging features, including improved allocation tracking and leak detection integrated with the Debug Navigator. In Xcode 8, released in September 2016, energy profiling was added to measure app impact on battery life, addressing growing concerns for mobile efficiency.[10] The most recent version, Instruments 26.0, arrived with Xcode 26 on September 15, 2025, featuring advancements in processor tracing for capturing detailed instruction-level execution flows on Apple silicon.[11]

Technical Foundations

Instruments is fundamentally built on DTrace, a dynamic tracing framework originally developed by Sun Microsystems for OpenSolaris to enable comprehensive kernel and user-space probing without requiring code recompilation or restarts.[12] Apple ported DTrace to macOS 10.5 Leopard, released in 2007, integrating it as a core technology for performance analysis tools like Instruments.[13] This port extended DTrace's capabilities to Apple's ecosystem, allowing low-overhead instrumentation of system calls, function entries, and custom events across processes. At its core, Instruments relies on trace data collection through DTrace scripts, which define probes written in the D programming language to capture events such as CPU usage, memory allocations, and I/O operations.[14] These scripts facilitate event aggregation, where raw trace data is summarized using DTrace's built-in aggregation functions—like count, sum, and average—to produce efficient, queryable datasets for analysis. Complementing this, Instruments employs a templating system for instrument bundles, structured as .instrpkg packages that use XML definitions to specify data schemas, UI layouts, and modeling logic often implemented in the CLIPS expert system language for intelligent event processing.[15] Instruments supports multi-platform tracing across macOS, iOS, watchOS, and tvOS, enabling on-device profiling for resource-constrained environments like iOS—where DTrace runs with restrictions for security—and remote collection from host machines for deeper analysis.[16] This is achieved through Apple's unified tracing infrastructure, which streams data via wireless or USB connections while maintaining low system impact.[17] Apple has introduced proprietary extensions to enhance DTrace's flexibility, notably the os_signpost API in macOS 10.14 Mojave, which allows developers to log custom events and intervals directly into trace streams for Instruments visualization. These signposts, integrated with the OS logging subsystem, provide lightweight markers for app-specific performance points without relying solely on DTrace probes.[18]

Core Functionality

Built-in Instruments

Instruments provides a collection of built-in instruments that enable developers to profile specific aspects of application and system performance on Apple platforms. These tools are pre-configured templates within the Instruments application, allowing for targeted analysis of resource usage without requiring custom setup. Many of these instruments utilize DTrace-based tracing for efficient data collection at the kernel level.[19] The Time Profiler instrument samples CPU usage by periodically capturing the call stacks of running threads, typically at 1 ms intervals, to construct a statistical profile of execution time. This reveals hotspots—functions consuming the most CPU cycles—through hierarchical call trees that display total time (weight) and self-time (excluding callees), aiding in the identification of performance bottlenecks. For instance, it aggregates samples to show percentages like 98.3% usage for a specific method, though it cannot precisely measure individual call frequencies.[20] The Allocations instrument tracks heap memory allocations, monitoring the creation, growth, and persistence of objects to uncover patterns in memory usage. It categorizes allocations by type (e.g., Malloc or VM), responsible callers, and stack traces, displaying metrics such as persistent bytes (total allocated memory) and instance counts (e.g., 41,900 instances totaling 7.67 MB for a Tile class). This helps detect inefficient allocation habits and object lifecycles that contribute to excessive memory footprints.[21] The Leaks instrument detects memory leaks by taking periodic heap snapshots and scanning for unreferenced blocks in writable memory, registers, and stacks. It identifies leaks as allocations without retainers, presenting them in table or outline views with details like address, size, and allocation stack traces, enabling developers to trace back to the originating code for remediation.[22] The Zombies instrument monitors for messages sent to deallocated objects by replacing freed memory with "zombie" placeholders, logging violations to debug "use after free" errors common in Objective-C and Swift. It captures the object type, deallocation time, and offending message, facilitating investigation of reference counting issues even when crash logs lack app-specific frames.[23] The Core Animation instrument profiles graphics rendering by tracking frame rates, layer updates, and GPU resource utilization, highlighting inefficiencies like unnecessary screen redraws. Using the Core Animation Profiling template, it visualizes commits to the render server and enables features like flashing updated regions to pinpoint energy-impacting visual changes.[10] The Network instrument logs socket-level activity for HTTP and other protocols, capturing packet transmissions, sizes, and timings to analyze data throughput and delays. It records transaction states (e.g., sending request, waiting for response) with metadata on headers, bodies, and durations—such as milliseconds for cache lookups versus seconds for blocking—grouped by connection or path for latency optimization.[24] The Power Profiler instrument (successor to Energy Log), measures power consumption on Apple Silicon devices by tracing subsystem impacts like CPU, GPU, display, and networking activity. It reports energy usage as a fraction of battery per hour, detailing device states (e.g., thermal throttling, brightness) and allowing on-device recording for up to 10 hours to identify power-hungry operations. Available on iOS 18 and later, iPadOS 18 and later, macOS Sequoia and later, it supports untethered analysis for real-world battery optimization.[25] The System Trace instrument captures low-level kernel events, thread scheduling decisions, and I/O operations through components like System Call Trace, Thread State Trace, and Virtual Memory Trace. It provides a timeline of OS interactions—such as scheduler switches affecting app threads or system call durations—enabling diagnosis of concurrency issues, blocking operations, and resource contention in complex applications.[26] Recent additions as of 2025 include the Processor Trace instrument, introduced in Xcode 16.3, which uses hardware-supported tracing on Apple silicon to accurately reconstruct execution paths with low overhead, capturing every function call and branch. Additionally, the SwiftUI instrument, added in Xcode 26, profiles SwiftUI view rendering, body computations, and update cycles to optimize declarative UI performance.[27][28]

Data Visualization and Analysis

Instruments presents collected trace data through a timeline view, which features a horizontal graph depicting events and performance metrics over time. This view enables developers to visualize peaks in resource usage, such as CPU, memory, or I/O activity, using graphical elements like histograms and colored bars; for instance, in hang analysis, red rectangles indicate severe hangs, while blue histogram bars represent CPU usage on the main thread. Developers can zoom into specific intervals by dragging to select time ranges and apply filters to isolate tracks for particular processes or threads, facilitating targeted investigation of performance bottlenecks. Developers can record traces while manually interacting with the app to capture user actions and correlate them with performance data for analysis of issues like responsiveness delays.[29][30] Complementing the timeline, detail panes provide in-depth processing of selected events, including extended backtraces, statistics tables, and histograms. The call tree detail view aggregates data by function or thread, displaying expandable outlines with quantitative metrics like percentage of CPU time spent (e.g., 98.3% in a specific getter during a hang); the heaviest stack trace pane further summarizes this with a single, prioritized call stack, color-coding frames based on source availability. These panes dynamically update with timeline selections, offering conceptual insights into execution patterns without requiring exhaustive numerical listings. For example, when analyzing memory from the Allocations instrument, detail panes reveal allocation backtraces and generation statistics.[30][29] Aggregation modes in Instruments include live processing, where data streams in real-time during recording for immediate feedback, and batch processing, which analyzes the full trace post-recording for comprehensive review. Processed data can be exported to CSV for tabular integration with external tools or GPX for location-specific traces, enabling further offline examination.[31][32]

Usage and Integration

Launching and Recording Sessions

Instruments, Apple's performance analysis tool integrated into Xcode, can be launched directly from the Xcode IDE or as a standalone application. To initiate a profiling session from within Xcode, developers select the Product > Profile menu option, which builds the app using the current scheme's configuration—typically Release for optimized profiling—and automatically opens Instruments with a suggested template based on common performance issues. Alternatively, Instruments can be accessed independently via Xcode's Open Developer Tool > Instruments menu, allowing selection of any target project or process without an immediate build.[24][4] Upon launching, users select from pre-built templates that bundle multiple instruments tailored to specific profiling goals, streamlining the setup process. For instance, the Leaks template uses the Leaks instrument, which detects memory allocations not properly deallocated. The Zombies instrument, which tracks messaging to deallocated objects to identify use-after-free errors, can be added separately or via its own template for more comprehensive memory analysis. These templates provide a ready-to-use configuration, though users can customize by adding or removing individual instruments from the template library.[22][33] Target attachment determines how Instruments connects to the application under test, supporting launches on simulators, physical devices, or attachment to existing processes. When profiling from Xcode, the scheme's run configuration dictates the target: selecting an iOS simulator launches the app virtually on the host Mac, while a connected device requires the app to be built and installed accordingly. For attaching to a running process, Instruments offers a chooser dialog listing active applications, enabling on-the-fly profiling without restarting; this is particularly useful for debugging live sessions on macOS apps. Schemes can be edited in Xcode (via Product > Scheme > Edit Scheme) to specify build-and-profile actions, ensuring the app launches in a profiled state upon recording.[4][34] Once configured, recording begins with the prominent Record button in Instruments' toolbar, which initiates data capture and launches or attaches to the target as specified. Basic controls include a Stop button to end the session and save the trace file, alongside Pause and Resume buttons for temporarily halting data collection during non-reproducible scenarios without losing the session context. Advanced options support extended traces for prolonged monitoring, such as multi-hour battery impact assessments, and integration with signposts—custom timing events emitted via the os_signpost API in code—which appear as annotated intervals in the trace timeline for correlating app-specific milestones.[29][18] For iOS and other device-based platforms, remote profiling introduces specific setup requirements to ensure secure and authorized access. Physical devices must have the app signed with a valid development provisioning profile from an Apple Developer account, which includes device UDIDs and entitlements; without this, Instruments cannot install or attach to the target, resulting in launch failures. Simulators bypass these restrictions, allowing immediate profiling on the development machine, while wireless debugging—enabled via Xcode's Window > Devices and Simulators—requires initial USB pairing and the same provisioning setup.[35]

Interpreting Results in Xcode

After capturing trace data in Instruments, developers analyze results directly within Xcode to identify and refine code issues. This integration transforms raw performance metrics into actionable insights by linking traces to source code, facilitating targeted debugging. Instruments processes the data through its timeline views, where events like function calls or allocations are displayed chronologically for examination. Symbolication automatically maps memory addresses from traces to human-readable source code lines and function names, using dSYM files generated during app builds to provide debugging symbols.[36] These files ensure that even optimized or stripped binaries can be correlated back to original code, enabling precise identification of performance bottlenecks without manual address resolution. To add or manage symbols if automatic detection fails, developers select File > Symbols in Instruments, where dSYM folders or archives can be imported for comprehensive coverage across app binaries and frameworks.[37] For deeper inspection, double-clicking any symbol or event in the trace timeline jumps directly to the corresponding source code in the Xcode editor, highlighting the exact line responsible.[7] This feature streamlines navigation, allowing immediate code review and edits without switching tools, and works seamlessly across custom code, system frameworks, and third-party libraries once symbolicated. Instruments integrates with the LLDB debugger to combine performance tracing with interactive debugging during live sessions. Developers can attach LLDB breakpoints to traced processes, pausing execution at key points to inspect variables, stack traces, and runtime state alongside Instruments data.[36] Recorded sessions can be exported and saved as .trace files via File > Save As, preserving all trace data, instruments, and annotations for offline review. These files are shareable among teams for collaborative analysis or can be submitted to Apple diagnostics for further investigation, maintaining fidelity to the original recording environment. Error correlation in Instruments links anomalies like memory leaks or hangs to specific API interactions. In the Leaks instrument, for instance, trace events reveal unbalanced retain-release cycles in Objective-C or strong reference loops in Swift, pinpointing responsible objects and call stacks.[38] Similarly, the Zombies instrument detects over-releases or messaging errors by simulating deallocated objects, correlating hangs to invalid API calls and guiding fixes through symbolized backtraces.

Advanced Capabilities

Custom Instrument Creation

Custom instrument creation allows developers to extend Instruments by defining specialized probes and visualizations tailored to specific application behaviors or frameworks. This process involves building .instrument bundles using Xcode projects, which encapsulate data collection logic, processing rules, and user interface components. These bundles can be distributed as templates for team-wide reuse, enabling consistent performance analysis across projects.[5] The Instrument Builder, an Xcode-based editor integrated into the Instruments workflow, facilitates the creation of these bundles by providing templates for custom instruments. Developers start by selecting a blank template in Instruments and adding components via the plus icon, or by creating a new Instruments Distribution Package target in Xcode for more advanced setups. This editor supports defining the instrument's metadata, such as name, category, and description, while allowing integration of data sources like os_signpost events or legacy DTrace scripts. For macOS applications, DTrace remains a viable option for low-level tracing, though os_signpost is preferred for cross-platform compatibility on iOS and macOS.[15] Custom probes are implemented by writing predicates to capture app-specific events, such as tracing custom API calls or workflow milestones. Using os_signpost, developers log begin/end intervals or discrete events with metadata, which Instruments captures efficiently without significant overhead. For instance, in a mobile navigation app like the sample GoatList project, signposts mark "Mobile Agent Exec" and "Mobile Agent Moved" events to track subgoal progress. In DTrace-based probes, predicates filter events using conditional logic (e.g., matching specific function calls), while actions define data aggregation, such as counting occurrences or printing stack traces. These probes reference DTrace scripting concepts, like providers (e.g., syscall or fbt) and variable scoping, to ensure precise event isolation.[39] Visualization plugins enhance the instrument's output by integrating custom charts, tables, or tracks directly into Instruments' timeline view. Developers use the Instruments framework in Objective-C (or Swift) to define UI extensions, such as plot templates for interval-based graphs or engineering-type tracks for dynamic data display. For complex processing, the CLIPS rules engine models raw signpost data into meaningful facts, applying conditional elements (e.g., "and" or "not") to aggregate events before rendering. This enables visualizations like per-thread plots avoiding overlaps or narrative-enriched tables that summarize performance stories. JavaScript may be used in limited contexts for scripting dynamic behaviors, but primary integration relies on native APIs for seamless performance.[40][5] Distribution of custom instruments occurs through packaging as .instrument bundles, which can be saved as templates in the user's Library/Application Support/Instruments/Templates directory for easy access in future sessions. These bundles support team environments by allowing export and import via Xcode, ensuring reproducibility without rebuilding from scratch. For broader adoption, developers compile the package target and share the resulting bundle, integrating it into organizational workflows for specialized analysis. Examples of custom instruments include Apple's Mobile Agent extension for modeling navigation tasks in apps, as well as third-party implementations for domain-specific needs. In machine learning frameworks, custom probes trace inference latencies using signposts around model execution calls, visualized as timeline intervals. Similarly, for game engines, extensions monitor rendering pipelines by logging draw calls and GPU events, providing targeted insights into frame rates and resource usage. These adaptations demonstrate how custom instruments bridge general-purpose tools with specialized requirements.[15]

Performance Optimization Workflows

Instruments provides developers with targeted workflows to optimize application performance by addressing key bottlenecks in memory, CPU, responsiveness, and energy consumption. These workflows leverage built-in instruments to profile, diagnose, and resolve issues, enabling iterative improvements that enhance app efficiency on Apple platforms. As of Xcode 26 (2025), new features such as Processor Trace and hardware-assisted CPU profiling further support these workflows on Apple silicon.[11] By systematically analyzing traces, developers can implement data-driven refactors that reduce resource usage without compromising functionality.

Memory Optimization

Memory optimization begins with the Allocations instrument, which tracks heap allocations, object lifecycles, and reference counts to identify inefficiencies.[41] To detect persistent objects—those remaining in memory longer than necessary—developers record a session during app usage scenarios prone to leaks, such as repeated view controller loads or data caching. The instrument's timeline reveals allocation patterns, highlighting objects with extended retention times that contribute to increased memory footprints.[42] For instance, filtering by object type in the statistics view can pinpoint over-retained instances, such as undismissed modal views or unoptimized image caches.[43] Reducing the memory footprint involves refactoring based on these insights, such as implementing proper deallocation in viewDidDisappear methods or using weak references in delegates to break retain cycles.[41] Developers can set heapshot markers at critical points—like before and after a complex operation—to compare live object graphs and isolate growth areas.[44] This approach minimizes dirty memory pages, where writing even a single byte to new memory can allocate up to 16 KB on iOS, by encouraging reuse of existing buffers or lazy loading of assets.[41] Overall, regular profiling with Allocations can help reduce an app's peak memory usage in scenarios with heavy data processing, improving background survival rates.[41]

CPU Bottleneck Resolution

Resolving CPU bottlenecks starts with the Time Profiler instrument, which generates call graphs to visualize execution paths and identify hot paths consuming disproportionate processing time. As of Xcode 26, Processor Trace provides detailed capture of every function call, and hardware-assisted tools enable precise optimization on Apple silicon.[11][6] During a recording session focused on compute-intensive tasks, such as data parsing or algorithm execution, the call graph highlights functions with high self-time percentages, indicating inefficient code segments.[45] Developers drill down into inverted call trees to trace stack frames, revealing bottlenecks like nested loops or redundant computations in frequently called methods.[46] Refactoring hot paths typically involves optimizing algorithms—for example, replacing O(n²) searches with hash tables—or vectorizing operations for Apple silicon efficiency.[47] By comparing before-and-after traces, developers confirm reductions in CPU utilization for targeted functions.[45] The Time Profiler, as detailed in the Built-in Instruments section, integrates with CPU Counters to categorize bottlenecks by type, such as instruction delivery or branch misprediction, guiding precise code adjustments.[45]

Responsiveness Fixes

Main thread analysis in Instruments uses templates like Hitches or Time Profiler to detect hangs and ensure UI fluidity, targeting operations that block user interactions. The new SwiftUI instrument, introduced in Xcode 26, helps profile view updates and data-driven changes for SwiftUI apps.[28][11] Recording during user flows, such as scrolling lists or transitioning views, reveals main thread overloads through timeline spikes exceeding 100 ms thresholds, which cause perceived freezes.[48] The thread tracks display call stacks for these events, identifying culprits like synchronous network calls or heavy computations on the UI thread.[48] Fixes center on offloading non-UI work to Dispatch queues, using async/await in Swift concurrency for structured parallelism or DispatchQueue.global() for legacy tasks.[48] For example, image decoding or file I/O can be dispatched concurrently, updating the main thread only for final UI renders via DispatchQueue.main.async.[48] Post-refactor traces in Instruments verify hitch reductions, with benchmarks showing frame rates stabilizing at 60 FPS and hang durations dropping below 16 ms.[48] This workflow prioritizes XCTest performance tests to enforce main thread budgets, preventing regressions in responsiveness.[48]

Battery Impact Reduction

Battery optimization employs the Energy Log (via Energy Diagnostics template) or Power Profiler to quantify an app's energy consumption, focusing on wakeups and network activity that drain resources. Enhancements in Xcode 26 improve Power Profiler for better battery and thermal analysis.[11][10] To address idle wakeups, developers enable logging on the device and import traces into Instruments, where the timeline exposes frequent background activations from timers or push notifications.[10] High wakeup counts, visible as CPU spikes during idle periods, signal inefficient polling; refactoring consolidates timers using Background App Refresh or coalesces events to Wi-Fi availability.[49] For network efficiency, the Network instrument within Power Profiler tracks data transfers, revealing energy-intensive patterns like frequent small requests.[25] Strategies include batching API calls, compressing payloads, or switching to efficient protocols like HTTP/2 to minimize radio wakeups.[49] Traces post-optimization show reductions in energy impact scores, extending battery life during prolonged sessions.[49] Integrating MetricKit reports further validates real-user data, ensuring sustained efficiency.[49]

Case Studies

In optimizing a video streaming app's rendering pipeline, developers used the Time Profiler to identify a hot path in frame decoding that spiked CPU usage during playback.[45] By offloading AVFoundation processing to a serial Dispatch queue and batching buffer updates, the refactor reduced decoding time, smoothing 4K playback on iPhone without frame drops.[48] Concurrent Allocations tracing confirmed no memory leaks from video caches, further lowering the footprint through timed purges.[41] For a physics-based game, Instruments' CPU profiling revealed bottlenecks in the simulation loop, where collision detections in a particle system accounted for a significant portion of frame time on Apple silicon.[50] Refactoring involved spatial partitioning to cull unnecessary checks and vectorizing computations with Accelerate framework, yielding a speedup in physics updates.[47] Energy Log analysis then targeted idle wakeups from background syncing, batching them to cut battery drain during extended play sessions.[10] These changes maintained 120 FPS while enhancing device longevity.[50]

References

  1. What Is Cocoa? - Apple Developer
  2. Instruments | Apple Developer Forums
  3. Inside Apple's new Xcode 4 development tool | AppleInsider
  4. Instruments New Features User Guide - Apple Developer
  5. Instruments Tutorials | Apple Developer Documentation
  6. Optimize CPU performance with Instruments - WWDC25 - Videos
  7. Getting Started with Instruments - WWDC19 - Videos
  8. Xcode Releases | xcodereleases.com
  9. No Shark on OS X Lion? - Ask Different - Apple Stack Exchange
  10. Measure Energy Impact with Instruments - Apple Developer
  11. Xcode 26 Release Notes | Apple Developer Documentation
  12. [PDF] DTrace: The Reverse Engineer's Unexpected Swiss Army Knife
  13. DTrace on Mac OS X! | The Observation Deck
  14. DTrace - objc.io
  15. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments
  16. Apple Developer Documentation
  17. System Trace in Depth - WWDC16 - Videos - Apple Developer
  18. Measuring Performance Using Logging - WWDC18 - Videos
  19. https://developer.apple.com/library/archive/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/index.html
  20. Determining execution frequency — Instruments Tutorials
  21. Technical Note TN2434: Minimizing your app's Memory Footprint
  22. Finding Memory Leaks - Apple Developer
  23. Investigating crashes for zombie objects - Apple Developer
  24. Analyzing HTTP traffic with Instruments - Apple Developer
  25. Measuring your app’s power use with Power Profiler | Apple Developer Documentation
  26. Analyzing the performance of your Metal app - Apple Developer
  27. Getting started with hang analysis — Instruments Tutorials
  28. Analyzing main thread activity — Instruments Tutorials | Apple Developer Documentation
  29. New Features in Instruments 4.2 - Apple Developer
  30. Why am I unable to export my xcode instruments data as a CSV ...
  31. Making changes to reduce memory use - Apple Developer
  32. Customizing the build schemes for a project - Apple Developer
  33. Manage Your Workflow in Xcode - Apple Developer
  34. Symbolication: Beyond the basics - WWDC21 - Videos
  35. Xcode 5 Release Notes - Apple Developer
  36. Apple Developer Documentation
  37. Creating Custom Instruments - WWDC18 - Videos - Apple Developer
  38. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments#Design-a-Custom-Modeler-for-MobileAgent-Activity
  39. https://developer.apple.com/documentation/xcode/creating-custom-modelers-for-intelligent-instruments#CLIPS-Modeler-Functions
  40. Reducing your app's memory use | Apple Developer Documentation
  41. https://developer.apple.com/documentation/xcode/reducing-your-app-s-memory-use#View-data-on-memory-use
  42. Gathering information about memory use - Apple Developer
  43. https://developer.apple.com/documentation/xcode/reducing-your-app-s-memory-use#Understand-memory-use-metrics
  44. Addressing CPU bottlenecks | Apple Developer Documentation
  45. https://developer.apple.com/documentation/xcode/understanding-and-improving-swiftui-performance
  46. Tuning your code's performance for Apple silicon
  47. Improving app responsiveness | Apple Developer Documentation
  48. Analyzing your app's battery use | Apple Developer Documentation
  49. Profile and optimize your game's memory - WWDC22 - Videos
User Avatar
No comments yet.