From 6f7fdffdda3853b5db3217fd7b5aa66a1429c8f6 Mon Sep 17 00:00:00 2001 From: "Parshutin, Eugeny" Date: Wed, 23 Apr 2025 14:59:26 -0500 Subject: [PATCH 1/7] doc: add docs source files and gh-action to deploy docs to gh-pages --- .github/workflows/deploy-docs.yml | 33 ++ docs/README.md | 18 + docs/conf.py | 37 ++ docs/gpa-user-guide/clock-domain-api.rst | 47 +++ .../compile-and-link-with-itt-api.rst | 129 +++++++ docs/gpa-user-guide/counter-api.rst | 113 ++++++ docs/gpa-user-guide/domain-api.rst | 81 ++++ docs/gpa-user-guide/gpa-user-guide.rst | 83 ++++ .../instrumenting-your-application.rst | 137 +++++++ docs/gpa-user-guide/marker-api.rst | 37 ++ docs/gpa-user-guide/metadata-api.rst | 69 ++++ .../minimizing-itt-api-overhead.rst | 88 +++++ docs/gpa-user-guide/relation-api.rst | 52 +++ docs/gpa-user-guide/string-handle-api.rst | 46 +++ docs/gpa-user-guide/task-api.rst | 209 ++++++++++ docs/gpa-user-guide/thread-naming-api.rst | 71 ++++ docs/index.rst | 47 +++ docs/requirements.txt | 2 + ...002AF5-830E-43B6-9CA1-A5015F87329D-low.png | Bin 0 -> 1187 bytes ...BE0C25-5938-4D25-8D9E-F2004C907256-low.png | Bin 0 -> 49420 bytes ...0BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif | Bin 0 -> 357 bytes ...FC2DCE-141C-4709-9F29-7D143D40EEB9-low.png | Bin 0 -> 262 bytes ...4B6013-D1E9-4593-B9EC-85791339769D-low.png | Bin 0 -> 668 bytes ...2C1D59-20E8-4428-AF7A-23727182579B-low.png | Bin 0 -> 955 bytes ...DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png | Bin 0 -> 90755 bytes ...B262AE-A77B-442B-9592-1EFA506C7128-low.png | Bin 0 -> 29883 bytes ...F7E148-45E3-4669-9D09-091ADEA45BBA-low.png | Bin 0 -> 21246 bytes docs/vtune-user-guide/api-support.rst | 28 ++ ...ach-itt-apis-to-a-launched-application.rst | 98 +++++ .../basic-usage-and-configuration.rst | 72 ++++ .../collection-control-api.rst | 121 ++++++ .../compile-and-link-with-ittapi.rst | 51 +++ .../configure-your-build-system.rst | 204 ++++++++++ .../vtune-user-guide/context-metadata-api.rst | 215 +++++++++++ docs/vtune-user-guide/counter-api.rst | 162 ++++++++ docs/vtune-user-guide/domain-api.rst | 65 ++++ docs/vtune-user-guide/event-api.rst | 129 +++++++ docs/vtune-user-guide/frame-api.rst | 168 ++++++++ docs/vtune-user-guide/histogram-api.rst | 187 +++++++++ .../vtune-user-guide/ijit_-getnewmethodid.rst | 40 ++ .../ijit_isprofilingactive.rst | 38 ++ docs/vtune-user-guide/ijit_notifyevent.rst | 257 +++++++++++++ .../instrument-your-application.rst | 137 +++++++ ...n-and-tracing-technology-api-reference.rst | 26 ++ .../jit-profiling-api-reference.rst | 12 + docs/vtune-user-guide/jit-profiling-api.rst | 335 ++++++++++++++++ docs/vtune-user-guide/load-module-api.rst | 39 ++ .../memory-allocation-apis.rst | 134 +++++++ .../minimize-itt-api-overhead.rst | 99 +++++ docs/vtune-user-guide/string-handle-api.rst | 38 ++ ...ion-and-tracing-technology-api-itt-api.rst | 68 ++++ docs/vtune-user-guide/task-api.rst | 176 +++++++++ docs/vtune-user-guide/thread-naming-api.rst | 84 ++++ .../user-defined-synchronization-api.rst | 363 ++++++++++++++++++ .../using-jit-profiling-api.rst | 195 ++++++++++ ...-api-task-data-in-intel-vtune-profiler.rst | 130 +++++++ docs/vtune-user-guide/vtune-user-guide.rst | 31 ++ 57 files changed, 5001 insertions(+) create mode 100755 .github/workflows/deploy-docs.yml create mode 100755 docs/README.md create mode 100644 docs/conf.py create mode 100644 docs/gpa-user-guide/clock-domain-api.rst create mode 100644 docs/gpa-user-guide/compile-and-link-with-itt-api.rst create mode 100644 docs/gpa-user-guide/counter-api.rst create mode 100644 docs/gpa-user-guide/domain-api.rst create mode 100644 docs/gpa-user-guide/gpa-user-guide.rst create mode 100644 docs/gpa-user-guide/instrumenting-your-application.rst create mode 100644 docs/gpa-user-guide/marker-api.rst create mode 100644 docs/gpa-user-guide/metadata-api.rst create mode 100644 docs/gpa-user-guide/minimizing-itt-api-overhead.rst create mode 100644 docs/gpa-user-guide/relation-api.rst create mode 100644 docs/gpa-user-guide/string-handle-api.rst create mode 100644 docs/gpa-user-guide/task-api.rst create mode 100644 docs/gpa-user-guide/thread-naming-api.rst create mode 100644 docs/index.rst create mode 100755 docs/requirements.txt create mode 100644 docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png create mode 100644 docs/vtune-user-guide/GUID-1ABE0C25-5938-4D25-8D9E-F2004C907256-low.png create mode 100644 docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif create mode 100644 docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png create mode 100644 docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png create mode 100644 docs/vtune-user-guide/GUID-682C1D59-20E8-4428-AF7A-23727182579B-low.png create mode 100644 docs/vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png create mode 100644 docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png create mode 100644 docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png create mode 100644 docs/vtune-user-guide/api-support.rst create mode 100644 docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst create mode 100644 docs/vtune-user-guide/basic-usage-and-configuration.rst create mode 100644 docs/vtune-user-guide/collection-control-api.rst create mode 100644 docs/vtune-user-guide/compile-and-link-with-ittapi.rst create mode 100644 docs/vtune-user-guide/configure-your-build-system.rst create mode 100644 docs/vtune-user-guide/context-metadata-api.rst create mode 100644 docs/vtune-user-guide/counter-api.rst create mode 100644 docs/vtune-user-guide/domain-api.rst create mode 100644 docs/vtune-user-guide/event-api.rst create mode 100644 docs/vtune-user-guide/frame-api.rst create mode 100644 docs/vtune-user-guide/histogram-api.rst create mode 100644 docs/vtune-user-guide/ijit_-getnewmethodid.rst create mode 100644 docs/vtune-user-guide/ijit_isprofilingactive.rst create mode 100644 docs/vtune-user-guide/ijit_notifyevent.rst create mode 100644 docs/vtune-user-guide/instrument-your-application.rst create mode 100644 docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst create mode 100644 docs/vtune-user-guide/jit-profiling-api-reference.rst create mode 100644 docs/vtune-user-guide/jit-profiling-api.rst create mode 100644 docs/vtune-user-guide/load-module-api.rst create mode 100644 docs/vtune-user-guide/memory-allocation-apis.rst create mode 100644 docs/vtune-user-guide/minimize-itt-api-overhead.rst create mode 100644 docs/vtune-user-guide/string-handle-api.rst create mode 100644 docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst create mode 100644 docs/vtune-user-guide/task-api.rst create mode 100644 docs/vtune-user-guide/thread-naming-api.rst create mode 100644 docs/vtune-user-guide/user-defined-synchronization-api.rst create mode 100644 docs/vtune-user-guide/using-jit-profiling-api.rst create mode 100644 docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst create mode 100644 docs/vtune-user-guide/vtune-user-guide.rst diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml new file mode 100755 index 00000000..3485f5e0 --- /dev/null +++ b/.github/workflows/deploy-docs.yml @@ -0,0 +1,33 @@ +name: Deploy Documentation + +on: + push: + branches: + - master + - docs + paths: + - 'docs/**' # Trigger only when the source docs files are modified + +permissions: + contents: write + +jobs: + build_and_deploy: + name: Build and deploy documentation + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install sphinx sphinx_rtd_theme + - name: Build documentation + run: python -m sphinx docs build + - name: Deploy to GitHub Pages + uses: peaceiris/actions-gh-pages@373f7f263a76c20808c831209c920827a82a2847 # v3.9.2 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_branch: gh-pages + publish_dir: build + force_orphan: true diff --git a/docs/README.md b/docs/README.md new file mode 100755 index 00000000..4ec2c1e6 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,18 @@ +# ITT/JIT API Documentation + +## Overview + +This repository contains the source files for the ITT/JIT API online documentation, +which is hosted on GitHub Pages. [View the documentation here](link). + +## Build Documentation from Sources + +1. Install Sphinx and the required Sphinx theme: + ```bash + pip install sphinx sphinx_rtd_theme +2. Navigate to the Documentation source folder: + ```bash + cd /docs +3. Build the Documentation with the following command: + ```bash + python -m sphinx . build diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 00000000..19705cd2 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,37 @@ +# +# Copyright (C) 2025 Intel Corporation +# +# SPDX-License-Identifier: GPL-2.0-only OR BSD-3-Clause +# + +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- + +project = 'ITT/JIT API Documentation' +copyright = '2025 Intel Corporation' +author = 'Intel Corporation' + +# -- General configuration --------------------------------------------------- + +extensions = [ + 'sphinx_rtd_theme', # ReadTheDocs theme + 'sphinx.ext.githubpages', # Support for GitHub Pages + 'sphinx.ext.ifconfig', # Conditional inclusion of content +] + +templates_path = ['_templates'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + +# -- Options for HTML output ------------------------------------------------- + +import sphinx_rtd_theme + +html_theme = 'sphinx_rtd_theme' +html_theme_options = { + 'style_external_links': True, # Ensure external links are styled correctly +} +html_baseurl = 'https://eparshut.github.io/ittapi/' diff --git a/docs/gpa-user-guide/clock-domain-api.rst b/docs/gpa-user-guide/clock-domain-api.rst new file mode 100644 index 00000000..be717f8e --- /dev/null +++ b/docs/gpa-user-guide/clock-domain-api.rst @@ -0,0 +1,47 @@ +.. _clock-domain-api: + +Clock Domain API +================ + + +Some applications require the capability to trace events with +user-defined timestamps and frequencies different from the timestamps +and frequencies generated by a CPU, for example, to instrument events +that occur on a GPU. For the purpose you can create a clock domain. + + +To create a clock domain, use the following primitive: + + +``__itt_clock_domain * ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data)`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - \ [in]\ + - \ ``fn``\ + - Pointer to a callback function that retrieves alternative CPU timestamps and frequencies and stores the timestamps and frequencies data in the clock domain structure field ``__itt_clock_info``. + * - \ [in]\ + - \ ``fn_data``\ + - Argument of a callback function; can be NULL. + + + + +Tasks issued from different clock domains are shown on the same timeline +by synchronizing a referenced clock domain base timestamp captured at +the moment of clock domain creation and a CPU timestamp captured at the +same time. + + +To recalculate clock domain base timestamps and frequencies, if +necessary, for example, when a GPU frequency changes, use the following +primitive: + + +``__itt_clock_domain_reset()`` + diff --git a/docs/gpa-user-guide/compile-and-link-with-itt-api.rst b/docs/gpa-user-guide/compile-and-link-with-itt-api.rst new file mode 100644 index 00000000..93bf3d78 --- /dev/null +++ b/docs/gpa-user-guide/compile-and-link-with-itt-api.rst @@ -0,0 +1,129 @@ +.. _compile-and-link-with-itt-api: + +Compile and Link with ITT API +============================= + + +Before instrumenting your application, configure your build system to be +able to reach the API headers and libraries: + + +- Add ``\sdk\include`` to your ``INCLUDE`` path +- Add ``\sdk\lib\x86`` to your 32-bit ``LIBRARIES`` + path +- Add ``\sdk\lib\x64`` to your 64-bit ``LIBRARIES`` + path + + +The default installation directory on Windows\* OS is +``C:\Program Files\IntelSWTools\GPA``. + + +Include the ITT API Header in Your Application +---------------------------------------------- + + +Add the following ``#include`` statements to every source file that you +want to instrument: + + +.. code-block:: cpp + + + #include + + +The ``ittnotify.h`` header contains definitions of ITT API routines and +important macros which provide the correct logic of API invocation from +a user application. + + +.. note:: + + + The\ ``ittnotify.h`` header defines many functions that are not + covered in this document. However, Intel® GPA supports only the + functions that are documented herein. + + +The ITT API is designed to incur almost zero overhead when tracing is +disabled. But if you need fully zero overhead, you can compile out all +ITT API calls from your application by defining the +INTEL_NO_ITTNOTIFY_API macro in your project at compile time, either on +the compiler command line, or in your source file, prior to including +the ``ittnotify.h``\ file. + + +Link the ``libittnotify.lib`` Static Library to Your Application +---------------------------------------------------------------- + + +You need to link the static library, ``libittnotify.lib``, to your +application. If tracing is enabled, this static library loads the ITT +API data collector and forwards ITT API instrumentation data to Intel +GPA.If tracing is disabled, the static library ignores ITT API calls, +providing nearly zero instrumentation overhead. + + +.. note:: + + + If you are running Intel® GPA on a system with a legacy version of + Microsoft\* Visual Studio*, you must have the corresponding security + updates installed to link against the dynamic version of the + ``libittnotify.lib`` static library: + + + .. list-table:: + :header-rows: 1 + + * - Microsoft\* Visual Studio\* Version + - Security Update + * - Microsoft Visual Studio 2005 + - KB2538218 + * - Microsoft Visual Studio 2008 + - KB2538241 + + + + +If you do not want to update your version of Visual Studio, you must +link the ``libittnotify.lib`` static library to your application. + + +UNICODE Support +--------------- + + +All ITT API functions with string arguments follow the Windows OS +UNICODE convention, the actual function names are suffixed with A for +the ASCII API and W for the UNICODE API. For example: + + +.. code-block:: cpp + + + __itt_domain_createA( const char* ); + __itt_domain_createW( const wchar_t* ); + + +To facilitate cross-platform code development, the ITT API features the +C macro ``__itt_domain_create``. If a UNICODE macro is defined when +compiling on a Windows OS, the C macro resolves into +``__itt_domain_createW``, otherwise it resolves into +``__itt_domain_createA``. + + +Conditional Compilation +----------------------- + + +For best performance in the release version of your code, use +conditional compilation to turn off annotations. Define the macro +INTEL_NO_ITTNOTIFY_API before you include ``ittnotify.h`` during +compilation to eliminate all ``__itt_*`` functions from your code. + + +You can also remove the static library from the linking stage by +defining this macro. + diff --git a/docs/gpa-user-guide/counter-api.rst b/docs/gpa-user-guide/counter-api.rst new file mode 100644 index 00000000..0d2aff01 --- /dev/null +++ b/docs/gpa-user-guide/counter-api.rst @@ -0,0 +1,113 @@ +.. _counter-api: + + +Counter API +=========== + + +A Counter is a user-defined characteristic or metric of hardware or +software behavior that can be used to collect information about and +correlate with execution breakdown, such as tasks, events, and markers. +For example, system on a chip (SoC) development benefits from several +counters representing different parts of the SoC to count some hardware +characteristics. + + +**Define and create a counter object** + + +Use these primitives: + + +``__itt_counter ITTAPI __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` + + +``__itt_counter ITTAPI __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` + + +``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``domain``\ + - Counter domain + * - [in] + - \ ``name``\ + - Counter name + * - [in] + - \ ``type``\ + - Counter type + + + + +Use these primitives: + + +**Directly set the counter value** + + +Use: + + +``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` + + +``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` + + +Parameters of the primitive: + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``id``\ + - Counter ID + * - [in] + - \ ``value_ptr``\ + - Counter value + + +Usage Example +------------- + + +This example creates a counter that measures temperature and memory +usage metrics: + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_counter temperatureCounter = __itt_counter_create("Temperature", "Domain"); + __itt_counter memoryUsageCounter = __itt_counter_create("Memory Usage", "Domain"); + unsigned __int64 temperature; + + + while (...) + { + ... + temperature = getTemperature(); + __itt_counter_set_value(temperatureCounter, &temperature); + + + __itt_counter_inc_delta(memoryUsageCounter, getAllocatedMemSize()); + __itt_counter_dec_delta(memoryUsageCounter, getDeallocatedMemSize()); + ... + } + + + __itt_counter_destroy(temperatureCounter); + __itt_counter_destroy(memoryUsageCounter); + diff --git a/docs/gpa-user-guide/domain-api.rst b/docs/gpa-user-guide/domain-api.rst new file mode 100644 index 00000000..c35004ba --- /dev/null +++ b/docs/gpa-user-guide/domain-api.rst @@ -0,0 +1,81 @@ +.. _domain-api: + +Domain API +========== + + +A ``domain`` enables tagging trace data for different modules or +libraries in a program. Domains are specified by unique character +strings, for example ``TBB.Internal.Control``. + + +Each domain is represented by an opaque ``__itt_domain`` structure, +which you can use to tag each of the ITT API calls in your code. + + +You can selectively enable or disable specific domains in your +application, in order to filter the subsets of instrumentation that are +collected into the output trace capture file. Upon the first start, the +application registers its domains in a configuration file of the Intel® +GPA Graphics Monitor. By default, upon the first start of the +application all the domains are enabled. To enable or disable domains +for subsequent starts of the application, do the following before the +start: + + +#. Open the Graphics Monitor Launcher Screen. +#. Click the **Options** button. +#. Click the **Tracing** tab. +#. Turn on or off the **User Domains** toggle buttons. + + +The overhead of a disabled domain is a single if check. + + +**To create a domain, use the following primitives:** + + +``__itt_domain *ITTAPI__itt_domain_createA ( const char *name)`` + + +``__itt_domain *ITTAPI __itt_domain_createW ( const wchar_t *name)`` + + +Or use the macro in the following way: + + +``__itt_domain *ITTAPI __itt_domain_create (__TEXT("TBB.Internal.Control"))`` + + +For a domain name, the URI naming style is recommended, for example, +com.my_company.my_application. The set of domains is expected to be +static over the application's execution time, therefore, there is no +mechanism to destroy a domain. + + +Any domain can be accessed by any thread in the process, regardless of +which thread created the domain. This call is thread-safe. + + +**Parameters of the primitives:** + + +.. list-table:: + + * - \ ``[in]``\ + - \ *name*\ + - Name of domain + + +Usage Example +------------- + + +.. code:: cpp + + + #include "ittnotify.h" + __itt_domain* pD = __itt_domain_create(__TEXT("My Domain") ); + + + diff --git a/docs/gpa-user-guide/gpa-user-guide.rst b/docs/gpa-user-guide/gpa-user-guide.rst new file mode 100644 index 00000000..b84a6f49 --- /dev/null +++ b/docs/gpa-user-guide/gpa-user-guide.rst @@ -0,0 +1,83 @@ +.. _gpa-user-guide: + +****************** +API Support in GPA +****************** + + +.. note:: + + + The Instrumentation and Tracing Technology API (ITT API) and the + Just-in-Time Profiling API (JIT API) are open source components. + Visit the `GitHub\* repository `__ + to access source code and contribute. + + +The Instrumentation and Tracing Technology API (ITT API) provided by the +Intel GPA enables your application to generate and control the +collection of trace data during its execution. + + +ITT API has the following features: + + +- Controls application performance overhead based on the amount of + traces that you collect. +- Enables trace collection without recompiling your application. +- Supports applications in C/C++ environments. +- Automatically traces data from Microsoft DirectX\* applications. +- Automatically traces data from OpenGL\* ES v1, v2, and v3 APIs on + Android\* OS applications. +- Supports instrumentation for tracing application code. + + +This chapter describes how to add basic instrumentation to your +application, and also includes examples of several advanced +instrumentation topics. + + +User applications/modules linked to the static ITT API library do not +have a runtime dependency on a dynamic library. Therefore, they can be +executed without Intel GPA or other Intel tools. + + +ITT API enables you to manually instrument your application for further +application performance analysis. + + +You can use the Intel GPA Trace Analyzer to view ITT trace data. The +Intel GPA Trace Analyzer obtains this data from your application through +the Intel GPA Monitor. + + +.. note:: + + + The ITT API is a set of pure C/C++ functions. There are no Java\* or + .NET\* APIs. If you need runtime environment support, you can use a + JNI, or C/C++ function call from the managed code. If the collector + causes significant overhead or data storage, you can pause the + analysis to reduce the overhead. + + +See Also +-------- + + +.. toctree:: + :maxdepth: 1 + + + compile-and-link-with-itt-api + instrumenting-your-application + minimizing-itt-api-overhead + clock-domain-api + counter-api + domain-api + marker-api + metadata-api + relation-api + string-handle-api + thread-naming-api + task-api \ No newline at end of file diff --git a/docs/gpa-user-guide/instrumenting-your-application.rst b/docs/gpa-user-guide/instrumenting-your-application.rst new file mode 100644 index 00000000..61856cd5 --- /dev/null +++ b/docs/gpa-user-guide/instrumenting-your-application.rst @@ -0,0 +1,137 @@ +.. _instrumenting-your-application: + +Instrument Your Application +=========================== + + +Graphics Trace Analyzer is an instrumentation-based tool. It obtains its +data from gpa_trace files, which are generated by Intel® GPA while +profiling an application that has been instrumented with Instrumentation +and Tracing Technology API (ITT API) calls. + + +To get the most out of the ITT APIs, you need to add API calls in your +code to designate logical tasks. This will help you visualize the +relationship between tasks in your code, including when they start and +end, relative to other CPU and GPU tasks. + + +At the highest level a task is a logical group of work executing on a +specific thread, and may correspond to any grouping of code within your +program that you consider important. You can mark up your code by +identifying the beginning and end of each logical execution chunk. + + +To resolve the majority of performance bottlenecks, the following API +calls are enough + + +- \__itt_domain_create() creates a domain required in most ITT API + calls. You need to define at least one domain. +- \__itt_string_handle_create() creates string handles for identifying + your tasks. String handles are more efficient for identifying traces + than strings. +- \__itt_task_begin() marks the beginning of a task. + + +Example +------- + + +The following sample shows how four basic ITT API functions are used in +a multi threaded application: + + +- + + + .. container:: + :name: LI_8CC703C571CC4A38B4933FE7AE7E170D + + + :ref:`Domain API` + + +- + + + .. container:: + :name: LI_D12ED1398398490EA2761534CB34111C + + + :ref:`String Handle API` + + +- + + + .. container:: + :name: LI_A68036F0DE3842049E37031CB63A785C + + + :ref:`Task API` + + +- + + + .. container:: + :name: LI_1304238F684E4DBEAC3E53BEA55D36E7 + + + :ref:`Thread Naming API` + + +.. code:: cpp + + + #include + #include + + + // Forward declaration of a thread function. + DWORD WINAPI workerthread(LPVOID); + bool g_done = false; + // Create a domain that is visible globally: we will use it in our example. + __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); + // Create string handles which associates with the "main" task. + __itt_string_handle* handle_main = __itt_string_handle_create("main"); + __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); + void main(int, char* argv[]) + { + // Create a task associated with the "main" routine. + __itt_task_begin(domain, __itt_null, __itt_null, handle_main); + // Now we'll create 4 worker threads + for (int i = 0; i < 4; i++) + { + // We might be curious about the cost of CreateThread. We add tracing to do the measurement. + __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); + CreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); + __itt_task_end(domain); + } + + + // Wait a while,... + Sleep(5000); + g_done = true; + // Mark the end of the main task + __itt_task_end(domain); + } + // Create string handle for the work task. + __itt_string_handle* handle_work = __itt_string_handle_create("work"); + DWORD WINAPI workerthread(LPVOID data) + { + // Set the name of this thread so it shows up in the UI as something meaningful + char threadname[32]; + wsprintf(threadname, "Worker Thread %d", data); + __itt_thread_set_name(threadname); + // Each worker thread does some number of "work" tasks + while(!g_done) + { + __itt_task_begin(domain, __itt_null, __itt_null, handle_work); + Sleep(150); + __itt_task_end(domain); + } + return 0; + } + diff --git a/docs/gpa-user-guide/marker-api.rst b/docs/gpa-user-guide/marker-api.rst new file mode 100644 index 00000000..c5d6f92f --- /dev/null +++ b/docs/gpa-user-guide/marker-api.rst @@ -0,0 +1,37 @@ +.. _marker-api: + +Marker API +========== + + +Marker is an instant event on a timeline that can be associated with a +particular process, a thread, or specified in a global scope. + + +**To create a marker, use the following primitive:** + + +``void __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope)`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``domain``\ + - Marker domain + * - [in] + - \ ``name``\ + - Marker name + * - [in] + - \ ``id``\ + - Optional parameter. Marker ID, or ``__itt_nullNOTEMarkers`` with different domains cannot have same IDs. + * - [in] + - \ ``scope``\ + - Marker scope: process, thread, and global + + + diff --git a/docs/gpa-user-guide/metadata-api.rst b/docs/gpa-user-guide/metadata-api.rst new file mode 100644 index 00000000..4200ca91 --- /dev/null +++ b/docs/gpa-user-guide/metadata-api.rst @@ -0,0 +1,69 @@ +.. _metadata-api: + +Metadata API +============ + + +Metadata is extra information, generic data which can be attached to a +task, a thread, a process, etc. Metadata has a type, name, and value. +The value encoding depends on a metadata type. It may contain either +string data or a number of integer or floating point values. + + +To create metadata, use the following primitives: + + +``void __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)`` + + +``void __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length)`` + + +``void __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length)`` + + +``void __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)`` + + +``void __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length)`` + + +``void __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length)`` + + +The following table defines the parameters used in the Metadata API +primitives. + + +.. list-table:: + :header-rows: 1 + + * - Type + - Parameter + - Description + * - [in] + - ``__itt_domain* domain`` + - Metadata domain + * - [in] + - ``__itt_scope scope`` + - Metadata scope: task, thread, process, and global. If a scope is undefined, metadata belongs to the last task in the thread. + * - [in] + - ``__itt_string_handle* name`` + - Metadata name + * - [in] + - ``__itt_metadata_type type`` + - Metadata type; used only for numeric metadata + * - [in] + - ``size_t count`` + - Number of numeric metadata items ``[in] size_t``\ length + * - [in] + - ``size_t length`` + - Number of symbols a metadata string + * - [in] + - ``void *data`` + ``const char *data`` + ``const wchar_t *data`` + - Actual metadata (array of numerics or string) + + + diff --git a/docs/gpa-user-guide/minimizing-itt-api-overhead.rst b/docs/gpa-user-guide/minimizing-itt-api-overhead.rst new file mode 100644 index 00000000..76e31e91 --- /dev/null +++ b/docs/gpa-user-guide/minimizing-itt-api-overhead.rst @@ -0,0 +1,88 @@ +.. _minimizing-itt-api-overhead: + +Minimize ITT API Overhead +========================= + + +The ITT API overhead and its impact on the overall application +performance depends on the amount of instrumentation code added to the +application. When instrumenting an application with ITT API, you should +balance between application performance and the amount of performance +data that you need to collect, in order to minimize API overhead while +collecting sufficient performance data. + + +Follow these guidelines to achieve good balance between overall +performance of the instrumented application and instrumentation detail: + + +- Instrument only those paths within your application that are + important for analysis. +- Create ITT domains and string handles outside the critical paths. +- Filter data collection by different aspects of your application that + can be analyzed separately. The overhead for a disabled API call + (thus filtering out the associated call) is always less than 10 clock + ticks, regardless of the API. + + +Usage Example: Using Domains and String Handles +----------------------------------------------- + + +The ITT APIs include a subset of functions which create domains and +string handles. These functions always return identical handles for the +same domain names and strings. This requires these functions to perform +string comparisons and table lookups, which can incur serious +performance penalties. In addition, the performance of these functions +is proportional to the log of the number of created domains or string +handles. It is best to create domains and string handles at global +scope, or during application startup. + + +The following code section creates two domains in the global scope. You +can use these domains to control the level of detail that is written to +the trace file. + + +.. code:: cpp + + + __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); + __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); + // Create string handles at global scope. + __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); + void MyFunction() + { + __itt_task_begin(basic, __itt_null, __itt_null, h_my_function); + Foo(); + FooEx(); + __itt_task_end(basic); + } + __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); + void Foo() + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo); + // Do some work here... + __itt_task_end(detailed); + } + __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); + void FooEx() + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo_ex); + // Do some work here... + __itt_task_end(detailed); + } + // This is my entry point. + int main(int argc, char** argv) + { + if(argc < 2) + { + //Disable detailed domain if we do not need tracing from that in this + //application run + detailed ->flags = 0; + } + MyFunction(); + } + diff --git a/docs/gpa-user-guide/relation-api.rst b/docs/gpa-user-guide/relation-api.rst new file mode 100644 index 00000000..803acad1 --- /dev/null +++ b/docs/gpa-user-guide/relation-api.rst @@ -0,0 +1,52 @@ +.. _relation-api: + +Relation API +============ + + +Relation API binds two named instances, for example, tasks, with a +reasonable relation attribute. Relations can be added before or after +the actual instances are created and persist independently of the +instances. + + +To logically group a bunch of tasks, you can use different types of +relations: + + +``void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail)`` + + +``void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail)`` + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 1 + + * - Type + - Parameter + - Description + * - [in] + - ``__itt_domain* domain`` + - Relation domain + * - [in] + - ``__itt_relation relation`` + - User-defined logical relation between two named instances + * - [in] + - ``__itt_id head`` + - Metadata name + * - [in] + - ``__itt_id tail`` + - IDs of two named related instances ``size_t`` count + * - [in] + - ``__itt_clock_domain* clock_domain`` + - User-defined clock domain + * - [in] + - ``unsigned long long timestamp`` + - User-defined timestamp for the corresponding clock domain + + + diff --git a/docs/gpa-user-guide/string-handle-api.rst b/docs/gpa-user-guide/string-handle-api.rst new file mode 100644 index 00000000..55a3157c --- /dev/null +++ b/docs/gpa-user-guide/string-handle-api.rst @@ -0,0 +1,46 @@ +.. _string-handle-api: + +String Handle API +================= + + +Many API calls require names to identify API objects. String handles are +pointers to names. They enable efficient handling of named objects in +run time and make collected traces data more compact. + + +**To create and return a handle value that can be associated with a +string, use the following primitive:** + + +``__itt_string_handle *ITTAPI __itt_string_handle_createA ( const char *name)`` + + +``__itt_string_handle *ITTAPI __itt_string_handle_createW ( const wchar_t *name)`` + + +Or use the macro in the following way: + + +``__itt_string_handle *ITTAPI __itt_string_handle_create (__TEXT("My Task"))`` + + +Consecutive calls to ``__itt_string_handle_create`` with the same name +return the same value. The set of string handles is expected to remain +static during the application's execution time, therefore, there is no +mechanism to destroy a string handle. Any string handle can be accessed +by any thread in the process, regardless of which thread created the +string handle. This call is thread-safe. + + +**Parameters of the primitive:** + + +.. list-table:: + + * - \ [in]\ + - \ *name*\ + - The input string + + + diff --git a/docs/gpa-user-guide/task-api.rst b/docs/gpa-user-guide/task-api.rst new file mode 100644 index 00000000..0df3b756 --- /dev/null +++ b/docs/gpa-user-guide/task-api.rst @@ -0,0 +1,209 @@ +.. _task-api: + +Task API +======== + + +A *task* is a logical unit of work performed by a particular thread. +Tasks can nest; thus, tasks typically correspond to functions, scopes, +or a case block in a switch statement. You can use the Task API to +assign tasks to threads. + + +The Task API does not enable a thread to suspend the current task and +switch to a different task (task switching), or move a task to a +different thread (task stealing). + + +A task instance represents a piece of work performed by a particular +thread for a period of time. The task is defined by the bracketing of +\__itt_task_begin() and \__itt_task_end() on the same thread. + + +Tasks can be of two types: simple or overlapped. + + +Simple tasks implicitly support a concept of embedded execution. This +means that the call \__itt_task_end() finalizes the most recent +\__itt_task_begin() call. For example, the following metacode is a valid +sequence, and execution time of "a" tasks incorporates the execution +time of "b" tasks: + + +``__itt_task_begin(a)`` + + +``__itt_task_begin(b)`` + + +``__itt_task_end(b)`` + + +``__itt_task_end(a)`` + + +Execution regions of overlapped tasks may intercept. For example, the +following metacode is a valid sequence, and a "b" task started after an +"a" task can finish upon completion of the "a" task: + + +``__itt_task_begin_overlapped(a)`` + + +``__itt_task_begin_overlapped(b)`` + + +``__itt_task_end_overlapped(a)`` + + +``__itt_task_end_overlapped(b)`` + + +Task API Functions +------------------ + + +**To create a simple task instance on a thread, use the following +functions:** + + +``void ITTAPI __itt_task_begin (const __itt_domain +*domain,__itt_id taskid, __itt_id parentid, __itt_string_handle +*name)`` + + +``void ITTAPI __itt_task_begin_fn (const __itt_domain *domain,__itt_id taskid, __itt_id parentid, void* address)`` + + +``void ITTAPI __itt_task_end (const __itt_domain *domain)`` + + +**To create a simple task instance in a different clock domain, use the +following functions:** + + +``void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` + + +``void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, void* fn)`` + + +``void ITTAPI _itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp)`` + + +**To create an overlapped task instance on a thread, use the following +functions:** + + +``void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` + + +``void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid)`` + + +The argument ``taskid`` is mandatory for these functions. + + +**To create an overlapped task instance in a different clock domain, use +the following functions:** + + +``void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` + + +``void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid)`` + + +The argument ``taskid`` is mandatory for these functions. + + + + +.. _task-api-IJIT_NOTIFYEVENT_FUNCTION: + + + + +ITTAPI__itt_task_* Function Parameters +------------------------------------------ + + +The following table defines the parameters used in the Task API +primitives. + + +.. list-table:: + :header-rows: 1 + + * - Type + - Parameter + - Description + * - [in] + - \ ``__itt_domain``\ + - The domain of the task. + * - [in] + - \ ``__itt_id taskid``\ + - User-defined ID optional for all task instances, except for overlapped task instances. \ ``__itt_null`` can be used as default for undefined task instances. Task ID is used to define relations between task instances. + * - [in] + - \ ``__itt_id parentid``\ + - Optional parameter. Parent instance ID, to which the task belongs, or \_\ ``_itt_null``. + * - [in] + - \ ``__itt_string_handle``\ + - The task string handle. + * - [in] + - ``void* fn`` + - Function address that can be used instead of the name. For example, the function address can be resolved into the function name by using debug symbol information. + * - [in] + - ``__itt_clock_domain`` + - User-defined clock domain. + * - [in] + - ``unsigned long long timestamp`` + - User-defined timestamp for the corresponding clock domain. + + +Usage Example +------------- + + +The following code snippet creates a domain and a couple of tasks at +global scope. + + +.. code:: cpp + + + #include "ittnotify.h" + + + void do_foo(double seconds); + + + __itt_domain* domain = __itt_domain_create(__TEXT("MyTraces.MyDomain")); + __itt_string_handle* shMyTask = __itt_string_handle_create(__TEXT("My Task"); + __itt_string_handle* shMySubtask = __itt_string_handle_create(__TEXT("My SubTask")); + + + void BeginFrame() { + __itt_task_begin(domain, __itt_null, __itt_null, shMyTask); + do_foo(1); + } + + + void DoWork() { + __itt_task_begin(domain, __itt_null, __itt_null, shMySubtask); + do_foo(1); + __itt_task_end(domain); + } + void EndFrame() { + do_foo(1); + __itt_task_end(domain); + } + + + int main() { + BeginFrame(); + DoWork(); + EndFrame(); + return 0; + } + diff --git a/docs/gpa-user-guide/thread-naming-api.rst b/docs/gpa-user-guide/thread-naming-api.rst new file mode 100644 index 00000000..5767851a --- /dev/null +++ b/docs/gpa-user-guide/thread-naming-api.rst @@ -0,0 +1,71 @@ +.. _thread-naming-api: + + +Thread Naming API +================= + + +By default, each thread in your application is displayed in the +**timeline** track with a default label generated from the process ID +and the thread ID, or with the OS thread name. You can use the Thread +Naming API in your code to give threads meaningful names. + + +To set thread name using a char or Unicode string, use the primitive: + + +``void __itt_thread_set_nameA (const __itt_char *name)`` + + +``void __itt_thread_set_nameW (const wchar_t *name)`` + + +Or use the macro in the following way: + + +``void__itt_thread_set_name(__TEXT("Main"))`` + + +**Parameters of the primitive:** + + +.. list-table:: + + * - \ [in]\ + - \ ``name``\ + - The thread name + + + + +If the thread name is set multiple times, only the last name is used. + + +Usage Example +------------- + + +You can use the following thread naming example to give a meaningful +name to the thread you wish to focus on and ignore the service thread. + + +.. code:: cpp + + + DWORD WINAPI service_thread(LPVOID lpArg) + { + __itt_thread_set_name(__TEXT("My worker thread")); + // Do thread work here + return 0; + } + + + int main(int argc, char* argv[]) + { + ... + CreateThread(NULL, 0, service_thread, NULL, 0, NULL); + CreateThread(NULL, 0, thread_function, NULL, 0, NULL); + ... + return 0; + } + diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 00000000..deae1b8e --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,47 @@ +.. _home: + +******************************************************************************************** +Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API Documentation +******************************************************************************************** + +Introduction +============ + + +.. note:: + + + The ITT and JIT API documentation from the Intel® VTune Profiler and Intel® Graphics + Performance Analyzers User Guides has been consolidated into this repository, + providing a single, unified source of information. + + +The ITT/JIT API is a open source feature of Intel's Analyzers tools that allows applications +to generate and control trace data during their execution. It enables developers to pinpoint +and measure specific areas of their code, providing valuable insights into performance +bottlenecks and resource utilization. + + +This open source profiling API includes: + +- Instrumentation and Tracing Technology (ITT) API. + It enables your application to generate and control the collection of trace data during + its execution across different Intel tools. +- JIT (Just-In-Time) Profiling API. + It provides functionality to report information about just-in-time generated code that + can be used by performance profiling tools. + +The ITT/JIT API consists of two parts: a *static* part and a *dynamic* part. + +- The dynamic part is specific for a tool and distributed only with a particular tool as + a dynamic(shared) library. +- The static part is a common part shared between tools. Currently, the static part is + distributed as an open source static library: `ittapi `__ + + +.. toctree:: + :maxdepth: 1 + :caption: Contents: + + vtune-user-guide/vtune-user-guide.rst + gpa-user-guide/gpa-user-guide.rst diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100755 index 00000000..856b3f4c --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,2 @@ +sphinx +sphinx_rtd_theme \ No newline at end of file diff --git a/docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png b/docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png new file mode 100644 index 0000000000000000000000000000000000000000..41117932e4a8a49dcae4baba0f024cf01e93f9f3 GIT binary patch literal 1187 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 I6VdnmKP2m0JOBUy literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif b/docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif new file mode 100644 index 0000000000000000000000000000000000000000..8a9671b2be3dd62cebad51b9251053badc3dc53f GIT binary patch literal 357 zcmZ?wbhEHblw=TMxT?+Y=kGs}^flZ`D+`vK+;-vVvg5Z5tG2amx-f0et;xG?e*W=0 zW8NvxuDzBGJ9(2=oxc0_=kLFI6zI8Qr}hn-zCu)#}(m6bVwah<1_60>js$F@K(?%?J7z4$l}X*)7l F0|15#i5>s| literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png b/docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png new file mode 100644 index 0000000000000000000000000000000000000000..6d8cdfd595653c040bc3b8282d5d8de8e014af81 GIT binary patch literal 262 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1SGw${mubWIwh_VCC){ui6xo&c?uz!xv2~x zrKt)=1`3X)=|IZRQo+!`%EZvh)KEd&z}Udxq>g$vP#=4Vr>`sfV-68^U1=Hqv&=vt z&H|6fVg?31We{epSZZGe6l6(v^mSxl*x1kgCy^D%kM(qM45_%4Ji{Vcu(gA+<9vLz zmzmTVw}?i^$Vf?7w=2Ip1v9z)l*8N%1v0tplsimX8w8KcaJs?Kv`iqCr7rkID$7#2 xg(eo7y&+zc#YBZHmfp-Mm?Hi}!cmcl;rbbl$%fG{6M+^nc)I$ztaD0e0szWfNNE57 literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png b/docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png new file mode 100644 index 0000000000000000000000000000000000000000..45257656fd20cf7f1b0d9d1c52eb905b1f44ccbc GIT binary patch literal 668 zcmV;N0%QG&P)5g6 z*%&pDrv|YVL+rBAqf_nu-+K(+=l1@G|L?>1`{(~2ycWh6_i0jWW(#P+k~a%W-YhJ6 zv#{jN!jd-&?eeF5%#Zal<`!V{pJ)<6-h%<5CrXHkXUZ z(F?4_Je(CYMc)zjYxc4N-^|uvGJL@a&_K+U;G3aWoEmX;`tRp204X3R}CwT|M z(ExJjFdem(pNfKWdKxlWgs#zAVy_kATls9I3O`KIy5mlGBO}5Ff%YP6Dvcf00007bV*G` z2jT)03@RlbmSTzk000SaNLh0L01FZT01FZU(%pXi00004XF*Lt006O%3;baP0009L zNklA_Ni>vDS{yGi=r05 z^;A{UG}AOAH2gY_-kcC2FbF-As=jX-}vzfZC+wJw*tu_+M<#I@E_Q1c;cs{RG zt9Zc!pvbG)yqX$D1b1JJh(am4u3M&ARjONCTV&!Sl}h19y`ITXJkKv^S=bFClgSi| z#mQuH(YU}-;Km`hptfz->kXP_U~7*vpr9a%q8g10x01nuU!@~vLKKkn$6}N(02PT%W;eQxWGUu`m6R-T_4|o20V_(5cJa! zBcs6v%XYgRbTR-PjYgnyR*%aj%W>RrII?Xg02&U5EX%Hf7#TpIFx#;MNm;fHStK8; zs`~Ej8(bV7!HyyFPiJSE)_?Kx)yc^T#P{*Tdl0Ma?3|vyj{61>%rTl7_SE%KwSTMC z+Mz+%a66sO`T2LaU%!0DegWLo)gQRES`F994g~WV^%SJ1hIM~`AGP4kilV^9bc0-6 zl()B$7v`;0Dn-X|9Y@6=0o>)~PuKI3?4yK!UquCiD1uhF=(}MUf*^nmgp5POo4AA! zQ3TRIJ~|9q$#HC78zezdh%A?qt|*GJ3lu)I6j1I#S#xdKn@M$WSpQTm@F;|`#Ar#f^ z_DsuU7&iFt5QYH@+XO^=o+}DsrLxVx4Hlj+p4onZTtB+bypLa|Wb7wlhR d#X*{D{{dAK!gX25@z4MO002ovPDHLkV1nv^wjBTf literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png b/docs/vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png new file mode 100644 index 0000000000000000000000000000000000000000..6895245413564de54a02b9328a029269e2730fe8 GIT binary patch literal 90755 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ð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 literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png b/docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png new file mode 100644 index 0000000000000000000000000000000000000000..55af6fbd77ee3318dfad4645dce050bf89c22740 GIT binary patch literal 29883 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 literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png b/docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png new file mode 100644 index 0000000000000000000000000000000000000000..f9aff5721db2cc64c0459b4e834b81391c23bfea GIT binary patch literal 21246 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

MkEAVg$Eu^$CucCRw+y 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 KA@Mht+y4ceF^(hv literal 0 HcmV?d00001 diff --git a/docs/vtune-user-guide/api-support.rst b/docs/vtune-user-guide/api-support.rst new file mode 100644 index 00000000..5a1b1c60 --- /dev/null +++ b/docs/vtune-user-guide/api-support.rst @@ -0,0 +1,28 @@ +.. _api-support: + +API Support +=========== + + +Intel® VTune™ Profiler supports two kinds of APIs: + + +- The Instrumentation and Tracing Technology API (ITT API) provided by + the Intel® VTune™ Profiler enables your application to generate and + control the collection of trace data during its execution. + + +- The JIT (Just-In-Time) Profiling API provides functionality to report + information about just-in-time generated code that can be used by + performance tools. You must insert JIT Profiling API calls in the + code generator to report information before JIT-compiled code goes to + execution. This information is collected at runtime and used by tools + like Intel® VTune™ Profiler to display performance metrics associated + with JIT-compiled code. + +.. toctree:: + :maxdepth: 1 + + + support-for-instrumentation-and-tracing-technology-api-itt-api + jit-profiling-api diff --git a/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst b/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst new file mode 100644 index 00000000..eba78093 --- /dev/null +++ b/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst @@ -0,0 +1,98 @@ +.. _attach-itt-apis-to-a-launched-application: + +Attach ITT APIs to a Launched Application +========================================= + + +You can use the Intel® VTune™ Profiler to attach to a running +application instrumented with ITT API. But before launching the +application, make sure to set up the following environment variable for +the ``ittnotify_collector``: + + +On Windows*: + + +``INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll`` + + +``INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll`` + + +On Linux*: + + +``INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so`` + + +``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` + + +On FreeBSD: + + +.. note:: + + + Header and library files are available from the + ``vtune_profiler_target_x86_64.tgz`` FreeBSD target package. See `Set + Up FreeBSD\* + System `__ for more + information. + + +``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` + + +.. note:: + + + The variables should contain the full path to the library without + quotes. + + +Example +------- + + +On Windows: + + +.. code:: bash + + + set INTEL_LIBITTNOTIFY32=C:\Program Files (x86)\Intel\oneAPI\vtune\latest\bin32\runtime\ittnotify_collector.dll + set INTEL_LIBITTNOTIFY64=C:\Program Files (x86)\Intel\oneAPI\vtune\latest\bin64\runtime\ittnotify_collector.dll + + +On Linux: + + +.. code:: bash + + + export INTEL_LIBITTNOTIFY32=/opt/intel/oneapi/vtune/latest/lib32/runtime/libittnotify_collector.so + export INTEL_LIBITTNOTIFY64=/opt/intel/oneapi/vtune/latest/lib64/runtime/libittnotify_collector.so + + +On FreeBSD: + + +.. note:: + + + You may need to change the path to reflect the placement of the + FreeBSD target package on your target system. + + +.. code:: bash + + + setenv INTEL_LIBITTNOTIFY64 /tmp/vtune_profiler_2021.9.0/lib64/runtime/libittnotify_collector.so + + +After you complete the configuration, you can start the instrumented +application in the correct environment and Intel® VTune™ Profiler will +collect user API data even if the application was launched before the +VTune Profiler. + diff --git a/docs/vtune-user-guide/basic-usage-and-configuration.rst b/docs/vtune-user-guide/basic-usage-and-configuration.rst new file mode 100644 index 00000000..8fbc7274 --- /dev/null +++ b/docs/vtune-user-guide/basic-usage-and-configuration.rst @@ -0,0 +1,72 @@ +.. _basic-usage-and-configuration: + +Basic Usage and Configuration +============================= + + +You can control performance data collection for your application by +adding basic instrumentation to your application and by configuring your +environment and your build system to use the Instrumentation and Tracing +Technology (ITT) APIs. + + +User applications/modules linked to the static ITT API library do not +have a runtime dependency on a dynamic library. Therefore, they can be +executed without Intel® VTune™ Profiler. + + +To use the ITT APIs, set up your C/C++ or Fortran application using the +steps provided in `Configuring Your Build +System `__. + + +Unicode Support +--------------- + + +All API functions that take parameters of type ``__itt_char`` follow the +Windows OS unicode convention. If UNICODE is defined when compiling on a +Windows OS, ``__itt_char`` is ``wchar_t``, otherwise it is ``char``. The +actual function names are suffixed with ``A`` for the ASCII APIs and +``W`` for the unicode APIs. Both types of functions are defined in the +DLL that implements the API. + + +Strings that are all ASCII characters are internally equivalent for both +the unicode and the ASCII API versions. For example, the following +strings are equivalent: + + +.. code:: cpp + + + __itt_sync_createA( addr, "OpenMP Scheduler", "Critical Section", 0); + __itt_sync_createW( addr, L"OpenMP Scheduler", L"Critical Section", 0); + + +See Also +-------- + + +.. container:: linklist + + + `Minimize ITT API + Overhead `__ + + +`Configure Your Build +System `__ + + +`Task Analysis `__ + +.. toctree:: + :maxdepth: 1 + + + configure-your-build-system + attach-itt-apis-to-a-launched-application + instrument-your-application + minimize-itt-api-overhead + view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler \ No newline at end of file diff --git a/docs/vtune-user-guide/collection-control-api.rst b/docs/vtune-user-guide/collection-control-api.rst new file mode 100644 index 00000000..ccaa251e --- /dev/null +++ b/docs/vtune-user-guide/collection-control-api.rst @@ -0,0 +1,121 @@ +.. _collection-control-api: + +Collection Control API +====================== + + +You can use the collection control APIs in your code to control the way +the Intel® VTune™ Profiler collects data for applications. + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_pause (void)``\ + - Run the application without collecting data. VTune Profiler reduces the overhead of collection, by collecting only critical information, such as thread and process creation. + * - \ ``void __itt_resume (void)``\ + - Resume data collection. VTune Profiler resumes collecting all data. + * - \ ``void __itt_detach (void)``\ + - Detach data collection. VTune Profiler detaches all collectors from all processes. Your application continues to work but no data is collected for the running collection. + + + + +Pausing the data collection has the following effects: + + +- Data collection is paused for the whole program, not only within the + current thread. + + +- Some runtime analysis overhead reduction. + + +- The following APIs are not affected by pausing the data collection: + + + - Domain API + + + - String Handle API + + + - Thread Naming API + + +- The following APIs are affected by pausing the data collection. Data + is not collected for these APIs while in paused state: + + + - Task API + + + - Frame API + + + - Event API + + + - User-Defined Synchronization API + + +.. note:: + + + The Pause/Resume API call frequency is about 1Hz for a reasonable + rate. Since this operation pauses and resumes data collection in all + processes in the analysis run with the corresponding collection state + notification to GUI, you are not recommended to call it on frequent + basis for small workloads. For small workloads, consider using the + `Frame + APIs `__. + + +Usage Example: Focus on Specific Code Section +--------------------------------------------- + + +The pause/resume calls shown in the following code snippet enable you to +focus the collection on a specific section of code, and start the +application run with collection paused. + + +.. code:: cpp + + + int main(int argc, char* argv[]) + { + // Do initialization work here + __itt_resume(); + // Do profiling work here + __itt_pause(); + // Do finalization work here + return 0; + } + + +Usage Example: Hide Sections of Code +------------------------------------ + + +The pause/resume calls shown in the following code snippet enable you to +hide some intensive work that you are not currently focusing on: + + +.. code:: cpp + + + int main(int argc, char* argv[]) + { + // Do work here + __itt_pause(); + // Do uninteresting work here + __itt_resume(); + // Do work here + __itt_detach(); + // Do uninteresting work here + return 0; + } + diff --git a/docs/vtune-user-guide/compile-and-link-with-ittapi.rst b/docs/vtune-user-guide/compile-and-link-with-ittapi.rst new file mode 100644 index 00000000..a87b556d --- /dev/null +++ b/docs/vtune-user-guide/compile-and-link-with-ittapi.rst @@ -0,0 +1,51 @@ +.. _compile-and-link-with-ittapi: + +***************************** +Compile and Link with ITT API +***************************** + + Before instrumenting your application, configure your build system to be able to reach the API headers and libraries: + + * Add \include to your INCLUDE path + * Add \build_\\bin to your LIBRARIES path + +Include the ITT API Header in Your Application +============================================== + + Add the following #include statements to every source file that you want to instrument: + + .. code-block:: c++ + + #include + + The ittnotify.h header contains definitions of ITT API routines and important macros which provide the correct logic of API invocation from a user application. + + + The ITT API is designed to incur almost zero overhead when tracing is disabled. But if you need fully zero overhead, you can compile out all ITT API calls from your application by defining the INTEL_NO_ITTNOTIFY_API macro in your project at compile time, either on the compiler command line, or in your source file, prior to including the ittnotify.h file. + +Link the libittnotify.lib Static Library to Your Application +============================================================ + + You need to link the static library, libittnotify.lib, to your application. If tracing is enabled, this static library loads the ITT API data collector and forwards ITT API instrumentation data to Intel Analyzer.If tracing is disabled, the static library ignores ITT API calls, providing nearly zero instrumentation overhead. + + + If you do not want to update your version of Visual Studio, you must link the libittnotify.lib static library to your application. + +UNICODE Support +=============== + + All ITT API functions with string arguments follow the Windows OS UNICODE convention, the actual function names are suffixed with A for the ASCII API and W for the UNICODE API. For example: + + .. code-block:: c++ + + __itt_domain_createA( const char* ); + __itt_domain_createW( const wchar_t* ); + + To facilitate cross-platform code development, the ITT API features the C macro __itt_domain_create. If a UNICODE macro is defined when compiling on a Windows OS, the C macro resolves into __itt_domain_createW, otherwise it resolves into __itt_domain_createA. + +Conditional Compilation +======================= + + For best performance in the release version of your code, use conditional compilation to turn off annotations. Define the macro INTEL_NO_ITTNOTIFY_API before you include ittnotify.h during compilation to eliminate all __itt_* functions from your code. + + You can also remove the static library from the linking stage by defining this macro. diff --git a/docs/vtune-user-guide/configure-your-build-system.rst b/docs/vtune-user-guide/configure-your-build-system.rst new file mode 100644 index 00000000..18630162 --- /dev/null +++ b/docs/vtune-user-guide/configure-your-build-system.rst @@ -0,0 +1,204 @@ +.. _configure-your-build-system: + +Configure Your Build System +=========================== + + +.. note:: + + + ITT API usage is supported on Windows*, Linux*, FreeBSD*, and + Android\* systems. It is not supported for QNX\* systems. + + +Before instrumenting your application, you need to configure your build +system to be able to reach the API headers and libraries. + + +For Windows\* and Linux\* systems: + + +- Add ``/sdk/include`` to your INCLUDE path for C/C++ + applications or ``/sdk/[lib32 or lib64]`` to your + INCLUDE path for Fortran applications +- Add ``/sdk/lib32`` to your 32-bit LIBRARIES path +- Add ``/sdk/lib64`` to your 64-bit LIBRARIES path + + +.. note:: + + + On Linux\* systems, you have to link the ``dl`` and ``pthread`` + libraries to enable ITT API functionality. Not linking these + libraries will not prevent your application from running, but no ITT + API data will be collected. + + +For FreeBSD\* systems: + + +.. note:: + + + Header and library files are available from the + ``vtune_profiler_target_x86_64.tgz`` FreeBSD target package. See `Set + Up FreeBSD\* + System `__ for more + information. + + +- Add ``/sdk/include`` to your INCLUDE path for C/C++ + applications or ``/sdk/[lib32 or lib64]`` to your + INCLUDE path for Fortran applications +- Add ``/sdk/lib64`` to your 64-bit LIBRARIES path + + +For the Android\* system, add the following libraries to your LIBRARIES +path depending on your device architecture: + + +- Add ``/target/android_v5_x86_64/lib-x86_64`` for the + Intel® 64 architecture +- Add ``/target/android_v5/lib-x86`` for the IA-32 + architecture +- Add ``/target/android_arm/lib-arm`` for the ARM\* + architecture + + +```` is the Intel® VTune™ Profiler installation directory. +The default installation path for the VTune Profiler varies with the +product shipment. + + +.. note:: + + + The ITT API headers, static libraries, and Fortran modules previously + located at ``/include`` and ``/lib32 [64]`` + folders were moved to the ``/sdk`` folder starting the + VTune Profiler 2021.1-beta08 release. Copies of these files are + retained at their old locations for backwards compatibility and these + copies should not be used for new projects. + + +Include the ITT API Header or Module in Your Application +-------------------------------------------------------- + + +**For C/C++ Applications** + + +Add the following ``#include`` statements to every source file that you +want to instrument: + + +.. code:: cpp + + + #include + + +The ``ittnotify.h`` header contains definitions of ITT API routines and +important macros which provide the correct logic of API invocation from +a user application. + + +The ITT API is designed to incur almost zero overhead when tracing is +disabled. But if you need fully zero overhead, you can compile out all +ITT API calls from your application by defining the +``INTEL_NO_ITTNOTIFY_API`` macro in your project at compile time, either +on the compiler command line, or in your source file, prior to including +the ``ittnotify.h`` file. + + +**For Fortran Applications** + + +Add the ``ITTNOTIFY`` module to your source files with the following +source line: + + +.. code:: + + + USE ITTNOTIFY + + +Insert ITT Notifications in Your Application +-------------------------------------------- + + +Insert ``__itt_*`` (C/C++) or ``ITT_*`` (Fortran) notifications in your +source code. + + +C/C++ example: + + +.. code:: cpp + + + __itt_pause(); + + +Fortran example: + + +.. code:: + + + CALL ITT_PAUSE() + + +For more information, see `Instrumenting Your +Application `__. + + +Link the libittnotify.a (Linux*, Android*, FreeBSD*) or libittnotify.lib (Windows*) Static Library to Your Application +---------------------------------------------------------------------------------------------------------------------- + + +You need to link the static library, ``libittnotify.a`` (Linux*, +FreeBSD*, Android*) or ``libittnotify.lib`` (Windows*), to your +application. If tracing is enabled, this static library loads the ITT +API implementation and forwards ITT API instrumentation data to VTune +Profiler. If tracing is disabled, the static library ignores ITT API +calls, causing nearly zero instrumentation overhead. + + +After you instrument your application by adding ITT API calls to your +code and link the ``libittnotify.a`` (Linux*, FreeBSD*, Android*) or +``libittnotify.lib`` (Windows*) static library, your application will +check the ``INTEL_LIBITTNOTIFY32`` or the\ ``INTEL_LIBITTNOTIFY64`` +environment variable depending on your application's architecture. If +that variable is set, it will load the libraries defined in the +variable. + + +Make sure to set these environment variables for the +``ittnotify_collector`` to enable data collection: + + +On Windows*: + + +``INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll`` + + +``INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll`` + + +On Linux*: + + +``INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so`` + + +``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` + + +On FreeBSD*: + + +``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` + diff --git a/docs/vtune-user-guide/context-metadata-api.rst b/docs/vtune-user-guide/context-metadata-api.rst new file mode 100644 index 00000000..c05a1c4c --- /dev/null +++ b/docs/vtune-user-guide/context-metadata-api.rst @@ -0,0 +1,215 @@ +.. _context-metadata-api: + +Context Metadata API +==================== + + +Use context metadata to collect counter-based metrics and attribute them +to hardware topology like: + + +- PCIe devices +- Block devices +- CPU cores +- Threads + + +With the Context Metadata API, you can define custom counters in your +code with special attributes. You can also get a set of metrics for the +collected data in any classical form of data representation in Intel® +VTune™ Profiler. + + +**Availability:** + + +By default, the Context Metadata API for data collection and +visualization is available in the `Input and Output +analysis `__ only. + + +To see this data when running other analysis types, + + +#. `Create a custom + analysis `__ based on + the predefined analysis type of your interest. +#. In `custom analysis + options `__, enable + the **Analyze all ITT API user data** checkbox. + + +**Define and create a counter object** + + +Use this structure to store context metadata: + + +.. code-block:: cpp + + + __itt_context_metadata + { + __itt_context_type type; /*!< Type of the context metadata value */ + void* value; /*!< Pointer to context metadata value itself */ + } + + +The structure accepts the following types of context metadata: + + +.. list-table:: + :header-rows: 0 + + * - \__itt_context_type + - Value + - Description + * - \__itt_context_name + - ASCII string char*/ Unicode string wchar_t\* type + - The name of the counter-based metric. This value is required. + * - \__itt_context_device + - ASCII string char*/ Unicode string wchar_t\* type + - Statistics subdomain to break down the counter samples (for example, network port ID, disk partition, etc.) + * - \__itt_context_units + - ASCII string char*/ Unicode string wchar_t\* type + - Units of measurement. For measurement of time, use the ns/us/ms/s units to correct data representation in VTune Profiler. + * - \__itt_context_pci_addr + - ASCII string char*/ Unicode string wchar_t\* type + - PCI address of device to associate with the counter. + * - \__itt_context_tid + - Unsigned 64-bit integer type + - Thread ID to associate with the counter. + * - \__itt_context_bandwidth_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1, calculate latency histogram and counter/sec timeline distribution. + * - \__itt_context_latency_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1,calculate the throughput histogram and counter/sec timeline distribution. + * - \__itt_context_on_thread_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1, show the counter on top of the Thread graph as percentage of the CPU Time distribution. + + + + +Before you associate context metadata with a counter, you should create +an ITT API Domain and ITT API Counter Instances. + + +The domain name provides a heading for the section of metrics for the +counters in the results of VTune Profiler. A single domain can combine +data from any number of counters. However, the name of the counters must +be unique within the same domain. + + +You can combine different counters under a single metric of the Context +Metadata. + + +**Add context information** + + +Once you have created all objects, you can add context information for +the selected counters. Use these primitives: + + +``__itt_bind_context_metadata_to_counter(__itt_counter counter, size_t length, __itt_context_metadata* metadata);`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - Type + - Parameter + - Description + * - [in] + - \ ``__itt_counter counter``\ + - Pointer to the counter instance associated with the context metadata + * - [in] + - \ ``size_t length``\ + - Number of elements in the array of context metadata + * - [in] + - \ ``__itt_context_metadata* metadata``\ + - Pointer to the array of context metadata + + + + +To create counter instances and submit counter data, use: + + +.. code-block:: cpp + + + __itt_counter_create_v3(__itt_domain* domain, const char* name, __itt_metadata_type type); + __itt_counter_set_value_v3(__itt_counter counter, void *value_ptr); + + +Usage Example +------------- + + +This example creates counters with context metadata that measures random +read operation metrics for an SSD NVMe device: + + +.. code:: cpp + + + #include "ittnotify.h" + #include "ittnotify_types.h" + + + // Create domain and counters: + __itt_domain* domain = __itt_domain_create("ITT API collected data"); + __itt_counter counter_read_op = __itt_counter_create_v3(domain, "Read Operations", __itt_metadata_u64); + __itt_counter counter_read_mb = __itt_counter_create_v3(domain, "Read Megabytes", __itt_metadata_u64); + __itt_counter counter_spin_time = __itt_counter_create_v3(domain, "Spin Time", __itt_metadata_u64); + + + // Create context metadata: + __itt_context_metadata metadata_read_op[] = { + {__itt_context_name, "Reads"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "Operations"}, + {__itt_context_pci_addr, "0001:10:00.1"}, + {__itt_context_latency_flag, &true_flag} + }; + __itt_context_metadata metadata_read_mb[] = { + {__itt_context_name, "Read"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "MB"}, + {__itt_context_pci_addr, "0001:10:00.1"}, + {__itt_context_bandwidth_flag, &true_flag} + }; + __itt_context_metadata metadata_spin_time[] = { + {__itt_context_name, "Spin Time"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "ms"}, + {__itt_context_tid, &thread_id} + }; + + + // Bind context metadata to counters: + __itt_bind_context_metadata_to_counter(counter_read_op, n, metadata_read_op); + __itt_bind_context_metadata_to_counter(counter_read_mb, n, metadata_read_mb); + __itt_bind_context_metadata_to_counter(counter_spin_time, n, metadata_spin_time); + + + while(1) + { + // Get collected data: + uint64_t read_op = get_user_read_operation_num(); + uint64_t read_mb = get_user_read_megabytes_num(); + uint64_t spin_time = get_user_spin_time(); + + + // Dump collected data: + __itt_counter_set_value_v3(counter_read_op, &read_op); + __itt_counter_set_value_v3(counter_read_mb, &read_mb); + __itt_counter_set_value_v3(counter_spin_time, &spin_time); + } + diff --git a/docs/vtune-user-guide/counter-api.rst b/docs/vtune-user-guide/counter-api.rst new file mode 100644 index 00000000..63f311e9 --- /dev/null +++ b/docs/vtune-user-guide/counter-api.rst @@ -0,0 +1,162 @@ +.. _counter-api: + +Counter API +=========== + + +Use the Counter API to observe user-defined global characteristic +counters that are unknown to VTune Profiler. For example, system on a +chip (SoC) development benefits from several counters representing +different parts of the SoC to count some hardware characteristics. + + +**Define and create a counter object** + + +Use these primitives: + + +``__itt_counter`` + + +``__itt_counter_create(const char *name, const char *domain);`` + + +``__itt_counter_createA(const char *name, const char *domain);`` + + +``__itt_counter_createW(const wchar_t *name, const wchar_t *domain);`` + + +``__itt_counter_create_typed (const char *name, const char *domain, __itt_metadata_type type);`` + + +``__itt_counter __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` + + +``__itt_counter __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` + + +``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` + + +A counter name and domain name should be specified. To load a +specialized type of data, specify the counter type. By default the +unsigned int64 type is used. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``domain``\ + - Counter domain + * - [in] + - \ ``name``\ + - Counter name + * - [in] + - \ ``type``\ + - Counter type + + + + +**Increment/decrement a counter value** + + +Use these primitives: + + +``__itt_counter_inc (__itt_counter id);`` + + +``__itt_counter_inc_delta(__itt_counter id, unsigned long long value);`` + + +``__itt_counter_dec(__itt_counter id);`` + + +``__itt_counter_dec_delta(__itt_counter id, unsigned long long value);`` + + +.. note:: + + + These primitives are applicable to uint64 counters only. + + +**Directly set the counter value** + + +Use: + + +``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` + + +``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` + + +Parameters of the primitive: + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``id``\ + - Counter ID + * - [in] + - \ ``value_ptr``\ + - Counter value + + + + +**Remove an existing counter** + + +Use: + + +``__itt_counter_destroy(__itt_counter id);`` + + +Usage Example +------------- + + +This example creates a counter that measures temperature and memory +usage metrics: + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_counter temperatureCounter = __itt_counter_create("Temperature", "Domain"); + __itt_counter memoryUsageCounter = __itt_counter_create("Memory Usage", "Domain"); + unsigned __int64 temperature; + + + while (...) + { + ... + temperature = getTemperature(); + __itt_counter_set_value(temperatureCounter, &temperature); + + + __itt_counter_inc_delta(memoryUsageCounter, getAllocatedMemSize()); + __itt_counter_dec_delta(memoryUsageCounter, getDeallocatedMemSize()); + ... + } + + + __itt_counter_destroy(temperatureCounter); + __itt_counter_destroy(memoryUsageCounter); + diff --git a/docs/vtune-user-guide/domain-api.rst b/docs/vtune-user-guide/domain-api.rst new file mode 100644 index 00000000..32523962 --- /dev/null +++ b/docs/vtune-user-guide/domain-api.rst @@ -0,0 +1,65 @@ +.. _domain-api: + +Domain API +========== + + +A ``domain`` enables tagging trace data for different modules or +libraries in a program. Domains are specified by unique character +strings, for example ``TBB.Internal.Control``. + + +Each domain is represented by an opaque ``__itt_domain`` structure, +which you can use to tag each of the ITT API calls in your code. + + +You can selectively enable or disable specific domains in your +application, in order to filter the subsets of instrumentation that are +collected into the output trace capture file. To disable a domain set +its flag field to 0 value. This disables tracing for a particular domain +while keeping the rest of the code unmodified. The overhead of a +disabled domain is a single if check. + + +**To create a domain, use the following primitives:** + + +``__itt_domain *ITTAPI__itt_domain_create ( const char *name)`` + + +For a domain name, the URI naming style is recommended, for example, +com.my_company.my_application. The set of domains is expected to be +static over the application's execution time, therefore, there is no +mechanism to destroy a domain. + + +Any domain can be accessed by any thread in the process, regardless of +which thread created the domain. This call is thread-safe. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *name*\ + - Name of domain + + + + +Usage Example +------------- + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_domain* pD = __itt_domain_create(L"My Domain" ); + pD->flags = 0; /* disable domain */ + diff --git a/docs/vtune-user-guide/event-api.rst b/docs/vtune-user-guide/event-api.rst new file mode 100644 index 00000000..4013aee3 --- /dev/null +++ b/docs/vtune-user-guide/event-api.rst @@ -0,0 +1,129 @@ +.. _event-api: + +Event API +========= + + +The event API is used to observe when demarcated events occur in your +application, or to identify how long it takes to execute demarcated +regions of code. Set annotations in the application to demarcate areas +where events of interest occur. After running analysis, you can see the +events marked in the Timeline pane. + + +Event API is a per-thread function that works in resumed state. This +function does not work in paused state. + + +.. note:: + + + - On Windows\* OS platforms you can define Unicode to use a wide + character version of APIs that pass strings. However, these + strings are internally converted to ASCII strings. + + + - On Linux\* OS platforms only a single variant of the API exists. + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``__itt_event __itt_event_create(const __itt_char *name, int namelen );``\ + - Create an event type with the specified name and length. This API returns a handle to the event type that should be passed into the following event start and event end APIs as a parameter. The namelen parameter refers to the name length in number of characters, not the number of bytes. + * - \ ``int __itt_event_start( __itt_event event );``\   + - Call this API with your previously created event type handle to register an instance of the event. Event start appears in the **Timeline** pane display as a tick mark. + * - \ ``int __itt_event_end( __itt_event event );``\ + - Call this API following a call to \__itt_event_start() to show the event as a tick mark with a duration line from start to end. If this API is not called, this event appears in the **Timeline** pane as a single tick mark. + + + + +Guidelines for Event API Usage +------------------------------ + + +- An \__itt_event_end() is always matched with the nearest preceding + \__itt_event_start(). Otherwise, the \__itt_event_end() call is + matched with the nearest unmatched \__itt_event_start() preceding it. + Any intervening events are nested. + + +- You can nest user events of the same or different type within each + other. In the case of nested events, the time is considered to have + been spent only in the most deeply nested user event region. + + +- You can overlap different ITT API events. In the case of overlapping + events the time is considered to have been spent only in the event + region with the later \__itt_event_start(). Unmatched + \__itt_event_end() calls are ignored. + + +.. note:: + + + To see events and user tasks in your results, `create a custom + analysis `__ (based + on the pre-defined analysis you are interested in) and select the + **Analyze user tasks, events and counters** checkbox in the analysis + settings. + + +Usage Example: Creating and Marking Single Events +------------------------------------------------- + + +The \__itt_event_create API returns a new event handle that you can +subsequently use to mark user events with the \__itt_event_start API. In +this example, two event type handles are created and used to set the +start points for tracking two different types of events. + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_event mark_event = __itt_event_create( "User Mark", 9 ); + __itt_event frame_event = __itt_event_create( "Frame Completed", 15 ); + ... + __itt_event_start( mark_event ); + ... + for( int f ; f__itt_frame_end_v3 with NULL as the *id* parameter designates the end of the frame. + + + + +``void __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id);`` + + +Define the end of the frame instance. A ``__itt_frame_end_v3`` call must +be paired with a ``__itt_frame_begin_v3`` call. The first call to +``__itt_frame_end_v3`` with a given ID ends the frame. Successive calls +with the same ID are ignored, as are calls that do not have a matching +``__itt_frame_begin_v3`` call. + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *domain*\ + - The domain for this frame instance + * - \ ``[in]``\ + - \ *id*\ + - The instance ID for this frame instance, or NULL for the current instance + + + + +@table_end + + +.. note:: + + + The analysis types based on the hardware event-based sampling + collection are limited to 64 distinct frame domains. + + +Guidelines for Frame API Usage +------------------------------ + + +- Use the frame API to denote the frame begin point and end point. + Consider a frame as the time period between frame begin and end + points. +- VTune Profiler does not attribute the time/samples between + ``__itt_frame_end_v3()`` and ``__itt_frame_begin_v3()`` to any + program unit and displays it as ``[Unknown]`` in the viewpoint. +- If there are consecutive ``__itt_frame_begin_v3`` calls in the same + domain, treat it as a ``__itt_frame_end_v3``/``__itt_frame_begin_v3`` + pair. +- Recursive/nested/overlapping frames for the same domain are not + allowed. +- The ``__itt_frame_begin_v3()`` and ``__itt_frame_end_v3()`` calls can + be made from different threads. +- The recommended maximum rate for calling the frame API is 1000 frames + per second. A higher rate may result in large product memory + consumption and slow finalization. + + +Usage Example +------------- + + +The following example uses the frame API to capture the Elapsed times +for the specified code sections. + + +.. code:: + + + #include "ittnotify.h" + + __itt_domain* pD = __itt_domain_create( L"My Domain" ); + + pD->flags = 1; /* enable domain */ + + for (int i = 0; i < getItemCount(); ++i) + { + __itt_frame_begin_v3(pD, NULL); + do_foo(); + __itt_frame_end_v3(pD, NULL); + } + + //... + + __itt_frame_begin_v3(pD, NULL); + do_foo_1(); + __itt_frame_end_v3(pD, NULL); + + //... + + __itt_frame_begin_v3(pD, NULL); + do_foo_2(); + __itt_frame_end_v3(pD, NULL); + diff --git a/docs/vtune-user-guide/histogram-api.rst b/docs/vtune-user-guide/histogram-api.rst new file mode 100644 index 00000000..2c2275ff --- /dev/null +++ b/docs/vtune-user-guide/histogram-api.rst @@ -0,0 +1,187 @@ +.. _histogram-api: + +Histogram API +============= + + +Use the Histogram API to define histograms that display arbitrary data +in histogram form in Intel® VTune™ Profiler. + + +The Histogram API enables you to define custom histogram graphs in your +code to display arbitrary data of your choice in VTune Profiler. + + +Histograms can be especially useful for showing statistics that can be +split by individual units for cross-comparison. + + +For example, you can use this API in your workload to: + + +- Track load distribution +- Track resource utilization +- Identify oversubscribed or underutilized worker nodes + + +Any histogram instance can be accessed by any thread in the process, +regardless of which thread created the histogram. The Histogram API call +is thread-safe. + + +.. note:: + + + By default, Histogram API data collection and visualization are + available in the `Input and Output + analysis `__ only. To + see the histogram in the result of other analysis types, `create a + custom analysis `__ + based on the pre-defined analysis type you are interested in, and + enable the **Analyze user histogram** checkbox in the `custom + analysis options `__. + + +Define and Create Histogram +--------------------------- + + +Before creating the histogram, an `ITT API +Domain `__ must be +created. The pointer to this domain is then passed to the primitive. + + +The domain name provides a heading for the histogram section on the +**Summary** tab of VTune Profiler result. + + +One domain can combine any number of histograms. However, the name of +the histogram must be unique within the same domain. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - ``domain`` + - Domain controlling the call + * - [in] + - ``name`` + - Histogram name + * - [in] + - ``x_axis_type`` + - Type of X axis data + * - [in] + - ``y_axis_type`` + - Type of Y axis data + + + + +.. container:: fignone + :name: GUID-788CEBA6-9355-4E6D-ADF7-9ED7BD8441A1 + + + |image1| + + +**Primitives:** + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - ``__itt_histogram* _itt_histogram_create(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Linux\* and Android\* OS. + * - ``__itt_histogram* _itt_histogram_createA(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for ASCII strings (``char``). + * - ``__itt_histogram* _itt_histogram_createW(__itt_domain* domain, const wchar_t* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for UNICODE strings (``wchar_t``). + + + + +Submit Data to Histogram +------------------------ + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - ``histogram`` + - Histogram instance to submit data to + * - [in] + - ``length`` + - Number of elements in submitted axis data array + * - [in] + - ``x_axis_data`` + - Array containing X axis data (may be ``NULL``). If ``x_axis_data`` is ``NULL``, VTune Profiler uses the indices of the ``y_axis_data`` array. + * - [in] + - ``y_axis_data`` + - Array containing Y axis data. + + + + +**Primitives:** + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - ``void _itt_histogram_submit(__itt_histogram* histogram, size_t length, void* x_axis_data, void* y_axis_data);`` + - Submit user statistics for the selected histogram instance. Array data for the Y-axis is mapped to array data for the X-axis, similar to coordinates of a point on a 2D plane. Data submitted during workload run is summarized into one common histogram for all calls of this primitive. It is recommended to determine an efficient interval between data submissions to lower collection overhead. + + + + +Usage Example +------------- + + +The following example creates a histogram to store worker thread +statistics: + + +.. code:: cpp + + + #include "ittnotify.h" + #include "ittnotify_types.h" + + + void submit_stats() + { + // Create domain + __itt_domain* domain = __itt_domain_create("Histogram statistics domain"); + + + // Create histogram + __itt_histogram* histogram = __itt_histogram_create(domain, "Worker TID 13454", __itt_metadata_u64, __itt_metadata_u64); + + + // Fill the statistics arrays with profiling data: + uint64_t* x_stats, y_stats; + size_t array_size; + get_worker_stats(x_stats, y_stats, array_size); + + + // Submit histogram statistics: + __itt_histogram_submit(histogram, array_size, x_stats, y_stats); + } + + +.. |image1| image:: GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png + :width: 1000px + diff --git a/docs/vtune-user-guide/ijit_-getnewmethodid.rst b/docs/vtune-user-guide/ijit_-getnewmethodid.rst new file mode 100644 index 00000000..2884d3e4 --- /dev/null +++ b/docs/vtune-user-guide/ijit_-getnewmethodid.rst @@ -0,0 +1,40 @@ +.. _ijit_-getnewmethodid: + +iJIT\_ GetNewMethodID +===================== + + +Generates a new unique method ID. + + +Syntax +------ + + +unsigned int iJIT_GetNewMethodID(void); + + +Description +----------- + + +The\ ``iJIT_GetNewMethodID`` function generates new method ID upon each +call. Use this API to obtain unique and valid method IDs for methods or +traces reported to the agent if you do not have your own mechanism to +generate unique method IDs. + + +Input Parameters +---------------- + + +None + + +Return Values +------------- + + +A new unique method ID. When out of unique method IDs, this API function +returns 0. + diff --git a/docs/vtune-user-guide/ijit_isprofilingactive.rst b/docs/vtune-user-guide/ijit_isprofilingactive.rst new file mode 100644 index 00000000..633f5b81 --- /dev/null +++ b/docs/vtune-user-guide/ijit_isprofilingactive.rst @@ -0,0 +1,38 @@ +.. _ijit_isprofilingactive: + +iJIT_IsProfilingActive +====================== + + +Returns the current mode of the agent. + + +Syntax +------ + + +iJIT_IsProfilingActiveFlags JITAPI iJIT IsProfilingActive ( void ) + + +Description +----------- + + +The ``iJIT_IsProfilingActive`` function returns the current mode of the +agent. + + +Input Parameters +---------------- + + +None + + +Return Values +------------- + + +``iJIT_SAMPLING_ON``, indicating that agent is running, or +``iJIT_NOTHING_RUNNING`` if no agent is running. + diff --git a/docs/vtune-user-guide/ijit_notifyevent.rst b/docs/vtune-user-guide/ijit_notifyevent.rst new file mode 100644 index 00000000..7a07de75 --- /dev/null +++ b/docs/vtune-user-guide/ijit_notifyevent.rst @@ -0,0 +1,257 @@ +.. _ijit_notifyevent: + +iJIT_NotifyEvent +================ + + +Reports information about JIT-compiled code to the agent. + + +Syntax +------ + + +int iJIT_NotifyEvent(iJIT_JVM_EVENT event_type,void +\*EventSpecificData); + + +Description +----------- + + +The ``iJIT_NotifyEvent``\ function sends a notification of +``event_type`` with the data pointed by ``EventSpecificData`` to the +agent. The reported information is used to attribute samples obtained +from any Intel® VTune™ Profiler collector. This API needs to be called +after JIT compilation and before the first entry into the JIT-compiled +code. + + +Input Parameters +---------------- + + +.. list-table:: + :header-rows: 0 + + * - Parameter + - Description + * - \ ``iJIT_JVM_EVENT event_type``\ + - Notification code sent to the agent. See a complete list of `event types <#EVENT_TYPE>`__ below. + * - \ ``void *EventSpecificData``\ + - Pointer to `event specific data <#STRUCTURE>`__. + + + + +The following values are allowed for ``event_type``: + + +.. list-table:: + :header-rows: 0 + + * - + - Send this notification after a JITted method has been loaded into memory, and possibly JIT compiled, but before the code is executed. Use the ``iJIT_Method_Load`` structure for ``EventSpecificData``. The return value of ``iJIT_NotifyEvent``\ is undefined. + * - \ ``iJVM_EVENT_TYPE_SHUTDOWN``\ + - Send this notification to terminate profiling. Use NULL for ``EventSpecificData``. ``iJIT_NotifyEvent`` returns 1 on success. + * - \ ``JVM_EVENT_TYPE_METHOD_UPDATE``\ + - Send this notification to provide new content for a previously reported dynamic code. The previous content will be invalidated starting from the time of the notification. Use the ``iJIT_Method_Load`` structure for ``EventSpecificData`` with the following required fields: + * - + - Send this notification when an inline dynamic code is JIT compiled and loaded into memory by the JIT engine, but before the parent code region starts executing. Use the ``iJIT_Method_Inline_Load`` structure for ``EventSpecificData``. + * - + - Send this notification when a dynamic code is JIT compiled and loaded into memory by the JIT engine, but before the code is executed. Use the ``iJIT_Method_Load_V2`` structure for ``EventSpecificData``. + + + + +The following structures can be used for ``EventSpecificData``: + + +**iJIT_Method_Inline_Load Structure** + + +When you use the ``iJIT_Method_Inline_Load`` structure to describe the +JIT compiled method, use ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` +as an event type to report it. The\ ``iJIT_Method_Inline_Load`` +structure has the following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. + * - \ ``unsigned int parent_method_id``\ + - Unique immediate parent’s method ID. Method ID may not be smaller than 999. You must either use the API function iJIT_GetNewMethodID to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + + + + +**iJIT_Method_Load Structure** + + +When you use the\ ``iJIT_Method_Load`` structure to describe the JIT +compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` as an +event type to report it. The\ ``iJIT_Method_Load`` structure has the +following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. + * - \ ``unsigned int class_id``\ + - This field is obsolete. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + * - \ ``void *user_data``\ + - This field is obsolete. + * - \ ``unsigned int user_data_size``\ + - This field is obsolete. + * - \ ``iJDEnvironmentType env``\ + - This field is obsolete. + + + + +**iJIT_Method_Load_V2 Structure** + + +When you use the ``iJIT_Method_Load_V2`` structure to describe the JIT +compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2`` as an +event type to report it. The\ ``iJIT_Method_Load_V2`` structure has the +following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + * - \ ``char *module_name``\ + - Module name. Can be NULL. The module name can be useful for distinguishing among different JIT engines. VTune Profiler will display reported methods grouped by specific module. + + + + +**LineNumberInfo Structure** + + +Use the ``LineNumberInfo`` structure to describe a single entry in the +line number information of a code region. A table of line number entries +provides information about how the reported code region is mapped to +source file. VTune Profiler uses line number information to attribute +the samples (virtual address) to a line number. It is acceptable to +report different code addresses for the same source line: + + +.. list-table:: + :header-rows: 0 + + * - \ **Offset**\ + - \ **Line Number**\ + * - 1 + - 2 + * - 12 + - 4 + * - 15 + - 2 + * - 18 + - 1 + * - 21 + - 30 + + + + +VTune Profiler constructs the following table using the client data: + + +.. list-table:: + :header-rows: 0 + + * - \ **Code sub-range**\ + - \ **Line Number**\ + * - 0-1 + - 2 + * - 1-12 + - 4 + * - 12-15 + - 2 + * - 15-18 + - 1 + * - 18-21 + - 30 + + + + +The ``LineNumberInfo`` structure has the following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int Offset``\ + - Opcode byte offset from the beginning of the method. + * - \ ``unsigned int LineNumber``\ + - Matching source line number offset (from beginning of source file). + + + + +Return Values +------------- + + +The return values are dependent on the particular ``iJIT_JVM_EVENT``. + diff --git a/docs/vtune-user-guide/instrument-your-application.rst b/docs/vtune-user-guide/instrument-your-application.rst new file mode 100644 index 00000000..63208726 --- /dev/null +++ b/docs/vtune-user-guide/instrument-your-application.rst @@ -0,0 +1,137 @@ +.. _instrument-your-application: + +Instrument Your Application +=========================== + + +To get the most out of the ITT APIs when collecting performance data +with Intel® VTune™ Profiler, you need to add API calls in your code to +designate logical tasks. This will help you visualize the relationship +between tasks in your code, including when they start and end, relative +to other CPU and GPU tasks. + + +At the highest level a task is a logical group of work executing on a +specific thread, and may correspond to any grouping of code within your +program that you consider important. You can mark up your code by +identifying the beginning and end of each logical task with +\__itt_task_begin and \__itt_task_end calls. For example, to track +"smoke rendering" separately from "detailed shadows", you should add API +tracking calls to the code modules for these specific features. + + +To get started, use the following API calls: + + +- \__itt_domain_create() creates a domain required in most ITT API + calls. You need to define at least one domain. +- \__itt_string_handle_create() creates string handles for identifying + your tasks. String handles are more efficient for identifying traces + than strings. +- \__itt_task_begin() marks the beginning of a task. +- \__itt_task_end() marks the end of a task. + + +Example +------- + + +The following sample shows how four basic ITT API functions are used in +a multi threaded application: + + +- + + + .. container:: + :name: LI_8CC703C571CC4A38B4933FE7AE7E170D + + + `Domain API `__ + + +- + + + .. container:: + :name: LI_D12ED1398398490EA2761534CB34111C + + + `String Handle + API `__ + + +- + + + .. container:: + :name: LI_A68036F0DE3842049E37031CB63A785C + + + `Task API `__ + + +- + + + .. container:: + :name: LI_1304238F684E4DBEAC3E53BEA55D36E7 + + + `Thread Naming + API `__ + + +.. code:: cpp + + + #include + #include + + + // Forward declaration of a thread function. + DWORD WINAPI workerthread(LPVOID); + bool g_done = false; + // Create a domain that is visible globally: we will use it in our example. + __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); + // Create string handles which associates with the "main" task. + __itt_string_handle* handle_main = __itt_string_handle_create("main"); + __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); + void main(int, char* argv[]) + { + // Create a task associated with the "main" routine. + __itt_task_begin(domain, __itt_null, __itt_null, handle_main); + // Now we'll create 4 worker threads + for (int i = 0; i < 4; i++) + { + // We might be curious about the cost of CreateThread. We add tracing to do the measurement. + __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); + .. code-block:: cppCreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); + __itt_task_end(domain); + } + + + // Wait a while,... + .. code-block:: cppSleep(5000); + g_done = true; + // Mark the end of the main task + __itt_task_end(domain); + } + // Create string handle for the work task. + __itt_string_handle* handle_work = __itt_string_handle_create("work"); + DWORD WINAPI workerthread(LPVOID data) + { + // Set the name of this thread so it shows up in the UI as something meaningful + char threadname[32]; + wsprintf(threadname, "Worker Thread %d", data); + __itt_thread_set_name(threadname); + // Each worker thread does some number of "work" tasks + while(!g_done) + { + __itt_task_begin(domain, __itt_null, __itt_null, handle_work); + .. code-block:: cppSleep(150); + __itt_task_end(domain); + } + return 0; + } + diff --git a/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst b/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst new file mode 100644 index 00000000..c1ae7b8b --- /dev/null +++ b/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst @@ -0,0 +1,26 @@ +.. _instrumentation-and-tracing-technology-api-reference: + +Instrumentation and Tracing Technology API Reference +==================================================== + + +Here are the tools available for use with the Instrumentation and +Tracing Technology API (ITT API) + +.. toctree:: + :maxdepth: 1 + + + domain-api + string-handle-api + collection-control-api + thread-naming-api + task-api + frame-api + histogram-api + user-defined-synchronization-api + event-api + counter-api + context-metadata-api + load-module-api + memory-allocation-apis \ No newline at end of file diff --git a/docs/vtune-user-guide/jit-profiling-api-reference.rst b/docs/vtune-user-guide/jit-profiling-api-reference.rst new file mode 100644 index 00000000..09b9ceac --- /dev/null +++ b/docs/vtune-user-guide/jit-profiling-api-reference.rst @@ -0,0 +1,12 @@ +.. _jit-profiling-api-reference: + +JIT Profiling API Reference +=========================== + +.. toctree:: + :maxdepth: 1 + + + ijit_notifyevent + ijit_isprofilingactive + ijit_-getnewmethodid \ No newline at end of file diff --git a/docs/vtune-user-guide/jit-profiling-api.rst b/docs/vtune-user-guide/jit-profiling-api.rst new file mode 100644 index 00000000..18184397 --- /dev/null +++ b/docs/vtune-user-guide/jit-profiling-api.rst @@ -0,0 +1,335 @@ +.. _jit-profiling-api: + +JIT Profiling API +================= + + +.. note:: + + + The Instrumentation and Tracing Technology API (ITT API) and the + Just-in-Time Profiling API (JIT API) are open source components. You + can access the source code and make contributions in the `GitHub\* + repository `__. + + +The JIT (Just-In-Time) Profiling API provides functionality to report +information about just-in-time generated code that can be used by +performance tools. You must insert JIT Profiling API calls in the code +generator to report information before JIT-compiled code goes to +execution. This information is collected at runtime and used by tools +like Intel® VTune™ Profiler to display performance metrics associated +with JIT-compiled code. + + +You can use the JIT Profiling API to profile such environments as +dynamic JIT compilation of JavaScript code traces, JIT execution in +OpenCL™ applications, Java*/.NET\* managed execution environments, and +custom ISV JIT engines. + + +The standard VTune Profiler installation contains a static part (as a +static library and source files) and a profiler object. The JIT engine +generating code during runtime communicates with a profiler object +through the static part. During runtime, the JIT engine reports the +information about JIT-compiled code stored in a trace file by the +profiler object. After collection, the VTune Profiler uses the generated +trace file to resolve the JIT-compiled code. If VTune Profiler is not +installed, profiling is disabled. + + +Use the JIT Profiling API to: + + +- :ref:`Profile trace-based and method-based JIT-compiled code` + + +- :ref:`Analyze split functions` + + +- :ref:`Explore inline functions` + + +JIT profiling is supported with the **Launch Application** target option +for event based sampling. + + +Environment Variables in the JIT Profiling API +---------------------------------------------- + + +The JIT Profiling API contains two environment variables, which in turn +contain paths to specific runtime libraries. + + +- ``INTEL_JIT_PROFILER32`` +- ``INTEL_JIT_PROFILER64`` + + +These variables are used to signal the replacement of the stub +implementation of the JIT API with the VTune Profiler JIT API collector. +Once you instrument your code with the JIT API and link it to the VTune +Profiler JIT API stub (``libjitprofiling.lib/libjitprofiling.a``), your code +loads the libraries defined in these environment variables, once the +variables are set. + + + + +Make sure to set these environment variables for the ittnotify_collector to enable data collection: + +On Windows*: + +.. code-block:: bash + + INTEL_JIT_PROFILER32=\bin32\runtime\ittnotify_collector.dll + INTEL_JIT_PROFILER64=\bin64\runtime\ittnotify_collector.dll + +On Linux*: + +.. code-block:: bash + + INTEL_JIT_PROFILER32=/lib32/runtime/libittnotify_collector.so + INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so + +On FreeBSD*: + +.. code-block:: bash + + INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so + + +.. _Profile trace-based and method-based JIT-compiled code : + +Profile Trace-based and Method-based JIT-compiled Code +------------------------------------------------------ + + +This is the most common scenario for using JIT Profiling API to profile +trace-based and method-based JIT-compiled code: + + +.. code:: cpp + + + #include + + + if (iJIT_IsProfilingActive() != iJIT_SAMPLING_ON) { + return; + } + + + iJIT_Method_Load jmethod = {0}; + jmethod.method_id = iJIT_GetNewMethodID(); + jmethod.method_name = "method_name"; + jmethod.class_file_name = "class_name"; + jmethod.source_file_name = "source_file_name"; + jmethod.method_load_address = code_addr; + jmethod.method_size = code_size; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, + (void*)&jmethod); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL); + + +**Usage Tips** + + +- If any ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an + already reported method, then such a method becomes invalid and its + memory region is treated as unloaded. VTune Profiler displays the + metrics collected by the method until it is overwritten. + + +- If supplied line number information contains multiple source lines + for the same assembly instruction (code location), then VTune + Profiler picks up the first line number. + + +- Dynamically generated code can be associated with a module name. Use + the ``iJIT_Method_Load_V2`` structure. + + + - If you register a function with the same method ID multiple times, + specifying different module names, then the VTune Profiler picks + up the module name registered first. If you want to distinguish + the same function between different JIT engines, supply different + method IDs for each function. Other symbolic information (for + example, source file) can be identical. + +.. _Analyze split functions : + +Analyze Split Functions +----------------------- + + +You can use the JIT Profiling API to analyze split functions (multiple +joint or disjoint code regions belonging to the same function) including +re-JITting with potential overlapping of code regions in time, which is +common in resource-limited environments. + + +.. code:: cpp + + + + + #include + + + unsigned int method_id = iJIT_GetNewMethodID(); + + + iJIT_Method_Load a = {0}; + a.method_id = method_id; + a.method_load_address = 0x100; + a.method_size = 0x20; + + + iJIT_Method_Load b = {0}; + b.method_id = method_id; + b.method_load_address = 0x200; + b.method_size = 0x30; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b) + + +**Usage Tips** + + +- If a ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an + already reported method, then such a method becomes invalid and its + memory region is treated as unloaded. + + +- All code regions reported with the same method ID are considered as + belonging to the same method. Symbolic information (method name, + source file name) will be taken from the first notification, and all + subsequent notifications with the same method ID will be processed + only for line number table information. So, the VTune Profiler will + map samples to a source line using the line number table from the + current notification while taking the source file name from the very + first one. + + + - If you register a second code region with a different source file + name and the same method ID, this information will be saved and + will not be considered as an extension of the first code region, + but VTune Profiler will use the source file of the first code + region and map performance metrics incorrectly. + + + - If you register a second code region with the same source file as + for the first region and the same method ID, the source file will + be discarded but VTune Profiler will map metrics to the source + file correctly. + + + - If you register a second code region with a null source file and + the same method ID, provided line number info will be associated + with the source file of the first code region. + +.. _Explore inline functions: + +Explore Inline Functions +------------------------ + + +You can use the JIT Profiling API to explore inline functions including +multi-level hierarchy of nested inline methods that shows how +performance metrics are distributed through them. + + +.. code:: cpp + + + #include + + + // method_id parent_id + // [-- c --] 3000 2000 + // [---- d -----] 2001 1000 + // [---- b ----] 2000 1000 + // [------------ a ----------------] 1000 n/a + + + iJIT_Method_Load a = {0}; + a.method_id = 1000; + + + iJIT_Method_Inline_Load b = {0}; + b.method_id = 2000; + b.parent_method_id = 1000; + + + iJIT_Method_Inline_Load c = {0}; + c.method_id = 3000; + c.parent_method_id = 2000; + + + iJIT_Method_Inline_Load d = {0}; + d.method_id = 2001; + d.parent_method_id = 1000; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&b); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&c); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&d); + + +**Usage Tips** + + +- Each inline (``iJIT_Method_Inline_Load``) method should be associated + with two method IDs: one for itself; one for its immediate parent. + + +- Address regions of inline methods of the same parent method cannot + overlap each other. + + +- Execution of the parent method must not be started until it and all + its inline methods are reported. + + +- In case of nested inline methods an order of + ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` events is not + important. + + +- If any event overwrites either inline method or top parent method, + then the parent, including inline methods, becomes invalid and its + memory region is treated as unloaded. + + +.. container:: See Also + + + .. rubric:: See Also + + .. container:: linklist + + + `JIT Profiling API + Reference `__ + + + `Using JIT Profiling + API `__ + + +`Basic Usage and +Configuration `__ See +prerequisites here + +.. toctree:: + :maxdepth: 1 + + + using-jit-profiling-api + jit-profiling-api-reference \ No newline at end of file diff --git a/docs/vtune-user-guide/load-module-api.rst b/docs/vtune-user-guide/load-module-api.rst new file mode 100644 index 00000000..2df6b7ab --- /dev/null +++ b/docs/vtune-user-guide/load-module-api.rst @@ -0,0 +1,39 @@ +.. _load-module-api: + +Load Module API +=============== + + +You can use the Load Module API in your code to analyze a module that +was loaded in an alternate location that cannot otherwise be tracked by +Intel VTune Profiler. For example, this would allow you to analyze code +that is typically executed in an isolated environment to which there is +no visibility of the code. This API allows you to explicitly set the +module location in an address space for analysis by VTune Profiler. + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_module_loadW (void* start_addr,void* end_addr, const wchar_t* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + * - \ ``void __itt_module_loadA(void* start_addr, void* end_addr, const char* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + * - \ ``void __itt_module_load(void* start_addr, void* end_addr, const char* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + + + + +Usage Example +------------- + + +.. code:: + + + #include "ittnotify.h" + __itt_module_load(relocatedBaseModuleAddress, relocatedEndModuleAddress, '/some/path/to/dynamic/library.so'); + diff --git a/docs/vtune-user-guide/memory-allocation-apis.rst b/docs/vtune-user-guide/memory-allocation-apis.rst new file mode 100644 index 00000000..0ff82588 --- /dev/null +++ b/docs/vtune-user-guide/memory-allocation-apis.rst @@ -0,0 +1,134 @@ +.. _memory-allocation-apis: + +Memory Allocation APIs +====================== + + +Intel® VTune™ Profiler provides a set of APIs to help it identify the +semantics of your ``malloc``-like heap management functions. + + +Annotating your code with these APIs allows VTune Profiler to correctly +determine memory objects as part of `Memory Access +Analysis `__. + + +Usage Tips +---------- + + +Follow these guidelines when using the memory allocation APIs: + + +- Create *wrapper* functions for your routines, and put the + ``__itt_heap_*_begin`` and ``__itt_heap_*_end`` calls in these + functions. + + +- Allocate a unique domain for each pair of allocate/free functions + when calling ``__itt_heap_function_create``. This allows the VTune + Profiler to verify a matching free function is called for every + allocate function call. + + +- Annotate the beginning and end of every allocate function and free + function. + + +- Call all function pairs from the same stack frame, otherwise the + VTune Profiler assumes an exception occurred and the allocation + attempt failed. + + +- Do not call an end function without first calling the matching begin + function. + + +Using Memory Allocation APIs in Your Code +----------------------------------------- + + +.. list-table:: + :header-rows: 0 + + * - Use This + - To Do This + * - + - Declare a handle type to match begin and end calls and domains. + * - + - Identify allocation functions. + * - + - Identify deallocation functions. + * - + - Identify reallocation functions. Note that ``itt_heap_reallocate_end()`` must be called after the attempt even if no memory is returned. VTune Profiler assumes C-runtime ``realloc`` semantics. + + + + +Usage Example: Heap Allocation +------------------------------ + + +.. code:: cpp + + + #include + + + void* user_defined_malloc(size_t size); + void user_defined_free(void *p); + void* user_defined_realloc(void *p, size_t s); + + + __itt_heap_function my_allocator; + __itt_heap_function my_reallocator; + __itt_heap_function my_freer; + + + void* my_malloc(size_t s) + { + void* p; + + + __itt_heap_allocate_begin(my_allocator, s, 0); + p = user_defined_malloc(s); + __itt_heap_allocate_end(my_allocator, &p, s, 0); + + + return p; + } + + + + + void my_free(void *p) + { + __itt_heap_free_begin (my_freer, p); + user_defined_free(p); + __itt_heap_free_end (my_freer, p); + } + + + void* my_realloc(void *p, size_t s) + { + void *np; + + + __itt_heap_reallocate_begin (my_reallocator, p, s, 0); + np = user_defined_realloc(p, s); + __itt_heap_reallocate_end(my_reallocator, p, &np, s, 0); + + + return(np); + } + + + // Make sure to call this init routine before any calls to + // user defined allocators. + void init_itt_calls() + { + my_allocator = __itt_heap_function_create("my_malloc", "mydomain"); + my_reallocator = __itt_heap_function_create("my_realloc", "mydomain"); + my_freer = __itt_heap_function_create("my_free", "mydomain"); + } + diff --git a/docs/vtune-user-guide/minimize-itt-api-overhead.rst b/docs/vtune-user-guide/minimize-itt-api-overhead.rst new file mode 100644 index 00000000..36659fb0 --- /dev/null +++ b/docs/vtune-user-guide/minimize-itt-api-overhead.rst @@ -0,0 +1,99 @@ +.. _minimize-itt-api-overhead: + +Minimize ITT API Overhead +========================= + + +The ITT API overhead and its impact on the overall application +performance depends on the amount of instrumentation code added to the +application. When instrumenting an application with ITT API, you should +balance between application performance and the amount of performance +data that you need to collect, in order to minimize API overhead while +collecting sufficient performance data. + + +Follow these guidelines to achieve good balance between overall +performance of the instrumented application and instrumentation detail: + + +- Instrument only those paths within your application that are + important for analysis. +- Create ITT domains and string handles outside the critical paths. +- Filter data collection by different aspects of your application that + can be analyzed separately. The overhead for a disabled API call + (thus filtering out the associated call) is always less than 10 clock + ticks, regardless of the API. + + +Conditional Compilation +----------------------- + + +For best performance in the release version of your code, use +conditional compilation to turn off annotations. Define the macro +INTEL_NO_ITTNOTIFY_API before you include ittnotify.h during compilation +to eliminate all \__itt_\* functions from your code. + + +You can also remove the static library from the linking stage by +defining this macro. + + +Usage Example: Using Domains and String Handles +----------------------------------------------- + + +The ITT APIs include a subset of functions which create domains and +string handles. These functions always return identical handles for the +same domain names and strings. This requires these functions to perform +string comparisons and table lookups, which can incur serious +performance penalties. In addition, the performance of these functions +is proportional to the log of the number of created domains or string +handles. It is best to create domains and string handles at global +scope, or during application startup. + + +The following code section creates two domains in the global scope. You +can use these domains to control the level of detail that is written to +the trace file. + + +.. code:: cpp + + + __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); + __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); + // Create string handles at global scope. + __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); + void MyFunction(int arg) + { + __itt_task_begin(basic, __itt_null, __itt_null, h_my_function); + Foo(arg); + FooEx(); + __itt_task_end(basic); + } + __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); + void Foo(int arg) + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo); + // Do some work here... + __itt_task_end(detailed); + } + __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); + void FooEx() + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo_ex); + // Do some work here... + __itt_task_end(detailed); + } + // This is my entry point. + int main(int argc, char** argv) + { + if(argc < 2) + //Disable detailed domain if we do not need tracing from that in this + //application run + detailed ->flags = 0; + MyFunction(atoi(argv[1])); } + diff --git a/docs/vtune-user-guide/string-handle-api.rst b/docs/vtune-user-guide/string-handle-api.rst new file mode 100644 index 00000000..b0057d6a --- /dev/null +++ b/docs/vtune-user-guide/string-handle-api.rst @@ -0,0 +1,38 @@ +.. _string-handle-api: + +String Handle API +================= + + +Many API calls require names to identify API objects. String handles are +pointers to names. They enable efficient handling of named objects in +run time and make collected traces data more compact. + + +**To create and return a handle value that can be associated with a +string, use the following primitive:** + + +``__itt_string_handle *ITTAPI__itt_string_handle_create ( const char *name)`` + + +Consecutive calls to ``__itt_string_handle_create`` with the same name +return the same value. The set of string handles is expected to remain +static during the application's execution time, therefore, there is no +mechanism to destroy a string handle. Any string handle can be accessed +by any thread in the process, regardless of which thread created the +string handle. This call is thread-safe. + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *name*\ + - The input string + + + diff --git a/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst b/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst new file mode 100644 index 00000000..69bc8642 --- /dev/null +++ b/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst @@ -0,0 +1,68 @@ +.. _support-for-instrumentation-and-tracing-technology-api-itt-api: + +Support for Instrumentation and Tracing Technology API (ITT API) +================================================================ + + +.. note:: + + + The Instrumentation and Tracing Technology API (ITT API) and the + Just-in-Time Profiling API (JIT API) are open source components. + Visit the `GitHub\* repository `__ + to access source code and contribute. + + +The Instrumentation and Tracing Technology API (ITT API) provided by the +Intel® VTune™ Profiler enables your application to generate and control +the collection of trace data during its execution. + + +ITT API has the following features: + + +- Controls application performance overhead based on the amount of + traces that you collect. +- Enables trace collection without recompiling your application. +- Supports applications in C/C++ and Fortran environments on Windows*, + Linux*, FreeBSD*, or Android\* systems. +- Supports instrumentation for tracing application code. + + +To use the APIs, add API calls in your code to designate logical tasks. +These markers will help you visualize the relationship between tasks in +your code relative to other CPU and GPU tasks. To see user tasks in your +performance analysis results, enable the **Analyze user tasks** checkbox +in analysis settings. + + +.. note:: + + + The ITT API is a set of pure C/C++ functions. There are no Java\* or + .NET\* APIs. If you need runtime environment support, you can use a + JNI, or C/C++ function call from the managed code. If the collector + causes significant overhead or data storage, you can pause the + analysis to reduce the overhead. + + +See Also +-------- + + +.. container:: linklist + + + `Task Analysis `__ + + +`View Instrumentation and Tracing Technology (ITT) API Task Data in +Intel® VTune™ +Profiler `__ + +.. toctree:: + :maxdepth: 1 + + + basic-usage-and-configuration + instrumentation-and-tracing-technology-api-reference \ No newline at end of file diff --git a/docs/vtune-user-guide/task-api.rst b/docs/vtune-user-guide/task-api.rst new file mode 100644 index 00000000..02e8a0c4 --- /dev/null +++ b/docs/vtune-user-guide/task-api.rst @@ -0,0 +1,176 @@ +.. _task-api: + +Task API +======== + + +A *task* is a logical unit of work performed by a particular thread. +Tasks can nest; thus, tasks typically correspond to functions, scopes, +or a case block in a switch statement. You can use the Task API to +assign tasks to threads. + + +Task API is a per-thread function that works in resumed state. This +function does not work in paused state. + + +The Task API does not enable a thread to suspend the current task and +switch to a different task (task switching), or move a task to a +different thread (task stealing). + + +A task instance represents a piece of work performed by a particular +thread for a period of time. The task is defined by the bracketing of +\__itt_task_begin() and \__itt_task_end() on the same thread. + + +.. note:: + + + To be able to see user tasks in your results, enable the **Analyze + user tasks** checkbox in analysis settings. + + +Task API Functions +------------------ + + +Create a task instance on a thread. This becomes the current task +instance for that thread. A call to\ ``__itt_task_end()`` on the same +thread ends the current task instance. + + +``void __itt_task_begin (const __itt_domain *domain,__itt_id taskid, __itt_id parentid, __itt_string_handle *name)`` + + +Trace the end of the current task. + + +``void __itt_task_end (const __itt_domain *domain)`` + + +``ITTAPI__itt_task_*`` Function Parameters +------------------------------------------ + + +The following table defines the parameters used in the Task API +primitives. + + +.. list-table:: + :header-rows: 0 + + * - Type + - Parameter + - Description + * - ``[in]`` + - \ ``__itt_domain``\ + - The domain of the task. + * - ``[in]`` + - \ ``__itt_id taskid``\ + - This is a reserved parameter. + * - ``[in]`` + - \ ``__itt_id parentid``\ + - This is a reserved parameter. + * - ``[in]`` + - \ ``__itt_string_handle``\ + - The task string handle. + + + + +Enable Task APIs +---------------- + + +The following steps are required to begin using task APIs: + + +#. Include ``ittnotify.h`` header. +#. Create domain and string handles for your tasks. +#. Insert task begin and task end marks in your code. +#. Link to ``libittnotify.lib`` (Windows*) or ``libittnotify.a`` + (Linux*). +#. Enable the **Analyze user tasks, events, and counters** option before + profiling. For more information, see `Task + Analysis `__ topic. + + +Usage Example +------------- + + +The following code snippet creates a domain and a couple of tasks at +global scope. + + +.. code:: cpp + + + #include "ittnotify.h" + + + void do_foo(double seconds); + + + __itt_domain* domain = __itt_domain_create("MyTraces.MyDomain"); + __itt_string_handle* shMyTask = __itt_string_handle_create("My Task"); + __itt_string_handle* shMySubtask = __itt_string_handle_create("My SubTask"); + + + void BeginFrame() { + __itt_task_begin(domain, __itt_null, __itt_null, shMyTask); + do_foo(1); + } + + + void DoWork() { + __itt_task_begin(domain, __itt_null, __itt_null, shMySubtask); + do_foo(1); + __itt_task_end(domain); + } + void EndFrame() { + do_foo(1); + __itt_task_end(domain); + } + + + int main() { + BeginFrame(); + DoWork(); + EndFrame(); + return 0; + } + + + #ifdef _WIN32 + #include + + + void do_foo(double seconds) { + clock_t goal = (clock_t)((double)clock() + seconds * CLOCKS_PER_SEC); + while (goal > clock()); + } + #else + #include + + + #define NSEC 1000000000 + #define TYPE long + + + void do_foo(double sec) { + struct timespec start_time; + struct timespec current_time; + + + clock_gettime(CLOCK_REALTIME, &start_time); + while(1) { + clock_gettime(CLOCK_REALTIME, ¤t_time); + TYPE cur_nsec=(long)((current_time.tv_sec-start_time.tv_sec-sec)*NSEC + current_time.tv_nsec - start_time.tv_nsec); + if(cur_nsec>=0) + break; + } + } + #endif + diff --git a/docs/vtune-user-guide/thread-naming-api.rst b/docs/vtune-user-guide/thread-naming-api.rst new file mode 100644 index 00000000..b2e12152 --- /dev/null +++ b/docs/vtune-user-guide/thread-naming-api.rst @@ -0,0 +1,84 @@ +.. _thread-naming-api: + +Thread Naming API +================= + + +By default, each thread in your application displays in the **timeline** +track with a default label generated from the process ID and the thread +ID, or with the OS thread name. You can use the Thread Naming API in +your code to give meaningful names to threads. + + +Thread Naming API is a per-thread function that works in all states +(paused or resumed). You must call this API from within the thread. + + +To set thread name using a char or Unicode string, use the primitive: + + +``void __itt_thread_set_name (const __itt_char *name)`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ ``name``\ + - The thread name + + + + +**To indicate that this thread should be ignored from analysis:** + + +``void __itt_thread_ignore (void)`` + + +It does not affect the concurrency of the application. It does not be +visible in the **Timeline** pane. + + +If the thread name is set multiple times, only the last name is used. + + +Usage Example +------------- + + +You can use the following thread naming example to give a meaningful +name to the thread you wish to focus on and ignore the service thread. + + +.. code:: cpp + + + DWORD WINAPI service_thread(LPVOID lpArg) + { + __itt_thread_ignore(); + // Do service work here. This thread will not be displayed. + return 0; + } + + + DWORD WINAPI thread_function(LPVOID lpArg) + { + __itt_thread_set_name("My worker thread"); + // Do thread work here + return 0; + } + + + int main(int argc, char* argv[]) + { + ... + CreateThread(NULL, 0, service_thread, NULL, 0, NULL); + CreateThread(NULL, 0, thread_function, NULL, 0, NULL); + ... + return 0; + } + diff --git a/docs/vtune-user-guide/user-defined-synchronization-api.rst b/docs/vtune-user-guide/user-defined-synchronization-api.rst new file mode 100644 index 00000000..ba89e35b --- /dev/null +++ b/docs/vtune-user-guide/user-defined-synchronization-api.rst @@ -0,0 +1,363 @@ +.. _user-defined-synchronization-api: + +User-Defined Synchronization API +================================ + + +While the Intel® VTune™ Profiler supports a significant portion of the +Windows\* OS and POSIX\* APIs, it is often useful for you to define your +own synchronization constructs. Any specially built constructs that you +create are not normally tracked by the VTune Profiler. However, the +VTune Profiler includes the synchronization API to help you gather +statistical information related to user-defined synchronization +constructs. + + +The User-Defined Synchronization API is a per-thread function that works +in resumed state. This function does not work in paused state. + + +Synchronization constructs may generally be modeled as a series of +signals. One thread or many threads may wait for a signal from another +group of threads telling them they may proceed with some action. By +tracking when a thread begins waiting for a signal, and then noting when +the signal occurs, the synchronization API can take a user-defined +synchronization object and give you an understanding of your code. The +API uses memory handles along with a set of primitives to gather +statistics on the user-defined synchronization object. + + +.. note:: + + + The User-Defined Synchronization API works with the **Threading** + analysis type. + + +- `Using User-Defined Synchronization API in Your + Code <#USING_USER-DEFINED_SYNC>`__ + + +- `Usage Example: User-Defined + Spin-Waits <#EXAMPLE_USER-DEFINED_SPIN-WAITS>`__ + + +- `Usage Example: User-Defined Synchronized Critical + Section <#EXAMPLE_USER-DEFINED_CRITICAL_SECTION>`__ + + +- `Usage Example: User-Level Synchronized + Barrier <#EXAMPLE_SYNCHRONIZED_BARRIER>`__ + + +Using User-Defined Synchronization API in Your Code +--------------------------------------------------- + + +The following table describes the user-defined synchronization API +primitives, available for use on Windows\* and Linux\* operating +systems: + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_sync_create (void *addr, const __itt_char *objtype, const __itt_char *objname, int attribute)``\ + - Register the creation of a sync object using char or Unicode string. + * - ``void __itt_sync_rename (void *addr, const __itt_char *name)`` + - Assign a name to a sync object using char or Unicode string, after it was created. + * - \ ``void __itt_sync_destroy (void *addr)``\ + - Track lifetime of the destroyed object. + * - \ ``void __itt_sync_prepare (void *addr)``\ + - Enter spin loop on user-defined sync object. + * - \ ``void __itt_sync_cancel (void *addr)``\ + - Quit spin loop without acquiring spin object. + * - \ ``void __itt_sync_acquired (void *addr)``\ + - Define successful spin loop completion (sync object acquired). + * - \ ``void __itt_sync_releasing (void *addr)``\ + - Start sync object releasing code. This primitive is called before the lock release call. + + + + +Each API call has a single parameter, addr. The address, not the value, +is used to differentiate between two or more distinct custom +synchronization objects. Each unique address enables the VTune Profiler +to track a separate custom object. Therefore, to use the same custom +object to protect access in different parts of your code, use the same +addr parameter around each. + + +When properly embedded in your code, the primitives tell the VTune +Profiler when the code is attempting to perform some type of +synchronization. Each prepare primitive must be paired with a cancel or +acquired primitive. + + +Each user-defined synchronization construct may involve any number of +synchronization objects. Each synchronization object must be triggered +off of a unique memory handle, which the user-defined synchronization +API uses to track the object. Any number of synchronization objects may +be tracked at one time using the user-defined synchronization API, as +long as each object uses a unique memory pointer. You can think of this +as modeling objects similar to the WaitForMultipleObjects function in +the Windows\* OS API. You can create more complex synchronization +constructs out of a group of synchronization objects; however, it is not +advisable to interlace different user-defined synchronization constructs +as this results in incorrect behavior. + + +|image1|\ API Usage Tips +------------------------ + + +The user-defined synchronization API requires proper placement of the +primitives within your code. Appropriate usage of the user-defined +synchronization API can be accomplished by following these guidelines: + + +- Put a prepare primitive immediately before the code that attempts to + obtain access to a synchronization object. + + +- Put either a cancel primitive or an acquired primitive immediately + after your code is no longer waiting for a synchronization object. + + +- The releasing primitive should be used immediately before the code + signals that it no longer holds a synchronization object. + + +- When using multiple prepare primitives to simulate any construct that + waits for multiple objects, the last individual cancel or acquired + primitive on an object related to the group of prepare primitives + determines if the behavior of the construct is a cancel or acquired + respectively. + + +- The time between a prepare primitive and an acquired primitive may be + considered impact time + + +- The time between a prepare primitive and a cancel primitive is + considered blocking time, even though the processor does not + necessarily block. + + +- Improper use of the user-defined synchronization API results in + incorrect statistical data. + + +Usage Example: User-Defined Spin-Waits +-------------------------------------- + + +The prepare API indicates to the VTune Profiler that the current thread +is about to begin waiting for a signal on a memory location. This call +must occur before you invoke the user synchronization construct. The +prepare API must always be paired with a call to either the acquired or +cancel API. + + +The following code snippet shows the use of the prepare and acquired API +used in conjunction with a user-defined spin-wait construct: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_prepare((void *) &spin ); + while(ResourceBusy); + // spin wait; + __itt_sync_acquired((void *) &spin ); + + +Using the cancel API may be applicable to other scenarios where the +current thread tests the user synchronization construct and decides to +do something useful instead of waiting for a signal from another thread. +See the following code example: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_prepare((void *) &spin ); + while(ResourceBusy) + { +     __itt_sync_cancel((void *) &spin ); +      + +     // +     // Do useful work +     // +     . . . . . +     . . . . . +     // +     // Once done with the useful work, this construct will test the +     // lock variable and try to acquire it again. Before this can +     // be done, a call to the prepare API is required. +     // +     __itt_sync_prepare((void *) &spin ); + } + __itt_sync_acquired((void *) &spin); + + +After you acquire a lock, you must call the releasing API before the +current thread releases the lock. The following example shows how to use +the releasing API: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_releasing((void *) &spin ); + // Code here should free the resource + + +Usage Example: User-Defined Synchronized Critical Section +--------------------------------------------------------- + + +The following code snippet shows how to create a critical section +construct that can be tracked using the user-defined synchronization +API: + + +.. code:: cpp + + + CSEnter() + { +   __itt_sync_prepare((void*) &cs); +   while(LockIsUsed) +   { +     if(LockIsFree) +     { +     // Code to actually acquire the lock goes here +     __itt_sync_acquired((void*) &cs); +     } +     if(timeout) +     { +     __itt_sync_cancel((void*) &cs ); +     } +   } + } + CSLeave() + { + if(LockIsMine) +     { +         __itt_sync_releasing((void*) &cs); +         // Code to actually release the lock goes here +     } + } + + +This simple critical section example demonstrates how to use the +user-defined synchronization primitives. When looking at this example, +note the following points: + + +- Each prepare primitive is paired with an acquired primitive or a + cancel primitive. + + +- The prepare primitive is placed immediately before the user code + begins waiting for the user lock. + + +- The acquired primitive is placed immediately after the user code + actually obtains the user lock. + + +- The releasing primitive is placed before the user code actually + releases the user lock. This ensures that another thread does not + call the acquired primitive before the VTune Profiler realizes that + this thread has released the lock. + + +Usage Example: User-Level Synchronized Barrier +---------------------------------------------- + + +Higher level constructs, such as barriers, are also easy to model using +the synchronization API. The following code snippet shows how to create +a barrier construct that can be tracked using the synchronization API: + + +.. code:: cpp + + + Barrier() + { + teamflag = false; + __itt_sync_releasing((void *) &counter); + InterlockedIncrement(&counter); // use the atomic increment primitive appropriate to your OS and compiler + + + if( counter == thread count ) + { + __itt_sync_acquired((void *) &counter); + __itt_sync_releasing((void *) &teamflag); + teamflag = true; + counter = 0; + } + else + { + __ itt_sync_prepare((void *) &teamflag); + Wait for team flag + __ itt_sync_acquired((void *) &teamflag); + } + } + + +When looking at this example, note the following points: + + +- There are two synchronization objects in this barrier code. The + counter object is used to do a gather-like signaling from all the + threads to the final thread indicating that each thread has entered + the barrier. Once the last thread hits the barrier it uses the + teamflag object to signal all the other threads that they may + proceed. + + +- As each thread enters the barrier it calls \__itt_sync_releasing to + tell the VTune Profiler that it is about to signal the last thread by + incrementing counter + + +- The last thread to enter the barrier calls \__itt_sync_acquired to + tell the VTune Profiler that it was successfully signaled by all the + other threads. + + +- The last thread to enter the barrier calls \__itt_sync_releasing to + tell the VTune Profiler that it is going to signal the barrier + completion to all the other threads by setting teamflag + + +- Each thread, except the last, calls the \__itt_sync_prepare primitive + to tell the VTune Profiler that it is about to start waiting for the + teamflag signal from the last thread. + + +- Finally, before leaving the barrier, each thread calls the + \__itt_sync_acquired primitive to tell the VTune Profiler that it + successfully received the end-of-barrier signal. + + +.. |image1| image:: GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif + :width: 25px + :height: 18px + diff --git a/docs/vtune-user-guide/using-jit-profiling-api.rst b/docs/vtune-user-guide/using-jit-profiling-api.rst new file mode 100644 index 00000000..6d14f9d3 --- /dev/null +++ b/docs/vtune-user-guide/using-jit-profiling-api.rst @@ -0,0 +1,195 @@ +.. _using-jit-profiling-api: + +Using JIT Profiling API +======================= + + +To include JIT Profiling support, do one of the following: + + +- + + + .. container:: + :name: LI_DB9BBDF5654E49BA9743FA34A8BEFC9C + + + Include the following files to your source tree: + + + - + + + .. container:: + :name: LI_EABD97D44F984162B38420A57167AC5B + + + ``jitprofiling.h``, located under \include + (Windows*) or /include (Linux*) + + + - + + + .. container:: + :name: LI_6E4F12C743D144E4A1515F4829612FB3 + + + ``ittnotify_config.h``, ``ittnotify_types.h`` and + ``jitprofiling.c``, located under + \sdk\src\ittnotify (Windows*) or + /sdk/src/ittnotify (Linux*) + + + .. note:: + + + To locate your see `Installation + Directory <#INSTALL-DIR-JIT>`__. + + +- + + + .. container:: + :name: LI_1B044705871E4F2F90A3733AAB95D071 + + + Use the static library provided with the product: + + + #. + + + .. container:: + :name: LI_EBB0F0A78ADC45FD973DB21B3CEFF629 + + + Include\ ``jitprofiling.h`` file, located under the + \include (Windows*) or /include + (Linux*) directory, in your code. This header file provides + all API function prototypes and type definitions. + + + #. + + + .. container:: + :name: LI_C273EB329F1449B2A460BED51529BC6B + + + Link to ``jitprofiling.lib`` (Windows*) or + ``jitprofiling.a`` (Linux*), located under + \lib32or \lib64 (Windows*) or + /lib32 or /lib32 (Linux*). + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``int iJIT_NotifyEvent( iJIT_JVM_EVENT event_type, void *EventSpecificData );``\ + - Use this API to send a notification of ``event_type`` with the data pointed by ``EventSpecificData`` to the agent. The reported information is used to attribute samples obtained from any Intel® VTune™ Profiler collector. + * - \ ``unsigned int iJIT_GetNewMethodID( void );``\ + - Generate a new method ID. You must use this function to assign unique and valid method IDs to methods reported to the profiler. This API returns a new unique method ID. When out of unique method IDs, this API function returns 0. + * - \ ``iJIT_IsProfilingActiveFlags iJIT_IsProfilingActive( void );``\ + - Returns the current mode of the profiler: off, or sampling, using the ``iJIT_IsProfilingActiveFlags`` enumeration. This API returns ``iJIT_SAMPLING_ON`` by default, indicating that Sampling is running. It returns ``iJIT_NOTHING_RUNNING`` if no profiler is running. + + + + +Lifetime of Allocated Data +-------------------------- + + +You send an event notification to the agent (VTune Profiler) with +event-specific data, which is a structure. The pointers in the structure +refer to memory you allocated and you are responsible for releasing it. +The pointers are used by the ``iJIT_NotifyEvent`` method to copy your +data in a trace file, and they are not used after the +``iJIT_NotifyEvent`` method returns. + + +JIT Profiling API Sample Application +------------------------------------ + + +VTune Profiler is installed with a sample application in the +``jitprofiling_vtune_amp_xe.zip`` (Windows*) or +``jitprofiling_vtune_amp_xe.tgz`` (Linux*) that emulates the creation +and execution of dynamic code. In addition, it uses the JIT profiling +API to notify the VTune Profiler when it transfers execution control to +dynamic code. + + +**To install and set up the sample code:** + + +#. Copy the ``jitprofiling_vtune_amp_xe.zip`` (Windows*) or + ``jitprofiling_vtune_amp_xe.tgz`` (Linux*) file from the + \samples\\C++ (Windows*) or + /samples//C++ (Linux*)directory to a writable + directory or share on your system. +#. Extract the sample from the archive file. + + +Build jitprofiling.c in Microsoft Visual Studio\* +------------------------------------------------- + + +#. Copy the ``jitprofiling_vtune_amp_xe.zip`` file from the + \samples\\C++ directory to a writable directory + or share on your system. +#. Extract the sample from the ``.zip`` file. +#. Open the ``jitprofiling.sln`` file with Microsoft Visual Studio. +#. Right-click **jitprofiling** in the **Solution Explorer** and select + **Properties**. The **jitprofiling Property Pages** window opens. +#. Set the **Platform** (top of the window) to **x64**. +#. Select **Configuration Properties** > **C/C++** > **General** and add + the path to the headers (````/include) to **Additional + Include Directories**. +#. Select **Configuration Properties** > **C/C++** > **Linker** > + **General** and add the path to the library (````/lib32 + or ````/lib64) to **Additional Library Directories**. +#. Click **OK** to apply the changes and close the window. +#. Rebuild the solution with the new project settings. + + +Installation Information +------------------------ + + +Follow these instructions in the Installation Guide to install VTune +Profiler on: + + +- `Windows + host `__ +- `Linux + host `__ + + +Whether you download Intel® VTune™ Profiler as a standalone component or +with the Intel® oneAPI Base Toolkit, the default path for your +```` is: + + +.. list-table:: + :header-rows: 0 + + * - Operating System + - Path to + * - Windows\* OS + - + * - Linux\* OS + - + + + + +Make sure that your installation of Intel® VTune™ Profiler has also +installed the `sampling +drivers `__ +necessary for data collection. + diff --git a/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst b/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst new file mode 100644 index 00000000..f7fd6643 --- /dev/null +++ b/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst @@ -0,0 +1,130 @@ +.. _view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler: + +View Instrumentation and Tracing Technology (ITT) API Task Data in Intel® VTune™ Profiler +========================================================================================= + + +User task and API data can be visualized in Intel® VTune™ Profiler +performance analysis results. + + +After you have added basic annotations to your application to control +performance data collection, you can view these annotations in the Intel +VTune Profiler timeline. All supported instrumentation and tracing +technology (ITT) API tasks can be visualized in VTune Profiler. + + +Use the following steps to include ITT API tasks in your performance +analysis collection: + + +#. + + + .. container:: + :name: LI_0A72C46E11A64608A344009FE3604A58 + + + Click the |image1| (standalone GUI)/|image2| (Visual Studio IDE) + **Configure Analysis** button on the Intel® VTune™ Profiler + toolbar. + + + The **Configure Analysis** window opens. + + +#. Set up the analysis target in the **WHERE** and **WHAT** panes. + + +#. + + + .. container:: + :name: LI_235EFD2738DB45079C9BA80E38C3EB1B + + + From **HOW** pane, click the |image3| Browse button and select an + analysis type. For more information about each analysis type, see + `Performance Analysis + Setup `__. + + +#. Select the **Analyze user tasks, events, and counters** checkbox to + view the API tasks, counters, and events that you added to your + application code. + + + .. note:: + + + In some cases, the **Analyze user tasks, events, and counters** + checkbox is in the expandable **Details** section. To enable the + checkbox, use the **Copy** button at the top of the tab to create + an editable version of the analysis type configuration. For more + information, see `Custom + Analysis `__ . + + +#. Click the |image4| Start button to `run the + analysis `__. + + +After collection completes, the analysis results appear in a viewpoint +specific to the analysis type selected. The API data collected is +available in the following locations: + + +- + + + .. container:: + :name: LI_5EF5EAB8A8BB4C07BDB94F5795C0709A + + + Timeline view: Each API type appears differently on the timeline + view. In the example below, the code was instrumented with the + task API, frame API, event API, and collection control API. Tasks + appear as yellow bars on the task thread. Frames appear at the top + of the timeline in pink. Events appear on the appropriate thread + as a triangle at the event time. Collection control events span + the entire timeline. Hover over a task, frame, or event to view + the type of API task. + + + .. image:: GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png + + +- + + + .. container:: + :name: LI_A7EED03FA1734E9897CB44961C34A900 + + + Grid view: Set the **Grouping** to **Task Domain / Task Type / + Function / Call Stack** or **Task Type / Function / Call Stack** + to view task data in the grid pane. + + + .. image:: GUID-1ABE0C25-5938-4D25-8D9E-F2004C907256-low.png + + +- + + + .. container:: + :name: LI_DF180FC79C644C788EF43E19B028ED7C + + + Platform tab: Individual tasks are available in a larger view on + the **Platform** tab. Hover over a task to get more information. + + + .. image:: GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png + + +.. |image1| image:: GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png +.. |image2| image:: GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png +.. |image3| image:: GUID-682C1D59-20E8-4428-AF7A-23727182579B-low.png +.. |image4| image:: GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png + diff --git a/docs/vtune-user-guide/vtune-user-guide.rst b/docs/vtune-user-guide/vtune-user-guide.rst new file mode 100644 index 00000000..a6916cfe --- /dev/null +++ b/docs/vtune-user-guide/vtune-user-guide.rst @@ -0,0 +1,31 @@ +.. _vtune-user-guide: + +******************** +API Support in VTune +******************** +.. toctree:: + :maxdepth: 1 + + /vtune-user-guide/api-support.rst + /vtune-user-guide/compile-and-link-with-ittapi.rst + /vtune-user-guide/basic-usage-and-configuration.rst + /vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst + /vtune-user-guide/using-jit-profiling-api.rst + /vtune-user-guide/jit-profiling-api-reference.rst + + +Add-ons +======= +.. toctree:: + :maxdepth: 1 + + /vtune-user-guide/minimize-itt-api-overhead.rst + /vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst + /vtune-user-guide/attach-itt-apis-to-a-launched-application.rst + + +API support for other program languages +======================================= + +- `RUST ITT API bindings `_ +- `Python ITT API bindings `_ From 132887d12c8532a44b9e81a2e7136b2ee9961cb5 Mon Sep 17 00:00:00 2001 From: Parshutin Date: Fri, 25 Apr 2025 20:57:53 +0200 Subject: [PATCH 2/7] doc: huge refactoring --- .github/workflows/deploy-docs.yml | 2 +- README.md | 17 +- docs/conf.py | 4 +- .../compile-and-link-with-itt-api.rst | 129 ---- docs/gpa-user-guide/counter-api.rst | 113 --- docs/gpa-user-guide/domain-api.rst | 81 -- docs/gpa-user-guide/gpa-user-guide.rst | 83 -- .../instrumenting-your-application.rst | 137 ---- .../minimizing-itt-api-overhead.rst | 88 --- docs/gpa-user-guide/string-handle-api.rst | 46 -- docs/gpa-user-guide/thread-naming-api.rst | 71 -- docs/index.rst | 43 +- docs/src/api-support.rst | 33 + docs/src/build.rst | 57 ++ docs/src/compile-and-link-with-itt-api.rst | 167 ++++ .../instrument-your-application.rst | 237 +++--- docs/src/itt-api-reference.rst | 26 + docs/src/itt-api-support.rst | 43 ++ .../ittapi}/clock-domain-api.rst | 0 .../ittapi}/collection-control-api.rst | 242 +++--- .../ittapi}/context-metadata-api.rst | 430 +++++------ .../ittapi}/counter-api.rst | 326 ++++---- .../ittapi}/domain-api.rst | 130 ++-- .../ittapi}/event-api.rst | 258 +++---- .../ittapi}/frame-api.rst | 338 ++++---- .../ittapi/histogram-api-schema.png} | Bin .../ittapi}/histogram-api.rst | 374 ++++----- .../ittapi}/load-module-api.rst | 78 +- .../ittapi}/marker-api.rst | 0 .../ittapi}/memory-allocation-apis.rst | 268 +++---- .../ittapi}/metadata-api.rst | 0 .../ittapi}/relation-api.rst | 0 .../ittapi}/string-handle-api.rst | 76 +- .../ittapi}/task-api.rst | 37 +- .../ittapi}/thread-naming-api.rst | 168 ++-- .../user-defined-synchronization-api.rst | 721 +++++++++--------- docs/src/jit-api-reference.rst | 13 + .../jit-api-support.rst} | 638 ++++++++-------- .../jitapi}/ijit_-getnewmethodid.rst | 82 +- .../jitapi}/ijit_isprofilingactive.rst | 78 +- .../jitapi}/ijit_notifyevent.rst | 552 +++++++------- .../minimize-itt-api-overhead.rst | 198 ++--- docs/src/overview.rst | 27 + docs/src/ref_collector.rst | 67 ++ docs/src/using-jit-api.rst | 119 +++ ...002AF5-830E-43B6-9CA1-A5015F87329D-low.png | Bin 1187 -> 0 bytes ...BE0C25-5938-4D25-8D9E-F2004C907256-low.png | Bin 49420 -> 0 bytes ...0BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif | Bin 357 -> 0 bytes ...FC2DCE-141C-4709-9F29-7D143D40EEB9-low.png | Bin 262 -> 0 bytes ...4B6013-D1E9-4593-B9EC-85791339769D-low.png | Bin 668 -> 0 bytes ...2C1D59-20E8-4428-AF7A-23727182579B-low.png | Bin 955 -> 0 bytes ...B262AE-A77B-442B-9592-1EFA506C7128-low.png | Bin 29883 -> 0 bytes ...F7E148-45E3-4669-9D09-091ADEA45BBA-low.png | Bin 21246 -> 0 bytes docs/vtune-user-guide/api-support.rst | 28 - ...ach-itt-apis-to-a-launched-application.rst | 98 --- .../basic-usage-and-configuration.rst | 72 -- .../compile-and-link-with-ittapi.rst | 51 -- .../configure-your-build-system.rst | 204 ----- ...n-and-tracing-technology-api-reference.rst | 26 - .../jit-profiling-api-reference.rst | 12 - ...ion-and-tracing-technology-api-itt-api.rst | 68 -- docs/vtune-user-guide/task-api.rst | 176 ----- .../using-jit-profiling-api.rst | 195 ----- ...-api-task-data-in-intel-vtune-profiler.rst | 130 ---- docs/vtune-user-guide/vtune-user-guide.rst | 31 - 65 files changed, 3195 insertions(+), 4493 deletions(-) delete mode 100644 docs/gpa-user-guide/compile-and-link-with-itt-api.rst delete mode 100644 docs/gpa-user-guide/counter-api.rst delete mode 100644 docs/gpa-user-guide/domain-api.rst delete mode 100644 docs/gpa-user-guide/gpa-user-guide.rst delete mode 100644 docs/gpa-user-guide/instrumenting-your-application.rst delete mode 100644 docs/gpa-user-guide/minimizing-itt-api-overhead.rst delete mode 100644 docs/gpa-user-guide/string-handle-api.rst delete mode 100644 docs/gpa-user-guide/thread-naming-api.rst create mode 100644 docs/src/api-support.rst create mode 100644 docs/src/build.rst create mode 100644 docs/src/compile-and-link-with-itt-api.rst rename docs/{vtune-user-guide => src}/instrument-your-application.rst (69%) create mode 100644 docs/src/itt-api-reference.rst create mode 100644 docs/src/itt-api-support.rst rename docs/{gpa-user-guide => src/ittapi}/clock-domain-api.rst (100%) rename docs/{vtune-user-guide => src/ittapi}/collection-control-api.rst (96%) rename docs/{vtune-user-guide => src/ittapi}/context-metadata-api.rst (96%) rename docs/{vtune-user-guide => src/ittapi}/counter-api.rst (78%) rename docs/{vtune-user-guide => src/ittapi}/domain-api.rst (96%) rename docs/{vtune-user-guide => src/ittapi}/event-api.rst (96%) rename docs/{vtune-user-guide => src/ittapi}/frame-api.rst (74%) rename docs/{vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png => src/ittapi/histogram-api-schema.png} (100%) rename docs/{vtune-user-guide => src/ittapi}/histogram-api.rst (94%) rename docs/{vtune-user-guide => src/ittapi}/load-module-api.rst (97%) rename docs/{gpa-user-guide => src/ittapi}/marker-api.rst (100%) rename docs/{vtune-user-guide => src/ittapi}/memory-allocation-apis.rst (95%) rename docs/{gpa-user-guide => src/ittapi}/metadata-api.rst (100%) rename docs/{gpa-user-guide => src/ittapi}/relation-api.rst (100%) rename docs/{vtune-user-guide => src/ittapi}/string-handle-api.rst (96%) rename docs/{gpa-user-guide => src/ittapi}/task-api.rst (86%) rename docs/{vtune-user-guide => src/ittapi}/thread-naming-api.rst (95%) rename docs/{vtune-user-guide => src/ittapi}/user-defined-synchronization-api.rst (95%) create mode 100644 docs/src/jit-api-reference.rst rename docs/{vtune-user-guide/jit-profiling-api.rst => src/jit-api-support.rst} (66%) rename docs/{vtune-user-guide => src/jitapi}/ijit_-getnewmethodid.rst (87%) rename docs/{vtune-user-guide => src/jitapi}/ijit_isprofilingactive.rst (80%) rename docs/{vtune-user-guide => src/jitapi}/ijit_notifyevent.rst (69%) rename docs/{vtune-user-guide => src}/minimize-itt-api-overhead.rst (95%) create mode 100644 docs/src/overview.rst create mode 100644 docs/src/ref_collector.rst create mode 100644 docs/src/using-jit-api.rst delete mode 100644 docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png delete mode 100644 docs/vtune-user-guide/GUID-1ABE0C25-5938-4D25-8D9E-F2004C907256-low.png delete mode 100644 docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif delete mode 100644 docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png delete mode 100644 docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png delete mode 100644 docs/vtune-user-guide/GUID-682C1D59-20E8-4428-AF7A-23727182579B-low.png delete mode 100644 docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png delete mode 100644 docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png delete mode 100644 docs/vtune-user-guide/api-support.rst delete mode 100644 docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst delete mode 100644 docs/vtune-user-guide/basic-usage-and-configuration.rst delete mode 100644 docs/vtune-user-guide/compile-and-link-with-ittapi.rst delete mode 100644 docs/vtune-user-guide/configure-your-build-system.rst delete mode 100644 docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst delete mode 100644 docs/vtune-user-guide/jit-profiling-api-reference.rst delete mode 100644 docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst delete mode 100644 docs/vtune-user-guide/task-api.rst delete mode 100644 docs/vtune-user-guide/using-jit-profiling-api.rst delete mode 100644 docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst delete mode 100644 docs/vtune-user-guide/vtune-user-guide.rst diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 3485f5e0..760dba95 100755 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -4,7 +4,7 @@ on: push: branches: - master - - docs + - docs # TODO: delete before merge to the main repo paths: - 'docs/**' # Trigger only when the source docs files are modified diff --git a/README.md b/README.md index cdb2ac50..53ffbe0e 100644 --- a/README.md +++ b/README.md @@ -27,8 +27,11 @@ a BSD/GPLv2 dual license with every tool supporting ITT API. To build the library: - On Windows, Linux, FreeBSD and OSX: requires [cmake](https://cmake.org) to be set in `PATH` - - Windows: requires Visual Studio installed or requires [Ninja](https://github.com/ninja-build/ninja/releases) to be set in `PATH` - - To enable fortran support requires [Intel Fortran Compiler](https://www.intel.com/content/www/us/en/docs/fortran-compiler/get-started-guide/current/overview.html) installed + - Windows: requires Visual Studio installed or requires + [Ninja](https://github.com/ninja-build/ninja/releases) to be set in `PATH` + - To enable fortran support requires + [Intel Fortran Compiler](https://www.intel.com/content/www/us/en/docs/fortran-compiler/get-started-guide/current/overview.html) + installed - To list available build options execute: `python buildall.py -h` ``` usage: buildall.py [-h] [-d] [-c] [-v] [-pt] [-ft] [--force_bits] @@ -44,15 +47,21 @@ optional arguments: --vs specify visual studio version (Windows only) --cmake_gen specify cmake build generator (Windows only) ``` + +### Documentation + +For detailed documentation, please visit the +[ITT/JIT API Documentation Page](https://intel.github.io/ittapi) + ### License All code in the repo is dual licensed under GPLv2 and 3-Clause BSD licenses ### Contributing -To contribute, please see our [contributing guide](CONTRIBUTING.md) +To contribute, please see our [contributing guide](CONTRIBUTING.md) To report bugs or request enhancements, please use the "Issues" page on GitHub ### Security -Please refer to the [security policy](SECURITY.md) for reporting vulnerabilties. +Please refer to the [security policy](SECURITY.md) for reporting vulnerabilties diff --git a/docs/conf.py b/docs/conf.py index 19705cd2..d1fd9023 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -32,6 +32,8 @@ html_theme = 'sphinx_rtd_theme' html_theme_options = { - 'style_external_links': True, # Ensure external links are styled correctly + 'style_external_links': True, } +# TODO: change before merge to the main repo +# html_baseurl = 'https://intel.github.io/ittapi/' html_baseurl = 'https://eparshut.github.io/ittapi/' diff --git a/docs/gpa-user-guide/compile-and-link-with-itt-api.rst b/docs/gpa-user-guide/compile-and-link-with-itt-api.rst deleted file mode 100644 index 93bf3d78..00000000 --- a/docs/gpa-user-guide/compile-and-link-with-itt-api.rst +++ /dev/null @@ -1,129 +0,0 @@ -.. _compile-and-link-with-itt-api: - -Compile and Link with ITT API -============================= - - -Before instrumenting your application, configure your build system to be -able to reach the API headers and libraries: - - -- Add ``\sdk\include`` to your ``INCLUDE`` path -- Add ``\sdk\lib\x86`` to your 32-bit ``LIBRARIES`` - path -- Add ``\sdk\lib\x64`` to your 64-bit ``LIBRARIES`` - path - - -The default installation directory on Windows\* OS is -``C:\Program Files\IntelSWTools\GPA``. - - -Include the ITT API Header in Your Application ----------------------------------------------- - - -Add the following ``#include`` statements to every source file that you -want to instrument: - - -.. code-block:: cpp - - - #include - - -The ``ittnotify.h`` header contains definitions of ITT API routines and -important macros which provide the correct logic of API invocation from -a user application. - - -.. note:: - - - The\ ``ittnotify.h`` header defines many functions that are not - covered in this document. However, Intel® GPA supports only the - functions that are documented herein. - - -The ITT API is designed to incur almost zero overhead when tracing is -disabled. But if you need fully zero overhead, you can compile out all -ITT API calls from your application by defining the -INTEL_NO_ITTNOTIFY_API macro in your project at compile time, either on -the compiler command line, or in your source file, prior to including -the ``ittnotify.h``\ file. - - -Link the ``libittnotify.lib`` Static Library to Your Application ----------------------------------------------------------------- - - -You need to link the static library, ``libittnotify.lib``, to your -application. If tracing is enabled, this static library loads the ITT -API data collector and forwards ITT API instrumentation data to Intel -GPA.If tracing is disabled, the static library ignores ITT API calls, -providing nearly zero instrumentation overhead. - - -.. note:: - - - If you are running Intel® GPA on a system with a legacy version of - Microsoft\* Visual Studio*, you must have the corresponding security - updates installed to link against the dynamic version of the - ``libittnotify.lib`` static library: - - - .. list-table:: - :header-rows: 1 - - * - Microsoft\* Visual Studio\* Version - - Security Update - * - Microsoft Visual Studio 2005 - - KB2538218 - * - Microsoft Visual Studio 2008 - - KB2538241 - - - - -If you do not want to update your version of Visual Studio, you must -link the ``libittnotify.lib`` static library to your application. - - -UNICODE Support ---------------- - - -All ITT API functions with string arguments follow the Windows OS -UNICODE convention, the actual function names are suffixed with A for -the ASCII API and W for the UNICODE API. For example: - - -.. code-block:: cpp - - - __itt_domain_createA( const char* ); - __itt_domain_createW( const wchar_t* ); - - -To facilitate cross-platform code development, the ITT API features the -C macro ``__itt_domain_create``. If a UNICODE macro is defined when -compiling on a Windows OS, the C macro resolves into -``__itt_domain_createW``, otherwise it resolves into -``__itt_domain_createA``. - - -Conditional Compilation ------------------------ - - -For best performance in the release version of your code, use -conditional compilation to turn off annotations. Define the macro -INTEL_NO_ITTNOTIFY_API before you include ``ittnotify.h`` during -compilation to eliminate all ``__itt_*`` functions from your code. - - -You can also remove the static library from the linking stage by -defining this macro. - diff --git a/docs/gpa-user-guide/counter-api.rst b/docs/gpa-user-guide/counter-api.rst deleted file mode 100644 index 0d2aff01..00000000 --- a/docs/gpa-user-guide/counter-api.rst +++ /dev/null @@ -1,113 +0,0 @@ -.. _counter-api: - - -Counter API -=========== - - -A Counter is a user-defined characteristic or metric of hardware or -software behavior that can be used to collect information about and -correlate with execution breakdown, such as tasks, events, and markers. -For example, system on a chip (SoC) development benefits from several -counters representing different parts of the SoC to count some hardware -characteristics. - - -**Define and create a counter object** - - -Use these primitives: - - -``__itt_counter ITTAPI __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` - - -``__itt_counter ITTAPI __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` - - -``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` - - -**Parameters of the primitives:** - - -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``domain``\ - - Counter domain - * - [in] - - \ ``name``\ - - Counter name - * - [in] - - \ ``type``\ - - Counter type - - - - -Use these primitives: - - -**Directly set the counter value** - - -Use: - - -``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` - - -``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` - - -Parameters of the primitive: - - -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``id``\ - - Counter ID - * - [in] - - \ ``value_ptr``\ - - Counter value - - -Usage Example -------------- - - -This example creates a counter that measures temperature and memory -usage metrics: - - -.. code:: cpp - - - #include "ittnotify.h" - - - __itt_counter temperatureCounter = __itt_counter_create("Temperature", "Domain"); - __itt_counter memoryUsageCounter = __itt_counter_create("Memory Usage", "Domain"); - unsigned __int64 temperature; - - - while (...) - { - ... - temperature = getTemperature(); - __itt_counter_set_value(temperatureCounter, &temperature); - - - __itt_counter_inc_delta(memoryUsageCounter, getAllocatedMemSize()); - __itt_counter_dec_delta(memoryUsageCounter, getDeallocatedMemSize()); - ... - } - - - __itt_counter_destroy(temperatureCounter); - __itt_counter_destroy(memoryUsageCounter); - diff --git a/docs/gpa-user-guide/domain-api.rst b/docs/gpa-user-guide/domain-api.rst deleted file mode 100644 index c35004ba..00000000 --- a/docs/gpa-user-guide/domain-api.rst +++ /dev/null @@ -1,81 +0,0 @@ -.. _domain-api: - -Domain API -========== - - -A ``domain`` enables tagging trace data for different modules or -libraries in a program. Domains are specified by unique character -strings, for example ``TBB.Internal.Control``. - - -Each domain is represented by an opaque ``__itt_domain`` structure, -which you can use to tag each of the ITT API calls in your code. - - -You can selectively enable or disable specific domains in your -application, in order to filter the subsets of instrumentation that are -collected into the output trace capture file. Upon the first start, the -application registers its domains in a configuration file of the Intel® -GPA Graphics Monitor. By default, upon the first start of the -application all the domains are enabled. To enable or disable domains -for subsequent starts of the application, do the following before the -start: - - -#. Open the Graphics Monitor Launcher Screen. -#. Click the **Options** button. -#. Click the **Tracing** tab. -#. Turn on or off the **User Domains** toggle buttons. - - -The overhead of a disabled domain is a single if check. - - -**To create a domain, use the following primitives:** - - -``__itt_domain *ITTAPI__itt_domain_createA ( const char *name)`` - - -``__itt_domain *ITTAPI __itt_domain_createW ( const wchar_t *name)`` - - -Or use the macro in the following way: - - -``__itt_domain *ITTAPI __itt_domain_create (__TEXT("TBB.Internal.Control"))`` - - -For a domain name, the URI naming style is recommended, for example, -com.my_company.my_application. The set of domains is expected to be -static over the application's execution time, therefore, there is no -mechanism to destroy a domain. - - -Any domain can be accessed by any thread in the process, regardless of -which thread created the domain. This call is thread-safe. - - -**Parameters of the primitives:** - - -.. list-table:: - - * - \ ``[in]``\ - - \ *name*\ - - Name of domain - - -Usage Example -------------- - - -.. code:: cpp - - - #include "ittnotify.h" - __itt_domain* pD = __itt_domain_create(__TEXT("My Domain") ); - - - diff --git a/docs/gpa-user-guide/gpa-user-guide.rst b/docs/gpa-user-guide/gpa-user-guide.rst deleted file mode 100644 index b84a6f49..00000000 --- a/docs/gpa-user-guide/gpa-user-guide.rst +++ /dev/null @@ -1,83 +0,0 @@ -.. _gpa-user-guide: - -****************** -API Support in GPA -****************** - - -.. note:: - - - The Instrumentation and Tracing Technology API (ITT API) and the - Just-in-Time Profiling API (JIT API) are open source components. - Visit the `GitHub\* repository `__ - to access source code and contribute. - - -The Instrumentation and Tracing Technology API (ITT API) provided by the -Intel GPA enables your application to generate and control the -collection of trace data during its execution. - - -ITT API has the following features: - - -- Controls application performance overhead based on the amount of - traces that you collect. -- Enables trace collection without recompiling your application. -- Supports applications in C/C++ environments. -- Automatically traces data from Microsoft DirectX\* applications. -- Automatically traces data from OpenGL\* ES v1, v2, and v3 APIs on - Android\* OS applications. -- Supports instrumentation for tracing application code. - - -This chapter describes how to add basic instrumentation to your -application, and also includes examples of several advanced -instrumentation topics. - - -User applications/modules linked to the static ITT API library do not -have a runtime dependency on a dynamic library. Therefore, they can be -executed without Intel GPA or other Intel tools. - - -ITT API enables you to manually instrument your application for further -application performance analysis. - - -You can use the Intel GPA Trace Analyzer to view ITT trace data. The -Intel GPA Trace Analyzer obtains this data from your application through -the Intel GPA Monitor. - - -.. note:: - - - The ITT API is a set of pure C/C++ functions. There are no Java\* or - .NET\* APIs. If you need runtime environment support, you can use a - JNI, or C/C++ function call from the managed code. If the collector - causes significant overhead or data storage, you can pause the - analysis to reduce the overhead. - - -See Also --------- - - -.. toctree:: - :maxdepth: 1 - - - compile-and-link-with-itt-api - instrumenting-your-application - minimizing-itt-api-overhead - clock-domain-api - counter-api - domain-api - marker-api - metadata-api - relation-api - string-handle-api - thread-naming-api - task-api \ No newline at end of file diff --git a/docs/gpa-user-guide/instrumenting-your-application.rst b/docs/gpa-user-guide/instrumenting-your-application.rst deleted file mode 100644 index 61856cd5..00000000 --- a/docs/gpa-user-guide/instrumenting-your-application.rst +++ /dev/null @@ -1,137 +0,0 @@ -.. _instrumenting-your-application: - -Instrument Your Application -=========================== - - -Graphics Trace Analyzer is an instrumentation-based tool. It obtains its -data from gpa_trace files, which are generated by Intel® GPA while -profiling an application that has been instrumented with Instrumentation -and Tracing Technology API (ITT API) calls. - - -To get the most out of the ITT APIs, you need to add API calls in your -code to designate logical tasks. This will help you visualize the -relationship between tasks in your code, including when they start and -end, relative to other CPU and GPU tasks. - - -At the highest level a task is a logical group of work executing on a -specific thread, and may correspond to any grouping of code within your -program that you consider important. You can mark up your code by -identifying the beginning and end of each logical execution chunk. - - -To resolve the majority of performance bottlenecks, the following API -calls are enough - - -- \__itt_domain_create() creates a domain required in most ITT API - calls. You need to define at least one domain. -- \__itt_string_handle_create() creates string handles for identifying - your tasks. String handles are more efficient for identifying traces - than strings. -- \__itt_task_begin() marks the beginning of a task. - - -Example -------- - - -The following sample shows how four basic ITT API functions are used in -a multi threaded application: - - -- - - - .. container:: - :name: LI_8CC703C571CC4A38B4933FE7AE7E170D - - - :ref:`Domain API` - - -- - - - .. container:: - :name: LI_D12ED1398398490EA2761534CB34111C - - - :ref:`String Handle API` - - -- - - - .. container:: - :name: LI_A68036F0DE3842049E37031CB63A785C - - - :ref:`Task API` - - -- - - - .. container:: - :name: LI_1304238F684E4DBEAC3E53BEA55D36E7 - - - :ref:`Thread Naming API` - - -.. code:: cpp - - - #include - #include - - - // Forward declaration of a thread function. - DWORD WINAPI workerthread(LPVOID); - bool g_done = false; - // Create a domain that is visible globally: we will use it in our example. - __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); - // Create string handles which associates with the "main" task. - __itt_string_handle* handle_main = __itt_string_handle_create("main"); - __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); - void main(int, char* argv[]) - { - // Create a task associated with the "main" routine. - __itt_task_begin(domain, __itt_null, __itt_null, handle_main); - // Now we'll create 4 worker threads - for (int i = 0; i < 4; i++) - { - // We might be curious about the cost of CreateThread. We add tracing to do the measurement. - __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); - CreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); - __itt_task_end(domain); - } - - - // Wait a while,... - Sleep(5000); - g_done = true; - // Mark the end of the main task - __itt_task_end(domain); - } - // Create string handle for the work task. - __itt_string_handle* handle_work = __itt_string_handle_create("work"); - DWORD WINAPI workerthread(LPVOID data) - { - // Set the name of this thread so it shows up in the UI as something meaningful - char threadname[32]; - wsprintf(threadname, "Worker Thread %d", data); - __itt_thread_set_name(threadname); - // Each worker thread does some number of "work" tasks - while(!g_done) - { - __itt_task_begin(domain, __itt_null, __itt_null, handle_work); - Sleep(150); - __itt_task_end(domain); - } - return 0; - } - diff --git a/docs/gpa-user-guide/minimizing-itt-api-overhead.rst b/docs/gpa-user-guide/minimizing-itt-api-overhead.rst deleted file mode 100644 index 76e31e91..00000000 --- a/docs/gpa-user-guide/minimizing-itt-api-overhead.rst +++ /dev/null @@ -1,88 +0,0 @@ -.. _minimizing-itt-api-overhead: - -Minimize ITT API Overhead -========================= - - -The ITT API overhead and its impact on the overall application -performance depends on the amount of instrumentation code added to the -application. When instrumenting an application with ITT API, you should -balance between application performance and the amount of performance -data that you need to collect, in order to minimize API overhead while -collecting sufficient performance data. - - -Follow these guidelines to achieve good balance between overall -performance of the instrumented application and instrumentation detail: - - -- Instrument only those paths within your application that are - important for analysis. -- Create ITT domains and string handles outside the critical paths. -- Filter data collection by different aspects of your application that - can be analyzed separately. The overhead for a disabled API call - (thus filtering out the associated call) is always less than 10 clock - ticks, regardless of the API. - - -Usage Example: Using Domains and String Handles ------------------------------------------------ - - -The ITT APIs include a subset of functions which create domains and -string handles. These functions always return identical handles for the -same domain names and strings. This requires these functions to perform -string comparisons and table lookups, which can incur serious -performance penalties. In addition, the performance of these functions -is proportional to the log of the number of created domains or string -handles. It is best to create domains and string handles at global -scope, or during application startup. - - -The following code section creates two domains in the global scope. You -can use these domains to control the level of detail that is written to -the trace file. - - -.. code:: cpp - - - __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); - __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); - // Create string handles at global scope. - __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); - void MyFunction() - { - __itt_task_begin(basic, __itt_null, __itt_null, h_my_function); - Foo(); - FooEx(); - __itt_task_end(basic); - } - __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); - void Foo() - { - // Skip tracing detailed data if the detailed domain is disabled. - __itt_task_begin(detailed, __itt_null, __itt_null, h_foo); - // Do some work here... - __itt_task_end(detailed); - } - __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); - void FooEx() - { - // Skip tracing detailed data if the detailed domain is disabled. - __itt_task_begin(detailed, __itt_null, __itt_null, h_foo_ex); - // Do some work here... - __itt_task_end(detailed); - } - // This is my entry point. - int main(int argc, char** argv) - { - if(argc < 2) - { - //Disable detailed domain if we do not need tracing from that in this - //application run - detailed ->flags = 0; - } - MyFunction(); - } - diff --git a/docs/gpa-user-guide/string-handle-api.rst b/docs/gpa-user-guide/string-handle-api.rst deleted file mode 100644 index 55a3157c..00000000 --- a/docs/gpa-user-guide/string-handle-api.rst +++ /dev/null @@ -1,46 +0,0 @@ -.. _string-handle-api: - -String Handle API -================= - - -Many API calls require names to identify API objects. String handles are -pointers to names. They enable efficient handling of named objects in -run time and make collected traces data more compact. - - -**To create and return a handle value that can be associated with a -string, use the following primitive:** - - -``__itt_string_handle *ITTAPI __itt_string_handle_createA ( const char *name)`` - - -``__itt_string_handle *ITTAPI __itt_string_handle_createW ( const wchar_t *name)`` - - -Or use the macro in the following way: - - -``__itt_string_handle *ITTAPI __itt_string_handle_create (__TEXT("My Task"))`` - - -Consecutive calls to ``__itt_string_handle_create`` with the same name -return the same value. The set of string handles is expected to remain -static during the application's execution time, therefore, there is no -mechanism to destroy a string handle. Any string handle can be accessed -by any thread in the process, regardless of which thread created the -string handle. This call is thread-safe. - - -**Parameters of the primitive:** - - -.. list-table:: - - * - \ [in]\ - - \ *name*\ - - The input string - - - diff --git a/docs/gpa-user-guide/thread-naming-api.rst b/docs/gpa-user-guide/thread-naming-api.rst deleted file mode 100644 index 5767851a..00000000 --- a/docs/gpa-user-guide/thread-naming-api.rst +++ /dev/null @@ -1,71 +0,0 @@ -.. _thread-naming-api: - - -Thread Naming API -================= - - -By default, each thread in your application is displayed in the -**timeline** track with a default label generated from the process ID -and the thread ID, or with the OS thread name. You can use the Thread -Naming API in your code to give threads meaningful names. - - -To set thread name using a char or Unicode string, use the primitive: - - -``void __itt_thread_set_nameA (const __itt_char *name)`` - - -``void __itt_thread_set_nameW (const wchar_t *name)`` - - -Or use the macro in the following way: - - -``void__itt_thread_set_name(__TEXT("Main"))`` - - -**Parameters of the primitive:** - - -.. list-table:: - - * - \ [in]\ - - \ ``name``\ - - The thread name - - - - -If the thread name is set multiple times, only the last name is used. - - -Usage Example -------------- - - -You can use the following thread naming example to give a meaningful -name to the thread you wish to focus on and ignore the service thread. - - -.. code:: cpp - - - DWORD WINAPI service_thread(LPVOID lpArg) - { - __itt_thread_set_name(__TEXT("My worker thread")); - // Do thread work here - return 0; - } - - - int main(int argc, char* argv[]) - { - ... - CreateThread(NULL, 0, service_thread, NULL, 0, NULL); - CreateThread(NULL, 0, thread_function, NULL, 0, NULL); - ... - return 0; - } - diff --git a/docs/index.rst b/docs/index.rst index deae1b8e..509de624 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,47 +1,22 @@ -.. _home: +.. _index: -******************************************************************************************** Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API Documentation -******************************************************************************************** - -Introduction -============ - +============================================================================================ .. note:: - - The ITT and JIT API documentation from the Intel® VTune Profiler and Intel® Graphics + The ITT/JIT API Documentation from the Intel® VTune Profiler and Intel® Graphics Performance Analyzers User Guides has been consolidated into this repository, providing a single, unified source of information. -The ITT/JIT API is a open source feature of Intel's Analyzers tools that allows applications -to generate and control trace data during their execution. It enables developers to pinpoint -and measure specific areas of their code, providing valuable insights into performance -bottlenecks and resource utilization. - - -This open source profiling API includes: - -- Instrumentation and Tracing Technology (ITT) API. - It enables your application to generate and control the collection of trace data during - its execution across different Intel tools. -- JIT (Just-In-Time) Profiling API. - It provides functionality to report information about just-in-time generated code that - can be used by performance profiling tools. - -The ITT/JIT API consists of two parts: a *static* part and a *dynamic* part. - -- The dynamic part is specific for a tool and distributed only with a particular tool as - a dynamic(shared) library. -- The static part is a common part shared between tools. Currently, the static part is - distributed as an open source static library: `ittapi `__ - - .. toctree:: :maxdepth: 1 :caption: Contents: - vtune-user-guide/vtune-user-guide.rst - gpa-user-guide/gpa-user-guide.rst + src/overview + src/build + src/api-support + src/ref_collector + GitHub Project + diff --git a/docs/src/api-support.rst b/docs/src/api-support.rst new file mode 100644 index 00000000..e3f4aca5 --- /dev/null +++ b/docs/src/api-support.rst @@ -0,0 +1,33 @@ +.. _api-support: + +API Usage and Reference +======================= + +.. note:: + + The ITT API is a set of pure C/C++ functions. There are no Java* or .NET* + APIs. If you need runtime environment support, you can use a JNI, or C/C++ + function call from the managed code. + + +C/C++ API Usage and Reference: +------------------------------ + +.. toctree:: + :maxdepth: 1 + + + itt-api-support + jit-api-support + + +Other Language API Bindings: +---------------------------- + +.. toctree:: + :maxdepth: 1 + + + Rust ITT API Bindings + Python ITT API Bindings + diff --git a/docs/src/build.rst b/docs/src/build.rst new file mode 100644 index 00000000..04e8b6a2 --- /dev/null +++ b/docs/src/build.rst @@ -0,0 +1,57 @@ +.. _build: + +Build from Source +================= + +Requirements for Building from Source +------------------------------------- + +- General development tools, including C/C++ compiler. +- `Python `__ 3.6 or later. +- `CMake `__ 3.5 or later. +- Windows only: + `Microsoft Visual Studio `__ 2015 or later + ether + `Ninja `__ 1.9 or later. +- To enable Fortran support, requires `Intel Fortran Compiler + `__ + installed. + + +Download the Source Code +------------------------ + +Download `ITT/JIT API source code `__ or clone +`the repository `__. + +.. code-block:: console + + git clone https://github.com/intel/ittapi.git + + +Build +----- + +To build the ITT/JIT API static library execute: + +.. code-block:: console + + python buildall.py + + +The ailable build options: + +.. code-block:: console + + usage: python buildall.py [-h] [-d] [-c] [-v] [-pt] [-ft] [--force_bits] + + optional arguments: + -h, --help show this help message and exit + -d, --debug specify debug build configuration (release by default) + -c, --clean delete any intermediate and output files + -v, --verbose enable verbose output from build process + -pt, --ptmark enable anomaly detection support + -ft, --fortran enable fortran support + --force_bits specify bit version for the target + --vs specify visual studio version (Windows only) + --cmake_gen specify cmake build generator (Windows only) diff --git a/docs/src/compile-and-link-with-itt-api.rst b/docs/src/compile-and-link-with-itt-api.rst new file mode 100644 index 00000000..9c48f605 --- /dev/null +++ b/docs/src/compile-and-link-with-itt-api.rst @@ -0,0 +1,167 @@ +.. _compile-and-link-with-itt-api: + +Compile and Link with ITT API +============================= + + +Before instrumenting your application, configure your build system to be +able to reach the API headers and libraries: + + +- Add ``\sdk\include`` to your ``INCLUDE`` path +- Add ``\build_\\bin`` + to your ``LIBRARIES`` path + + +Include the ITT API Header or Module in Your Application +-------------------------------------------------------- + + +**For C/C++ Applications** + + +Add the following ``#include`` statements to every source file that you +want to instrument: + + +.. code:: cpp + + + #include + + +The ``ittnotify.h`` header contains definitions of ITT API routines and +important macros which provide the correct logic of API invocation from +a user application. + + +The ITT API is designed to incur almost zero overhead when tracing is +disabled. But if you need fully zero overhead, you can compile out all +ITT API calls from your application by defining the +``INTEL_NO_ITTNOTIFY_API`` macro in your project at compile time, either +on the compiler command line, or in your source file, prior to including +the ``ittnotify.h`` file. + + +**For Fortran Applications** + + +Add the ``ITTNOTIFY`` module to your source files with the following +source line: + + +.. code:: cpp + + + USE ITTNOTIFY + + +Insert ITT Notifications in Your Application +-------------------------------------------- + + +Insert ``__itt_*`` (C/C++) or ``ITT_*`` (Fortran) notifications in your +source code. + + +C/C++ example: + + +.. code:: cpp + + + __itt_pause(); + + +Fortran example: + + +.. code:: cpp + + + CALL ITT_PAUSE() + + +For more information, see `Instrumenting Your Application +`__ and `ITT API Reference +`__. + + +Link the libittnotify Static Library to Your Application +-------------------------------------------------------- + + +You need to link the static library, ``libittnotify.a`` (Linux*, FreeBSD*) or +``libittnotify.lib`` (Windows*), to your application. If tracing is enabled, +this static library loads the ITT API data dynamic collector and forwards ITT +API instrumentation data to it. If tracing is disabled, the static library +ignores ITT API calls, providing nearly zero instrumentation overhead. + + +Set the INTEL_LIBITTNOTIFY environment variables to enable data collection +-------------------------------------------------------------------------- + + +After you instrument your application by adding ITT API calls to your code and +link the ``libittnotify.a/libittnotify.lib`` static library, your application +will check the ``INTEL_LIBITTNOTIFY32`` or the ``INTEL_LIBITTNOTIFY64`` +environment variable depending on your application's architecture to load the +**dynamic** part of the library. If that variable is set, it will load the +libraries defined in the variable. + + +Make sure to set these environment variables to enable data collection: + + +**On Windows** + + +.. code-block:: console + + + set INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll + set INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll + + +**On Linux** + + +.. code-block:: console + + + export INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so + export INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so + + +**On FreeBSD** + + +.. code-block:: console + + + setenv INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so + + +Unicode Support +--------------- + + +All API functions that take parameters of type ``__itt_char`` follow the +Windows OS unicode convention. If UNICODE is defined when compiling on a +Windows OS, ``__itt_char`` is ``wchar_t``, otherwise it is ``char``. The +actual function names are suffixed with ``A`` for the ASCII APIs and +``W`` for the unicode APIs. Both types of functions are defined in the +DLL that implements the API. + + +Strings that are all ASCII characters are internally equivalent for both +the unicode and the ASCII API versions. For example, the following +strings are equivalent: + + +.. code:: cpp + + + __itt_sync_createA( addr, "OpenMP Scheduler", "Critical Section", 0); + __itt_sync_createW( addr, L"OpenMP Scheduler", L"Critical Section", 0); + diff --git a/docs/vtune-user-guide/instrument-your-application.rst b/docs/src/instrument-your-application.rst similarity index 69% rename from docs/vtune-user-guide/instrument-your-application.rst rename to docs/src/instrument-your-application.rst index 63208726..5930b8ec 100644 --- a/docs/vtune-user-guide/instrument-your-application.rst +++ b/docs/src/instrument-your-application.rst @@ -1,137 +1,100 @@ -.. _instrument-your-application: - -Instrument Your Application -=========================== - - -To get the most out of the ITT APIs when collecting performance data -with Intel® VTune™ Profiler, you need to add API calls in your code to -designate logical tasks. This will help you visualize the relationship -between tasks in your code, including when they start and end, relative -to other CPU and GPU tasks. - - -At the highest level a task is a logical group of work executing on a -specific thread, and may correspond to any grouping of code within your -program that you consider important. You can mark up your code by -identifying the beginning and end of each logical task with -\__itt_task_begin and \__itt_task_end calls. For example, to track -"smoke rendering" separately from "detailed shadows", you should add API -tracking calls to the code modules for these specific features. - - -To get started, use the following API calls: - - -- \__itt_domain_create() creates a domain required in most ITT API - calls. You need to define at least one domain. -- \__itt_string_handle_create() creates string handles for identifying - your tasks. String handles are more efficient for identifying traces - than strings. -- \__itt_task_begin() marks the beginning of a task. -- \__itt_task_end() marks the end of a task. - - -Example -------- - - -The following sample shows how four basic ITT API functions are used in -a multi threaded application: - - -- - - - .. container:: - :name: LI_8CC703C571CC4A38B4933FE7AE7E170D - - - `Domain API `__ - - -- - - - .. container:: - :name: LI_D12ED1398398490EA2761534CB34111C - - - `String Handle - API `__ - - -- - - - .. container:: - :name: LI_A68036F0DE3842049E37031CB63A785C - - - `Task API `__ - - -- - - - .. container:: - :name: LI_1304238F684E4DBEAC3E53BEA55D36E7 - - - `Thread Naming - API `__ - - -.. code:: cpp - - - #include - #include - - - // Forward declaration of a thread function. - DWORD WINAPI workerthread(LPVOID); - bool g_done = false; - // Create a domain that is visible globally: we will use it in our example. - __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); - // Create string handles which associates with the "main" task. - __itt_string_handle* handle_main = __itt_string_handle_create("main"); - __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); - void main(int, char* argv[]) - { - // Create a task associated with the "main" routine. - __itt_task_begin(domain, __itt_null, __itt_null, handle_main); - // Now we'll create 4 worker threads - for (int i = 0; i < 4; i++) - { - // We might be curious about the cost of CreateThread. We add tracing to do the measurement. - __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); - .. code-block:: cppCreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); - __itt_task_end(domain); - } - - - // Wait a while,... - .. code-block:: cppSleep(5000); - g_done = true; - // Mark the end of the main task - __itt_task_end(domain); - } - // Create string handle for the work task. - __itt_string_handle* handle_work = __itt_string_handle_create("work"); - DWORD WINAPI workerthread(LPVOID data) - { - // Set the name of this thread so it shows up in the UI as something meaningful - char threadname[32]; - wsprintf(threadname, "Worker Thread %d", data); - __itt_thread_set_name(threadname); - // Each worker thread does some number of "work" tasks - while(!g_done) - { - __itt_task_begin(domain, __itt_null, __itt_null, handle_work); - .. code-block:: cppSleep(150); - __itt_task_end(domain); - } - return 0; - } - +.. _instrument-your-application: + +Instrument Your Application +=========================== + + +To get the most out of the ITT APIs when collecting performance data, +you need to add API calls in your code to designate logical tasks. +This will help you visualize the relationship between tasks in your code, +including when they start and end, relative to other CPU and GPU tasks. + + +At the highest level a task is a logical group of work executing on a +specific thread, and may correspond to any grouping of code within your +program that you consider important. You can mark up your code by +identifying the beginning and end of each logical task with +``__itt_task_begin`` and ``__itt_task_end`` calls. For example, to track +"smoke rendering" separately from "detailed shadows", you should add API +tracking calls to the code modules for these specific features. + + +To get started, use the following API calls: + + +- ``__itt_domain_create()`` creates a domain required in most ITT API + calls. You need to define at least one domain. +- ``__itt_string_handle_create()`` creates string handles for identifying + your tasks. String handles are more efficient for identifying traces + than strings. +- ``__itt_task_begin()`` marks the beginning of a task. +- ``__itt_task_end()`` marks the end of a task. + + +Example +------- + + +The following sample shows how four basic ITT API functions are used in +a multi threaded application: + + +- `Domain API `__ +- `String Handle API `__ +- `Task API `__ +- `Thread Naming API `__ + + +.. code:: cpp + + + #include + #include + + + // Forward declaration of a thread function. + DWORD WINAPI workerthread(LPVOID); + bool g_done = false; + // Create a domain that is visible globally: we will use it in our example. + __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); + // Create string handles which associates with the "main" task. + __itt_string_handle* handle_main = __itt_string_handle_create("main"); + __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); + void main(int, char* argv[]) + { + // Create a task associated with the "main" routine. + __itt_task_begin(domain, __itt_null, __itt_null, handle_main); + // Now we'll create 4 worker threads + for (int i = 0; i < 4; i++) + { + // We might be curious about the cost of CreateThread. We add tracing to do the measurement. + __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); + .. code-block:: cppCreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); + __itt_task_end(domain); + } + + + // Wait a while,... + .. code-block:: cppSleep(5000); + g_done = true; + // Mark the end of the main task + __itt_task_end(domain); + } + // Create string handle for the work task. + __itt_string_handle* handle_work = __itt_string_handle_create("work"); + DWORD WINAPI workerthread(LPVOID data) + { + // Set the name of this thread so it shows up in the UI as something meaningful + char threadname[32]; + wsprintf(threadname, "Worker Thread %d", data); + __itt_thread_set_name(threadname); + // Each worker thread does some number of "work" tasks + while(!g_done) + { + __itt_task_begin(domain, __itt_null, __itt_null, handle_work); + .. code-block:: cppSleep(150); + __itt_task_end(domain); + } + return 0; + } + diff --git a/docs/src/itt-api-reference.rst b/docs/src/itt-api-reference.rst new file mode 100644 index 00000000..d65236b4 --- /dev/null +++ b/docs/src/itt-api-reference.rst @@ -0,0 +1,26 @@ +.. _itt-api-reference: + +ITT API Reference +================= + +.. toctree:: + :maxdepth: 1 + + + ittapi/clock-domain-api + ittapi/collection-control-api + ittapi/context-metadata-api + ittapi/counter-api + ittapi/domain-api + ittapi/event-api + ittapi/frame-api + ittapi/histogram-api + ittapi/load-module-api + ittapi/marker-api + ittapi/memory-allocation-apis + ittapi/metadata-api + ittapi/relation-api + ittapi/string-handle-api + ittapi/task-api + ittapi/thread-naming-api + ittapi/user-defined-synchronization-api diff --git a/docs/src/itt-api-support.rst b/docs/src/itt-api-support.rst new file mode 100644 index 00000000..4c440ce7 --- /dev/null +++ b/docs/src/itt-api-support.rst @@ -0,0 +1,43 @@ +.. _itt-api-support: + +ITT API +======= + + +The Instrumentation and Tracing Technology API (ITT API) enables +your application to generate and control the collection of trace +data during its execution. + + +ITT API has the following features: + + +- Controls application performance overhead based on the amount of + traces that you collect. +- Enables trace collection without recompiling your application. +- Supports applications in C/C++ and Fortran environments on Windows*, + Linux* or FreeBSD* systems. +- Supports instrumentation for tracing application code. + + +User applications/modules linked to the static ITT API library do not +have a runtime dependency on a dynamic library. Therefore, they can be +executed independently. + + +ITT API enables you to manually instrument your application for further +application performance analysis. + + +ITT API Usage and Reference +--------------------------- + +.. toctree:: + :maxdepth: 1 + + + compile-and-link-with-itt-api + instrument-your-application + minimize-itt-api-overhead + itt-api-reference + diff --git a/docs/gpa-user-guide/clock-domain-api.rst b/docs/src/ittapi/clock-domain-api.rst similarity index 100% rename from docs/gpa-user-guide/clock-domain-api.rst rename to docs/src/ittapi/clock-domain-api.rst diff --git a/docs/vtune-user-guide/collection-control-api.rst b/docs/src/ittapi/collection-control-api.rst similarity index 96% rename from docs/vtune-user-guide/collection-control-api.rst rename to docs/src/ittapi/collection-control-api.rst index ccaa251e..4c69cefc 100644 --- a/docs/vtune-user-guide/collection-control-api.rst +++ b/docs/src/ittapi/collection-control-api.rst @@ -1,121 +1,121 @@ -.. _collection-control-api: - -Collection Control API -====================== - - -You can use the collection control APIs in your code to control the way -the Intel® VTune™ Profiler collects data for applications. - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``void __itt_pause (void)``\ - - Run the application without collecting data. VTune Profiler reduces the overhead of collection, by collecting only critical information, such as thread and process creation. - * - \ ``void __itt_resume (void)``\ - - Resume data collection. VTune Profiler resumes collecting all data. - * - \ ``void __itt_detach (void)``\ - - Detach data collection. VTune Profiler detaches all collectors from all processes. Your application continues to work but no data is collected for the running collection. - - - - -Pausing the data collection has the following effects: - - -- Data collection is paused for the whole program, not only within the - current thread. - - -- Some runtime analysis overhead reduction. - - -- The following APIs are not affected by pausing the data collection: - - - - Domain API - - - - String Handle API - - - - Thread Naming API - - -- The following APIs are affected by pausing the data collection. Data - is not collected for these APIs while in paused state: - - - - Task API - - - - Frame API - - - - Event API - - - - User-Defined Synchronization API - - -.. note:: - - - The Pause/Resume API call frequency is about 1Hz for a reasonable - rate. Since this operation pauses and resumes data collection in all - processes in the analysis run with the corresponding collection state - notification to GUI, you are not recommended to call it on frequent - basis for small workloads. For small workloads, consider using the - `Frame - APIs `__. - - -Usage Example: Focus on Specific Code Section ---------------------------------------------- - - -The pause/resume calls shown in the following code snippet enable you to -focus the collection on a specific section of code, and start the -application run with collection paused. - - -.. code:: cpp - - - int main(int argc, char* argv[]) - { - // Do initialization work here - __itt_resume(); - // Do profiling work here - __itt_pause(); - // Do finalization work here - return 0; - } - - -Usage Example: Hide Sections of Code ------------------------------------- - - -The pause/resume calls shown in the following code snippet enable you to -hide some intensive work that you are not currently focusing on: - - -.. code:: cpp - - - int main(int argc, char* argv[]) - { - // Do work here - __itt_pause(); - // Do uninteresting work here - __itt_resume(); - // Do work here - __itt_detach(); - // Do uninteresting work here - return 0; - } - +.. _collection-control-api: + +Collection Control API +====================== + + +You can use the collection control APIs in your code to control the way +the Intel® VTune™ Profiler collects data for applications. + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_pause (void)``\ + - Run the application without collecting data. VTune Profiler reduces the overhead of collection, by collecting only critical information, such as thread and process creation. + * - \ ``void __itt_resume (void)``\ + - Resume data collection. VTune Profiler resumes collecting all data. + * - \ ``void __itt_detach (void)``\ + - Detach data collection. VTune Profiler detaches all collectors from all processes. Your application continues to work but no data is collected for the running collection. + + + + +Pausing the data collection has the following effects: + + +- Data collection is paused for the whole program, not only within the + current thread. + + +- Some runtime analysis overhead reduction. + + +- The following APIs are not affected by pausing the data collection: + + + - Domain API + + + - String Handle API + + + - Thread Naming API + + +- The following APIs are affected by pausing the data collection. Data + is not collected for these APIs while in paused state: + + + - Task API + + + - Frame API + + + - Event API + + + - User-Defined Synchronization API + + +.. note:: + + + The Pause/Resume API call frequency is about 1Hz for a reasonable + rate. Since this operation pauses and resumes data collection in all + processes in the analysis run with the corresponding collection state + notification to GUI, you are not recommended to call it on frequent + basis for small workloads. For small workloads, consider using the + `Frame + APIs `__. + + +Usage Example: Focus on Specific Code Section +--------------------------------------------- + + +The pause/resume calls shown in the following code snippet enable you to +focus the collection on a specific section of code, and start the +application run with collection paused. + + +.. code:: cpp + + + int main(int argc, char* argv[]) + { + // Do initialization work here + __itt_resume(); + // Do profiling work here + __itt_pause(); + // Do finalization work here + return 0; + } + + +Usage Example: Hide Sections of Code +------------------------------------ + + +The pause/resume calls shown in the following code snippet enable you to +hide some intensive work that you are not currently focusing on: + + +.. code:: cpp + + + int main(int argc, char* argv[]) + { + // Do work here + __itt_pause(); + // Do uninteresting work here + __itt_resume(); + // Do work here + __itt_detach(); + // Do uninteresting work here + return 0; + } + diff --git a/docs/vtune-user-guide/context-metadata-api.rst b/docs/src/ittapi/context-metadata-api.rst similarity index 96% rename from docs/vtune-user-guide/context-metadata-api.rst rename to docs/src/ittapi/context-metadata-api.rst index c05a1c4c..205d8c6f 100644 --- a/docs/vtune-user-guide/context-metadata-api.rst +++ b/docs/src/ittapi/context-metadata-api.rst @@ -1,215 +1,215 @@ -.. _context-metadata-api: - -Context Metadata API -==================== - - -Use context metadata to collect counter-based metrics and attribute them -to hardware topology like: - - -- PCIe devices -- Block devices -- CPU cores -- Threads - - -With the Context Metadata API, you can define custom counters in your -code with special attributes. You can also get a set of metrics for the -collected data in any classical form of data representation in Intel® -VTune™ Profiler. - - -**Availability:** - - -By default, the Context Metadata API for data collection and -visualization is available in the `Input and Output -analysis `__ only. - - -To see this data when running other analysis types, - - -#. `Create a custom - analysis `__ based on - the predefined analysis type of your interest. -#. In `custom analysis - options `__, enable - the **Analyze all ITT API user data** checkbox. - - -**Define and create a counter object** - - -Use this structure to store context metadata: - - -.. code-block:: cpp - - - __itt_context_metadata - { - __itt_context_type type; /*!< Type of the context metadata value */ - void* value; /*!< Pointer to context metadata value itself */ - } - - -The structure accepts the following types of context metadata: - - -.. list-table:: - :header-rows: 0 - - * - \__itt_context_type - - Value - - Description - * - \__itt_context_name - - ASCII string char*/ Unicode string wchar_t\* type - - The name of the counter-based metric. This value is required. - * - \__itt_context_device - - ASCII string char*/ Unicode string wchar_t\* type - - Statistics subdomain to break down the counter samples (for example, network port ID, disk partition, etc.) - * - \__itt_context_units - - ASCII string char*/ Unicode string wchar_t\* type - - Units of measurement. For measurement of time, use the ns/us/ms/s units to correct data representation in VTune Profiler. - * - \__itt_context_pci_addr - - ASCII string char*/ Unicode string wchar_t\* type - - PCI address of device to associate with the counter. - * - \__itt_context_tid - - Unsigned 64-bit integer type - - Thread ID to associate with the counter. - * - \__itt_context_bandwidth_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1, calculate latency histogram and counter/sec timeline distribution. - * - \__itt_context_latency_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1,calculate the throughput histogram and counter/sec timeline distribution. - * - \__itt_context_on_thread_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1, show the counter on top of the Thread graph as percentage of the CPU Time distribution. - - - - -Before you associate context metadata with a counter, you should create -an ITT API Domain and ITT API Counter Instances. - - -The domain name provides a heading for the section of metrics for the -counters in the results of VTune Profiler. A single domain can combine -data from any number of counters. However, the name of the counters must -be unique within the same domain. - - -You can combine different counters under a single metric of the Context -Metadata. - - -**Add context information** - - -Once you have created all objects, you can add context information for -the selected counters. Use these primitives: - - -``__itt_bind_context_metadata_to_counter(__itt_counter counter, size_t length, __itt_context_metadata* metadata);`` - - -**Parameters of the primitive:** - - -.. list-table:: - :header-rows: 0 - - * - Type - - Parameter - - Description - * - [in] - - \ ``__itt_counter counter``\ - - Pointer to the counter instance associated with the context metadata - * - [in] - - \ ``size_t length``\ - - Number of elements in the array of context metadata - * - [in] - - \ ``__itt_context_metadata* metadata``\ - - Pointer to the array of context metadata - - - - -To create counter instances and submit counter data, use: - - -.. code-block:: cpp - - - __itt_counter_create_v3(__itt_domain* domain, const char* name, __itt_metadata_type type); - __itt_counter_set_value_v3(__itt_counter counter, void *value_ptr); - - -Usage Example -------------- - - -This example creates counters with context metadata that measures random -read operation metrics for an SSD NVMe device: - - -.. code:: cpp - - - #include "ittnotify.h" - #include "ittnotify_types.h" - - - // Create domain and counters: - __itt_domain* domain = __itt_domain_create("ITT API collected data"); - __itt_counter counter_read_op = __itt_counter_create_v3(domain, "Read Operations", __itt_metadata_u64); - __itt_counter counter_read_mb = __itt_counter_create_v3(domain, "Read Megabytes", __itt_metadata_u64); - __itt_counter counter_spin_time = __itt_counter_create_v3(domain, "Spin Time", __itt_metadata_u64); - - - // Create context metadata: - __itt_context_metadata metadata_read_op[] = { - {__itt_context_name, "Reads"}, - {__itt_context_device, "NVMe SSD Intel DC 660p"}, - {__itt_context_units, "Operations"}, - {__itt_context_pci_addr, "0001:10:00.1"}, - {__itt_context_latency_flag, &true_flag} - }; - __itt_context_metadata metadata_read_mb[] = { - {__itt_context_name, "Read"}, - {__itt_context_device, "NVMe SSD Intel DC 660p"}, - {__itt_context_units, "MB"}, - {__itt_context_pci_addr, "0001:10:00.1"}, - {__itt_context_bandwidth_flag, &true_flag} - }; - __itt_context_metadata metadata_spin_time[] = { - {__itt_context_name, "Spin Time"}, - {__itt_context_device, "NVMe SSD Intel DC 660p"}, - {__itt_context_units, "ms"}, - {__itt_context_tid, &thread_id} - }; - - - // Bind context metadata to counters: - __itt_bind_context_metadata_to_counter(counter_read_op, n, metadata_read_op); - __itt_bind_context_metadata_to_counter(counter_read_mb, n, metadata_read_mb); - __itt_bind_context_metadata_to_counter(counter_spin_time, n, metadata_spin_time); - - - while(1) - { - // Get collected data: - uint64_t read_op = get_user_read_operation_num(); - uint64_t read_mb = get_user_read_megabytes_num(); - uint64_t spin_time = get_user_spin_time(); - - - // Dump collected data: - __itt_counter_set_value_v3(counter_read_op, &read_op); - __itt_counter_set_value_v3(counter_read_mb, &read_mb); - __itt_counter_set_value_v3(counter_spin_time, &spin_time); - } - +.. _context-metadata-api: + +Context Metadata API +==================== + + +Use context metadata to collect counter-based metrics and attribute them +to hardware topology like: + + +- PCIe devices +- Block devices +- CPU cores +- Threads + + +With the Context Metadata API, you can define custom counters in your +code with special attributes. You can also get a set of metrics for the +collected data in any classical form of data representation in Intel® +VTune™ Profiler. + + +**Availability:** + + +By default, the Context Metadata API for data collection and +visualization is available in the `Input and Output +analysis `__ only. + + +To see this data when running other analysis types, + + +#. `Create a custom + analysis `__ based on + the predefined analysis type of your interest. +#. In `custom analysis + options `__, enable + the **Analyze all ITT API user data** checkbox. + + +**Define and create a counter object** + + +Use this structure to store context metadata: + + +.. code-block:: cpp + + + __itt_context_metadata + { + __itt_context_type type; /*!< Type of the context metadata value */ + void* value; /*!< Pointer to context metadata value itself */ + } + + +The structure accepts the following types of context metadata: + + +.. list-table:: + :header-rows: 0 + + * - \__itt_context_type + - Value + - Description + * - \__itt_context_name + - ASCII string char*/ Unicode string wchar_t\* type + - The name of the counter-based metric. This value is required. + * - \__itt_context_device + - ASCII string char*/ Unicode string wchar_t\* type + - Statistics subdomain to break down the counter samples (for example, network port ID, disk partition, etc.) + * - \__itt_context_units + - ASCII string char*/ Unicode string wchar_t\* type + - Units of measurement. For measurement of time, use the ns/us/ms/s units to correct data representation in VTune Profiler. + * - \__itt_context_pci_addr + - ASCII string char*/ Unicode string wchar_t\* type + - PCI address of device to associate with the counter. + * - \__itt_context_tid + - Unsigned 64-bit integer type + - Thread ID to associate with the counter. + * - \__itt_context_bandwidth_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1, calculate latency histogram and counter/sec timeline distribution. + * - \__itt_context_latency_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1,calculate the throughput histogram and counter/sec timeline distribution. + * - \__itt_context_on_thread_flag + - Unsigned 64-bit integer type (0,1) + - If this flag is set to 1, show the counter on top of the Thread graph as percentage of the CPU Time distribution. + + + + +Before you associate context metadata with a counter, you should create +an ITT API Domain and ITT API Counter Instances. + + +The domain name provides a heading for the section of metrics for the +counters in the results of VTune Profiler. A single domain can combine +data from any number of counters. However, the name of the counters must +be unique within the same domain. + + +You can combine different counters under a single metric of the Context +Metadata. + + +**Add context information** + + +Once you have created all objects, you can add context information for +the selected counters. Use these primitives: + + +``__itt_bind_context_metadata_to_counter(__itt_counter counter, size_t length, __itt_context_metadata* metadata);`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - Type + - Parameter + - Description + * - [in] + - \ ``__itt_counter counter``\ + - Pointer to the counter instance associated with the context metadata + * - [in] + - \ ``size_t length``\ + - Number of elements in the array of context metadata + * - [in] + - \ ``__itt_context_metadata* metadata``\ + - Pointer to the array of context metadata + + + + +To create counter instances and submit counter data, use: + + +.. code-block:: cpp + + + __itt_counter_create_v3(__itt_domain* domain, const char* name, __itt_metadata_type type); + __itt_counter_set_value_v3(__itt_counter counter, void *value_ptr); + + +Usage Example +------------- + + +This example creates counters with context metadata that measures random +read operation metrics for an SSD NVMe device: + + +.. code:: cpp + + + #include "ittnotify.h" + #include "ittnotify_types.h" + + + // Create domain and counters: + __itt_domain* domain = __itt_domain_create("ITT API collected data"); + __itt_counter counter_read_op = __itt_counter_create_v3(domain, "Read Operations", __itt_metadata_u64); + __itt_counter counter_read_mb = __itt_counter_create_v3(domain, "Read Megabytes", __itt_metadata_u64); + __itt_counter counter_spin_time = __itt_counter_create_v3(domain, "Spin Time", __itt_metadata_u64); + + + // Create context metadata: + __itt_context_metadata metadata_read_op[] = { + {__itt_context_name, "Reads"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "Operations"}, + {__itt_context_pci_addr, "0001:10:00.1"}, + {__itt_context_latency_flag, &true_flag} + }; + __itt_context_metadata metadata_read_mb[] = { + {__itt_context_name, "Read"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "MB"}, + {__itt_context_pci_addr, "0001:10:00.1"}, + {__itt_context_bandwidth_flag, &true_flag} + }; + __itt_context_metadata metadata_spin_time[] = { + {__itt_context_name, "Spin Time"}, + {__itt_context_device, "NVMe SSD Intel DC 660p"}, + {__itt_context_units, "ms"}, + {__itt_context_tid, &thread_id} + }; + + + // Bind context metadata to counters: + __itt_bind_context_metadata_to_counter(counter_read_op, n, metadata_read_op); + __itt_bind_context_metadata_to_counter(counter_read_mb, n, metadata_read_mb); + __itt_bind_context_metadata_to_counter(counter_spin_time, n, metadata_spin_time); + + + while(1) + { + // Get collected data: + uint64_t read_op = get_user_read_operation_num(); + uint64_t read_mb = get_user_read_megabytes_num(); + uint64_t spin_time = get_user_spin_time(); + + + // Dump collected data: + __itt_counter_set_value_v3(counter_read_op, &read_op); + __itt_counter_set_value_v3(counter_read_mb, &read_mb); + __itt_counter_set_value_v3(counter_spin_time, &spin_time); + } + diff --git a/docs/vtune-user-guide/counter-api.rst b/docs/src/ittapi/counter-api.rst similarity index 78% rename from docs/vtune-user-guide/counter-api.rst rename to docs/src/ittapi/counter-api.rst index 63f311e9..b4235828 100644 --- a/docs/vtune-user-guide/counter-api.rst +++ b/docs/src/ittapi/counter-api.rst @@ -1,162 +1,164 @@ -.. _counter-api: - -Counter API -=========== - - -Use the Counter API to observe user-defined global characteristic -counters that are unknown to VTune Profiler. For example, system on a -chip (SoC) development benefits from several counters representing -different parts of the SoC to count some hardware characteristics. - - -**Define and create a counter object** - - -Use these primitives: - - -``__itt_counter`` - - -``__itt_counter_create(const char *name, const char *domain);`` - - -``__itt_counter_createA(const char *name, const char *domain);`` - - -``__itt_counter_createW(const wchar_t *name, const wchar_t *domain);`` - - -``__itt_counter_create_typed (const char *name, const char *domain, __itt_metadata_type type);`` - - -``__itt_counter __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` - - -``__itt_counter __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` - - -``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` - - -A counter name and domain name should be specified. To load a -specialized type of data, specify the counter type. By default the -unsigned int64 type is used. - - -**Parameters of the primitives:** - - -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``domain``\ - - Counter domain - * - [in] - - \ ``name``\ - - Counter name - * - [in] - - \ ``type``\ - - Counter type - - - - -**Increment/decrement a counter value** - - -Use these primitives: - - -``__itt_counter_inc (__itt_counter id);`` - - -``__itt_counter_inc_delta(__itt_counter id, unsigned long long value);`` - - -``__itt_counter_dec(__itt_counter id);`` - - -``__itt_counter_dec_delta(__itt_counter id, unsigned long long value);`` - - -.. note:: - - - These primitives are applicable to uint64 counters only. - - -**Directly set the counter value** - - -Use: - - -``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` - - -``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` - - -Parameters of the primitive: - - -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``id``\ - - Counter ID - * - [in] - - \ ``value_ptr``\ - - Counter value - - - - -**Remove an existing counter** - - -Use: - - -``__itt_counter_destroy(__itt_counter id);`` - - -Usage Example -------------- - - -This example creates a counter that measures temperature and memory -usage metrics: - - -.. code:: cpp - - - #include "ittnotify.h" - - - __itt_counter temperatureCounter = __itt_counter_create("Temperature", "Domain"); - __itt_counter memoryUsageCounter = __itt_counter_create("Memory Usage", "Domain"); - unsigned __int64 temperature; - - - while (...) - { - ... - temperature = getTemperature(); - __itt_counter_set_value(temperatureCounter, &temperature); - - - __itt_counter_inc_delta(memoryUsageCounter, getAllocatedMemSize()); - __itt_counter_dec_delta(memoryUsageCounter, getDeallocatedMemSize()); - ... - } - - - __itt_counter_destroy(temperatureCounter); - __itt_counter_destroy(memoryUsageCounter); - +.. _counter-api: + +Counter API +=========== + + +A Counter is a user-defined characteristic or metric of hardware or +software behavior that can be used to collect information about and +correlate with execution breakdown, such as tasks, events, and markers. +For example, system on a chip (SoC) development benefits from several +counters representing different parts of the SoC to count some hardware +characteristics. + + +**Define and create a counter object** + + +Use these primitives: + + +``__itt_counter`` + + +``__itt_counter_create(const char *name, const char *domain);`` + + +``__itt_counter_createA(const char *name, const char *domain);`` + + +``__itt_counter_createW(const wchar_t *name, const wchar_t *domain);`` + + +``__itt_counter_create_typed (const char *name, const char *domain, __itt_metadata_type type);`` + + +``__itt_counter __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` + + +``__itt_counter __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` + + +``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` + + +A counter name and domain name should be specified. To load a +specialized type of data, specify the counter type. By default the +unsigned int64 type is used. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``domain``\ + - Counter domain + * - [in] + - \ ``name``\ + - Counter name + * - [in] + - \ ``type``\ + - Counter type + + + + +**Increment/decrement a counter value** + + +Use these primitives: + + +``__itt_counter_inc (__itt_counter id);`` + + +``__itt_counter_inc_delta(__itt_counter id, unsigned long long value);`` + + +``__itt_counter_dec(__itt_counter id);`` + + +``__itt_counter_dec_delta(__itt_counter id, unsigned long long value);`` + + +.. note:: + + + These primitives are applicable to uint64 counters only. + + +**Directly set the counter value** + + +Use: + + +``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` + + +``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` + + +Parameters of the primitive: + + +.. list-table:: + :header-rows: 0 + + * - [in] + - \ ``id``\ + - Counter ID + * - [in] + - \ ``value_ptr``\ + - Counter value + + + + +**Remove an existing counter** + + +Use: + + +``__itt_counter_destroy(__itt_counter id);`` + + +Usage Example +------------- + + +This example creates a counter that measures temperature and memory +usage metrics: + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_counter temperatureCounter = __itt_counter_create("Temperature", "Domain"); + __itt_counter memoryUsageCounter = __itt_counter_create("Memory Usage", "Domain"); + unsigned __int64 temperature; + + + while (...) + { + ... + temperature = getTemperature(); + __itt_counter_set_value(temperatureCounter, &temperature); + + + __itt_counter_inc_delta(memoryUsageCounter, getAllocatedMemSize()); + __itt_counter_dec_delta(memoryUsageCounter, getDeallocatedMemSize()); + ... + } + + + __itt_counter_destroy(temperatureCounter); + __itt_counter_destroy(memoryUsageCounter); + diff --git a/docs/vtune-user-guide/domain-api.rst b/docs/src/ittapi/domain-api.rst similarity index 96% rename from docs/vtune-user-guide/domain-api.rst rename to docs/src/ittapi/domain-api.rst index 32523962..e87e4f0a 100644 --- a/docs/vtune-user-guide/domain-api.rst +++ b/docs/src/ittapi/domain-api.rst @@ -1,65 +1,65 @@ -.. _domain-api: - -Domain API -========== - - -A ``domain`` enables tagging trace data for different modules or -libraries in a program. Domains are specified by unique character -strings, for example ``TBB.Internal.Control``. - - -Each domain is represented by an opaque ``__itt_domain`` structure, -which you can use to tag each of the ITT API calls in your code. - - -You can selectively enable or disable specific domains in your -application, in order to filter the subsets of instrumentation that are -collected into the output trace capture file. To disable a domain set -its flag field to 0 value. This disables tracing for a particular domain -while keeping the rest of the code unmodified. The overhead of a -disabled domain is a single if check. - - -**To create a domain, use the following primitives:** - - -``__itt_domain *ITTAPI__itt_domain_create ( const char *name)`` - - -For a domain name, the URI naming style is recommended, for example, -com.my_company.my_application. The set of domains is expected to be -static over the application's execution time, therefore, there is no -mechanism to destroy a domain. - - -Any domain can be accessed by any thread in the process, regardless of -which thread created the domain. This call is thread-safe. - - -**Parameters of the primitives:** - - -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *name*\ - - Name of domain - - - - -Usage Example -------------- - - -.. code:: cpp - - - #include "ittnotify.h" - - - __itt_domain* pD = __itt_domain_create(L"My Domain" ); - pD->flags = 0; /* disable domain */ - +.. _domain-api: + +Domain API +========== + + +A ``domain`` enables tagging trace data for different modules or +libraries in a program. Domains are specified by unique character +strings, for example ``TBB.Internal.Control``. + + +Each domain is represented by an opaque ``__itt_domain`` structure, +which you can use to tag each of the ITT API calls in your code. + + +You can selectively enable or disable specific domains in your +application, in order to filter the subsets of instrumentation that are +collected into the output trace capture file. To disable a domain set +its flag field to 0 value. This disables tracing for a particular domain +while keeping the rest of the code unmodified. The overhead of a +disabled domain is a single if check. + + +**To create a domain, use the following primitives:** + + +``__itt_domain *ITTAPI__itt_domain_create ( const char *name)`` + + +For a domain name, the URI naming style is recommended, for example, +com.my_company.my_application. The set of domains is expected to be +static over the application's execution time, therefore, there is no +mechanism to destroy a domain. + + +Any domain can be accessed by any thread in the process, regardless of +which thread created the domain. This call is thread-safe. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *name*\ + - Name of domain + + + + +Usage Example +------------- + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_domain* pD = __itt_domain_create(L"My Domain" ); + pD->flags = 0; /* disable domain */ + diff --git a/docs/vtune-user-guide/event-api.rst b/docs/src/ittapi/event-api.rst similarity index 96% rename from docs/vtune-user-guide/event-api.rst rename to docs/src/ittapi/event-api.rst index 4013aee3..8ff9ac13 100644 --- a/docs/vtune-user-guide/event-api.rst +++ b/docs/src/ittapi/event-api.rst @@ -1,129 +1,129 @@ -.. _event-api: - -Event API -========= - - -The event API is used to observe when demarcated events occur in your -application, or to identify how long it takes to execute demarcated -regions of code. Set annotations in the application to demarcate areas -where events of interest occur. After running analysis, you can see the -events marked in the Timeline pane. - - -Event API is a per-thread function that works in resumed state. This -function does not work in paused state. - - -.. note:: - - - - On Windows\* OS platforms you can define Unicode to use a wide - character version of APIs that pass strings. However, these - strings are internally converted to ASCII strings. - - - - On Linux\* OS platforms only a single variant of the API exists. - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``__itt_event __itt_event_create(const __itt_char *name, int namelen );``\ - - Create an event type with the specified name and length. This API returns a handle to the event type that should be passed into the following event start and event end APIs as a parameter. The namelen parameter refers to the name length in number of characters, not the number of bytes. - * - \ ``int __itt_event_start( __itt_event event );``\   - - Call this API with your previously created event type handle to register an instance of the event. Event start appears in the **Timeline** pane display as a tick mark. - * - \ ``int __itt_event_end( __itt_event event );``\ - - Call this API following a call to \__itt_event_start() to show the event as a tick mark with a duration line from start to end. If this API is not called, this event appears in the **Timeline** pane as a single tick mark. - - - - -Guidelines for Event API Usage ------------------------------- - - -- An \__itt_event_end() is always matched with the nearest preceding - \__itt_event_start(). Otherwise, the \__itt_event_end() call is - matched with the nearest unmatched \__itt_event_start() preceding it. - Any intervening events are nested. - - -- You can nest user events of the same or different type within each - other. In the case of nested events, the time is considered to have - been spent only in the most deeply nested user event region. - - -- You can overlap different ITT API events. In the case of overlapping - events the time is considered to have been spent only in the event - region with the later \__itt_event_start(). Unmatched - \__itt_event_end() calls are ignored. - - -.. note:: - - - To see events and user tasks in your results, `create a custom - analysis `__ (based - on the pre-defined analysis you are interested in) and select the - **Analyze user tasks, events and counters** checkbox in the analysis - settings. - - -Usage Example: Creating and Marking Single Events -------------------------------------------------- - - -The \__itt_event_create API returns a new event handle that you can -subsequently use to mark user events with the \__itt_event_start API. In -this example, two event type handles are created and used to set the -start points for tracking two different types of events. - - -.. code:: cpp - - - #include "ittnotify.h" - - - __itt_event mark_event = __itt_event_create( "User Mark", 9 ); - __itt_event frame_event = __itt_event_create( "Frame Completed", 15 ); - ... - __itt_event_start( mark_event ); - ... - for( int f ; f`__ (based + on the pre-defined analysis you are interested in) and select the + **Analyze user tasks, events and counters** checkbox in the analysis + settings. + + +Usage Example: Creating and Marking Single Events +------------------------------------------------- + + +The \__itt_event_create API returns a new event handle that you can +subsequently use to mark user events with the \__itt_event_start API. In +this example, two event type handles are created and used to set the +start points for tracking two different types of events. + + +.. code:: cpp + + + #include "ittnotify.h" + + + __itt_event mark_event = __itt_event_create( "User Mark", 9 ); + __itt_event frame_event = __itt_event_create( "Frame Completed", 15 ); + ... + __itt_event_start( mark_event ); + ... + for( int f ; f__itt_frame_end_v3 with NULL as the *id* parameter designates the end of the frame. - - - - -``void __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id);`` - - -Define the end of the frame instance. A ``__itt_frame_end_v3`` call must -be paired with a ``__itt_frame_begin_v3`` call. The first call to -``__itt_frame_end_v3`` with a given ID ends the frame. Successive calls -with the same ID are ignored, as are calls that do not have a matching -``__itt_frame_begin_v3`` call. - - -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *domain*\ - - The domain for this frame instance - * - \ ``[in]``\ - - \ *id*\ - - The instance ID for this frame instance, or NULL for the current instance - - - - -@table_end - - -.. note:: - - - The analysis types based on the hardware event-based sampling - collection are limited to 64 distinct frame domains. - - -Guidelines for Frame API Usage ------------------------------- - - -- Use the frame API to denote the frame begin point and end point. - Consider a frame as the time period between frame begin and end - points. -- VTune Profiler does not attribute the time/samples between - ``__itt_frame_end_v3()`` and ``__itt_frame_begin_v3()`` to any - program unit and displays it as ``[Unknown]`` in the viewpoint. -- If there are consecutive ``__itt_frame_begin_v3`` calls in the same - domain, treat it as a ``__itt_frame_end_v3``/``__itt_frame_begin_v3`` - pair. -- Recursive/nested/overlapping frames for the same domain are not - allowed. -- The ``__itt_frame_begin_v3()`` and ``__itt_frame_end_v3()`` calls can - be made from different threads. -- The recommended maximum rate for calling the frame API is 1000 frames - per second. A higher rate may result in large product memory - consumption and slow finalization. - - -Usage Example -------------- - - -The following example uses the frame API to capture the Elapsed times -for the specified code sections. - - -.. code:: - - - #include "ittnotify.h" - - __itt_domain* pD = __itt_domain_create( L"My Domain" ); - - pD->flags = 1; /* enable domain */ - - for (int i = 0; i < getItemCount(); ++i) - { - __itt_frame_begin_v3(pD, NULL); - do_foo(); - __itt_frame_end_v3(pD, NULL); - } - - //... - - __itt_frame_begin_v3(pD, NULL); - do_foo_1(); - __itt_frame_end_v3(pD, NULL); - - //... - - __itt_frame_begin_v3(pD, NULL); - do_foo_2(); - __itt_frame_end_v3(pD, NULL); - +.. _frame-api: + +Frame API +========= + + +Use the frame API to insert calls to the desired places in your code and +analyze performance per frame, where frame is the time period between +frame begin and end points. When frames are displayed in Intel® VTune™ +Profiler, they are displayed in a separate track, so they provide a way +to visually separate this data from normal task data. + + +Frame API is a per-process function that works in resumed state. This +function does not work in paused state. + + +You can run the frame analysis to: + + +- Analyze Windows OS game applications that use DirectX\* rendering. +- Analyze graphical applications performing repeated calculations. +- Analyze transaction processing on a per transaction basis to discover + input cases that cause bad performance. + + +Frames represent a series of non-overlapping regions of Elapsed time. +Frames are global in nature and not connected with any specific thread. +ITT APIs that enable analyzing code frames and presenting the analysis +data. + + +Adding Frame API to Your Code +----------------------------- + + +Create a domain instance with the ``__itt_domain_create()`` function: + + +.. code:: c + + __itt_domain *ITTAPI__itt_domain_create ( const char *name ); + + +For a domain name, the URI naming style is recommended, for example, +com.my_company.my_application. The set of domains is expected to be +static over the application's execution time, therefore, there is no +mechanism to destroy a domain. Any domain can be accessed by any +thread in the process, regardless of which thread created the domain. +This call is thread-safe. + + +Define the beginning of the frame instance. An ``__itt_frame_begin_v3`` +call must be paired with an ``__itt_frame_end_v3`` call: + + +.. code:: c + + + void __itt_frame_begin_v3(const __itt_domain *domain, __itt_id *id); + + +Successive calls to ``__itt_frame_begin_v3`` with the same ID are +ignored until a call to ``__itt_frame_end_v3`` with the same ID. + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *domain*\ + - The domain for this frame instance + * - \ ``[in]``\ + - \ *id*\ + - The instance ID for this frame instance. Can be NULL, + in which case the next call to ``__itt_frame_end_v3`` + with NULL as the *id* parameter designates the end + of the frame. + + +Define the end of the frame instance. A ``__itt_frame_end_v3`` call must +be paired with a ``__itt_frame_begin_v3`` call. The first call to +``__itt_frame_end_v3`` with a given ID ends the frame. Successive calls +with the same ID are ignored, as are calls that do not have a matching +``__itt_frame_begin_v3`` call: + + +.. code:: c + + + void __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id); + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *domain*\ + - The domain for this frame instance + * - \ ``[in]``\ + - \ *id*\ + - The instance ID for this frame instance, or NULL for the + current instance + + +.. note:: + + + The analysis types based on the hardware event-based sampling + collection are limited to 64 distinct frame domains. + + +Guidelines for Frame API Usage +------------------------------ + + +- Use the frame API to denote the frame begin point and end point. + Consider a frame as the time period between frame begin and end + points. +- VTune Profiler does not attribute the time/samples between + ``__itt_frame_end_v3()`` and ``__itt_frame_begin_v3()`` to any + program unit and displays it as ``[Unknown]`` in the viewpoint. +- If there are consecutive ``__itt_frame_begin_v3`` calls in the same + domain, treat it as a ``__itt_frame_end_v3``/``__itt_frame_begin_v3`` + pair. +- Recursive/nested/overlapping frames for the same domain are not + allowed. +- The ``__itt_frame_begin_v3()`` and ``__itt_frame_end_v3()`` calls can + be made from different threads. +- The recommended maximum rate for calling the frame API is 1000 frames + per second. A higher rate may result in large product memory + consumption and slow finalization. + + +Usage Example +------------- + + +The following example uses the frame API to capture the Elapsed times +for the specified code sections. + + +.. code:: c + + + #include "ittnotify.h" + + __itt_domain* pD = __itt_domain_create( L"My Domain" ); + + pD->flags = 1; /* enable domain */ + + for (int i = 0; i < getItemCount(); ++i) + { + __itt_frame_begin_v3(pD, NULL); + do_foo(); + __itt_frame_end_v3(pD, NULL); + } + + //... + + __itt_frame_begin_v3(pD, NULL); + do_foo_1(); + __itt_frame_end_v3(pD, NULL); + + //... + + __itt_frame_begin_v3(pD, NULL); + do_foo_2(); + __itt_frame_end_v3(pD, NULL); + diff --git a/docs/vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png b/docs/src/ittapi/histogram-api-schema.png similarity index 100% rename from docs/vtune-user-guide/GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png rename to docs/src/ittapi/histogram-api-schema.png diff --git a/docs/vtune-user-guide/histogram-api.rst b/docs/src/ittapi/histogram-api.rst similarity index 94% rename from docs/vtune-user-guide/histogram-api.rst rename to docs/src/ittapi/histogram-api.rst index 2c2275ff..9dbc09f9 100644 --- a/docs/vtune-user-guide/histogram-api.rst +++ b/docs/src/ittapi/histogram-api.rst @@ -1,187 +1,187 @@ -.. _histogram-api: - -Histogram API -============= - - -Use the Histogram API to define histograms that display arbitrary data -in histogram form in Intel® VTune™ Profiler. - - -The Histogram API enables you to define custom histogram graphs in your -code to display arbitrary data of your choice in VTune Profiler. - - -Histograms can be especially useful for showing statistics that can be -split by individual units for cross-comparison. - - -For example, you can use this API in your workload to: - - -- Track load distribution -- Track resource utilization -- Identify oversubscribed or underutilized worker nodes - - -Any histogram instance can be accessed by any thread in the process, -regardless of which thread created the histogram. The Histogram API call -is thread-safe. - - -.. note:: - - - By default, Histogram API data collection and visualization are - available in the `Input and Output - analysis `__ only. To - see the histogram in the result of other analysis types, `create a - custom analysis `__ - based on the pre-defined analysis type you are interested in, and - enable the **Analyze user histogram** checkbox in the `custom - analysis options `__. - - -Define and Create Histogram ---------------------------- - - -Before creating the histogram, an `ITT API -Domain `__ must be -created. The pointer to this domain is then passed to the primitive. - - -The domain name provides a heading for the histogram section on the -**Summary** tab of VTune Profiler result. - - -One domain can combine any number of histograms. However, the name of -the histogram must be unique within the same domain. - - -**Parameters of the primitives:** - - -.. list-table:: - :header-rows: 0 - - * - [in] - - ``domain`` - - Domain controlling the call - * - [in] - - ``name`` - - Histogram name - * - [in] - - ``x_axis_type`` - - Type of X axis data - * - [in] - - ``y_axis_type`` - - Type of Y axis data - - - - -.. container:: fignone - :name: GUID-788CEBA6-9355-4E6D-ADF7-9ED7BD8441A1 - - - |image1| - - -**Primitives:** - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - ``__itt_histogram* _itt_histogram_create(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Linux\* and Android\* OS. - * - ``__itt_histogram* _itt_histogram_createA(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for ASCII strings (``char``). - * - ``__itt_histogram* _itt_histogram_createW(__itt_domain* domain, const wchar_t* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for UNICODE strings (``wchar_t``). - - - - -Submit Data to Histogram ------------------------- - - -**Parameters of the primitives:** - - -.. list-table:: - :header-rows: 0 - - * - [in] - - ``histogram`` - - Histogram instance to submit data to - * - [in] - - ``length`` - - Number of elements in submitted axis data array - * - [in] - - ``x_axis_data`` - - Array containing X axis data (may be ``NULL``). If ``x_axis_data`` is ``NULL``, VTune Profiler uses the indices of the ``y_axis_data`` array. - * - [in] - - ``y_axis_data`` - - Array containing Y axis data. - - - - -**Primitives:** - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - ``void _itt_histogram_submit(__itt_histogram* histogram, size_t length, void* x_axis_data, void* y_axis_data);`` - - Submit user statistics for the selected histogram instance. Array data for the Y-axis is mapped to array data for the X-axis, similar to coordinates of a point on a 2D plane. Data submitted during workload run is summarized into one common histogram for all calls of this primitive. It is recommended to determine an efficient interval between data submissions to lower collection overhead. - - - - -Usage Example -------------- - - -The following example creates a histogram to store worker thread -statistics: - - -.. code:: cpp - - - #include "ittnotify.h" - #include "ittnotify_types.h" - - - void submit_stats() - { - // Create domain - __itt_domain* domain = __itt_domain_create("Histogram statistics domain"); - - - // Create histogram - __itt_histogram* histogram = __itt_histogram_create(domain, "Worker TID 13454", __itt_metadata_u64, __itt_metadata_u64); - - - // Fill the statistics arrays with profiling data: - uint64_t* x_stats, y_stats; - size_t array_size; - get_worker_stats(x_stats, y_stats, array_size); - - - // Submit histogram statistics: - __itt_histogram_submit(histogram, array_size, x_stats, y_stats); - } - - -.. |image1| image:: GUID-B7DAD9A8-CF14-45D0-A8CD-4C84DA066F3D-low.png - :width: 1000px - +.. _histogram-api: + +Histogram API +============= + + +Use the Histogram API to define histograms that display arbitrary data +in histogram form in Intel® VTune™ Profiler. + + +The Histogram API enables you to define custom histogram graphs in your +code to display arbitrary data of your choice in VTune Profiler. + + +Histograms can be especially useful for showing statistics that can be +split by individual units for cross-comparison. + + +For example, you can use this API in your workload to: + + +- Track load distribution +- Track resource utilization +- Identify oversubscribed or underutilized worker nodes + + +Any histogram instance can be accessed by any thread in the process, +regardless of which thread created the histogram. The Histogram API call +is thread-safe. + + +.. note:: + + + By default, Histogram API data collection and visualization are + available in the `Input and Output + analysis `__ only. To + see the histogram in the result of other analysis types, `create a + custom analysis `__ + based on the pre-defined analysis type you are interested in, and + enable the **Analyze user histogram** checkbox in the `custom + analysis options `__. + + +Define and Create Histogram +--------------------------- + + +Before creating the histogram, an `ITT API +Domain `__ must be +created. The pointer to this domain is then passed to the primitive. + + +The domain name provides a heading for the histogram section on the +**Summary** tab of VTune Profiler result. + + +One domain can combine any number of histograms. However, the name of +the histogram must be unique within the same domain. + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - ``domain`` + - Domain controlling the call + * - [in] + - ``name`` + - Histogram name + * - [in] + - ``x_axis_type`` + - Type of X axis data + * - [in] + - ``y_axis_type`` + - Type of Y axis data + + + + +.. container:: fignone + :name: GUID-788CEBA6-9355-4E6D-ADF7-9ED7BD8441A1 + + + |image1| + + +**Primitives:** + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - ``__itt_histogram* _itt_histogram_create(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Linux\* and Android\* OS. + * - ``__itt_histogram* _itt_histogram_createA(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for ASCII strings (``char``). + * - ``__itt_histogram* _itt_histogram_createW(__itt_domain* domain, const wchar_t* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` + - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for UNICODE strings (``wchar_t``). + + + + +Submit Data to Histogram +------------------------ + + +**Parameters of the primitives:** + + +.. list-table:: + :header-rows: 0 + + * - [in] + - ``histogram`` + - Histogram instance to submit data to + * - [in] + - ``length`` + - Number of elements in submitted axis data array + * - [in] + - ``x_axis_data`` + - Array containing X axis data (may be ``NULL``). If ``x_axis_data`` is ``NULL``, VTune Profiler uses the indices of the ``y_axis_data`` array. + * - [in] + - ``y_axis_data`` + - Array containing Y axis data. + + + + +**Primitives:** + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - ``void _itt_histogram_submit(__itt_histogram* histogram, size_t length, void* x_axis_data, void* y_axis_data);`` + - Submit user statistics for the selected histogram instance. Array data for the Y-axis is mapped to array data for the X-axis, similar to coordinates of a point on a 2D plane. Data submitted during workload run is summarized into one common histogram for all calls of this primitive. It is recommended to determine an efficient interval between data submissions to lower collection overhead. + + + + +Usage Example +------------- + + +The following example creates a histogram to store worker thread +statistics: + + +.. code:: cpp + + + #include "ittnotify.h" + #include "ittnotify_types.h" + + + void submit_stats() + { + // Create domain + __itt_domain* domain = __itt_domain_create("Histogram statistics domain"); + + + // Create histogram + __itt_histogram* histogram = __itt_histogram_create(domain, "Worker TID 13454", __itt_metadata_u64, __itt_metadata_u64); + + + // Fill the statistics arrays with profiling data: + uint64_t* x_stats, y_stats; + size_t array_size; + get_worker_stats(x_stats, y_stats, array_size); + + + // Submit histogram statistics: + __itt_histogram_submit(histogram, array_size, x_stats, y_stats); + } + + +.. |image1| image:: histogram-api-schema.png + :width: 800px + diff --git a/docs/vtune-user-guide/load-module-api.rst b/docs/src/ittapi/load-module-api.rst similarity index 97% rename from docs/vtune-user-guide/load-module-api.rst rename to docs/src/ittapi/load-module-api.rst index 2df6b7ab..1a00d933 100644 --- a/docs/vtune-user-guide/load-module-api.rst +++ b/docs/src/ittapi/load-module-api.rst @@ -1,39 +1,39 @@ -.. _load-module-api: - -Load Module API -=============== - - -You can use the Load Module API in your code to analyze a module that -was loaded in an alternate location that cannot otherwise be tracked by -Intel VTune Profiler. For example, this would allow you to analyze code -that is typically executed in an isolated environment to which there is -no visibility of the code. This API allows you to explicitly set the -module location in an address space for analysis by VTune Profiler. - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``void __itt_module_loadW (void* start_addr,void* end_addr, const wchar_t* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - * - \ ``void __itt_module_loadA(void* start_addr, void* end_addr, const char* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - * - \ ``void __itt_module_load(void* start_addr, void* end_addr, const char* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - - - - -Usage Example -------------- - - -.. code:: - - - #include "ittnotify.h" - __itt_module_load(relocatedBaseModuleAddress, relocatedEndModuleAddress, '/some/path/to/dynamic/library.so'); - +.. _load-module-api: + +Load Module API +=============== + + +You can use the Load Module API in your code to analyze a module that +was loaded in an alternate location that cannot otherwise be tracked by +Intel VTune Profiler. For example, this would allow you to analyze code +that is typically executed in an isolated environment to which there is +no visibility of the code. This API allows you to explicitly set the +module location in an address space for analysis by VTune Profiler. + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_module_loadW (void* start_addr,void* end_addr, const wchar_t* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + * - \ ``void __itt_module_loadA(void* start_addr, void* end_addr, const char* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + * - \ ``void __itt_module_load(void* start_addr, void* end_addr, const char* path)``\ + - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. + + + + +Usage Example +------------- + + +.. code:: + + + #include "ittnotify.h" + __itt_module_load(relocatedBaseModuleAddress, relocatedEndModuleAddress, '/some/path/to/dynamic/library.so'); + diff --git a/docs/gpa-user-guide/marker-api.rst b/docs/src/ittapi/marker-api.rst similarity index 100% rename from docs/gpa-user-guide/marker-api.rst rename to docs/src/ittapi/marker-api.rst diff --git a/docs/vtune-user-guide/memory-allocation-apis.rst b/docs/src/ittapi/memory-allocation-apis.rst similarity index 95% rename from docs/vtune-user-guide/memory-allocation-apis.rst rename to docs/src/ittapi/memory-allocation-apis.rst index 0ff82588..b402a766 100644 --- a/docs/vtune-user-guide/memory-allocation-apis.rst +++ b/docs/src/ittapi/memory-allocation-apis.rst @@ -1,134 +1,134 @@ -.. _memory-allocation-apis: - -Memory Allocation APIs -====================== - - -Intel® VTune™ Profiler provides a set of APIs to help it identify the -semantics of your ``malloc``-like heap management functions. - - -Annotating your code with these APIs allows VTune Profiler to correctly -determine memory objects as part of `Memory Access -Analysis `__. - - -Usage Tips ----------- - - -Follow these guidelines when using the memory allocation APIs: - - -- Create *wrapper* functions for your routines, and put the - ``__itt_heap_*_begin`` and ``__itt_heap_*_end`` calls in these - functions. - - -- Allocate a unique domain for each pair of allocate/free functions - when calling ``__itt_heap_function_create``. This allows the VTune - Profiler to verify a matching free function is called for every - allocate function call. - - -- Annotate the beginning and end of every allocate function and free - function. - - -- Call all function pairs from the same stack frame, otherwise the - VTune Profiler assumes an exception occurred and the allocation - attempt failed. - - -- Do not call an end function without first calling the matching begin - function. - - -Using Memory Allocation APIs in Your Code ------------------------------------------ - - -.. list-table:: - :header-rows: 0 - - * - Use This - - To Do This - * - - - Declare a handle type to match begin and end calls and domains. - * - - - Identify allocation functions. - * - - - Identify deallocation functions. - * - - - Identify reallocation functions. Note that ``itt_heap_reallocate_end()`` must be called after the attempt even if no memory is returned. VTune Profiler assumes C-runtime ``realloc`` semantics. - - - - -Usage Example: Heap Allocation ------------------------------- - - -.. code:: cpp - - - #include - - - void* user_defined_malloc(size_t size); - void user_defined_free(void *p); - void* user_defined_realloc(void *p, size_t s); - - - __itt_heap_function my_allocator; - __itt_heap_function my_reallocator; - __itt_heap_function my_freer; - - - void* my_malloc(size_t s) - { - void* p; - - - __itt_heap_allocate_begin(my_allocator, s, 0); - p = user_defined_malloc(s); - __itt_heap_allocate_end(my_allocator, &p, s, 0); - - - return p; - } - - - - - void my_free(void *p) - { - __itt_heap_free_begin (my_freer, p); - user_defined_free(p); - __itt_heap_free_end (my_freer, p); - } - - - void* my_realloc(void *p, size_t s) - { - void *np; - - - __itt_heap_reallocate_begin (my_reallocator, p, s, 0); - np = user_defined_realloc(p, s); - __itt_heap_reallocate_end(my_reallocator, p, &np, s, 0); - - - return(np); - } - - - // Make sure to call this init routine before any calls to - // user defined allocators. - void init_itt_calls() - { - my_allocator = __itt_heap_function_create("my_malloc", "mydomain"); - my_reallocator = __itt_heap_function_create("my_realloc", "mydomain"); - my_freer = __itt_heap_function_create("my_free", "mydomain"); - } - +.. _memory-allocation-apis: + +Memory Allocation APIs +====================== + + +Intel® VTune™ Profiler provides a set of APIs to help it identify the +semantics of your ``malloc``-like heap management functions. + + +Annotating your code with these APIs allows VTune Profiler to correctly +determine memory objects as part of `Memory Access +Analysis `__. + + +Usage Tips +---------- + + +Follow these guidelines when using the memory allocation APIs: + + +- Create *wrapper* functions for your routines, and put the + ``__itt_heap_*_begin`` and ``__itt_heap_*_end`` calls in these + functions. + + +- Allocate a unique domain for each pair of allocate/free functions + when calling ``__itt_heap_function_create``. This allows the VTune + Profiler to verify a matching free function is called for every + allocate function call. + + +- Annotate the beginning and end of every allocate function and free + function. + + +- Call all function pairs from the same stack frame, otherwise the + VTune Profiler assumes an exception occurred and the allocation + attempt failed. + + +- Do not call an end function without first calling the matching begin + function. + + +Using Memory Allocation APIs in Your Code +----------------------------------------- + + +.. list-table:: + :header-rows: 0 + + * - Use This + - To Do This + * - + - Declare a handle type to match begin and end calls and domains. + * - + - Identify allocation functions. + * - + - Identify deallocation functions. + * - + - Identify reallocation functions. Note that ``itt_heap_reallocate_end()`` must be called after the attempt even if no memory is returned. VTune Profiler assumes C-runtime ``realloc`` semantics. + + + + +Usage Example: Heap Allocation +------------------------------ + + +.. code:: cpp + + + #include + + + void* user_defined_malloc(size_t size); + void user_defined_free(void *p); + void* user_defined_realloc(void *p, size_t s); + + + __itt_heap_function my_allocator; + __itt_heap_function my_reallocator; + __itt_heap_function my_freer; + + + void* my_malloc(size_t s) + { + void* p; + + + __itt_heap_allocate_begin(my_allocator, s, 0); + p = user_defined_malloc(s); + __itt_heap_allocate_end(my_allocator, &p, s, 0); + + + return p; + } + + + + + void my_free(void *p) + { + __itt_heap_free_begin (my_freer, p); + user_defined_free(p); + __itt_heap_free_end (my_freer, p); + } + + + void* my_realloc(void *p, size_t s) + { + void *np; + + + __itt_heap_reallocate_begin (my_reallocator, p, s, 0); + np = user_defined_realloc(p, s); + __itt_heap_reallocate_end(my_reallocator, p, &np, s, 0); + + + return(np); + } + + + // Make sure to call this init routine before any calls to + // user defined allocators. + void init_itt_calls() + { + my_allocator = __itt_heap_function_create("my_malloc", "mydomain"); + my_reallocator = __itt_heap_function_create("my_realloc", "mydomain"); + my_freer = __itt_heap_function_create("my_free", "mydomain"); + } + diff --git a/docs/gpa-user-guide/metadata-api.rst b/docs/src/ittapi/metadata-api.rst similarity index 100% rename from docs/gpa-user-guide/metadata-api.rst rename to docs/src/ittapi/metadata-api.rst diff --git a/docs/gpa-user-guide/relation-api.rst b/docs/src/ittapi/relation-api.rst similarity index 100% rename from docs/gpa-user-guide/relation-api.rst rename to docs/src/ittapi/relation-api.rst diff --git a/docs/vtune-user-guide/string-handle-api.rst b/docs/src/ittapi/string-handle-api.rst similarity index 96% rename from docs/vtune-user-guide/string-handle-api.rst rename to docs/src/ittapi/string-handle-api.rst index b0057d6a..22dea063 100644 --- a/docs/vtune-user-guide/string-handle-api.rst +++ b/docs/src/ittapi/string-handle-api.rst @@ -1,38 +1,38 @@ -.. _string-handle-api: - -String Handle API -================= - - -Many API calls require names to identify API objects. String handles are -pointers to names. They enable efficient handling of named objects in -run time and make collected traces data more compact. - - -**To create and return a handle value that can be associated with a -string, use the following primitive:** - - -``__itt_string_handle *ITTAPI__itt_string_handle_create ( const char *name)`` - - -Consecutive calls to ``__itt_string_handle_create`` with the same name -return the same value. The set of string handles is expected to remain -static during the application's execution time, therefore, there is no -mechanism to destroy a string handle. Any string handle can be accessed -by any thread in the process, regardless of which thread created the -string handle. This call is thread-safe. - - -**Parameters of the primitive:** - - -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *name*\ - - The input string - - - +.. _string-handle-api: + +String Handle API +================= + + +Many API calls require names to identify API objects. String handles are +pointers to names. They enable efficient handling of named objects in +run time and make collected traces data more compact. + + +**To create and return a handle value that can be associated with a +string, use the following primitive:** + + +``__itt_string_handle *ITTAPI__itt_string_handle_create ( const char *name)`` + + +Consecutive calls to ``__itt_string_handle_create`` with the same name +return the same value. The set of string handles is expected to remain +static during the application's execution time, therefore, there is no +mechanism to destroy a string handle. Any string handle can be accessed +by any thread in the process, regardless of which thread created the +string handle. This call is thread-safe. + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ *name*\ + - The input string + + + diff --git a/docs/gpa-user-guide/task-api.rst b/docs/src/ittapi/task-api.rst similarity index 86% rename from docs/gpa-user-guide/task-api.rst rename to docs/src/ittapi/task-api.rst index 0df3b756..02eb74da 100644 --- a/docs/gpa-user-guide/task-api.rst +++ b/docs/src/ittapi/task-api.rst @@ -178,9 +178,9 @@ global scope. void do_foo(double seconds); - __itt_domain* domain = __itt_domain_create(__TEXT("MyTraces.MyDomain")); - __itt_string_handle* shMyTask = __itt_string_handle_create(__TEXT("My Task"); - __itt_string_handle* shMySubtask = __itt_string_handle_create(__TEXT("My SubTask")); + __itt_domain* domain = __itt_domain_create("MyTraces.MyDomain"); + __itt_string_handle* shMyTask = __itt_string_handle_create("My Task"); + __itt_string_handle* shMySubtask = __itt_string_handle_create("My SubTask"); void BeginFrame() { @@ -207,3 +207,34 @@ global scope. return 0; } + + #ifdef _WIN32 + #include + + + void do_foo(double seconds) { + clock_t goal = (clock_t)((double)clock() + seconds * CLOCKS_PER_SEC); + while (goal > clock()); + } + #else + #include + + + #define NSEC 1000000000 + #define TYPE long + + + void do_foo(double sec) { + struct timespec start_time; + struct timespec current_time; + + + clock_gettime(CLOCK_REALTIME, &start_time); + while(1) { + clock_gettime(CLOCK_REALTIME, ¤t_time); + TYPE cur_nsec=(long)((current_time.tv_sec-start_time.tv_sec-sec)*NSEC + current_time.tv_nsec - start_time.tv_nsec); + if(cur_nsec>=0) + break; + } + } + #endif diff --git a/docs/vtune-user-guide/thread-naming-api.rst b/docs/src/ittapi/thread-naming-api.rst similarity index 95% rename from docs/vtune-user-guide/thread-naming-api.rst rename to docs/src/ittapi/thread-naming-api.rst index b2e12152..277c9fdc 100644 --- a/docs/vtune-user-guide/thread-naming-api.rst +++ b/docs/src/ittapi/thread-naming-api.rst @@ -1,84 +1,84 @@ -.. _thread-naming-api: - -Thread Naming API -================= - - -By default, each thread in your application displays in the **timeline** -track with a default label generated from the process ID and the thread -ID, or with the OS thread name. You can use the Thread Naming API in -your code to give meaningful names to threads. - - -Thread Naming API is a per-thread function that works in all states -(paused or resumed). You must call this API from within the thread. - - -To set thread name using a char or Unicode string, use the primitive: - - -``void __itt_thread_set_name (const __itt_char *name)`` - - -**Parameters of the primitive:** - - -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ ``name``\ - - The thread name - - - - -**To indicate that this thread should be ignored from analysis:** - - -``void __itt_thread_ignore (void)`` - - -It does not affect the concurrency of the application. It does not be -visible in the **Timeline** pane. - - -If the thread name is set multiple times, only the last name is used. - - -Usage Example -------------- - - -You can use the following thread naming example to give a meaningful -name to the thread you wish to focus on and ignore the service thread. - - -.. code:: cpp - - - DWORD WINAPI service_thread(LPVOID lpArg) - { - __itt_thread_ignore(); - // Do service work here. This thread will not be displayed. - return 0; - } - - - DWORD WINAPI thread_function(LPVOID lpArg) - { - __itt_thread_set_name("My worker thread"); - // Do thread work here - return 0; - } - - - int main(int argc, char* argv[]) - { - ... - CreateThread(NULL, 0, service_thread, NULL, 0, NULL); - CreateThread(NULL, 0, thread_function, NULL, 0, NULL); - ... - return 0; - } - +.. _thread-naming-api: + +Thread Naming API +================= + + +By default, each thread in your application displays in the **timeline** +track with a default label generated from the process ID and the thread +ID, or with the OS thread name. You can use the Thread Naming API in +your code to give meaningful names to threads. + + +Thread Naming API is a per-thread function that works in all states +(paused or resumed). You must call this API from within the thread. + + +To set thread name using a char or Unicode string, use the primitive: + + +``void __itt_thread_set_name (const __itt_char *name)`` + + +**Parameters of the primitive:** + + +.. list-table:: + :header-rows: 0 + + * - \ ``[in]``\ + - \ ``name``\ + - The thread name + + + + +**To indicate that this thread should be ignored from analysis:** + + +``void __itt_thread_ignore (void)`` + + +It does not affect the concurrency of the application. It does not be +visible in the **Timeline** pane. + + +If the thread name is set multiple times, only the last name is used. + + +Usage Example +------------- + + +You can use the following thread naming example to give a meaningful +name to the thread you wish to focus on and ignore the service thread. + + +.. code:: cpp + + + DWORD WINAPI service_thread(LPVOID lpArg) + { + __itt_thread_ignore(); + // Do service work here. This thread will not be displayed. + return 0; + } + + + DWORD WINAPI thread_function(LPVOID lpArg) + { + __itt_thread_set_name("My worker thread"); + // Do thread work here + return 0; + } + + + int main(int argc, char* argv[]) + { + ... + CreateThread(NULL, 0, service_thread, NULL, 0, NULL); + CreateThread(NULL, 0, thread_function, NULL, 0, NULL); + ... + return 0; + } + diff --git a/docs/vtune-user-guide/user-defined-synchronization-api.rst b/docs/src/ittapi/user-defined-synchronization-api.rst similarity index 95% rename from docs/vtune-user-guide/user-defined-synchronization-api.rst rename to docs/src/ittapi/user-defined-synchronization-api.rst index ba89e35b..e591ff95 100644 --- a/docs/vtune-user-guide/user-defined-synchronization-api.rst +++ b/docs/src/ittapi/user-defined-synchronization-api.rst @@ -1,363 +1,358 @@ -.. _user-defined-synchronization-api: - -User-Defined Synchronization API -================================ - - -While the Intel® VTune™ Profiler supports a significant portion of the -Windows\* OS and POSIX\* APIs, it is often useful for you to define your -own synchronization constructs. Any specially built constructs that you -create are not normally tracked by the VTune Profiler. However, the -VTune Profiler includes the synchronization API to help you gather -statistical information related to user-defined synchronization -constructs. - - -The User-Defined Synchronization API is a per-thread function that works -in resumed state. This function does not work in paused state. - - -Synchronization constructs may generally be modeled as a series of -signals. One thread or many threads may wait for a signal from another -group of threads telling them they may proceed with some action. By -tracking when a thread begins waiting for a signal, and then noting when -the signal occurs, the synchronization API can take a user-defined -synchronization object and give you an understanding of your code. The -API uses memory handles along with a set of primitives to gather -statistics on the user-defined synchronization object. - - -.. note:: - - - The User-Defined Synchronization API works with the **Threading** - analysis type. - - -- `Using User-Defined Synchronization API in Your - Code <#USING_USER-DEFINED_SYNC>`__ - - -- `Usage Example: User-Defined - Spin-Waits <#EXAMPLE_USER-DEFINED_SPIN-WAITS>`__ - - -- `Usage Example: User-Defined Synchronized Critical - Section <#EXAMPLE_USER-DEFINED_CRITICAL_SECTION>`__ - - -- `Usage Example: User-Level Synchronized - Barrier <#EXAMPLE_SYNCHRONIZED_BARRIER>`__ - - -Using User-Defined Synchronization API in Your Code ---------------------------------------------------- - - -The following table describes the user-defined synchronization API -primitives, available for use on Windows\* and Linux\* operating -systems: - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``void __itt_sync_create (void *addr, const __itt_char *objtype, const __itt_char *objname, int attribute)``\ - - Register the creation of a sync object using char or Unicode string. - * - ``void __itt_sync_rename (void *addr, const __itt_char *name)`` - - Assign a name to a sync object using char or Unicode string, after it was created. - * - \ ``void __itt_sync_destroy (void *addr)``\ - - Track lifetime of the destroyed object. - * - \ ``void __itt_sync_prepare (void *addr)``\ - - Enter spin loop on user-defined sync object. - * - \ ``void __itt_sync_cancel (void *addr)``\ - - Quit spin loop without acquiring spin object. - * - \ ``void __itt_sync_acquired (void *addr)``\ - - Define successful spin loop completion (sync object acquired). - * - \ ``void __itt_sync_releasing (void *addr)``\ - - Start sync object releasing code. This primitive is called before the lock release call. - - - - -Each API call has a single parameter, addr. The address, not the value, -is used to differentiate between two or more distinct custom -synchronization objects. Each unique address enables the VTune Profiler -to track a separate custom object. Therefore, to use the same custom -object to protect access in different parts of your code, use the same -addr parameter around each. - - -When properly embedded in your code, the primitives tell the VTune -Profiler when the code is attempting to perform some type of -synchronization. Each prepare primitive must be paired with a cancel or -acquired primitive. - - -Each user-defined synchronization construct may involve any number of -synchronization objects. Each synchronization object must be triggered -off of a unique memory handle, which the user-defined synchronization -API uses to track the object. Any number of synchronization objects may -be tracked at one time using the user-defined synchronization API, as -long as each object uses a unique memory pointer. You can think of this -as modeling objects similar to the WaitForMultipleObjects function in -the Windows\* OS API. You can create more complex synchronization -constructs out of a group of synchronization objects; however, it is not -advisable to interlace different user-defined synchronization constructs -as this results in incorrect behavior. - - -|image1|\ API Usage Tips ------------------------- - - -The user-defined synchronization API requires proper placement of the -primitives within your code. Appropriate usage of the user-defined -synchronization API can be accomplished by following these guidelines: - - -- Put a prepare primitive immediately before the code that attempts to - obtain access to a synchronization object. - - -- Put either a cancel primitive or an acquired primitive immediately - after your code is no longer waiting for a synchronization object. - - -- The releasing primitive should be used immediately before the code - signals that it no longer holds a synchronization object. - - -- When using multiple prepare primitives to simulate any construct that - waits for multiple objects, the last individual cancel or acquired - primitive on an object related to the group of prepare primitives - determines if the behavior of the construct is a cancel or acquired - respectively. - - -- The time between a prepare primitive and an acquired primitive may be - considered impact time - - -- The time between a prepare primitive and a cancel primitive is - considered blocking time, even though the processor does not - necessarily block. - - -- Improper use of the user-defined synchronization API results in - incorrect statistical data. - - -Usage Example: User-Defined Spin-Waits --------------------------------------- - - -The prepare API indicates to the VTune Profiler that the current thread -is about to begin waiting for a signal on a memory location. This call -must occur before you invoke the user synchronization construct. The -prepare API must always be paired with a call to either the acquired or -cancel API. - - -The following code snippet shows the use of the prepare and acquired API -used in conjunction with a user-defined spin-wait construct: - - -.. code:: cpp - - - long spin = 1; - . . . . - . . . . - __itt_sync_prepare((void *) &spin ); - while(ResourceBusy); - // spin wait; - __itt_sync_acquired((void *) &spin ); - - -Using the cancel API may be applicable to other scenarios where the -current thread tests the user synchronization construct and decides to -do something useful instead of waiting for a signal from another thread. -See the following code example: - - -.. code:: cpp - - - long spin = 1; - . . . . - . . . . - __itt_sync_prepare((void *) &spin ); - while(ResourceBusy) - { -     __itt_sync_cancel((void *) &spin ); -      - -     // -     // Do useful work -     // -     . . . . . -     . . . . . -     // -     // Once done with the useful work, this construct will test the -     // lock variable and try to acquire it again. Before this can -     // be done, a call to the prepare API is required. -     // -     __itt_sync_prepare((void *) &spin ); - } - __itt_sync_acquired((void *) &spin); - - -After you acquire a lock, you must call the releasing API before the -current thread releases the lock. The following example shows how to use -the releasing API: - - -.. code:: cpp - - - long spin = 1; - . . . . - . . . . - __itt_sync_releasing((void *) &spin ); - // Code here should free the resource - - -Usage Example: User-Defined Synchronized Critical Section ---------------------------------------------------------- - - -The following code snippet shows how to create a critical section -construct that can be tracked using the user-defined synchronization -API: - - -.. code:: cpp - - - CSEnter() - { -   __itt_sync_prepare((void*) &cs); -   while(LockIsUsed) -   { -     if(LockIsFree) -     { -     // Code to actually acquire the lock goes here -     __itt_sync_acquired((void*) &cs); -     } -     if(timeout) -     { -     __itt_sync_cancel((void*) &cs ); -     } -   } - } - CSLeave() - { - if(LockIsMine) -     { -         __itt_sync_releasing((void*) &cs); -         // Code to actually release the lock goes here -     } - } - - -This simple critical section example demonstrates how to use the -user-defined synchronization primitives. When looking at this example, -note the following points: - - -- Each prepare primitive is paired with an acquired primitive or a - cancel primitive. - - -- The prepare primitive is placed immediately before the user code - begins waiting for the user lock. - - -- The acquired primitive is placed immediately after the user code - actually obtains the user lock. - - -- The releasing primitive is placed before the user code actually - releases the user lock. This ensures that another thread does not - call the acquired primitive before the VTune Profiler realizes that - this thread has released the lock. - - -Usage Example: User-Level Synchronized Barrier ----------------------------------------------- - - -Higher level constructs, such as barriers, are also easy to model using -the synchronization API. The following code snippet shows how to create -a barrier construct that can be tracked using the synchronization API: - - -.. code:: cpp - - - Barrier() - { - teamflag = false; - __itt_sync_releasing((void *) &counter); - InterlockedIncrement(&counter); // use the atomic increment primitive appropriate to your OS and compiler - - - if( counter == thread count ) - { - __itt_sync_acquired((void *) &counter); - __itt_sync_releasing((void *) &teamflag); - teamflag = true; - counter = 0; - } - else - { - __ itt_sync_prepare((void *) &teamflag); - Wait for team flag - __ itt_sync_acquired((void *) &teamflag); - } - } - - -When looking at this example, note the following points: - - -- There are two synchronization objects in this barrier code. The - counter object is used to do a gather-like signaling from all the - threads to the final thread indicating that each thread has entered - the barrier. Once the last thread hits the barrier it uses the - teamflag object to signal all the other threads that they may - proceed. - - -- As each thread enters the barrier it calls \__itt_sync_releasing to - tell the VTune Profiler that it is about to signal the last thread by - incrementing counter - - -- The last thread to enter the barrier calls \__itt_sync_acquired to - tell the VTune Profiler that it was successfully signaled by all the - other threads. - - -- The last thread to enter the barrier calls \__itt_sync_releasing to - tell the VTune Profiler that it is going to signal the barrier - completion to all the other threads by setting teamflag - - -- Each thread, except the last, calls the \__itt_sync_prepare primitive - to tell the VTune Profiler that it is about to start waiting for the - teamflag signal from the last thread. - - -- Finally, before leaving the barrier, each thread calls the - \__itt_sync_acquired primitive to tell the VTune Profiler that it - successfully received the end-of-barrier signal. - - -.. |image1| image:: GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif - :width: 25px - :height: 18px - +.. _user-defined-synchronization-api: + +User-Defined Synchronization API +================================ + + +While the Intel® VTune™ Profiler supports a significant portion of the +Windows\* OS and POSIX\* APIs, it is often useful for you to define your +own synchronization constructs. Any specially built constructs that you +create are not normally tracked by the VTune Profiler. However, the +VTune Profiler includes the synchronization API to help you gather +statistical information related to user-defined synchronization +constructs. + + +The User-Defined Synchronization API is a per-thread function that works +in resumed state. This function does not work in paused state. + + +Synchronization constructs may generally be modeled as a series of +signals. One thread or many threads may wait for a signal from another +group of threads telling them they may proceed with some action. By +tracking when a thread begins waiting for a signal, and then noting when +the signal occurs, the synchronization API can take a user-defined +synchronization object and give you an understanding of your code. The +API uses memory handles along with a set of primitives to gather +statistics on the user-defined synchronization object. + + +.. note:: + + + The User-Defined Synchronization API works with the **Threading** + analysis type. + + +- `Using User-Defined Synchronization API in Your + Code <#USING_USER-DEFINED_SYNC>`__ + + +- `Usage Example: User-Defined + Spin-Waits <#EXAMPLE_USER-DEFINED_SPIN-WAITS>`__ + + +- `Usage Example: User-Defined Synchronized Critical + Section <#EXAMPLE_USER-DEFINED_CRITICAL_SECTION>`__ + + +- `Usage Example: User-Level Synchronized + Barrier <#EXAMPLE_SYNCHRONIZED_BARRIER>`__ + + +Using User-Defined Synchronization API in Your Code +--------------------------------------------------- + + +The following table describes the user-defined synchronization API +primitives, available for use on Windows\* and Linux\* operating +systems: + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``void __itt_sync_create (void *addr, const __itt_char *objtype, const __itt_char *objname, int attribute)``\ + - Register the creation of a sync object using char or Unicode string. + * - ``void __itt_sync_rename (void *addr, const __itt_char *name)`` + - Assign a name to a sync object using char or Unicode string, after it was created. + * - \ ``void __itt_sync_destroy (void *addr)``\ + - Track lifetime of the destroyed object. + * - \ ``void __itt_sync_prepare (void *addr)``\ + - Enter spin loop on user-defined sync object. + * - \ ``void __itt_sync_cancel (void *addr)``\ + - Quit spin loop without acquiring spin object. + * - \ ``void __itt_sync_acquired (void *addr)``\ + - Define successful spin loop completion (sync object acquired). + * - \ ``void __itt_sync_releasing (void *addr)``\ + - Start sync object releasing code. This primitive is called before the lock release call. + + + + +Each API call has a single parameter, addr. The address, not the value, +is used to differentiate between two or more distinct custom +synchronization objects. Each unique address enables the VTune Profiler +to track a separate custom object. Therefore, to use the same custom +object to protect access in different parts of your code, use the same +addr parameter around each. + + +When properly embedded in your code, the primitives tell the VTune +Profiler when the code is attempting to perform some type of +synchronization. Each prepare primitive must be paired with a cancel or +acquired primitive. + + +Each user-defined synchronization construct may involve any number of +synchronization objects. Each synchronization object must be triggered +off of a unique memory handle, which the user-defined synchronization +API uses to track the object. Any number of synchronization objects may +be tracked at one time using the user-defined synchronization API, as +long as each object uses a unique memory pointer. You can think of this +as modeling objects similar to the WaitForMultipleObjects function in +the Windows\* OS API. You can create more complex synchronization +constructs out of a group of synchronization objects; however, it is not +advisable to interlace different user-defined synchronization constructs +as this results in incorrect behavior. + + +API Usage Tips +-------------- + + +The user-defined synchronization API requires proper placement of the +primitives within your code. Appropriate usage of the user-defined +synchronization API can be accomplished by following these guidelines: + + +- Put a prepare primitive immediately before the code that attempts to + obtain access to a synchronization object. + + +- Put either a cancel primitive or an acquired primitive immediately + after your code is no longer waiting for a synchronization object. + + +- The releasing primitive should be used immediately before the code + signals that it no longer holds a synchronization object. + + +- When using multiple prepare primitives to simulate any construct that + waits for multiple objects, the last individual cancel or acquired + primitive on an object related to the group of prepare primitives + determines if the behavior of the construct is a cancel or acquired + respectively. + + +- The time between a prepare primitive and an acquired primitive may be + considered impact time + + +- The time between a prepare primitive and a cancel primitive is + considered blocking time, even though the processor does not + necessarily block. + + +- Improper use of the user-defined synchronization API results in + incorrect statistical data. + + +Usage Example: User-Defined Spin-Waits +-------------------------------------- + + +The prepare API indicates to the VTune Profiler that the current thread +is about to begin waiting for a signal on a memory location. This call +must occur before you invoke the user synchronization construct. The +prepare API must always be paired with a call to either the acquired or +cancel API. + + +The following code snippet shows the use of the prepare and acquired API +used in conjunction with a user-defined spin-wait construct: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_prepare((void *) &spin ); + while(ResourceBusy); + // spin wait; + __itt_sync_acquired((void *) &spin ); + + +Using the cancel API may be applicable to other scenarios where the +current thread tests the user synchronization construct and decides to +do something useful instead of waiting for a signal from another thread. +See the following code example: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_prepare((void *) &spin ); + while(ResourceBusy) + { +     __itt_sync_cancel((void *) &spin ); +      + +     // +     // Do useful work +     // +     . . . . . +     . . . . . +     // +     // Once done with the useful work, this construct will test the +     // lock variable and try to acquire it again. Before this can +     // be done, a call to the prepare API is required. +     // +     __itt_sync_prepare((void *) &spin ); + } + __itt_sync_acquired((void *) &spin); + + +After you acquire a lock, you must call the releasing API before the +current thread releases the lock. The following example shows how to use +the releasing API: + + +.. code:: cpp + + + long spin = 1; + . . . . + . . . . + __itt_sync_releasing((void *) &spin ); + // Code here should free the resource + + +Usage Example: User-Defined Synchronized Critical Section +--------------------------------------------------------- + + +The following code snippet shows how to create a critical section +construct that can be tracked using the user-defined synchronization +API: + + +.. code:: cpp + + + CSEnter() + { +   __itt_sync_prepare((void*) &cs); +   while(LockIsUsed) +   { +     if(LockIsFree) +     { +     // Code to actually acquire the lock goes here +     __itt_sync_acquired((void*) &cs); +     } +     if(timeout) +     { +     __itt_sync_cancel((void*) &cs ); +     } +   } + } + CSLeave() + { + if(LockIsMine) +     { +         __itt_sync_releasing((void*) &cs); +         // Code to actually release the lock goes here +     } + } + + +This simple critical section example demonstrates how to use the +user-defined synchronization primitives. When looking at this example, +note the following points: + + +- Each prepare primitive is paired with an acquired primitive or a + cancel primitive. + + +- The prepare primitive is placed immediately before the user code + begins waiting for the user lock. + + +- The acquired primitive is placed immediately after the user code + actually obtains the user lock. + + +- The releasing primitive is placed before the user code actually + releases the user lock. This ensures that another thread does not + call the acquired primitive before the VTune Profiler realizes that + this thread has released the lock. + + +Usage Example: User-Level Synchronized Barrier +---------------------------------------------- + + +Higher level constructs, such as barriers, are also easy to model using +the synchronization API. The following code snippet shows how to create +a barrier construct that can be tracked using the synchronization API: + + +.. code:: cpp + + + Barrier() + { + teamflag = false; + __itt_sync_releasing((void *) &counter); + InterlockedIncrement(&counter); // use the atomic increment primitive appropriate to your OS and compiler + + + if( counter == thread count ) + { + __itt_sync_acquired((void *) &counter); + __itt_sync_releasing((void *) &teamflag); + teamflag = true; + counter = 0; + } + else + { + __ itt_sync_prepare((void *) &teamflag); + Wait for team flag + __ itt_sync_acquired((void *) &teamflag); + } + } + + +When looking at this example, note the following points: + + +- There are two synchronization objects in this barrier code. The + counter object is used to do a gather-like signaling from all the + threads to the final thread indicating that each thread has entered + the barrier. Once the last thread hits the barrier it uses the + teamflag object to signal all the other threads that they may + proceed. + + +- As each thread enters the barrier it calls \__itt_sync_releasing to + tell the VTune Profiler that it is about to signal the last thread by + incrementing counter + + +- The last thread to enter the barrier calls \__itt_sync_acquired to + tell the VTune Profiler that it was successfully signaled by all the + other threads. + + +- The last thread to enter the barrier calls \__itt_sync_releasing to + tell the VTune Profiler that it is going to signal the barrier + completion to all the other threads by setting teamflag + + +- Each thread, except the last, calls the \__itt_sync_prepare primitive + to tell the VTune Profiler that it is about to start waiting for the + teamflag signal from the last thread. + + +- Finally, before leaving the barrier, each thread calls the + \__itt_sync_acquired primitive to tell the VTune Profiler that it + successfully received the end-of-barrier signal. + diff --git a/docs/src/jit-api-reference.rst b/docs/src/jit-api-reference.rst new file mode 100644 index 00000000..b5b18406 --- /dev/null +++ b/docs/src/jit-api-reference.rst @@ -0,0 +1,13 @@ +.. _jit-api-reference: + +JIT API Reference +================= + +.. toctree:: + :maxdepth: 1 + + + jitapi/ijit_notifyevent + jitapi/ijit_isprofilingactive + jitapi/ijit_-getnewmethodid + diff --git a/docs/vtune-user-guide/jit-profiling-api.rst b/docs/src/jit-api-support.rst similarity index 66% rename from docs/vtune-user-guide/jit-profiling-api.rst rename to docs/src/jit-api-support.rst index 18184397..8838df79 100644 --- a/docs/vtune-user-guide/jit-profiling-api.rst +++ b/docs/src/jit-api-support.rst @@ -1,335 +1,303 @@ -.. _jit-profiling-api: - -JIT Profiling API -================= - - -.. note:: - - - The Instrumentation and Tracing Technology API (ITT API) and the - Just-in-Time Profiling API (JIT API) are open source components. You - can access the source code and make contributions in the `GitHub\* - repository `__. - - -The JIT (Just-In-Time) Profiling API provides functionality to report -information about just-in-time generated code that can be used by -performance tools. You must insert JIT Profiling API calls in the code -generator to report information before JIT-compiled code goes to -execution. This information is collected at runtime and used by tools -like Intel® VTune™ Profiler to display performance metrics associated -with JIT-compiled code. - - -You can use the JIT Profiling API to profile such environments as -dynamic JIT compilation of JavaScript code traces, JIT execution in -OpenCL™ applications, Java*/.NET\* managed execution environments, and -custom ISV JIT engines. - - -The standard VTune Profiler installation contains a static part (as a -static library and source files) and a profiler object. The JIT engine -generating code during runtime communicates with a profiler object -through the static part. During runtime, the JIT engine reports the -information about JIT-compiled code stored in a trace file by the -profiler object. After collection, the VTune Profiler uses the generated -trace file to resolve the JIT-compiled code. If VTune Profiler is not -installed, profiling is disabled. - - -Use the JIT Profiling API to: - - -- :ref:`Profile trace-based and method-based JIT-compiled code` - - -- :ref:`Analyze split functions` - - -- :ref:`Explore inline functions` - - -JIT profiling is supported with the **Launch Application** target option -for event based sampling. - - -Environment Variables in the JIT Profiling API ----------------------------------------------- - - -The JIT Profiling API contains two environment variables, which in turn -contain paths to specific runtime libraries. - - -- ``INTEL_JIT_PROFILER32`` -- ``INTEL_JIT_PROFILER64`` - - -These variables are used to signal the replacement of the stub -implementation of the JIT API with the VTune Profiler JIT API collector. -Once you instrument your code with the JIT API and link it to the VTune -Profiler JIT API stub (``libjitprofiling.lib/libjitprofiling.a``), your code -loads the libraries defined in these environment variables, once the -variables are set. - - - - -Make sure to set these environment variables for the ittnotify_collector to enable data collection: - -On Windows*: - -.. code-block:: bash - - INTEL_JIT_PROFILER32=\bin32\runtime\ittnotify_collector.dll - INTEL_JIT_PROFILER64=\bin64\runtime\ittnotify_collector.dll - -On Linux*: - -.. code-block:: bash - - INTEL_JIT_PROFILER32=/lib32/runtime/libittnotify_collector.so - INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so - -On FreeBSD*: - -.. code-block:: bash - - INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so - - -.. _Profile trace-based and method-based JIT-compiled code : - -Profile Trace-based and Method-based JIT-compiled Code ------------------------------------------------------- - - -This is the most common scenario for using JIT Profiling API to profile -trace-based and method-based JIT-compiled code: - - -.. code:: cpp - - - #include - - - if (iJIT_IsProfilingActive() != iJIT_SAMPLING_ON) { - return; - } - - - iJIT_Method_Load jmethod = {0}; - jmethod.method_id = iJIT_GetNewMethodID(); - jmethod.method_name = "method_name"; - jmethod.class_file_name = "class_name"; - jmethod.source_file_name = "source_file_name"; - jmethod.method_load_address = code_addr; - jmethod.method_size = code_size; - - - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, - (void*)&jmethod); - iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL); - - -**Usage Tips** - - -- If any ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an - already reported method, then such a method becomes invalid and its - memory region is treated as unloaded. VTune Profiler displays the - metrics collected by the method until it is overwritten. - - -- If supplied line number information contains multiple source lines - for the same assembly instruction (code location), then VTune - Profiler picks up the first line number. - - -- Dynamically generated code can be associated with a module name. Use - the ``iJIT_Method_Load_V2`` structure. - - - - If you register a function with the same method ID multiple times, - specifying different module names, then the VTune Profiler picks - up the module name registered first. If you want to distinguish - the same function between different JIT engines, supply different - method IDs for each function. Other symbolic information (for - example, source file) can be identical. - -.. _Analyze split functions : - -Analyze Split Functions ------------------------ - - -You can use the JIT Profiling API to analyze split functions (multiple -joint or disjoint code regions belonging to the same function) including -re-JITting with potential overlapping of code regions in time, which is -common in resource-limited environments. - - -.. code:: cpp - - - - - #include - - - unsigned int method_id = iJIT_GetNewMethodID(); - - - iJIT_Method_Load a = {0}; - a.method_id = method_id; - a.method_load_address = 0x100; - a.method_size = 0x20; - - - iJIT_Method_Load b = {0}; - b.method_id = method_id; - b.method_load_address = 0x200; - b.method_size = 0x30; - - - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b) - - -**Usage Tips** - - -- If a ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an - already reported method, then such a method becomes invalid and its - memory region is treated as unloaded. - - -- All code regions reported with the same method ID are considered as - belonging to the same method. Symbolic information (method name, - source file name) will be taken from the first notification, and all - subsequent notifications with the same method ID will be processed - only for line number table information. So, the VTune Profiler will - map samples to a source line using the line number table from the - current notification while taking the source file name from the very - first one. - - - - If you register a second code region with a different source file - name and the same method ID, this information will be saved and - will not be considered as an extension of the first code region, - but VTune Profiler will use the source file of the first code - region and map performance metrics incorrectly. - - - - If you register a second code region with the same source file as - for the first region and the same method ID, the source file will - be discarded but VTune Profiler will map metrics to the source - file correctly. - - - - If you register a second code region with a null source file and - the same method ID, provided line number info will be associated - with the source file of the first code region. - -.. _Explore inline functions: - -Explore Inline Functions ------------------------- - - -You can use the JIT Profiling API to explore inline functions including -multi-level hierarchy of nested inline methods that shows how -performance metrics are distributed through them. - - -.. code:: cpp - - - #include - - - // method_id parent_id - // [-- c --] 3000 2000 - // [---- d -----] 2001 1000 - // [---- b ----] 2000 1000 - // [------------ a ----------------] 1000 n/a - - - iJIT_Method_Load a = {0}; - a.method_id = 1000; - - - iJIT_Method_Inline_Load b = {0}; - b.method_id = 2000; - b.parent_method_id = 1000; - - - iJIT_Method_Inline_Load c = {0}; - c.method_id = 3000; - c.parent_method_id = 2000; - - - iJIT_Method_Inline_Load d = {0}; - d.method_id = 2001; - d.parent_method_id = 1000; - - - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&b); - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&c); - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&d); - - -**Usage Tips** - - -- Each inline (``iJIT_Method_Inline_Load``) method should be associated - with two method IDs: one for itself; one for its immediate parent. - - -- Address regions of inline methods of the same parent method cannot - overlap each other. - - -- Execution of the parent method must not be started until it and all - its inline methods are reported. - - -- In case of nested inline methods an order of - ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` events is not - important. - - -- If any event overwrites either inline method or top parent method, - then the parent, including inline methods, becomes invalid and its - memory region is treated as unloaded. - - -.. container:: See Also - - - .. rubric:: See Also - - .. container:: linklist - - - `JIT Profiling API - Reference `__ - - - `Using JIT Profiling - API `__ - - -`Basic Usage and -Configuration `__ See -prerequisites here - -.. toctree:: - :maxdepth: 1 - - - using-jit-profiling-api - jit-profiling-api-reference \ No newline at end of file +.. _jit-api-support: + +JIT API +======= + + +The JIT (Just-In-Time) Profiling API provides functionality to report +information about just-in-time generated code that can be used by +performance tools. You must insert JIT Profiling API calls in the code +generator to report information before JIT-compiled code goes to +execution. This information is collected at runtime and used by tools +like Intel® VTune™ Profiler to display performance metrics associated +with JIT-compiled code. + + +You can use the JIT Profiling API to profile such environments as +dynamic JIT compilation of JavaScript code traces, JIT execution in +OpenCL™ applications, Java*/.NET\* managed execution environments, and +custom ISV JIT engines. + + +The JIT engine generating code during runtime communicates with a profiler +object (Collector) through the static part. During runtime, the JIT engine +reports the information about JIT-compiled code stored in a trace file by +the profiler object. After collection, profiling tool uses the generated +trace file to resolve the JIT-compiled code. + + +Use the JIT Profiling API to: + + +- :ref:`Profile trace-based and method-based JIT-compiled code` + + +- :ref:`Analyze split functions` + + +- :ref:`Explore inline functions` + + +JIT profiling is supported with the **Launch Application** target option +for event based sampling. + + +Environment Variables in the JIT Profiling API +---------------------------------------------- + + +The JIT Profiling API contains two environment variables, which in turn +contain paths to specific runtime libraries. + + +- ``INTEL_JIT_PROFILER32`` +- ``INTEL_JIT_PROFILER64`` + + +These variables are used to signal the replacement of the stub +implementation of the JIT API with the JIT API collector. +Once you instrument your code with the JIT API and link it to the +JIT API stub (``libjitprofiling.lib/libjitprofiling.a``), your code +loads the libraries defined in these environment variables, once the +variables are set. + + +Make sure to set these environment variables for the ittnotify_collector +to enable data collection: + +On Windows*: + +.. code-block:: bash + + INTEL_JIT_PROFILER32=\bin32\runtime\ittnotify_collector.dll + INTEL_JIT_PROFILER64=\bin64\runtime\ittnotify_collector.dll + +On Linux*: + +.. code-block:: bash + + INTEL_JIT_PROFILER32=/lib32/runtime/libittnotify_collector.so + INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so + +On FreeBSD*: + +.. code-block:: bash + + INTEL_JIT_PROFILER64=/lib64/runtime/libittnotify_collector.so + + +.. _Profile trace-based and method-based JIT-compiled code : + +Profile Trace-based and Method-based JIT-compiled Code +------------------------------------------------------ + + +This is the most common scenario for using JIT Profiling API to profile +trace-based and method-based JIT-compiled code: + + +.. code:: cpp + + + #include + + + if (iJIT_IsProfilingActive() != iJIT_SAMPLING_ON) { + return; + } + + + iJIT_Method_Load jmethod = {0}; + jmethod.method_id = iJIT_GetNewMethodID(); + jmethod.method_name = "method_name"; + jmethod.class_file_name = "class_name"; + jmethod.source_file_name = "source_file_name"; + jmethod.method_load_address = code_addr; + jmethod.method_size = code_size; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, + (void*)&jmethod); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL); + + +**Usage Tips** + + +- If any ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an + already reported method, then such a method becomes invalid and its + memory region is treated as unloaded. + + +- If supplied line number information contains multiple source lines + for the same assembly instruction (code location), then profiling + tool picks up the first line number. + + +- Dynamically generated code can be associated with a module name. Use + the ``iJIT_Method_Load_V2`` structure. + + +- If you register a function with the same method ID multiple times, + specifying different module names, then profiling tool picks + up the module name registered first. If you want to distinguish + the same function between different JIT engines, supply different + method IDs for each function. Other symbolic information (for + example, source file) can be identical. + +.. _Analyze split functions : + +Analyze Split Functions +----------------------- + + +You can use the JIT Profiling API to analyze split functions (multiple +joint or disjoint code regions belonging to the same function) including +re-JITting with potential overlapping of code regions in time, which is +common in resource-limited environments. + + +.. code:: cpp + + + + + #include + + + unsigned int method_id = iJIT_GetNewMethodID(); + + + iJIT_Method_Load a = {0}; + a.method_id = method_id; + a.method_load_address = 0x100; + a.method_size = 0x20; + + + iJIT_Method_Load b = {0}; + b.method_id = method_id; + b.method_load_address = 0x200; + b.method_size = 0x30; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b) + + +**Usage Tips** + + +- If a ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an + already reported method, then such a method becomes invalid and its + memory region is treated as unloaded. + + +- All code regions reported with the same method ID are considered as + belonging to the same method. Symbolic information (method name, + source file name) will be taken from the first notification, and all + subsequent notifications with the same method ID will be processed + only for line number table information. + + +- If you register a second code region with a different source file + name and the same method ID, this information will be saved and + will not be considered as an extension of the first code region, + but profiling tool will use the source file of the first code + region and map performance metrics incorrectly. + + +- If you register a second code region with the same source file as + for the first region and the same method ID, the source file will + be discarded but profiling tool will map metrics to the source + file correctly. + + +- If you register a second code region with a null source file and + the same method ID, provided line number info will be associated + with the source file of the first code region. + +.. _Explore inline functions: + +Explore Inline Functions +------------------------ + + +You can use the JIT Profiling API to explore inline functions including +multi-level hierarchy of nested inline methods that shows how +performance metrics are distributed through them. + + +.. code:: cpp + + + #include + + + // method_id parent_id + // [-- c --] 3000 2000 + // [---- d -----] 2001 1000 + // [---- b ----] 2000 1000 + // [------------ a ----------------] 1000 n/a + + + iJIT_Method_Load a = {0}; + a.method_id = 1000; + + + iJIT_Method_Inline_Load b = {0}; + b.method_id = 2000; + b.parent_method_id = 1000; + + + iJIT_Method_Inline_Load c = {0}; + c.method_id = 3000; + c.parent_method_id = 2000; + + + iJIT_Method_Inline_Load d = {0}; + d.method_id = 2001; + d.parent_method_id = 1000; + + + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&b); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&c); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED, (void*)&d); + + +**Usage Tips** + + +- Each inline (``iJIT_Method_Inline_Load``) method should be associated + with two method IDs: one for itself; one for its immediate parent. + + +- Address regions of inline methods of the same parent method cannot + overlap each other. + + +- Execution of the parent method must not be started until it and all + its inline methods are reported. + + +- In case of nested inline methods an order of + ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` events is not + important. + + +- If any event overwrites either inline method or top parent method, + then the parent, including inline methods, becomes invalid and its + memory region is treated as unloaded. + + +See Also +-------- + + +.. toctree:: + :maxdepth: 1 + + + using-jit-api + jit-api-reference + diff --git a/docs/vtune-user-guide/ijit_-getnewmethodid.rst b/docs/src/jitapi/ijit_-getnewmethodid.rst similarity index 87% rename from docs/vtune-user-guide/ijit_-getnewmethodid.rst rename to docs/src/jitapi/ijit_-getnewmethodid.rst index 2884d3e4..46155b07 100644 --- a/docs/vtune-user-guide/ijit_-getnewmethodid.rst +++ b/docs/src/jitapi/ijit_-getnewmethodid.rst @@ -1,40 +1,42 @@ -.. _ijit_-getnewmethodid: - -iJIT\_ GetNewMethodID -===================== - - -Generates a new unique method ID. - - -Syntax ------- - - -unsigned int iJIT_GetNewMethodID(void); - - -Description ------------ - - -The\ ``iJIT_GetNewMethodID`` function generates new method ID upon each -call. Use this API to obtain unique and valid method IDs for methods or -traces reported to the agent if you do not have your own mechanism to -generate unique method IDs. - - -Input Parameters ----------------- - - -None - - -Return Values -------------- - - -A new unique method ID. When out of unique method IDs, this API function -returns 0. - +.. _ijit_-getnewmethodid: + +iJIT\_ GetNewMethodID +===================== + + +Generates a new unique method ID. + + +Syntax +------ + +.. code:: cpp + + + unsigned int iJIT_GetNewMethodID(void); + + +Description +----------- + + +The\ ``iJIT_GetNewMethodID`` function generates new method ID upon each +call. Use this API to obtain unique and valid method IDs for methods or +traces reported to the agent if you do not have your own mechanism to +generate unique method IDs. + + +Input Parameters +---------------- + + +None + + +Return Values +------------- + + +A new unique method ID. When out of unique method IDs, this API function +returns 0. + diff --git a/docs/vtune-user-guide/ijit_isprofilingactive.rst b/docs/src/jitapi/ijit_isprofilingactive.rst similarity index 80% rename from docs/vtune-user-guide/ijit_isprofilingactive.rst rename to docs/src/jitapi/ijit_isprofilingactive.rst index 633f5b81..a86191f6 100644 --- a/docs/vtune-user-guide/ijit_isprofilingactive.rst +++ b/docs/src/jitapi/ijit_isprofilingactive.rst @@ -1,38 +1,40 @@ -.. _ijit_isprofilingactive: - -iJIT_IsProfilingActive -====================== - - -Returns the current mode of the agent. - - -Syntax ------- - - -iJIT_IsProfilingActiveFlags JITAPI iJIT IsProfilingActive ( void ) - - -Description ------------ - - -The ``iJIT_IsProfilingActive`` function returns the current mode of the -agent. - - -Input Parameters ----------------- - - -None - - -Return Values -------------- - - -``iJIT_SAMPLING_ON``, indicating that agent is running, or -``iJIT_NOTHING_RUNNING`` if no agent is running. - +.. _ijit_isprofilingactive: + +iJIT_IsProfilingActive +====================== + + +Returns the current mode of the agent. + + +Syntax +------ + +.. code:: cpp + + + iJIT_IsProfilingActiveFlags JITAPI iJIT IsProfilingActive ( void ); + + +Description +----------- + + +The ``iJIT_IsProfilingActive`` function returns the current mode of the +agent. + + +Input Parameters +---------------- + + +None + + +Return Values +------------- + + +``iJIT_SAMPLING_ON``, indicating that agent is running, or +``iJIT_NOTHING_RUNNING`` if no agent is running. + diff --git a/docs/vtune-user-guide/ijit_notifyevent.rst b/docs/src/jitapi/ijit_notifyevent.rst similarity index 69% rename from docs/vtune-user-guide/ijit_notifyevent.rst rename to docs/src/jitapi/ijit_notifyevent.rst index 7a07de75..b12263b5 100644 --- a/docs/vtune-user-guide/ijit_notifyevent.rst +++ b/docs/src/jitapi/ijit_notifyevent.rst @@ -1,257 +1,295 @@ -.. _ijit_notifyevent: - -iJIT_NotifyEvent -================ - - -Reports information about JIT-compiled code to the agent. - - -Syntax ------- - - -int iJIT_NotifyEvent(iJIT_JVM_EVENT event_type,void -\*EventSpecificData); - - -Description ------------ - - -The ``iJIT_NotifyEvent``\ function sends a notification of -``event_type`` with the data pointed by ``EventSpecificData`` to the -agent. The reported information is used to attribute samples obtained -from any Intel® VTune™ Profiler collector. This API needs to be called -after JIT compilation and before the first entry into the JIT-compiled -code. - - -Input Parameters ----------------- - - -.. list-table:: - :header-rows: 0 - - * - Parameter - - Description - * - \ ``iJIT_JVM_EVENT event_type``\ - - Notification code sent to the agent. See a complete list of `event types <#EVENT_TYPE>`__ below. - * - \ ``void *EventSpecificData``\ - - Pointer to `event specific data <#STRUCTURE>`__. - - - - -The following values are allowed for ``event_type``: - - -.. list-table:: - :header-rows: 0 - - * - - - Send this notification after a JITted method has been loaded into memory, and possibly JIT compiled, but before the code is executed. Use the ``iJIT_Method_Load`` structure for ``EventSpecificData``. The return value of ``iJIT_NotifyEvent``\ is undefined. - * - \ ``iJVM_EVENT_TYPE_SHUTDOWN``\ - - Send this notification to terminate profiling. Use NULL for ``EventSpecificData``. ``iJIT_NotifyEvent`` returns 1 on success. - * - \ ``JVM_EVENT_TYPE_METHOD_UPDATE``\ - - Send this notification to provide new content for a previously reported dynamic code. The previous content will be invalidated starting from the time of the notification. Use the ``iJIT_Method_Load`` structure for ``EventSpecificData`` with the following required fields: - * - - - Send this notification when an inline dynamic code is JIT compiled and loaded into memory by the JIT engine, but before the parent code region starts executing. Use the ``iJIT_Method_Inline_Load`` structure for ``EventSpecificData``. - * - - - Send this notification when a dynamic code is JIT compiled and loaded into memory by the JIT engine, but before the code is executed. Use the ``iJIT_Method_Load_V2`` structure for ``EventSpecificData``. - - - - -The following structures can be used for ``EventSpecificData``: - - -**iJIT_Method_Inline_Load Structure** - - -When you use the ``iJIT_Method_Inline_Load`` structure to describe the -JIT compiled method, use ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` -as an event type to report it. The\ ``iJIT_Method_Inline_Load`` -structure has the following fields: - - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. - * - \ ``unsigned int parent_method_id``\ - - Unique immediate parent’s method ID. Method ID may not be smaller than 999. You must either use the API function iJIT_GetNewMethodID to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - - - - -**iJIT_Method_Load Structure** - - -When you use the\ ``iJIT_Method_Load`` structure to describe the JIT -compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` as an -event type to report it. The\ ``iJIT_Method_Load`` structure has the -following fields: - - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. - * - \ ``unsigned int class_id``\ - - This field is obsolete. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - * - \ ``void *user_data``\ - - This field is obsolete. - * - \ ``unsigned int user_data_size``\ - - This field is obsolete. - * - \ ``iJDEnvironmentType env``\ - - This field is obsolete. - - - - -**iJIT_Method_Load_V2 Structure** - - -When you use the ``iJIT_Method_Load_V2`` structure to describe the JIT -compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2`` as an -event type to report it. The\ ``iJIT_Method_Load_V2`` structure has the -following fields: - - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must either use the API function ``iJIT_GetNewMethodID`` to get a valid and unique method ID, or else manage ID uniqueness and correct range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name and appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` is 0. See ``LineNumberInfo`` structure for a description of a single entry in the line number info array. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - * - \ ``char *module_name``\ - - Module name. Can be NULL. The module name can be useful for distinguishing among different JIT engines. VTune Profiler will display reported methods grouped by specific module. - - - - -**LineNumberInfo Structure** - - -Use the ``LineNumberInfo`` structure to describe a single entry in the -line number information of a code region. A table of line number entries -provides information about how the reported code region is mapped to -source file. VTune Profiler uses line number information to attribute -the samples (virtual address) to a line number. It is acceptable to -report different code addresses for the same source line: - - -.. list-table:: - :header-rows: 0 - - * - \ **Offset**\ - - \ **Line Number**\ - * - 1 - - 2 - * - 12 - - 4 - * - 15 - - 2 - * - 18 - - 1 - * - 21 - - 30 - - - - -VTune Profiler constructs the following table using the client data: - - -.. list-table:: - :header-rows: 0 - - * - \ **Code sub-range**\ - - \ **Line Number**\ - * - 0-1 - - 2 - * - 1-12 - - 4 - * - 12-15 - - 2 - * - 15-18 - - 1 - * - 18-21 - - 30 - - - - -The ``LineNumberInfo`` structure has the following fields: - - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int Offset``\ - - Opcode byte offset from the beginning of the method. - * - \ ``unsigned int LineNumber``\ - - Matching source line number offset (from beginning of source file). - - - - -Return Values -------------- - - -The return values are dependent on the particular ``iJIT_JVM_EVENT``. - +.. _ijit_notifyevent: + +iJIT_NotifyEvent +================ + + +Reports information about JIT-compiled code to the agent. + + +Syntax +------ + +.. code:: cpp + + + int iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void EventSpecificData); + + +Description +----------- + + +The ``iJIT_NotifyEvent``\ function sends a notification of +``event_type`` with the data pointed by ``EventSpecificData`` to the +agent. The reported information is used to attribute samples obtained +from any profiling tool collector. This API needs to be called +after JIT compilation and before the first entry into the JIT-compiled +code. + + +Input Parameters +---------------- + + +.. list-table:: + :header-rows: 0 + + * - Parameter + - Description + * - \ ``iJIT_JVM_EVENT event_type``\ + - Notification code sent to the agent. See a complete list of + `event types <#EVENT_TYPE>`__ below. + * - \ ``void *EventSpecificData``\ + - Pointer to `event specific data <#STRUCTURE>`__. + + + + +The following values are allowed for ``event_type``: + + +.. list-table:: + :header-rows: 0 + + * - + - Send this notification after a JITted method has been loaded into + memory, and possibly JIT compiled, but before the code is executed. + Use the ``iJIT_Method_Load`` structure for ``EventSpecificData``. + The return value of ``iJIT_NotifyEvent``\ is undefined. + * - \ ``iJVM_EVENT_TYPE_SHUTDOWN``\ + - Send this notification to terminate profiling. Use NULL for + ``EventSpecificData``. ``iJIT_NotifyEvent`` returns 1 on success. + * - \ ``JVM_EVENT_TYPE_METHOD_UPDATE``\ + - Send this notification to provide new content for a previously reported + dynamic code. The previous content will be invalidated starting from the + time of the notification. Use the ``iJIT_Method_Load`` structure for + ``EventSpecificData`` with the following required fields: + * - + - Send this notification when an inline dynamic code is JIT compiled and + loaded into memory by the JIT engine, but before the parent code region + starts executing. Use the ``iJIT_Method_Inline_Load`` + structure for ``EventSpecificData``. + * - + - Send this notification when a dynamic code is JIT compiled and loaded into + memory by the JIT engine, but before the code is executed. Use the + ``iJIT_Method_Load_V2`` structure for ``EventSpecificData``. + + + + +The following structures can be used for ``EventSpecificData``: + + +**iJIT_Method_Inline_Load Structure** + + +When you use the ``iJIT_Method_Inline_Load`` structure to describe the +JIT compiled method, use ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` +as an event type to report it. The\ ``iJIT_Method_Inline_Load`` +structure has the following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must + either use the API function ``iJIT_GetNewMethodID`` to get a valid + and unique method ID, or else manage ID uniqueness and correct + range by yourself. + * - \ ``unsigned int parent_method_id``\ + - Unique immediate parent’s method ID. Method ID may not be smaller + than 999. You must either use the API function iJIT_GetNewMethodID + to get a valid and unique method ID, or else manage ID uniqueness + and correct range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name + and appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, + then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` + is 0. See ``LineNumberInfo`` structure for a description of a single entry + in the line number info array. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + + + + +**iJIT_Method_Load Structure** + + +When you use the\ ``iJIT_Method_Load`` structure to describe the JIT +compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` as an +event type to report it. The\ ``iJIT_Method_Load`` structure has the +following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must + either use the API function ``iJIT_GetNewMethodID`` to get a valid + and unique method ID, or else manage ID uniqueness and correct + range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name + and appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, + then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` + is 0. See ``LineNumberInfo`` structure for a description of a single entry + in the line number info array. + * - \ ``unsigned int class_id``\ + - This field is obsolete. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + * - \ ``void *user_data``\ + - This field is obsolete. + * - \ ``unsigned int user_data_size``\ + - This field is obsolete. + * - \ ``iJDEnvironmentType env``\ + - This field is obsolete. + + + + +**iJIT_Method_Load_V2 Structure** + + +When you use the ``iJIT_Method_Load_V2`` structure to describe the JIT +compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2`` as an +event type to report it. The\ ``iJIT_Method_Load_V2`` structure has the +following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int method_id``\ + - Unique method ID. Method ID cannot be smaller than 999. You must either + use the API function ``iJIT_GetNewMethodID`` to get a valid and unique + method ID, or else manage ID uniqueness and correct range by yourself. + * - \ ``char *method_name``\ + - The name of the method, optionally prefixed with its class name and + appended with its complete signature. This argument cannot be set to NULL. + * - \ ``void *method_load_address``\ + - The base address of the method code. Can be NULL if the method is not JITted. + * - \ ``unsigned int method_size``\ + - The virtual address on which the method is inlined. If NULL, + then data provided with the event are not accepted. + * - \ ``unsigned int line_number_size``\ + - The number of entries in the line number table. 0 if none. + * - \ ``pLineNumberInfo line_number_table``\ + - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` + is 0. See ``LineNumberInfo`` structure for a description of a single entry + in the line number info array. + * - \ ``char *class_file_name``\ + - Class name. Can be NULL. + * - \ ``char *source_file_name``\ + - Source file name. Can be NULL. + * - \ ``char *module_name``\ + - Module name. Can be NULL. The module name can be useful for + distinguishing among different JIT engines. + + + + +**LineNumberInfo Structure** + + +Use the ``LineNumberInfo`` structure to describe a single entry in the +line number information of a code region. A table of line number entries +provides information about how the reported code region is mapped to +source file. Profiling tool uses line number information to attribute +the samples (virtual address) to a line number. It is acceptable to +report different code addresses for the same source line: + + +.. list-table:: + :header-rows: 0 + + * - \ **Offset**\ + - \ **Line Number**\ + * - 1 + - 2 + * - 12 + - 4 + * - 15 + - 2 + * - 18 + - 1 + * - 21 + - 30 + + + + +Profilers construct the following table using the client data: + + +.. list-table:: + :header-rows: 0 + + * - \ **Code sub-range**\ + - \ **Line Number**\ + * - 0-1 + - 2 + * - 1-12 + - 4 + * - 12-15 + - 2 + * - 15-18 + - 1 + * - 18-21 + - 30 + + + + +The ``LineNumberInfo`` structure has the following fields: + + +.. list-table:: + :header-rows: 0 + + * - Field + - Description + * - \ ``unsigned int Offset``\ + - Opcode byte offset from the beginning of the method. + * - \ ``unsigned int LineNumber``\ + - Matching source line number offset (from beginning of source file). + + + + +Return Values +------------- + + +The return values are dependent on the particular ``iJIT_JVM_EVENT``. + diff --git a/docs/vtune-user-guide/minimize-itt-api-overhead.rst b/docs/src/minimize-itt-api-overhead.rst similarity index 95% rename from docs/vtune-user-guide/minimize-itt-api-overhead.rst rename to docs/src/minimize-itt-api-overhead.rst index 36659fb0..876fa0b6 100644 --- a/docs/vtune-user-guide/minimize-itt-api-overhead.rst +++ b/docs/src/minimize-itt-api-overhead.rst @@ -1,99 +1,99 @@ -.. _minimize-itt-api-overhead: - -Minimize ITT API Overhead -========================= - - -The ITT API overhead and its impact on the overall application -performance depends on the amount of instrumentation code added to the -application. When instrumenting an application with ITT API, you should -balance between application performance and the amount of performance -data that you need to collect, in order to minimize API overhead while -collecting sufficient performance data. - - -Follow these guidelines to achieve good balance between overall -performance of the instrumented application and instrumentation detail: - - -- Instrument only those paths within your application that are - important for analysis. -- Create ITT domains and string handles outside the critical paths. -- Filter data collection by different aspects of your application that - can be analyzed separately. The overhead for a disabled API call - (thus filtering out the associated call) is always less than 10 clock - ticks, regardless of the API. - - -Conditional Compilation ------------------------ - - -For best performance in the release version of your code, use -conditional compilation to turn off annotations. Define the macro -INTEL_NO_ITTNOTIFY_API before you include ittnotify.h during compilation -to eliminate all \__itt_\* functions from your code. - - -You can also remove the static library from the linking stage by -defining this macro. - - -Usage Example: Using Domains and String Handles ------------------------------------------------ - - -The ITT APIs include a subset of functions which create domains and -string handles. These functions always return identical handles for the -same domain names and strings. This requires these functions to perform -string comparisons and table lookups, which can incur serious -performance penalties. In addition, the performance of these functions -is proportional to the log of the number of created domains or string -handles. It is best to create domains and string handles at global -scope, or during application startup. - - -The following code section creates two domains in the global scope. You -can use these domains to control the level of detail that is written to -the trace file. - - -.. code:: cpp - - - __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); - __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); - // Create string handles at global scope. - __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); - void MyFunction(int arg) - { - __itt_task_begin(basic, __itt_null, __itt_null, h_my_function); - Foo(arg); - FooEx(); - __itt_task_end(basic); - } - __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); - void Foo(int arg) - { - // Skip tracing detailed data if the detailed domain is disabled. - __itt_task_begin(detailed, __itt_null, __itt_null, h_foo); - // Do some work here... - __itt_task_end(detailed); - } - __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); - void FooEx() - { - // Skip tracing detailed data if the detailed domain is disabled. - __itt_task_begin(detailed, __itt_null, __itt_null, h_foo_ex); - // Do some work here... - __itt_task_end(detailed); - } - // This is my entry point. - int main(int argc, char** argv) - { - if(argc < 2) - //Disable detailed domain if we do not need tracing from that in this - //application run - detailed ->flags = 0; - MyFunction(atoi(argv[1])); } - +.. _minimize-itt-api-overhead: + +Minimize ITT API Overhead +========================= + + +The ITT API overhead and its impact on the overall application +performance depends on the amount of instrumentation code added to the +application. When instrumenting an application with ITT API, you should +balance between application performance and the amount of performance +data that you need to collect, in order to minimize API overhead while +collecting sufficient performance data. + + +Follow these guidelines to achieve good balance between overall +performance of the instrumented application and instrumentation detail: + + +- Instrument only those paths within your application that are + important for analysis. +- Create ITT domains and string handles outside the critical paths. +- Filter data collection by different aspects of your application that + can be analyzed separately. The overhead for a disabled API call + (thus filtering out the associated call) is always less than 10 clock + ticks, regardless of the API. + + +Conditional Compilation +----------------------- + + +For best performance in the release version of your code, use +conditional compilation to turn off annotations. Define the macro +``INTEL_NO_ITTNOTIFY_API`` before you include ittnotify.h during compilation +to eliminate all \__itt_\* functions from your code. + + +You can also remove the static library from the linking stage by +defining this macro. + + +Usage Example: Using Domains and String Handles +----------------------------------------------- + + +The ITT APIs include a subset of functions which create domains and +string handles. These functions always return identical handles for the +same domain names and strings. This requires these functions to perform +string comparisons and table lookups, which can incur serious +performance penalties. In addition, the performance of these functions +is proportional to the log of the number of created domains or string +handles. It is best to create domains and string handles at global +scope, or during application startup. + + +The following code section creates two domains in the global scope. You +can use these domains to control the level of detail that is written to +the trace file. + + +.. code:: cpp + + + __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); + __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); + // Create string handles at global scope. + __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); + void MyFunction(int arg) + { + __itt_task_begin(basic, __itt_null, __itt_null, h_my_function); + Foo(arg); + FooEx(); + __itt_task_end(basic); + } + __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); + void Foo(int arg) + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo); + // Do some work here... + __itt_task_end(detailed); + } + __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); + void FooEx() + { + // Skip tracing detailed data if the detailed domain is disabled. + __itt_task_begin(detailed, __itt_null, __itt_null, h_foo_ex); + // Do some work here... + __itt_task_end(detailed); + } + // This is my entry point. + int main(int argc, char** argv) + { + if(argc < 2) + //Disable detailed domain if we do not need tracing from that in this + //application run + detailed ->flags = 0; + MyFunction(atoi(argv[1])); } + diff --git a/docs/src/overview.rst b/docs/src/overview.rst new file mode 100644 index 00000000..935b8bd9 --- /dev/null +++ b/docs/src/overview.rst @@ -0,0 +1,27 @@ +.. _overview: + +Overview +======== + +The Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API is an open +source feature of Intel's Analyzers tools that allows applications to generate and control +trace data during their execution. It enables developers to pinpoint and measure specific areas +of their code, providing valuable insights into performance bottlenecks and resource utilization. + + +The ITT/JIT API includes: + +- Instrumentation and Tracing Technology (ITT) API. + It enables your application to generate and control the collection of trace data during + its execution across different Intel tools. +- JIT (Just-In-Time) Profiling API. + It provides functionality to report information about just-in-time generated code that + can be used by performance profiling tools. + +The ITT/JIT API consists of two parts: a **static** part and a **dynamic** part. + +- The **dynamic** part is specific for a tool and distributed only with a particular tool as + a dynamic(shared) library. The reference implementation of the **dynamic** part is provided + `here `__ as a Reference Collector. +- The **static** part is a common part shared between tools. Currently, the static part is + distributed as an open source static library: `ittapi `__ diff --git a/docs/src/ref_collector.rst b/docs/src/ref_collector.rst new file mode 100644 index 00000000..1978a8b1 --- /dev/null +++ b/docs/src/ref_collector.rst @@ -0,0 +1,67 @@ +.. _ref_collector: + +ITT API Reference Collector +=========================== + + +This is a reference implementation of the ITT API **dynamic** part that +performs tracing data from ITT API function calls to log files. + + +To use this solution, it is required to build it as a shared library and the +full library path to the ``INTEL_LIBITTNOTIFY64`` or ``INTEL_LIBITTNOTIFY32`` +environment variable: + + +**On Linux** + + +.. code-block:: console + + make + export INTEL_LIBITTNOTIFY64=/libittnotify_refcol.so + + +**On FreeBSD** + + +.. code-block:: console + + make + setenv INTEL_LIBITTNOTIFY64 /libittnotify_refcol.so + + +Temp directory is used by default to save log files. To change the log directory, +use the ``INTEL_LIBITTNOTIFY_LOG_DIR`` environment variable: + + +**On Linux** + + +.. code-block:: console + + + export INTEL_LIBITTNOTIFY_LOG_DIR= + + +**On FreeBSD** + + +.. code-block:: console + + + setenv INTEL_LIBITTNOTIFY_LOG_DIR + + +This implementation adds logging of some of the ITT API function calls. Adding +logging of other ITT API function calls is welcome. The solution provides 4 +functions with different log levels that take ``printf`` format for logging: + + +.. code-block:: c + + LOG_FUNC_CALL_INFO(const char *msg_format, ...); + LOG_FUNC_CALL_WARN(const char *msg_format, ...); + LOG_FUNC_CALL_ERROR(const char *msg_format, ...); + LOG_FUNC_CALL_FATAL(const char *msg_format, ...); + diff --git a/docs/src/using-jit-api.rst b/docs/src/using-jit-api.rst new file mode 100644 index 00000000..1fa72d42 --- /dev/null +++ b/docs/src/using-jit-api.rst @@ -0,0 +1,119 @@ +.. _using-jit-api: + +Using JIT API +============= + + +To include JIT Profiling support, do one of the following: + + +- + + + .. container:: + :name: LI_DB9BBDF5654E49BA9743FA34A8BEFC9C + + + Include the following files to your source tree: + + + - + + + .. container:: + :name: LI_EABD97D44F984162B38420A57167AC5B + + + ``jitprofiling.h``, located under \include + (Windows*) or /include (Linux*) + + + - + + + .. container:: + :name: LI_6E4F12C743D144E4A1515F4829612FB3 + + + ``ittnotify_config.h``, ``ittnotify_types.h`` and + ``jitprofiling.c``, located under + \sdk\src\ittnotify (Windows*) or + /sdk/src/ittnotify (Linux*) + + + .. note:: + + + To locate your see `Installation + Directory <#INSTALL-DIR-JIT>`__. + + +- + + + .. container:: + :name: LI_1B044705871E4F2F90A3733AAB95D071 + + + Use the static library provided with the product: + + + #. + + + .. container:: + :name: LI_EBB0F0A78ADC45FD973DB21B3CEFF629 + + + Include\ ``jitprofiling.h`` file, located under the + \include (Windows*) or /include + (Linux*) directory, in your code. This header file provides + all API function prototypes and type definitions. + + + #. + + + .. container:: + :name: LI_C273EB329F1449B2A460BED51529BC6B + + + Link to ``jitprofiling.lib`` (Windows*) or + ``jitprofiling.a`` (Linux*), located under + \lib32or \lib64 (Windows*) or + /lib32 or /lib32 (Linux*). + + +.. list-table:: + :header-rows: 0 + + * - Use This Primitive + - To Do This + * - \ ``int iJIT_NotifyEvent( iJIT_JVM_EVENT event_type, void *EventSpecificData );``\ + - Use this API to send a notification of ``event_type`` with the data pointed by + ``EventSpecificData`` to the agent. The reported information is used to attribute + samples obtained from any profiling tool collector. + * - \ ``unsigned int iJIT_GetNewMethodID( void );``\ + - Generate a new method ID. You must use this function to assign unique and valid + method IDs to methods reported to the profiler. This API returns a new unique + method ID. When out of unique method IDs, this API function returns 0. + * - \ ``iJIT_IsProfilingActiveFlags iJIT_IsProfilingActive( void );``\ + - Returns the current mode of the profiler: off, or sampling, using the + ``iJIT_IsProfilingActiveFlags`` enumeration. This API returns + ``iJIT_SAMPLING_ON`` by default, indicating that Sampling is running. + It returns ``iJIT_NOTHING_RUNNING`` if no profiler is running. + + + + +Lifetime of Allocated Data +-------------------------- + + +You send an event notification to the agent (Collector) with +event-specific data, which is a structure. The pointers in the structure +refer to memory you allocated and you are responsible for releasing it. +The pointers are used by the ``iJIT_NotifyEvent`` method to copy your +data in a trace file, and they are not used after the +``iJIT_NotifyEvent`` method returns. + diff --git a/docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png b/docs/vtune-user-guide/GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png deleted file mode 100644 index 41117932e4a8a49dcae4baba0f024cf01e93f9f3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1187 zcmV;U1YG-xP)WdKxYbs#Y`AWC&^ATls9I3O`GIx{djH8UV9Ff%YPDF}6$00007bV*G` z2jT_}2rMAPly|J6vqb&LZO$Qiigq)_2$7_X%RiBsE8MDUKCn-vxiEx3re;B4pzb1 zO4m{;q7=JrwKOvuH?!GICjXQ9lV*1&$^My5c9O}z8Kw+BCS(#4eQVZiH<|3tBoy9Z zhP>bV@KYKz+Ay?K= z!!X;)0(zKI?!+p;)76=*me(51c1J^XaF_{kBVx!fw<>ED-GsPrPx5=eh+=2LeRl8y zeQIijTGboP4mgt`j_}yV;A9}di<)6x56Fiu(u2|aY|q)qn>YDb9vNmU&Wo_z24*&t zm6Qe9c=h|_u7Ez+nMWcr+gYhLJ&>?%7-BZGTu|I;?ZvMXju<`r;C5O;O$b8F2CXqT zNeTH1FkbjPG8&_6M}J6ZMpMXDa7zruW}e9C!1?$%jIMq3+Y%IopUL!N+`d>%Z#d1z z4tAZAb)(^)k8Q(nOY1j7r9tnL_f{^A|2EDJ& z6-&A)l#P>rtn57(bwoP*cnvjLE;6`@2{37BY)jWJ229q?zth?~KlAo6hb}U(A&L<; zFa$|u)~oLhS>MC-?3ZZym8*7B_-H{*=c^kS*c52iumc&yfGyYRmq=;f#O`N!`Y%z{ z4M1Q}W5Ly@!~85UT@xzC$9I?aO~iJ<9J`j%>&@x;7&aHAr?}b(7_h=qlgw&Iucd}9 zKX5()4de~dSRl%R29Jj6!G=WuLFsh<2}BsoA7*|{RG$+DQr>EJ0D*z(yB5{wbZAGe zuywQTp%NJGjVu)PQA(h^dkMUMThNdR2n=+zr0OqSX6$1&3fg0K$=T^m$UiM1Zb{k{8+U+>=5)(z=2@|EI~1GOZ!DOt&NRhrVnA>5RoybgIMO+l zREjDhp1lbCG|x&1?(;s^6ZclWnOO%_cLV@?(_29-cKscR(rLm!a`@GIuwaN!OI$g+3xY8diqZhBog)q zrwITf(<<1*jT-JL^sNT+m%Al<(2=afELwqvUA{{*ACL!&L9wK zALI{I5ZslxZYXo$40yTBj#{$g=kY-IIr%zU&EI?g^dtpEu z{J+<`I+>V(uKxrb|4%nDdpkR`PcERFv1BmN1_$Y;X60gQ1}gqFO$`FQ1$__~QS-<= z>F`b@oJ;!in6z#eWCEQ4lki^Rlxj#Ujcnr_$*x+GxIOV#Gbg%A@EBTeQdd1Lw42x` zbPA`HRq+JWzQxdfP)q@tQK(c}cOKjd;;IHBd@mX@9CetM|uQ<5iehQb$ zl+w+~s+5rade)XL)4k^L&h|a3X}I&PHClbt*~rEY)m~CF z+rJHu>a9{$Lbib!{N4=n?~U)3;#i?pO#8AO!|u){{CuVAbC+g&xmTq?;)KJA<+^^ma z9JfS5TIVn^ww`zf`pp3(d0n`<}XIkIf}N?#Ldntv8y*I&kklwViSaJRIZ| z{7C{=wO>Ti*CO01WsVn)e(JB^{qy<5zCoZPI~W;+$9*}P>heOF+V~{=!)2+$qpep} zQ#=DthfC-hdE*u&eDodu4}!^xGnn3&4~MDiy$=cM>T@hGv-fqe#i+pgBfad$hEF^q z`Z+v&NWFKbHgcN59_ut=hvg*@AMAlG!)V#crVlXOOm1++ znz4+n?{C)=Uq|4We_@~KGE315)ztTd6%-UKu(Qbab$dhE88UkTd!R+*pDY~e+qmBz z(1xoYHmm>q$F=sBb#+HW8}xB*9F|JYgSYUb8@ds@_==V+h+G43a5$aj!d z$g@DNmTfizoemIjnSp~y8-bm=L`Fxwj%!wl5VxI28CA5@D;eUkPX3VP8plxnz;O`J+21CMIijHkervKepn` zKQd2BxPOX5isdfZ1!a*xE5os35IXkA`E-vji4g>@DJS(^#s*Ib$ zVvWU~%%o?1=rX_S(0Xe7s*8T%{`Z2xpLI~cC{r6Uhy%5-b{xZ-v{xRIRP%*AcsEeNAu;4tYSmUGVBG%32b&ZsppO1K-BB7dSCx_ti+Br=phjMZN zyxWcy>iG=)$VmNOGgAzN_p}n$Z1&i8H|h;v^XJt4_iyjB%^$~A&;h;D`}bN|%(+?& zxv2)x3oBJ29g{8i3tl=k=1ohtCTQ2OTKpOOo)*aK{C^npUyc>Eda}4*xs;%_aj|X# z=ve2%XXD00xM}+e=Ft8#DVag!1bhs0mt!fmwY_?`PbrdW$BXoA!A4Z#vHT4ZC-nU7)IWL*nuE2#}s! zAIt8}R;s%F*ZojlTA$}iCyU%{1xRAyw+EsVGBd0n@j5Au_le*r-5>D0B}sUl@ZfLG z1~)doo7-6n0^Rzhz)@Ry>#!gqk6YjN%RSx2rv1sgjd9`auCl7F^Ufxy@7S)+V<$6? zRQiLJCX0^cAu%CHAM5W~z?Zi|v5aHJ_fn?^*TR|g5%>VwR|B(l;vw9#eRX%7r+Yr~ z`NF-wMd0zIPWDf>-^1Yz?5Qt_t{X#7Q#pbAnMw19B(}DdVP>>(-lN$BE*HPsMqG#6 z9#V?vg_;{W%B6qp0 z6GgrDCV8^r$V=I%JVov0XIT}!fuhE#s^c@hp2e>pH4acZ3*gUSTc$y?ms(GD;2ULi zuj554Df%?0`;}R{qE-v}Y{FkGR@3jk5OOOd^uQ9K_GP+51@iwIV5a}Z`Y_ZY(yFMw z-qr;5$o0|UNAeue@s3anDtB6AP_kGU>Xv=jODGVUSEpehTk*%8pi2;H42%ic6z*jG z05svnSm^to9=Gn`-Y|YAo{IqrP(YK0ft|f3XT~3Ro0Qc^v%1~0wuSEv;aYR-4v*0IvbkAB{k=?v_~UhOS!bGWE6s#K!x(ok!ATzdkbc9&iTzsJ6= zu}vF3!a+HH-St3M+kx^hI@4VVCXqc9kfY)0YL&5-?3NXv5#W zk;o(dr0M?@@u2Aq%e?WcEZ^X*3c;aQI4l3)G3=`E+?hj8rtu0MJjvQQPCo7wT8&w^ zSiz6`>&uDW>!ZZgi_6l)KYa7QTHYtuA@HC1Hb){2m)f3ol5V<7^D`}^Grzkv+zai+ z`=d^3euH>7Em=YguCEDC>jgU?wB+|dcj!Fgf*ORav<{y!{xLy`9vx& zpp&OFR%wsOeN(OTS0H z!roLrsa=05@bS;ASo3)rsm5VI*%6^Zu!}8}UxYuWr#Y|i{EJWvJU!z|&RCIDsh055 z@gIZ}-}0;LQ#ZqfXr$l!{FQwb#*YCpi&%>-`^*If>?xWvgQFTRX}g_oFPYw>`}gQ7`t1f|IhMAYyVhvc zN1r6|!sg74#Hto46qR-YqgV1J))c5K<(VJ$HC{sHyck@EntaiDcv2=<0)P1R?A-n5 z2_s|uC4U6t_(&+z`JA0nr`a1q>g2{K67EJ2tfJxceTv~lPnjbS znR#3$RX|-i-pR&W_v^hoAu2LEGq~AZDcsuQZ|+`^wB5R%^r1~TR(U<1{hq$KtZ!V% zBLF!vt%+LSgYk)6NSO2<2%nsKb$MXHpPM%fWEFZwikOmAeXA%efBYG6^8e|@+r9A+ zRGhBTS+yoE_TTEkg9NgLQoTgE3>Jur7X*V7&NA<2|q0ebP)A zJN$TKcNc9#drhHBGC&>sg1oK3gD)?9_quSMvOvFR{hBV_?;Pt3|E8(W#lfV5>1gjf ztlgvFv~%SkpPA{p>ZIYeDw@$Sk$Tpc5?a9Gqd?;ci;&!r;vEY~!XvKrjh+wMJfk4i zmcf^mnNR+LUfPYZOVEo*n#onyl^IKR(%kh@r$+m*d+Dbxje|b8PcfTw*84|}h zAG4vs$`d(fYX~pAHZ1^k>8-b#VYv*(VsTxbjeI7|_8KtDSZTj3Yi0EJ8s?1ohV88I>tt+R5JQ-x3GmjPD7$@MWu{(61GdE5v!%2PV&#IzLa#h=I=UUz!{t zTFO^h-^$WtYTC-v>KKd1q+6^tyr1@NFOa=vp6P<^%!%Q?igfEJ#2wlhhm2=%r&&8? z%gG$d%YmPZ4lU9SEG~8O`hJvr^=6h9q;~ka_Zii(G{x*O)xdxGcr42=^N4G@DP=2I z$5E~^FHH{Am1cPJM97CD!`yH9ly)I#G5zV2!-`##QGeu{J6m5|frP>y_GeS_)FN%C(FPy4tI@#zRUiOo4@LeUj#H-l`(epU5nXbtOH%NU53i*XkrMK$e$YX_tw`#8uQy5qTd^LOg zHa;P8XkylC_@Q&u+qX98Fr!Y+Mz(Y92ij z$9#r79->n%+Dq8gj&p9F>(85M77Hi$ysLIImM6TH`;@bH65#*}l>? ze26}U7zM_~afJ>#x<~A_2u*^!FI9E%w}wheN6fD5c%ERHutHx+VaVG(FXPiAEAqz$ z@m_sdy&YOC_{N3LO6v--BOI`rRE~n3S7l1D2631_jn4|pWc}w@l)nv2`1fB+ngXHB zQ(QfsOfSIs0W6V`lKB)C+3qI4O9t*)GD(C)73zPc6#?ph_7J+b82-!*x#y=P-c>rt zizpJeCMRj0!R}}J>eP-L&C%1E?m;n=k>d!KS|f zf2rsAI#-G2hrxraKLEMJ{r*tjm1w%0M-|##qsD7_a5670f2N-)3f;f!d_J|`KKt`> zcI>sEs!W4j?f2}p>T@~%-}}0ZoHnhmfuh56jJNtCc0GBL2wfRATg-~~a2bFJIofW7 z_Llewi{~j{-Q2Y1q|h>?)Wc#E*5 z74q#6hLsKf64fF{3GdSz$Qq=4x8M``A~)bes!(u-23f2J{0WPPwGMB3xK)o1{jp5m zIwLmWN5Fj&@IXK7xFso+OABQ7J(LA}E2rKa4DpIZaUNLl4t)>xY$Z`5%zl~h*TL<| z2q<*=mxh>F2!}_yFTqN>a}w`F^~GVS!w5!6UAb_v5JE7~=|_mDR=C97Q1F)eC55FH zqIFw2kA&FEnj{-b*A(b0=9e`54|RUelNZsIHm^s7vSd!|1)&LrUmq`|2r+}7*npwr z^8SkEUUQIG+t2oo@qN76jF%$mKAJ0wm!tX(S>NW%3I5+tmy_EGib9SOsBf39hN-g| zd{;}MSsPhm9U@-`zjD0$3XA=&^TEx&o{f*6<6Nk&ya_#o z8~Gg)Y|Afl%p6er)H}ouzXcccT&OwY~iRy7FVSq}<-dI{thxe`VU<@$|;jliIDE1nQ!OO%z+y{w#i|Dc=YkeT^c=IJ?-qVp5GUH?iZjaNv#cEwk_auFQ?!KXrym5QU}3 zXDi(1aSxO6TiY__g3%6aO+t0!F$T06qSQNJ#d`&s^B*?H-qupVB^&G-?`XeIx4<~Q zC~Ks3n$FwlB+q2S%pBLQGgs%y0L)I0i(zWcb(`Ju&0de2B@5P1t2`ea``p^Wc{?4_PKIkqS{MunU^e*QRSM4V%*HY0!fkNn2qVn^%N(hRBa^r9V(M~3P8 z3rF>W;b#$tA*1)a{bK_%e9SqGLEr15(k3{U+h1XLy5w4ety693#pzYcjLF~G*EKU0 z)T!$!oJ>z~E=#BkJ*}1OeWNKjfE9;!H0`D+Uz|}2z4tvCxqh499VGUnYGpz^jxJxx z>q$$GFvjplk2wZd(Ov&g+uRV1za`X-v(yCTmR}iH><}HFHzNQWL(N|G@5*jwI!}~1 zNS5vX$PpXbb>ac+4acLBBI_IZOdbqeeGjtEyMAV4LqiZ?msbMo2)Qu3DF!4)A_P#k z{hzfYk9Y39*~7_DpBW7#y{L91Qs!!Y+lanazWg{Pgj?#F{Y62JXhNXYHtNHXqEs?` zD-umH$!cf*$!}`kaQI9DrYMh(_eo!22E*h@rUf3VC7BF}?`K9P>aVPN)?U^EjbxVZ z$MeKZ5Gj{vB#dChdwKiVO1+rb59+AIHMksT^%t)0xuxWZJzzt*h{?WdMs7K=&+wQc7qWrA) zaIwb8O%a=ob*D!e!KqO6!L`!qWMpLdqY0BfTH|Dzb)_mhp18_IhoPk|h4+o2)a1@(`kUz5srCBNanbqMaPLaNG|-&&SA-i8S`2Uu=3J z(m@u{em`X5rDybcjfEd-8Fc6-oHH1L0xCmuSU%hx*xeZ-;445MH*T zn00=+3ow2~=OnbuvF30D@w)bjlBU(=Wa?bz(GQT@++7AS7VW3vR8zvvY%Jj=mg8d` z!tK8=yfo9U&j7-CU3Ts7nV9()`Z5{GN0t!CS(l zTADRyz~5p1$M>2<0@YySY~mDsFRS50)dyRB=W$NTqRYy*Up-ZR*JWSp4hJl+jcdYz z_zAN;7(4iTkksC5HUC4x`IHpt=H;Ytl`a5z?5zGTK14hYpv(P9QtfAMVptv*;R9#@ z<&!l)-yKg1vLvk36D4@MYseJn*H=eCFTomJL@Ej6@KyP7c$GJ=^d^Q z7~kWZBJi&|GOFNR3^SK}X(DIS@m@@~x`Aqe3JQ;x`G)BDwul*uQNvy|t#leXokIt2 zmuUo8>96k>1^NeWp?^&DGA3xi~pD(`_oJ@`o+P z)772$plDBDqV0Wp8%p8<$0$ryQSgmaEJ?rjS%-zkSUiQ4!}*4Y&nA*VSMcj!<9^Km z{~3386`p;5yfryn>nKnZ^i?D7tq`R?v0mn&Be6P9DV!%oRw^E!-wRX?3;fYEIY3g5mT3T!r;shYlx%-G;4z0*8 z=Y`WsxLV3v?}*fx3Y==wAe*JOhNYnBa!62D)+CI8T6*AgFD{-$iu37Xk?3r*Vj|U6 zRj+6zR@=O{JZ6K*jobo%)-_)SA`o=nSY3$be0OYqczmSKZ14h7m2`j)6Kl89h+jD7 ze!3ijCUgff`17zpUufo(08i>uy|ZEev-QpM^Ydb>D?N$#32Xb)#VAUGZlG1@BukxI z|CMRFbRKGv9+F=7=A$W0o;%+gi%Vc}pbXPhQY0P7Nq$`CB|cQ7N#doN-_0_kN9X1L zq`tXTms9PkQhDfl-OT*0g6YjZTHt6h|Ldp-^%!!p7>Z0|5^Z%;sqoU1w^Zm(9NBrK z9p=91^6?K}Yh-4}M+W8$)w2mO;GG%@6vM_Fcb$WXVqJ1cec_-#B3F$@s#Br`j zba!`{g#Y?hTwgFOHeX;f*14vF3oBGkdWXYQRQ|JB;aM-d#z%rwm$e4ju~=n0{j(>I zlijIKrNQaKJ7s!}NtcG1!_YdbV76-v!_}f0lyo3-IwgT?H2Fm4aqpPczWEDfI$Ex$;|v=M864y?;0@Ph+D`UzrR2j0xK+O!O?=_ zk=b2pc~Oa!B1aIEnKc^JCd>{!Cb;}@jcq|j%*@9r;$Ki?r!f3sN=!-C0&ssvdJ!hp z(FMG(U&@aqG5DI(MTtZsPikqkO;=rtrfO#t!1gRZnogiV%(kLajJ|`8I@nE#^k$B` zooV+ojdGP9|Ey6;ty|-5%#!D_jYMm5zV3IFEL)=A0l4?3P#s_9JR3fmOdO4itI%*r zsh=Vp;^)<8(=U{81bpW`l6e2jqB=P@cyMAwyD(D8chpQ3v0NQ`eNg{DwE*6Q^a@26 z;EaQ;aR`fiygeKI3z{>Y|lBwh=(Z9bke8WG*)^4r0UnHd+8T0nRjq{$|<-u zw4`>st(K`!uwE2DQ<7ptt*UKz0Fajf{v?{AeEJk$9-uB?-1PnrO+xOpp* z{>SPna_pdLih!V^@H5AR;O$31(qKUdcBB2e{_?`|a-{PF?_gt0#>x@krKAwOMmbODybAMm%U5DKUX)bRaz(-zb=vUwu*LN-h6Q=78_Yf$3!ZO> z07tDYseApMBTm|pkJRT}WYwV;#Z^8QMjAR?fp-@>(`khE&7)`z`h1l^tf2Re;q$}w zU5fub?x^x<1LXE3y<`jf3++v2pIP7c)r7QV@rPnjy((EL5g4J*EK5b6M{wdA9@=z9e;fro@3Jd?NBzEfwo|5 z9KvPjGoU8X-YAC;B?>7@Kf7d{bWPKv%wBB7zBcL;$zZg>+Gtyoe{#hLPuvx8P5 z5XiE<_@QKB=o~ef9MG7n!T%#Wivlm=a=}+AFVhAO{9b>!=z1U{)}*#yxEvs~-`Gh| zBw$)h5L;pD~^1n&39aBio^wjs#Yrn3&$Y8Hv z{>hUQln*gkImo;1N=x^337RDW7YD&L;50ZiR1xqeegJ>tM8$cf!jnxsJJtwtvypWc z8MbZ@C+Hc>AsH(aD}ji=Xkbs6}J~J=Xh$ zbc2ynr1R1xTkpbbpM;hi6NzXIR1_#IjE6$<&^M&)so-#kzFH4f2LEc$NBbSX_tTbY z5=4fwwqTp701s;H_sPzcO@-H-4uLL>0m_E*zi!-BN7zN57*Q^aReH_koreNc7g1WB zAPwRY#du;{%tXxG?*(yhr|_>P$X_}T^pI&glgcz^)|%^dkuyIt=Xck!nkI^-A*d*5 z7-GT4L5F?X74SzV(lB}-T%H{v03FPM#nXpoYY#16z2S^M?yK}6 z{Xr~dMvx7e*#OAeLiN;CM}lv~A49S(iVrv$;wqg8cS0E*EPet2a1KS&K=>F7=njT#gn>dk{Ilu0<>vP`BCy@IUg@J#f}E(R(k z$CMg`f($u_!=0)7M|FdDW4#vOs#3@tdS-9L( zC)${462CC@X~3d~b8#Df_58auX{o#^8VdW`7K~qCT7EG+{gzVP*yI!Y2Kn0B>W^Zz znJ;feB#5S=M`6^dw@l?E`+JQY!h+z@=3QUD;IlhybdjEK>_)LT{ItaJS{!pvuP?TQCiq5E;K{*r zzeICmbD@4Pq4&dIM^xm1=Z)q;#{l1V5iy8EDgyYQIS7#QF$gg9b#=WT-{<0P<9#&8 zkNjJ~2DGDu5Gja>zY}e!ED%Dr)YzQz3zf42c6TcH*QX?6wp3x~@_Ai~won_jin@vy zF;`}3C&>#tN#HGKQ2~_uALGlvbHP%`r6}3>44N_ zHupau$g1-_(F+!tyyV@*8cX{~;Ll7UdD;$3-{Ds(e$vc?@3F@frX#gUq;Zta2@@%R z&>~KT?X{V*z^WPZ28#?vG~(hS_RV=g0jaFofgN0|kf{<4i&N>15JG&dm{GogJymEX zUlLvEXkA@w8U&*}4A47pT4RU3>KM7oBIuNVyz+XZ*HadEa6z%v#fIs28wj2z(Qv{q zJJzf4!d`Pgt@$#HSpYc`y-V$$b!EHpy;k9*9U*~FwYcc&`pqMw8bt3=iCUjWHboq? zLZC2EA8KkWjduKj`E!MSar)XS{CzRD(^eY}@E&jtLi|{bFEA^Mm??A>ezGwdCN*qU zT-Ei=3sGGlqfZMoe{X5ybvw2Tb3sV~!*!EsI`bCZigE&Q6#T^Gu=q`$nGQy$VD@1zy zW?8d~#}=EvxnU@!1zaFcfEPfKNWx@|wOHshAY{ht_$H`l!7ur{|G zTu2q9c&xXmry9}bsA)t0tCr96R?m_%u7yKSmskctdHdz793kJE{m)iVWuBW+Ll)}s zvSBRaLKzf1fb)wjlbsX&0DQh%F8|HvIJimJFrTZ-@G6Kh6_^(7j|iuGChvz4{Ve2S zo@hh;x>AOd=qHjF!wz2!{Q~i4;c1kKxo$iz!Y zdyJBL8VXWXtA&GS5M#SoJ4+TMGgF8`zcFd0HQ>@3w zIL@RuFe%Y_*kc%22(&@Wsa!6#bokd}w_4E(3fIt}9hSEQnHFZ*bm#y|AHB9Gsk^=b zyrn?2GS{yUPZ#Ar(UG2}>a`)3C>RRVx356ag5^8Q%MBmFYd}~w!*Py-unUxa%Z!P?1%_L~wpe?%@`EqTnKn2XkN&>_(*q4)-?h&@x}O z$ZEzjtWH%sQd`hSjTM7kD;}EK5DQW^5YZ7WW4tiV2SziNQmwmUIJC&I&wJ=k#TgR5 zQmA}oM@R7PhBh=|btv?`zS;$SRKceqLs<;>iZ)e~<>cd?tNQ<_tpg@`q}kfS(geCI zVU6Q|x@!}~L%CIE?wJlEfIm+M&~YULDsU9TtEiQy85b{0kYQJ6Nj(gVRHF_BlRHk~ z@kc}(WZwXbcO9+~QEd7tukW(#WS4~x#tnzllh9-e`D z$&kGxZF{WLsBXzNJYReJj`~t&V?o#PVT9^wHl=@_(0pY`<;RE|vwBvxeq>?xgXy3v z_cy->MNoi56waK1I|K^fhGTTyoUWXrvE{V10G{|**Fxuf31Js4Iff2gc}b`DIyy1| z;?|nT(h^L-Qjtle`5)41SyYaRPNT9D+horx87zyLuS@5?V)w$)v(TEG)Fb!Z=#|Sa zG+cA@HHnZhWKP1C1_@-Zqe59cRlN{%lVGI=ST#lLX{ zI)wUh^0Qdp@MdAwPNDAq(z}DM6qQb(O_@13EQl$TPxtMua$L&O)KQFABabe?6%Hu# z%SFaRBzKvEzAJI6UB;(`3@q?%Xz&1EW}SUkmH%(}kL6)2eg zQMrS&R{h#d$EsnX@gYh&*yYA9+>w%3Z2l8)5n(pZBns=$K2P(1!mloDudhc}pIiaX z$Ml0heR3-qgI2PX&Oyj})iMLXb{Vv!>cY^_jQvS}v<#S*_Iu3}S4pG+0431+CQV`C zU6n+ldPfLNyU}%~@!zDDa@}>8jaWDw`YolhG_Bdu&cW$l4nctp?&hNUDoSSTV;2P5@gKBs}?xHsmLnx6tdg>d0IphQn~*{7nQ%IS#T@nUqELeUE6+mrOqH-Aj|EWuog}0N^p(p4)X?f@z9~b zsc@46aq+jT@t+)is~02Ikoqn;-OJ!pQfop#y;e4*>_rOdff(14J{r$~fv%pZs9LlJaa~d0p-1k!$i`wohV$&R&%f?iQJ%%` zt|Idju`p31W#-WDClp|C%3sOJlT&gPNO1Y@2;^YK-IE}&dKYv`a6YU@-hb>wWaw#d0op>q?(>F(Nat!d^ zPtY)q)(6b-u#;bC<1iw3aXfxh2^6dS&Oo95KF8Qj6`yza%>6^Ds&!>i$Z2U$<=V?z zo^xrWH`L^%S5g05YHgiLdPum=_e+HHwFM+nEfqbh7GTS3R`S2{&nL_*3(AIoOONl+ zW_@4m+Y|`_B6z+PWTFYc>7Doz2UjJ&_g5e#ZX~2?smG)rP5_bFkY@&SCR9N~y|aIV z-0>}Z<+t-f)vT+7Bih4a5`mTHm5`M$u@OOTRLT+k`tj zw4s}L2D>_cj*Ku17fXhIZ-PeO(&)yxP{n;H=9AV>ln(&~)-feg1;Qs0)D34U)nC%k zA`qPf0znMZm`1DHni@QwtE7qJ$Qp#;jt$wzFAp>_(8{^`c^7liGp`!TOUepST}uTN zZJ+~W>7ccie+&;`pn1eA;`|uZ%CgYlrq7(qh{#v6jOigfC$F?syDhtNCmVp1fi7Lt z!er%Qkf2P9+#1V&`;`vjZFUhd+nby0is*ltAW3$rI4SL24_Pb)y_z!D+D)*|T9fQI?kGdCyhf3y$>wiC~PQ3?r0d_1|t4RA*O^%oZ-12QC5ySNl*dg%u)kuJHE^yLO0f0z`dlr&Zjp`wa?pfJLOE$8=5<3-on+PnbERQMD% z{zYVR8{2ugDgr30ZxZG0;_)&H>6voCGUet-pYhRd#9IxkgI{H%I`PO`emaJEcu=QR z2fB(?%e#N4YABUe%y{PeAyo)m9~px64|E3NBw57+>xuK^XG~RwdGp%YJ#!~@(%#3@ z`2&(G42vxWCFj%>Y9YQ*14YS)w$k1EDP8GTM#qWe^w;ypYIN;F-j}}b-I0^5 ztWi);QpYo-(qvoHmufUj_t{NmG-t&tz5kx%fma{7P{c%=O#$vy5I*uwXQMI{>d66!%zD)#1qi%08((^LDsBD^0tWDToSfpU z@cHD|O^nI&hub3}(A$rG`HNzMcr&@~Fm`Ig!?p)hcOXhA3ylngM2LeujtHyH0KWCI z??uQox{uxNKuvMdl(ku!XlO1G4hO5OtL_4X&l+2vD-0qljU0=39h^C~R8rQoeL3c$ zq8idMzWXp`v;1c^g82C$vSy?AsJ5W9u^_P_i8yNuVqVcdocu-LBm&LYy{50nUm*u1 zob?r!hzu%Q0XfDM9Tc-(3Io8Aa%NLxUn+k&?VrJd45B%r6-No$md_EquPf2Q zOhr0bp8iT0R$GP$Ji_E$s}}^7VF8H2mE3w@_sU^7P$K(1VHU$ES5s5LN5JnYdxapL z!O0z=%Fh;$jX18H#0YX2cGA{x$)BgLy93t^4fCV$%4u@|aqDDGs zNIVYxcl^2jm-qp)d%YE-aWl)yh#;+c%PAHcQOL=J*+gAwvah;d-P9O(5F<;p+s5|1Uf{4sMREM|hH;34~^Q zHqTgs8hvw`oxj0r+B-4X>)QqXdj&xEVtSXHC>q~H0WpE*mrjH;Mz`dywyn$Rm=x5WMx08ARhezxplqYGsWP}v4dAiUi%(7wRBcfn(zOrTh8y;x# z6WLsyu5SJcFlbSIW}o3#t6mc7;yj81zr}5rYGHv=3e&^Oqp~XNPWz?W0zM1pnYrbw zCO*Z=C5w2!l-Rm2hK&Y+2>QJWyXf*qdU}nCmE4063g0q~$%Ofr!&_<3ZAzp!uX=p- z`pJF_vcD5U}_x5#J_E%G?#b_U|G92b5 z)t8D4Q1X~^B>z(bSH=HJ4N%P$qylQ7A`PMjqI3#B{Er$yP7a3IF?-9aR=zwW9;Z?@ zsW0nWIzLm2h;!jeYbDR8S)ofC&G42WoC1l&sDMFig>Wb#R`#7}0h?Izw;ZHK?s73s z7E7bL@Ra!~wb8?n^&t{BrwZH35|i1_(ZGg>PeDiF40KG(Jv!*S|8!Ni<1QjTj+7`@ zby_`5d7Hab#S;!%UdU-am9+dglI3o!KWL-XQZ~~0{XWYB1><9Gd|9O5a(8_WmhS=X z?isNExU&Uh1-Q-3v=y8>(hulpG!tJi=f2*U={U_*6){##p%i@4sx-EiwM;uBfchYU6CZjOG*PO}kOPRc>QuqS z<5UV`$|Ml-&D0gDQN@VMzG|BImd?(g-0v0>gYKqum9E);!)Glm%aDKq7>kC|aH?@6 z=IkDIjtx~5a+KcZe0LI(7fZl#Vzgsok9$v(DaK&3^8><~^4=I6g5A$A8~nQ$n5-oB z<~2-{ePI2)e5k)w)C!C$A3a!_Ur)(PPwX9{ZC~i^PVFos6k$WDPoGAh+AZ@ttwdXb ze{+e;Sa~3E3C6%o^x!jsboMq@Q{0NDFX=31$^MThJd~6;J@z*WGYw&qY^unx{|&^- z@?7@BuH|Jy3fH!AKJrHkIX+09m_Uq5DpKDHJpH_UWEk|e@ep1GlB-K3o<$wUlTuPK9(%=<_8hyRc+(Zk6j;&X6B+r#uZ*M)?R#K$5PGSc9 z>#H30yvUO|+A6x$YTpXiAK18@zl2BYb5ysb%c|p!cL?_W75Yqdu>)7g3&&8W(i~c^gz8sn8vQr>|HL}AC3S`9XCMZ@jm9U8l2 zs?B353K;1I3lBm0OqjM3TA@qQY=q!~y2z71Bt5<v{_svPYQF1eq3&`98ehZU5$!RmV6+z zAp9Hnf45V0N|OYNnoYgI62z(hm$DnmCs$$ptL+$VD+mA6c6%o73Yri`B>rxW{+WFr z=HrzI3EC+SO4Hb9jsVNk$8+X;IKMlI{asJUFPVtKWe#09ZV-OJ6LaLjWz^vqOaIF! zM4Ed61Jp*S>7W1ket)4;t5l!7<==m=l_JvplcCOaPKmf(YUU2-J2cTslfAj?TR@adb=s)Vn{?E@C$o=m> zW03ezH>trN@*hDFSyXl6*`KU(L!6w7O;A39upPkV@Kuu0Q?#0Uljr%aAfh$;c8Tn* zHBVSh{FBazW|lpWV>0K&KOJ0bkdse5Se3ZPi32JTa3vl6GUuhabryM;d`$HJ5cbt! zRekNYn@&NxTPdX^q`OO$l$4N=?(S|-q`Q%p?v#?QO?Piny6@Wf{m%KmbMABR^YD+4 zu-Dvc%{9k(#~AaSRwZ+i!W@JCazE1e5o0;I%-hr>0c@sL)BPgzl1|_cbtiCVdMUfM zZMKfO`G>~i_M*R?Pd!8Xm3GQcU+VP{X~;57Sg&pG7Zc@>J#y_X#$+y>BZEEF5835B z$L+##@AzHemyt&=bQr0l6(={GKkmMG%#aR{Jx3{e^+PUHc2^u`OqlfJF>*qDCdXI( zPkel?D%RVD<8scMSsF1jU8>!|EhkGichNF+@NBa z{yfPP+nypHpr1w91&yp)G+@n#N#KS{;5wIfH-vo3`O{MWEbrx5Fk1ezv>mZFdT#=# ztqqd%fDqQ-M`9G>hA+UUiozUYI7(D z(|p6tuCM3l68z6;^ z(T{+w<{6UE7+de5@RNzF$h(P`TSU|C`+67cf%T-Zn%&TxZuwtlPacM$>s%O6J9;q6 z&Q?7h?=Mdl>_^OM71DU|D7^0~jpwhoGopbtW$an37|6d?@zck)5b1!}@!bwx5ZtC% zH_S$R);x>%B~phz9-??VOFlFsvEd0owYG<H|9jG(nJ$362~&>8%kK zJWK=CKC07R1l8vb3wmP%z}G-0EI#Mb`qrw{$bGk?T8;~VhgjKOqYPL_V|w|(d>o^R zS4BN4H`J%_EjkP4f!l@RCa>A8FTCgpsR2| zn87iD0LC^mJ|P=xZ%2EETJ}qJj``K-po&##LppwK)mQa?jncQ2JmZ`6BxvmgLLa}~ zOz8fkJF$ymwp7-Xjmw}4seW!_u6t#eAn^c z*zU|q9qP&Mh{6)|+tn1g|_=um9J!|?) zgf~@ip}=bf0IxMaCwQXMNtI0vqVwJgzUT##UqB&>ZTStGxn3+c*-*+6J3`6HEORznP&&_mSkXJrVO>`OG~8Vp2XMR z)UEP|$_!hvs^6K!$t01O%5~nB%Lp|ZluXOS--i6LK-YQT-OI$908CKzGfq65-_L_z zBl+YH0TyMgXM3H;je z%gvAkQjsvE2+0%8*&W7PKXYCd1gh7(z+w;I`M5*aciaBmYq!x| z;Z1BDzm2Sn&a2bU1E(R=+DMVO;vW!Rc-q3N!1cm|S46H%tkb!Rh3KY+)K!jl}5~pA2ou=3;x( zP8EBj=EF3=R<=9*bw}MP6AY8R~2S={sU}rmy3ARgGRL zj6g|&4N&i&IrY0=R0G(7LGmOQRFOdjZ=A8=^`itO_KoMD(I`S4k4h9h_e)O;&uyCK z>qC`P-U1Z8`4gD*Us5xthoSZDJ+msNAzeJ4Hx2=!RPq^uEw!+7);$CEI6E=QTLSi6 z2Ad6bZA0-Sm6q#3dFsHEw{$|RcKDShM{;w8HubPa{urK3?Gv>Iju_9-f!*JWUdNfx zT~jkBvWE!pE&Kb>df@4GBiIY}q-Y7YPuMHAdjxNCS}>hMnV(So|BLw%#fd!+V3L0k zDBAtN4FK}m%!{v#BU${95jZC)%Warft<2|Oev~VPL&L!f&na8i>UiEK5(1w^m8)BO znM=E}DB^LDYXKjpZM2jPnmHAjU5cfVnIoj9}>%7-Az2$vCqHv$-kom+7vBK_z@S^;dokO05 zXA9Hb{&`T$bK=5i2H0#TaN$Q*xWb=?P-}eHNT^4yqOnn9@Ptg&zY zhB!x2N250DpWSxk|1u_PIss#n@zjVBa3u+6p|L2!(>T&$XqP1JbHeK@z$bwl?;aUs zg?!)~f3c8ep17)J6v7j~XQ@i?BxHP4;&BC(af2PS64C76N8`~ip!)dhb#+VSja;g; zoBn>N9)-@plX|+%M>gZNpDBN*%Lz!EpIxuo{YM7IMA!i4#mo}kN1Y!P@Z|zV`=^iH zsEqJr@#~a=a1N+BH{j>i_@?wil`(>!ckFZHa(>xf$oHG3J8zTM!7kcmuCM*$vP1NN zopqa*`qql$B$98?EzIafhTPzYNfPD;3lGTZs6dK%wkk*K+$nfbulJ~-+sDSs=gXot z=62VR5t%ITPj2DGC%3;-Pa<0Wp6RP;emm(HH&9_^4J{vYMLoIGs274=;>FC&c3xvT z5GW~;MhTMw9%i7Zi0+SfyGRA|387R3Y8NsPNwKAb&`lMH0ASJrc}A7b%=SM=q%VPZ zQI*7}+U5Yg^ZP$8XZn#PNYMOdiksYTSg1Ts$kVS@Tm4mCuB8-$r-&qHcU2*aq%c2U zlZET5G62&idstAkm|)ibu^h`vouKwte!5yCw}j^OSAe~ML*LKO&9t8_DHW4{--cz1 zsRH;qn{1X~Y7kWDEca#@-%|HvDaB#JphUu098mll&V;`+Am%3#V?Zl9ET_N7VbKzd z1~&PGmy5O$#_CPa+MzBlhl_r!9};8&6fA;$PNB>)!PFm)TYzpb(5UDq(NbFRGw(Y; z+&;t-AzUM2Sv;!opmc6DTKAk@2)Ke>m>uyg{WfPlGw4&6+%q8XDIKfBf*EdFWKTk< zO9O`zu*Q>uEC?;{#-W^<^eY0--iMnVJ(nMO4^TB8`CFVDR0sHU`9WQZpz8;H0+6nH z@tlj8)2ilOv=2vl*kEJS$=BeEbFPlgc(p%_MRiMRc4xPPbI%)N*Ec<qOv$o+_dL@Ivq))Qq$#sW!O|A2^&1(GzkXLg_@^4^Q< zb1#vAbrumE{7Xk6NVKLj%$d|%8thRDw_M@+X-@0hS&QC<=h>qC^n^o(=k6N(5kJp^ zxfZ{MU@RFHOi#B9i(|g#YM(Al*i1e#reOWH7#U)6OZDjRQ266eYwEnJso(0uHr(^B z!yk>8srD=dQNs0X^F=p@sR#rw1bnE8$90L1<^U{m#=R)#$SmSI1rxX{>gpqm45~ zi0qIh#IRLIkK0Ydp~<3z#nge98qcfu_ndD`_;u<x8N5bjAEZGob->^cQD-l`9zaF%yh)Bf4IchHf)F>hJt?hdI52#yZ4;ajCOYW}> z-&!wO=rq_N@Q+9>dx8c>M(VtUydU_PwdHaH>Djg+kZns{l^Tpwvd z=Zr+p^MttFZ0nEr=<1I{?~V;YN1m64cViS@&%7tDkUYqQy4vplfKSrk6?aC#Hg2=a z%e{AZ{7z0z20~Rly;kJB{x!5dTVe~#%q!Vshzcw%(VZ8b{G{Wp)WFLG+?1S7cu=Yf z4u$SL@lt2`I^R*NzjfQQmERdKj~ir@*pmEG!>bW5JW-YBo61xJsz}lz#Sp+ljKei# z@9An3|EeYdIMw=>>c?BwFRU#$NQX~OY!{lGF~5EL_V6~BWo0}rETu9^m~q86e6jxl zS8lAq<>}JMoe6rsNCYg%i5Y@V@2*c*A#Y(oX0JURNOpK(`!%a(qYUPvcKsE$e>&oh z8{a;d_~WEPhYZBDWAPE^m-@IkfW|bv|_SUD_G3sczT_ZWGp?pYw4q@p3ObYU1*4aB~@s zlRNOaR*xBn=eduFt#@~UK}nq5uBnc#&g7{|J?n9uSv4x|JAs1HAS&5 z{aH^z^=C8KUxQa!VP;TSD)mg3M##oQDS@3{F)q<{ZFigU z@kAI{y8Si`5KZMdw{N_E7HzdxiNNb1vch6)*O-HYm_+%z5$HuWZzahg$H)5|1U8weupu2|IaPkjnB;i$E#l4pz@WTWM zu5|r?S>_TUinU0S=kj~?#S~78!I6O>cuq_u+!I8QfYVGN9crW9EHd+S)?t$sA*HqX zcIT-5qP|TMr7t;6webMP$5hK{3A+9sF)O}^7h3tjK>>&Ll33W3 zO7WR%dL#^r5=euk`s?>`hg?P;mih{F-Tlcc*}^yRlM^3TZtw?1f1F12FN`Ln+oJpg zI?=eD2R-`M2|$Pp_#nSC;hb8|ik&rtmdvRP^?&qz4l8sods+1kU1v`rQP?GpT{wQJ zGEGKVg4rHv&u@o;9&5>(l*AM-GZ%D?>41x2K|lh8sdq-5xJS|tYF^xqZLW3&`sjI7N0SM)v-BSC31(=UkCzGWL92gRn5& zHgtWTCP^1AK<>QIB;)|ww$KeJBCv=$p@>q8U1BFyW#^$7Gec68XgjmCLxr6EBzAG5v@o20L!(kCRZu=9t>lr>aD zrOK4kjT%Y9R!g?Cah{yx;v!%(9&F>|!X)uymU<4AbC`t)+)Vy{m*DcoQHX#)T}`~? ze-n<%=Kxhoa%$93l2r<5CPP6_LF#v0Mg2_3kdy=g<$f?>vMPKnm7)z#?AVB1_o zWauNwkZTW@@3Ysj&mQUX|HU@GfAVAlrp1`y{?<@R=_~azpY7|Nrf4EXSpla&n!lin zwGH%-*}a|x_QwJpsxzlhU&VZj(5kZ{tBP||Z*lkwj|Ma7i>uA18A%| z>^aT(_YbN4SOmMKj=Ulw?oUmc`cnuQf^k3>mzQh+O$3JXNWw)SoYojAlvE=G#p4>^ zk4K(E+b%({%)A7~EZIILE=&8>tKmh|+f3&Drz?i(?mRye8ST6r`{!?N(wvL5de`7n z1Bs$Ac%p_xhvy;!Gjx3oO`~&`Ofm$py2xVsMvdF=rvr^Ly=iQM1wzOu39Y9g& zlSeXsHQN%*D;Fff+MA^&&-GZbE0PFu*30408%LE*m|3abVcH{ske|Q$1)MK z4WvW#Jv+o-q1c96?}U(cZJ-+N3nzdIWvnl^UT|s)e)hfx5c7DkF1A{5vyUfreSIBh zlR!>ON9S2yuq;Sco^{3`Z+Y}a%Jpq!lR%*IF1%$$2%1vr99Rki5@Y$;wE*+!FJg;F z{X1gEaVs{yppv&Hv(xogF(A{y2y{g7b29OHyqb7F1y7&$Ra9O`)$R?7pG)5L{^Rwn zZ#DY|jP2{w?aIbRVy}sP3EW!i75Cxnp)KNJm$&dR!Z((wL19S4o++4_YaC08&T~6N zz|u%3Hq5qbtUfn_gL0k=zt}-UXL<0gae8wl&TFQ|%6Cj0U%yrU3on{VZDMtP)DK#H z<2k8I?l=9aBkU1YS!3DH-On=B=_8sC*iK01XAC!Fx)5g#M;ilX!4EpB_Ld**_A{@C z70B%JLwGqh(%3Ezx=hH$&lAM0TYzjz;}1PMgt%F0#~H$IKQYb1oS8C-{);Nuu@Un3 z_dyRsRlEai7UDpMtE=3Dv#pf2lVUhCYa`O(si~<%Ja6O5lQpjNv?}L}jAq}7=nMk} zGTY?_lluG4j}S8*xqt_lFvqP;b+C^F9O9{HGJWN)bI(Wp@+n-7Kf|2G%pCjXoOvCS z_S00`0CLHvfY-H8zqO!RQse3FMyE*P<5}=T?x>oMN6-ZlXPM~wZ|r=vdQomh_9dG9 z993MbmDdnLCGwknIL_Q6r>8Kd>it(Arwyho0cyvwn9H)&hyx9?!cQ$shAmej-3!&S z?3!{|ckz?~L;e6Q7}b)Nim(R0^)JSC2D59>{LL(l!9LvM*2l5W#}~`Ct}0;H=kO;3 zAL!?2^OW^|QFvbCcx+hU-mI}}-yhOl?Sva0JX>5%O-=0vdOEQR3X(r&onfcf?k{ea z;&b_NJ#RQX<<8s9i^1^F<<5RZ`%f0&@Gpljj6!3*9Q{PYwub(Kqr#+97pW*St<(_Q znWR<7s`y%6BS6I@Rgjgz!xkY(8O-x1nWW{1$Q~+=>*^;2o}m>J?45pqWk{UONaPAE zbWglOrVSj(6M(49RzCYC(~a5`^&xe4Cv}v3tnsR3HKN5wc_+8zqfXbBF`@n`CBQ9i zNW>@|(A`XXe=@CmAo8A{^e%zR+!^hF(ar6YG0-BfP37Ak-$Je~rpi~X$!D4-h3-&V zy-u8Mt{owQ%0mqgdS*X(jx8#r6JS7X4yIp`Y=DTFe)x)iz=w@+u&z8B$QZ{_{Y8)L z7^gz}f;nghwe5{*->JpEoDXcfTh{jyl`C=glClDlIX9W6kjpKU+TjnIr)^$yi{$y!-=>&=@LWEAV2wPX8dyW zSnl&ho{4tnen*UWx&POGmDt}ZF{Ny=Y`3A}7u+g3yl4EzRHu|!@7==LV^-|l{95wW zrm=VtPc~!j!D#jqeTbI0`}X^JzhJvNsdIg;ynvJ%p-$f_DZDl+&VKm&a#8zi{x$Sm zH>`tuF(@QJF~g5nF^fIfY{)@?S5&+8R>BxnLaAH#9JsG%Jb8S8k|b zuqfXz?Efkn)2&+qYLuPio_kY#RBuAjlmg`W7MbZ^(u*!BG6h3dwC)<~OZyIcd*Y8- zAqGKGRYsoz(cGC$Q#(Tn-m24gN%s$GBT;_mg{X`5QkK0YMg0uNkR%nv;?#Hci4Ne_i5xu6HP1=e4R5G7C@^sjBd-2a`D#Q3jN zdkEYnGGA&+B1zS6wK*Y^M${ir9SQi6*;OGXMi+DD1{(XM++_i<0UX{z?mVDXs~K&3 z)6?&wXaZ;|JzIC>NsM+&KjZl^1-BX!XrPp!RF1r`xU`(y17oWrODyVVO$PJuCI69k zNS&uf{bLPG-{fH%rn|)66uyT!e6 z_^_lLh(og0_rtD*2H1fpFHQtMxudbtll@{j5*WV~Yd>0TJ)tF*w&A>&p^NznN( zrse`LHHx(dCzvCa>q$mMmQ^!zI5MF)g{G0&s2$oZ#ie$xNh8=WG$p@*g-HHss`-cD z1`5t>ha_RHSDC8}u{r9T(zE*_XkesXvxu+H^Xo8p%0(C}qnLv`8)5Y`Us5@$aKgwI z_g_(0l>L#zSNmB{SAI?v*ZGNcVCFW0<>0H^ZTv8L8l` ztIQECg7)XmY=ZvHm*0mb{xgj(-Un|WTe5eLQgMcJ6Yh@}!{1@Ne zj^hzuqgF~`x*-S=Q-8Z}`mr^4v!Nm3xt;$%>v@^8>8IlT<|VXvZx0?S)v%F9bHtsm zp`Z0qqXZD}$MR^KtC|!~5HviAk%0ng|BC=jcf75qhes=aAT4!oKVZ;-fSF+EA zN4J>4bR*4NO~-Tw{6*HkXuCvg_-*E7B3F5D!xo)8-kdn2SDp|7@t-N8CJGeIbX#6+ zu8?sF|H;~D_-Y!JL-QI3nr3__Qk{A;qxT*0{rogTF5?|ohVkOGdY$`Y;kv|smN-)@ z$zDCfE2*>8WAS><_O^69Vj3H*Ee}t>77bF4)Dq~>-TW*?%eHbLK~__+z1Hg@Byr+D z3V(HEKbOEH;V=?ybDC`%$*+QeMF%?Sc{{U_!#z~a3m<+p)Y7;yi(oHqZ>C!d7gZJs z7+d-`1S67!Vwq58`3m4%%!wczSdca04=;!Y+8Q(fD?INyy|2t__$$`b#^G4-!j9^* z59*2Z%FxwAsyFnTeI3zV-3<- zGqDFVa>i+Fi&7aJ?$t|=`pCBbapd`Y;5k?Uy#+F~QfQ+^{@5_ZS9|&~T;tVTZ|XE- zd$!*p2jJ9nhs2N{GtbA`agSs`Mf9nVrg4p%9j;MF_^&m_Rb;=a$tIA7;~j75bB8f5 zpt|ONNd{-path-7`;Jy0d*eeJT_$F;z=R$X{YVl%%z$u~?`IJiN;&&Zd_I^elo%QR+XIL7Qeg`ZznyL4L1ozPkGOWhTN&F*8T6mN9jhIyc4Y)qXQ>JCnx5oi#oBdgN z(5{seu3n-B%6!fA@BNx2^MJT8R9X+zM)0NPk)=htQdsg|Qfs9Ac*yQ984X^3x#t8P zO^hkU-NTKwu*U&K#mQ>#Rh14TxoAsUE=rygDgEBNkhw_+?kZ0#h9|DSUq-vhsWg~w zLc?vY^TUon)r@IP1=g`eiD9CFz9nPdXBXhyFc{fVi^t#X?$2UmgUEJ&a=q$n9i!n_8HOXbgR-SQP74_=~AE0$*1l0xJ?W!Bn+mz_>G z5y~hrjMQN_1$&)*JWgEy>F6BzF5Wp{Cg)wtokJ*{^8bZCNY}Bh?GE7$uzq;M4u+A= z8@`zuZNO8<#|ZrSZ@$RzoawM(G`#&Bls;Jf5Bk9WxvRqamQy?38z~{l9IDpdCM}B7 zl(j!!JcwKbIyN|N4&WX0N2@>UU5z07_;;5xp{?Nc#<%ng1)x2f?Hash>2&)>gCk^m zCwKDi-nWo-lz+BWbo+`v9VG>j1l!E&x6cHgguQ>s7QJz`U9K1Vv-$&UxQKQCBqNdi zKJ2|N8=zXsAXO2#di~2^ESS`BD<5DA>IHn_88e^jZ(nZQ_4`(nsbwq_du!)44U0Yd zwj7WQsp)aWF7d*!T!4}p10VEz(&1RYSDE{yFFpedJXyoYoHFId5lU=V&%zJT?75F2 z(#yED$zJkAR`Mo*?E$u&+X17zH6W-X$p+~|0D1p&`|mv8bmzj~M7VUatOJTE>0WnR zPu+)_4U_^-`wYo454`KIZE620wbS@90?$L{Wg*33@_hOOR-}3oHUdOn2tIDyQ4%kRK_C4rxdH)o$zC1^)#Jh+5w>taZWYwm$wc<%3 zMXuvh@mIVX@>q_heSE(`9=D(384?d$;cn%!>vRJVQFK&s0M=q5a9Y6@f)HG-Bvq-? z6?0&MkewlreREz@oDpS*P6FL6+il9~5PS-l6aD0-WvhcTq+FPisf4C|>L#BE5hK3B zGmUU7J3iCk_(b^X`9bmsJrOH99JJQ`;zVsD*+f=NWBnJ!xT>Fo?xM8@^UxfEFdP)A(fXk#p(`39<4BW#+mzCEU{48N-{i)FBL%R#EgvIhlhs>iBObp zqMPH-`N89<_r(o?vMo5D*HOb`_V6r{K$Hf*SVwhb>4$~wl1Bk61p#f}o@)FFtmva9 zMEfhq2)F4jh$XYW{WNww@0$tTk@$3&)gej#i%8n^(@4b5NU&*34lm zHZZ8I?Wd@Jx9J;);0b+KSDqd=iIhY>SGaj4TdRHa>C}>|Ez+Kz9$q1P`MU|nNY{K5 z+L*O9UBjGkSLfXE@4N@v>_E|D1WXQ(54~_*dSIhBKQX!9J4=w4#yL!&AC;#Nx`9(V zn!xjauA)VbW`<3e3`$KY49iu0BoG$Oph0~&xjhWWm=fdQ<$$@=w5hIIvSja-!hk< zSGloME$w8JeSf36@dnSxT;6EV%TG?B+gi6=^qVn;=cPS0kq%})RXwQ)&JZsSUX)zi z5>We_7Vha_iaJe81VxB=@N68`G=Kmp8Df`9bVKTHRtc)CKsL)v`MY;{Na`}V{g<WX(bdXh9n1@kod zPEWkdMS5vL2q@gJ>u2>`8yrvN;Gj6Tn@IYcIu#UOw1g7Toa7$)Fg^g_VuYcwm8w$o zX{wZ@+}n#1B`yW>g^Zd8IxCebv46u1WhiDuif984m|suHP>uVC@*HGZ&fz(ljv43q znw(`>z@URrnLITi5vSPEd*FTOXMkM3eLOb5%3<*iif-F!X<4_$fL1mDUw66pL(1vBDLS$HA7CXuDI3I)%_`;Yem0K^YUD~#qFu5wp&N; zOt00N$}M{rFy)6~qP0j8C2%k)1d%}6^)~uG#L%S%AZ^jWzOdYF6XhaY#Z+$J$5n5O zm4PN}!{>n`){BjtnhfVaZ{1+N6wCD02AmM{Lj#h6liCAqtKl^Ny@hG*t|VUz+^6kt zelCvB^=^qC48RY^zf9`qwtKPwAse77>k`Bh1U6=0fTO9R^sR8(_cK;5;==4N6wgu$ z$k#98TCCVx0t%wvt@p^dC)_;E`=|(L69eFY$}GJ2u0)K2OTukLz9qR@Q&Y z=cSk~qJU!JhyoQV_xvsW-*Klr?qjcBo#HfE+)x_v(Wk%zI(AdA=1E!A`<#upSzB(U zG8yp28Db=Fp>H`ieBbJs*x!m$9T_-0VFRa+x8USJ2-v%Jas=i?{EByZkxb+LYm zdm-Fp2yXi;(GGLgJ~+;BwpjrkUO!OTLCsg29>rJYP?goY<;pjWxR$gCMXD~@Pf|C? zDxnaUGRx?Sr$2pL7VrdS9PE|61$M}I)b!VJ2#V#4{sAo4Rde-nz;AVrddicDkbaJm zVmi;F22dz5nmuOpQyG}=yx|ufA+>?7J+x$Je??^{O@H1T^g-AuxylQGu~fG`H@xJ` z%rqG*sWWOoS@j8!*ygcC#6J8q62PP<>@6q`A(NQAdSTxCRXlibyTcqgG(PBzq!+4r z{*n}*1dd|>dJqDs$FrOz^eB#-)w!2xQgoq=e=8lGb$xL2PT?19U{ZX;NRvRf_t zasr?)Akj!j81b`uBbtR-<-``_(_TWYdCl44cZH zK*SI=A$jMdg9AQ+#x(mQLCh9*El!?uYGoK{2De?`%Dq!2ASpJIngzu`g-^}b!mnS8 z%BDU%wYGdHY5`6JyCd;8w+50GzzZ475;XYi3<3_g;E3x@71w2VsrD(}` z!+3!2gOI~u8H^TR+%Cu}hyanQy0+N=z3ekTasH=y*yYGcFp2gbO5p%PF%iJ^N4>iC z_e8XP?CAU>Qf2F_(xDRsvHQ^8i2M#6bSy=%+)?-LrM1C-c$Anv*Voq* zMo0522FG}ycQ}+&ZA5V}YbX2Ne44nKSwP6oKi+S^D>WDN4l0r(i0Pr-vXH8t`jT~i z#bK42+Lb>sSc}@c%qy)5<@~^V0Mq8zP*twg_Rv$lQcA8x^q)@UGGrGmf%SZ!CmF;= z!QYj4$pX`)08-#@Zi}3-F7Vy5=NE$^FgXbRmuWdn{ccs|X2tPuM@8RnP#QIX|u76edg&-~xh zdjZ836;NcNqNCS=V^I=QQ_<@U@d?o8XFRW-U)rLY4Xzoi5~Y_5_-NLLd<02nbWUC{ zS25*>E?S0t`HNZT{{O8k^xYb>;2-Zlc&>~igSk8s>WW)`pTFE=R%jFNW^f9l z@?U?44mcmO0x4fG_}v3Cnf*tKK$3l{+B!OsZCd=Es57--b6Dv%PvZIc_B^yGDIRFh z?___05MZ;cPKQKRZ8Pl_HsR#*g$=rpub43E5+s-JZjbG^SL`k>b#Dg(Q_*(62i9n{ zd0xuK48C{bdp(OWKzkpds?t=sJ)wWk^zlC8PX@5_w>x(I{Ot)<6V2jj(yKTfsSDe{ zH|X2-!tIRnI?NzKUwdvkIyxxe8e!%^t>npT{wCje=ZS_(a`5GJIVM~(_(@kK{57MRQ6L-uz_f1m>suoe>;O>5qt7NODJ2{e~1m^z7Gy+rm3^0=s0DpXnWz-OIBQQ5-Ksd z{52XV^q$?j>pR97&V)cI#OuD*eLt}*ZNJ=2G2QCvaJy`yc2;ykXc5Ln*4c>onwT|_ zz^W+?z`P~1-XAC!x0(uO4pV=ea)631oN$-&#lBd%Xo@s~dH^l}s}i+27E#Y$W|HYl zJh`3`p7ZD3U1jH#_V1h^{8~Wq_uzH{=f3aPGsS4eAS~JsMu|>V7r8&rbl!McRsqcUj!t+UKBJMk(VCS64973O{FsXw@{mOC1 z$xk#%c%ZcxunUp-ie<#o!HFZVaovBUu<9_$R24)EF_o=5#nExN0TDfkdQZnQT!T$k z?Z=iQ2bq}~a-+lWVU3^S(dMAo(}A`&D?|=8-}Q-Cg5Gi{H<5B!|Z0h2g360o&bJZM? zRGX>~#_sbF28K22@1LaZPgGoZ5=tYL+V*mUo$8c2N(b=&#Mux+>&P^%Z=Y^dCTFTH zw4|D@i62t|Dk=mtY7ig}0@dP$L<{OrsGw^ZAnVb7SU)g-N+G4ALQ_cm9l*$0JxRM= zBT;UEj8{yfQ&L5Uh7!D~s}oLijid^WMN-54F+Uu7?PN2-Y99Nx9cR{`t)TtDP+s*e!-9^@ZWC z7qg3Y>5eX2SI%zaP0(<0J-TU0XHPKX3v*$@PTR}>iQL4iRrbJ;b;`i6K7wI?`5rsfgT`^Q2% z4CzSzCks$gR%YPgaTnueX>jo8S?+Q%2$V0#pKJ9O{4rtI|d?xPv@ zf`@pV2Nq|K#ymo9=UeGO|Ej>?jEzVYK`v)ISitWgP0rD74GVM~5I7CopO`JwHyanQb0`|LZ#t7)>0W@=7&4W8nuCyF_ zQY9DQLGei6(@Yd+aUbETGVkT)eq#lB9px>Z4(QOM2@=Cq!P0o6}qTC4sdC+-4?W`;pGN6ww2?*xB5QQKA>z)lT`s zGS5Bf_qJEijQF6m1k}n9su!C9rj`94L1y59Zf1taylAWS)zbjWxv@kp3)x|NCRPRW zU4 z-x{_)fkQ&z#XRr@FIS@S({A8aZuKf#wQk~HhUYZBeb(fK=hFKiz$iNVO~>bON9*g! z$sit`M4OfO<&x@3DFv+g@llR>)H6FlkFKAK&do(8*43OAR^1y_3GJK92-7p$iC&HS zC!fXJV4Th;*iM$4hKB8ki_9NMydrNGjWB_^7(q#c17$;G7QZrpER3LFBnjPt&fa!9 zz;K@pz5#z*6F1BkgwOYa_X+JR@t$yF-~%(8_>@`7T>Re7p`i7?_PD@yIW2b5^G3g8 zqUqffa*{Gza)oob6ocIKT7%|^Zci~6V{=$Nn^PsWTSrYHZ+)C~5ep*y3F9qac~6mT zCcDC2U0L&Hu%N}W@6McdP-rZ(c%u0*oqp#%UaIrhFxUwH`P*H+bp7?55c|nFGBE{M z`SZAhSH<-)b_nVXZBl_q$$k5S7IH;thJfg{k&lkf*~#VM zvG?QA(fZL~TUaZgt{QX`xdqtU*>arRnEt9HKGe^Bj}C7?>ZaHE=v*b zBzv|!9nKT74_+MB)DAM%nx~yu1~F#9x;*2)#p`LcDeyR&D%~l#Y+Y=F7sU5T0{iGt z5UtJRWpJjpt{d{XtCQ-il}(_h80z0&k3u{?$-H^DUR!0wm##lH-VPLrj>6tYw@r8v z83Su=HwAAQ#$^Cdc$~(2oc^|y;M?0a zSdR;PkRHO)v3Q`MVQQavz|Q(+FWY>&7u?L==c?Z4mRk3uR}Wwqk1y6XMM!*JO+rY= zl5}6MmsDT9Jo-K>H{ui;x_p&-^CdbmaHui^>2g~tcS#RsNmN{%zk@&W_cQ z#9Yq(r(DK9Z5j@Sf3o3wH}5Zzr)O^)SxWT~rrUfw1}CgF#s}s*rWz$h9Lc4I0R+5!nJ9-6wqQJ%*P3TxF_;O|d)A zc4L+G4%j?-#pih~JTc@SeQUTX_bNB}+7`|1bt@c=KAe=KdYKcs*M|F>48Ci@^T;m@ zf9D(B20Q3(WMp|ApP_@q(YvoXWnVFyVDavqF9Pq4`1V)y-ONBHZnsY6dxtA-gpwjenxXO z7hKCV&C1P4R|e#B)UPr3OJGsXXzB&ml-UWNIvgOiN1O1jBZFK}w6A^LJ?)`i#ES^n zkmxxmBlL93-+%t6^j;|ty5Fq;&JpxF3D*OGmL4zRfZz_P0xZTu{tve9ikXj!>yPfU zXDyP7KyMHc3q1rV-m8;5;r-@f(js4-)#9EwkU$OYoXlmf$L@?t* zTdHwq-)&j926?OA=$#aJ-vC|>fZE8LE)v{Op+lOS8OeLR4-fgMry!%2(LB43meN`5u2uK`F_#6 z+xlS(e6n+b5Bg+bf&RFkq0=?pR$T232nUi$|HEa1sRvX|7(hmx#6^x#vJ)ivj9YIw z_tyVOfjvHo`d)NeMNJ+Do%QXKrhdkAI|3M zf?g2<+lF9+4sCc}v#?xx%g2&6EEsv|Y4Q12RT2I!ic(l4jSHkCBgDNUUb30wt}5Pt<2?G3XC5PXO2#xJ`t~&Vq~oGwzcBenYH}I{FGBXf;4&{>+Kg}A z9rk-|={7tmpyQFp>o;Y(Er=kE`;6t@rUB<525R8;Sx625=jPtudqQLJCMG7JQiav= z!0L1J8{B*#iWKTFyF2_9NZ)AlZUAYLp$0DBHOGu|pGNeh*78(JDQ0Gu9BtZKMn`E& zmcl3lET_gMc$wex!~Q6o2}l-6=CW|t6^>zU&}a{38V2Y;0y^p}UY{U_JRflKhV7uj zF$UJFgFFN;IaL0U@3cyT6&Q|C-Iys?%);O|Huu}L&Mc+cp5f)E$j-M`r}MC-`P3H} z>80N49o|=%k4ugVV@HomN7UzPsF6JdiHTQ;Ue^iUt|8a}Md{vlIrwk{O5D)~??!$sUKq5-lK=r#vLi~kJVjbuIj}`k zINuC*D;*+OR)JjPf}~~Kp^gZ|bCW-!V2O(sZF9zn(tRGvqsrWMKvhsuvM1g|r6&=L zc4xaB1sTHqFHw3ydOGT5C`QtVKNuwalCTx+vlvjTg1xq0uyF`BU$%X6yMcXJX}h;R zW_jFfBdp~H-u+6#2IOtPR01lH;Qs!8{qXU~R}x9V)2)DYOAm9sa+U`bogE6~4LkIC zUkMj$jwEa034cU(xT~LpADyY9NwQG+`h7M$>c`eMUUEVlY1_r+WcL?=SI4_M39m$ zX+*k1K}xziq#Ft8?(T+7OLup-q_k&k^?ASN{mwaD`~wzi?K#&RcZ@M^*Z~K>W3stI zx#8HhxIgq6*CkUhz-0cUvd7MKo#=*|kxFrW!h|05aUaODhkTBp(EViOE^qW-_zq&e z8ZSYXvO`=9p3qA1fkmw=9~D5DzYP@MS_+~JJZkTaPnMY3mg4Y-)b$@n-a?YEpus;P z#|GuNZCuOUy7H&mY#-*b%*6-7FlI(RCkIuZ`KrU z`en7Y#U@Lr>ZjyJ895BK!d27MzylH>P~Xr}Q3eU5!2n2r9HUAHlp5LZdXP~kQlsMnP2-%>S_dICNLILzO@ z4WZE3-qJ9d=3D=d7G^Ef517_mS^WTI^gRos**9GUst7e+^JCM0ONmv@kZcJgC4?9V z9C2nen>B}in8pKz4TI5uIsPbTSG$0hVR1uYtblH~YX@$2T3eBoE)F%vn1rBh?p9M# zkrBV-BX{H*k$cqY;y{5NDoCc>ZSW6D{}u5>bh(&DPkRF5(U)>eO!j zIsPd(LhfIA?q&D*!Yg}F14DfSAZtYxG=(-EBEH^V zCf{}K^;{{hyH^6i1S-vBuAT*(Eh+%C+OQRyuOB}|!~ukwi@BddVdhsHwsw&~l8Yd0 z&h4?E|MA9P{i{;okV%v%>UI}H7;*iH3)GJ4^Zqh;A{7^$Uj1(SA0)}syEp!hxOw$J zp&5p{tHPl^;$&kxZx6W-Jr`KX^B=si+=VfS3*f%4*&d^qt+8%5NyVV1Q4g98Gd^eJQ1DZs5M* zGAlrJ@Xp0%UqC)$*x(}Lo(qut{;tD%lny@o^o9>N|K+~8hEqPFjtg(GK>f5ldZD5X zTukvLdGgF<{6|?bwJ1-4eFc@_9@(>G)4RC6u%7-f;dI`LW7^7GS{=*a^1r26j+r)( zo1sAAh}7RKoM{oD8!FMLyiaG{vH>P%o>H=yJu$x5@YyqoEb#O=KFH7JPoZW4ZdWo9 zh&X@=z;ZX;K-Hs=j^8sR*M4{LazdG(rGWeOYlH-4(Usgl7QpT24k4{{XuF!21HR(u0M!^$$?^rj>fg z>a53!rZbk3Ll#*lA+IXOM{|aIr$>zvgzVpQrq`HLe0c-sH%5-)rS;7%eC1nc3OWo? zvnvPhOTmgW+ltgt&2G(c?>_>MP^6~G8(=qxQT>aI?f!%KH#uB!JIxA`Xx1a*guoS-%M8Pn2Pz@TS-1|m=JL483xBho~)^*k| zD%By{55%f-t!H!?GUA4?|N3{?_J3p>&Yb^C&J?x{)9z2DKA#x!IVzZahIWM@ z&p5fx3A<(&q*lv%&}~Aec{mCCp;G{h7Q+4<p3xY>TZT>2?Ox6aQjxF4YFJ z<>~uCS$ykKn_D`0+w ztRVcMRO+QG>nNP{o)H@YF;gE?>~7{W44mihO8i<|HqFADaRXBS%edn3gFyFWGGm-U zjxit@5#N;w=JB&5+wA%8I`dH3=!YZBh0lpPZvdX^Zxsj38#Q1A%?3Be|DSo&MY;eS zX}@_ZD}`-5ft7X)-i0GhbKOgGJZm<{gw;ZJ$0+hE+~Iwts6&9jfrB>Mvm6=<5;X`H zKt`qkujgKi`)yVEt^&ZoQ7z^q`{WHlCROQ2z<6PNga!(zn_g{Tout>GdkF64^wryJ zZh=Z-qd%U}*5?DI#FNG_8ChA5@Z9`JbdkT4F2P;>Ia2`p2Izc~{PKaQ$KspXSC_hX zO6&%e8?0=W1(3;H)%brS73?@EAPo82*6ZZt<|DL2{p)mT144O|E1+odmox+70bazv zmEk@@Tkh5dhG+K-p0uZH)C)jp~2Nc~G2N_pWVi_x7quG@9HH4qChP7S5#dI}ZZyl;7V5Os@UTaf9l z9*_n(yH6vNwQ$LrNvtm^!i5O|IG*gznp8`7JO!wv7B~<0ykZh&0z@^#^JM@gefZ&$ zVGOD}0Z0gNE!r>k2r`;dgl)25vpu59^V7*kkO5qV{~uiLE?oAs$EbW4)3Gb)t;>zX z`uq^%?1=ZZg)m&d5}}{c2KPuHxBtGS3VN(G97h7A5BdIgr)fZX6)p?XoizKM-r?Sb zNZBQk1+`_yxxSOdZA?Mo>2osUIkXjG_%2UcC@U>HvrPX|&1#_NwPo$3=$(9u&lbaW zU*1MbE*y40Zce(wcX<^%_Q^pY#4`LQQ$!Up0&<>A)OG8b5DrYC&q70WF+l;^djz}P zMib#IPWh^GoF-l-BE#DmMOBf@KE`!Nb^`wMJVS7h^zO-Ef&Z^2lOY(;WQN=J&7-8; z+pPa-iMm!jmIz%|OTKRhGM-5#k`Y@nK%qfw%k2TtI^rAsiqwF}EWca`8u1|+{N|vV zI%yxS)F4$@f!M;ZsF=~8njRbTgiKe>r<1=d%R`!!!4bW#Hm~G5Tt3OyY=0AC-}Kz? zi)GXloUsCg6Q{-af(VW;FBxir-%C+CSlE`7^eSDO;(Uw7mr0DvM)H&> zc7bsCy1z^p=wt%Y!*4dugWf<5gw>?U+U_cqTfVR$(Hfa2HT#oazF19?4tDv43X~1;uo7WH#R7} zWHH9PH&{F)XMNrHRxdP!MOB>c>=qHAa$>68JBrZtK7R|god4yHK-mEYp%m$Ne##>r z57qbPik#sKA=#A^;)A=7tWwMu_}kwc1Q7fIGD|dqQW7vE1qgnLIujFD9D&1QCj7I> z<{p4kJx-syeQxCWn5$Jn_{QZ#MDWLDM?*-awI}7a-LCO|wghl=GsP zrF1pXF^NnRjisWpkRvk>x5ACdWA@c-XY7i~0@BGybhLh8%>m_OhgbsNZ&|8CY%6hf^oPqKUEBhM5wEi9JG0s0Ab^=6 zN$FtC8o1ZbpJ9V0{$J@`$?(*f@VM@3Qb)YUXdsp2M?kbQ9cl_c53rtQcbfcaU20Zl zu%0uYF8@e4%_)Ir|Jn1qAKNBrJ=o-9OxCO+rr@ZFWh(I~d0*{8k&qS5Hg*>|h| z#c1-zd(G~24p;Xqh0yKGB5RuAfWs{$taD~Z<|pkgl=`b^csy18?V5m#yB71xn0YC| zg`{N~D^8P#>L9!J-abkiZlP~)9{JHOsp0rJ8`~pM37v*(Yk~<3Xq_Es@cyUOdPl32 zh_(T^SYY;`M1CCT2$9Ku7H$W-@lQgS^!}SEMb~00Bd6A{hB~5dcPV|7Q9G+ejZG7A z1N4QRv&$WbVFLjmy%@iJXE?G()W5X*-(=X2v%DPF2*1W_fSS4q4nSTH2pv&FLV*-}6L*454mW%mcDG<^QVEpc?emV>+TUOk{i%mg2=KdsGQs3X4ib>6OY zqA&@;rc(kzuyijP;HMoWLpoV2J#&p5+*cd)@mUWe^PzMpe1WHyEaXmf&{*A=UrMW2 zJTL?N7}y}`A`znm3z$bhAOi56FtD|K`6OCR=&U{08$M_*yLC>GcK?Olr1Go*>S`&e z?ZY1}2w4`uu!0yksq5$*@6XSN_t9Cbb__Jik$F5z$g6`y5<3rQn<>jehdsGZ{(t|- zko_eZ;L~Q-vb?cR&3|>ISfAJ z(Jto!0OoSe*;xH6j+eg_fKLWw1EHGy>39*=fk>zT1;~3623-P&es?&YDMf*jjc)B{ zk4)MY#~ktuMwje)O(?Qi=w-zKi8KBp<{=5--LI>fAP!v4)p;?1>5^emFxItBLD zhBKf;xabGmYqpL1d1y+D2cOaN^Bw2CEEEGWTRa^e9$K9xqwnev@E7dMV{6?$!}<;W zMals9D?iYD6Zn9o@orKhqpByz6cCIea!jt|`CeZ3v#7lpW#dAVo2DU1Fm3fEMUAHa z-UdKDr`TTw$||`U1r!u%@>?+|V@-(txr z-;*N@B}>?r$mgYZ1uFDb^7`YsGRkm;`E=UyQHIY11RJmG*1l76Imuvu)-FwMp;^?J zbspm(Sn9}`;Hj@oNuMggOQ3*ue5IqW1ur8E$L#QM#2$xcMT~*QWLUS4 zh=`7dpT40{;`)8fPckk)Jt4H)bJ*72iVhgh1k_gTo$Kwh?dJD7$3F;|%G2d5^?d_n z!>kS5@GCxlk`;U#QypzwqtqWlPmPMg9x2tTS5=NIB0J8t zB4y=g>5&wOP$c{Ez>i0oCH{4g;z+fwbDlY{&s|ma%dLwsvgTKu(sY*LWYmyav-Iz* zO+h-Fc<0y&Q8vD(7h9+6Uz_$92UxeD)E9legNkh`t<-Ex@9RzZATt5uW#Akp2+0Lv$lCF!EXW=rOd zd#O8cbU=Qvv|qb?CXe7a$x@+#m$}UGraPgfz*K;s)-U^-{<5ZtwSExhGgolZCA6*P zauu9o6aUIPPTWcmKA$6x)VL$BisaDIHGHSHI791(gjkMEwER@Hy_j2AsX1TMRwfMt z%9iFCBgY)P*D4uEl2#BX1->GQvyMj+1m;Ll(-9-$v&&;_$S9q?t83NGV#6E8C&ox< zKkF!VA7G4C;^Y31UezB!l!(hAb@_v`-xw3Q&%5mS1!BHW>JwR_1?-9kB_0=P_UIuY-AaehCoN*{xR6mRyF84{hKP24?zaIOtk_}Z!pr?J-M_+J{vMN%0hYjf zc%P}!$k=3^NADF9+}qnWp8|BB3c?b1dGoNW>4v#_nL#{r-qM!xF?bOj3{8W8vxZ7< z!V5&SKy8VixXO|x^MF+l+-`6Ou{9+P@%xBk`16OD+w0`Oq6YFM_qC?-Vtgp!|29Py{vdf*KN2MPAS z7HZ8aTUw5yxH>xh;4hd{av3Clr`*CAnq#1U<^z@}{xcjR4p;ggQ{*Z`m-xFR4wJ24 zuPqne<9+yZ-JssCcgQBn)XDBdv}D_<$;$f4^UoS7jQxd;O_CU# z5ubiv{AKQulMek9Zyu%%JO-F4kFmC}diqVX!(ZFq7e-P)58Z|Z+HhQNj67rhKd zGnExd+G-qgqC!f~Ui8U}HuMPEsgHfv|91RB3WL+z09+{h^6P+!a#tTFk~jup8| zXRSMRq_Gla3dEWEDe16>WEVASDz?X5^>&=tBQb$W=5D8^13y{uwwuRVwUlg#G_!^# zwxAcj8zH}`eK4R=n=IGlk|^TH2_`#0nPg8HPO`5;DDKmwZ?~*sV(a&bZR-a!CBni- zY<5tCgsuit<)9_G(TEbDy1uNh(0Zn+JblN%j{l-QV)3fpP{GvBpLN-VBubZCSA&(+ z&mHe-l@D=S{Pe{ElZpThy zo_=m(^a%?bqx&i)aM7J?qTnxhgp8IQ@5RJmd%_J^v{83Vzeb=*?ncqeL41I={T~0^ z;V@sNm1!=aFX2?xuC~i0LzlOQAqJ261sPo4T(vOvB)3*%Fb!~t^Gc~)YL@^3=!`uU z+-u*_k&8Nyd4#J>d&01>U?bk=Gxz~Zu}t-QNo)G8?DdOb6o+l{JSpda{s!+plg)h^5EGL!Yhbr}gTwmJWX96XDf zmQuQzA`gc4y%>oQU^Hj7IB|Ce4!i|hc=dGR-a7c2g;bq=a|?Kn?1f%u+PJg`SqWP_ zuQ?c$C_tB=)Ax5Ix((2_>ETiR%ruvp`uddGnn@SS@SMl|rRsahGTip6xB6@$UzdT3 zu&D@g`+sm}Bf()jpioQ5;>lJ%zeAc8NsZ6_x!$EC7Wwmth5WHtMBdlRHL6DXfrggW z3?mX0cW|8*^f}D3A?x_I-b<}!;|bx4q$zcs6fBYT{e;9tuRl88`{`$xl8>$i1-)XK z2zJh;Trjdgb~S$w>aX2U`&fbg)F#XpA@4~M)Ej^`@@{=MT7?RAT)PE{}9jCXZySg_sh}#)-dS#Qlf%2_j~xwvYPKH&u;e+P^C{pw zX{=l~EbZ-qiY^bj>Shb48uZLRn}zs1pQpajsphxzYUZ3JVZy%BCZ(#eV7vIdur`ReQt|Ra&uFG%lSgceRU&UihGew~J(JcEUsP0?P%(WbII^s8CYH z`Fh^OVT4UeeLk|GsK7y%as!RbUqe>S%t%j-RGI+XH%jGGM#(F4tb}4bC4=>K?gbsVNMNvppKRE#*!yi z_n+R3jZ-j0`=2 z|KKrSLGk5z9l^e_vD13v{B_Ei=XP#ySGVdhZ(-43wbB+CGe@b@q+`fRulcR}vAf;@ zxkcgk3IpO*v)eAJ>u;Va#Uws_DWdlA#Y+`TSsPMsKj!{*TKMUDGJO!tY;J{el2?CEj-sb`^meP@dn7j_}a*f)=M`7X9eI^VMa2|ot z$X)baI0Q6TGe+h6vjN;9>qJ@Anuu@45r_ob)t~f|EEpma2&K70|Kepcg~gJseo)nP zMxw3rkV#JhwqT@1XSod_^Jm7t2^z5BIh*nY(1?FyXmi#714F5PV<`2fzZjYcN<}$xbZMChEiYhpvDjC)&K4c@ zPFj8<1JP;TU%aNE2oJT-Isx!>GXU8&?R^}`?O$kWhDkqAVqb-*2-e_z;I9gSr6i_5 z$3G4!lW9I2LNs!Ae|H!=2vdGOSh*+GPktXK&ax$aRQC>Fos=C2&ifCR&CEpCt%F)d z(0b-E1btCL-@C)T4M)U1QujnzH)6MO&qsy4#@0(;4DDZ5Et0~w%}>+%IU*@2N-82--YJ%(SFd5gYp!PQ*(rTI#m zC?c!j{ZWJ#?LoLSZL-No$}=Ii!h{GfC?!28gZdxN_gRQy9tP`b1%vX!V4<_1Mbvsl ztgPxuxKfl7CS~8Z)=>$T*zoaz(5i!zo$U8i{;E~ils!wuqNsiPWCx;TM{vj;_~E{t zEgpmqi{sm&R#Dld7EhU_s( z#Eeqpfys1_jELTqQDq1kU1%x+AR8=aVSxB}x^*Wi$5_)V%=b%yVnQ3ty9<0*h z4;z1IcH>U6&fDTrRLCVIr3Prmh7foA($}tL_4C$yV zyC}e~j_1(D%4H;Bk8rB_xNTD}Id6u~-I_4LovP>Cj1xR;>dCLIuEJYCTHb`hpLExv z1^?Ra0t}*7AJN@jH)cDpPa9agY{$CU?rOLiTn%`GXeFlSjN26t3*}sdUOE)10$<)e zJWfRu___0RE~a#&w!LT8Q!qrWEm~;ffDLTM-T>|8d?POV^K%C-UPv-vGFqn7EIr;I zW#{F@=q?&l-|jnpba68Rx2}Bfq`LHmTxUMiOVbsnv+9$`UM%>r)X50in->iy`+K$P zm6_ys9>*ilN$bxQ-_fSgyA4=Z-|R$X;uDflgB)z3kD!$&dV7>y>y~=dBm>sF{3iA^ zLg9SpGB^If`vwwNNuSIqo6EZGQ|#{p`g4nsg(o&!61)ymd&1WC*@|TalM-*?OIq|A zbQRLn3!G&$D7~14rx1pdt*x%tLXTwnb)jx{V{ht@TW`KG*ty)#PdaaVK&c0e);n>> zTR?XtfD!pUmd%~jTz<5Bg#i4nP`zgj5x38tcFI(<~7p`)Ddcw4T^ZgY{I z%^7My{a9$ZGbe;9>q+=Luc%pt2!$`$lm7)@yF>7FH4LMKHg(&$%PFmI!l`ETIjIhK zBKzxf;21@aBrt#w7b!%^j+`nkRKzgQ>S$~PSuU~5bWCfk$tzw9R(4RcyAaz>s88NN zQ7xH}@R@AtkbchO-bZ2=%lvMtCc@1|BDSM|6elb()bSQXS}Squ!;Air7DRVzxY*Tp z|43ISgXBZ$H87v^)mG$>Y~@|+XHaF=8}Z5Q1v*3Ku{Vcj_&?fbmwca2kE_x!bQ>|B znqL=vzhfoxjj{&U5;(24=BjT(X$OZtHCK*5hy<>)wb>C`Z{VQ8OH1+HRy(71IK0*l zjVM*v1l)fV=irt@9A>@H5?X%}GU-5-6*%_3#Slv!4~{;wlD$&M^l}cgGS3lkEe#6o zt!GXH2lGII#K(%INb}_>I3_+tm75J}0dxi)dwn`iUwJ6-0wdvi-i%yUujzvS1^8i< z?FyWHz8iYl7M32-8kSzfYSBtk@1BjUm1?nKfx&WbiT*J3v7!7ONh?-b@-HYo{$CWH zXV=6xtyquO#pw@Fk&ipoiEbyjEzhCmyagWzV&@LAIfiP}i(Ld~Adyp`2!sZUmO0jI?Dt8*QiJ2F2XK?<;Y&zJU@QnHvD{l; z3?F}@4;m&;~nLPpUxxT#J81vI@95- zRB?8O^-Xdvt>^}OVi?(vy0XvqPEO$R^88`r$jpLvv~C`c2_7ERu}pG}FX}!UjS?R> zK;!=yN&dVE!@jHSFkO4|(1cW6jwkj=WLGFa_|zyVlbcc!!zFPKd|Pk&t3bibrM z8APNN`vt+54p|eqosoc$(7X+AWcJrKb+|D$R9Q#UsMj-1yJ^PW zgu2bhwl+8uy+*`lr#Xu@2;C6Dw?OF|%lZTOcop1g4)8%ZU$4cNYpWS;{<7+Lq+JC+ zPOD}M-yWgQs%iy%lPKmaN)afof&A-3M;6l307#a^AU;W*(y+nn{$bH!dd9Z^TH+pD zS68>N@Op;f>YbIjIpe#}DPlkFh|eph2x*^z?uW}z3YloP=g$I&8|CjBu%5ndF)=gq zu#6V5GJF8YFjtZnCjezr{9W0Ai}+6R?ceu$}MeXWWG? zH#~aPCA+G5@tOWZ0z(2>(2hSAP-(QjKdv7ffQI6E+wge3NGOsPW7cnp_e*+Pjj{~D z7_Q;jT=`d=5~aM3n(i-dHG|zw8uPPU3%0)w3e*x&@(u29+TP6WxiY(Kmx;RC7P_SZ z$utkdB)TMz1XjrrSPyn~b|p(rgsgp=1CMNNv_c|_<)-QDH~9+bGjE(0E$hi~kk&VP zLQOw?VrMpYaUm#HEd^g*zDjdD;aLPwl9`+~rN)Y2ydRKkZj?12*b$F#nx|-#N0FHY zxN0(9^x*5&xE}+)`KY5_SH*fgfI))gA)q<=)%2rd!@t4Hl^jfRR+CSyl&qKl45MQ- zy$!5qq%g6#P?%kk4rd2{;!cF0Ed_P19KtGTL8`N2&)S`Le=*RQ|L8$y_~y+?SbMM?C5-3Nj?!AJFK$AX2q`qaz^ncr7^&(Dij_v&TEI%$y%&36Y#n zu{EQT$x6tmlSv}sQ&V>e)o5Zn_9-BYcu~L zVLf^Efrg(XvKLo*@25N|yplZpmlN#Kddsen2<$m} zFGnLvd2cOP-o=;PJkvg@^qIBQrB19(t+deu`#GxeU@S=eKnbeW8cQtAB+Ugb5S_Gl zGg2_(u)Li_$Yy{B%3{7sTo>!$e2{haNIn7BU!A!!2^BRpRJ4TwbB7ZnC~o7dyZOs= z2KJRKb|6$&b_TDLjxXXFu{-pbcm=8c)$u0F`+Fa6ee_a<6n+q0PdMXep*i0!D-@SP z3s0e>rlvX{6y{f$jFRv_-E2ZBz6Vg5)boa1;DW%Q{i{p@3qhT=Zj*iCS{tzDxSxF3 zPOvt4wj{{fBSZXpEwOr(jrdR*{uWM9(`9>kV8i6WEwf93n0{X9G0e;%FwwO>@uIn79{N%jA#t(!gEV z8{tU?&ijv&a~Zur_KZh6HpvmTPQu!Cm5i~AtDDHf+Q|m(PqWuV>6+fJcqjru91|p z#r!WRQiV^?Hor5fq^n>@j0Hz)%eN(y9Vr?inlO(xDeuEU5sOL@CwQ(W?NbSJJO(WU z#K=MFP()MeV2#1*6P%_GUmTjTOZLSeKiq0nU`f&w!;tfzcl-(~tey>gPQ~wCW^{HD z-if|JfD2rYKdsHihTItTH#RX07x{Dn9ZOt3mJ&%)?F9^UTXUFC$`C$Xc?Y#()4bsE1-< z?0yVG9`=5`nmk~$6^_@z3fTHemu}=W7I@6SXAQIvAr6q+8QUE`FoVrbr@ePqhsCAH z!g1k%Y+}h_RtJC_x|tFUWp)jCy(cKItM7rhv68Q7u@m0S)tajfY?tV^zUYe}?g9c~ zMp8b#)!AYU}?_VxDq`&aw&{*eq|$o2k$8FdVJA1xBy00n%#6_*z) I6VdnmKP2m0JOBUy diff --git a/docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif b/docs/vtune-user-guide/GUID-240BEE5F-39AC-464F-BA3C-4DC896BECB76-low.gif deleted file mode 100644 index 8a9671b2be3dd62cebad51b9251053badc3dc53f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 357 zcmZ?wbhEHblw=TMxT?+Y=kGs}^flZ`D+`vK+;-vVvg5Z5tG2amx-f0et;xG?e*W=0 zW8NvxuDzBGJ9(2=oxc0_=kLFI6zI8Qr}hn-zCu)#}(m6bVwah<1_60>js$F@K(?%?J7z4$l}X*)7l F0|15#i5>s| diff --git a/docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png b/docs/vtune-user-guide/GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png deleted file mode 100644 index 6d8cdfd595653c040bc3b8282d5d8de8e014af81..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 262 zcmeAS@N?(olHy`uVBq!ia0vp^Vj#@H1SGw${mubWIwh_VCC){ui6xo&c?uz!xv2~x zrKt)=1`3X)=|IZRQo+!`%EZvh)KEd&z}Udxq>g$vP#=4Vr>`sfV-68^U1=Hqv&=vt z&H|6fVg?31We{epSZZGe6l6(v^mSxl*x1kgCy^D%kM(qM45_%4Ji{Vcu(gA+<9vLz zmzmTVw}?i^$Vf?7w=2Ip1v9z)l*8N%1v0tplsimX8w8KcaJs?Kv`iqCr7rkID$7#2 xg(eo7y&+zc#YBZHmfp-Mm?Hi}!cmcl;rbbl$%fG{6M+^nc)I$ztaD0e0szWfNNE57 diff --git a/docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png b/docs/vtune-user-guide/GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png deleted file mode 100644 index 45257656fd20cf7f1b0d9d1c52eb905b1f44ccbc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 668 zcmV;N0%QG&P)5g6 z*%&pDrv|YVL+rBAqf_nu-+K(+=l1@G|L?>1`{(~2ycWh6_i0jWW(#P+k~a%W-YhJ6 zv#{jN!jd-&?eeF5%#Zal<`!V{pJ)<6-h%<5CrXHkXUZ z(F?4_Je(CYMc)zjYxc4N-^|uvGJL@a&_K+U;G3aWoEmX;`tRp204X3R}CwT|M z(ExJjFdem(pNfKWdKxlWgs#zAVy_kATls9I3O`KIy5mlGBO}5Ff%YP6Dvcf00007bV*G` z2jT)03@RlbmSTzk000SaNLh0L01FZT01FZU(%pXi00004XF*Lt006O%3;baP0009L zNklA_Ni>vDS{yGi=r05 z^;A{UG}AOAH2gY_-kcC2FbF-As=jX-}vzfZC+wJw*tu_+M<#I@E_Q1c;cs{RG zt9Zc!pvbG)yqX$D1b1JJh(am4u3M&ARjONCTV&!Sl}h19y`ITXJkKv^S=bFClgSi| z#mQuH(YU}-;Km`hptfz->kXP_U~7*vpr9a%q8g10x01nuU!@~vLKKkn$6}N(02PT%W;eQxWGUu`m6R-T_4|o20V_(5cJa! zBcs6v%XYgRbTR-PjYgnyR*%aj%W>RrII?Xg02&U5EX%Hf7#TpIFx#;MNm;fHStK8; zs`~Ej8(bV7!HyyFPiJSE)_?Kx)yc^T#P{*Tdl0Ma?3|vyj{61>%rTl7_SE%KwSTMC z+Mz+%a66sO`T2LaU%!0DegWLo)gQRES`F994g~WV^%SJ1hIM~`AGP4kilV^9bc0-6 zl()B$7v`;0Dn-X|9Y@6=0o>)~PuKI3?4yK!UquCiD1uhF=(}MUf*^nmgp5POo4AA! zQ3TRIJ~|9q$#HC78zezdh%A?qt|*GJ3lu)I6j1I#S#xdKn@M$WSpQTm@F;|`#Ar#f^ z_DsuU7&iFt5QYH@+XO^=o+}DsrLxVx4Hlj+p4onZTtB+bypLa|Wb7wlhR d#X*{D{{dAK!gX25@z4MO002ovPDHLkV1nv^wjBTf diff --git a/docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png b/docs/vtune-user-guide/GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png deleted file mode 100644 index 55af6fbd77ee3318dfad4645dce050bf89c22740..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29883 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 diff --git a/docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png b/docs/vtune-user-guide/GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png deleted file mode 100644 index f9aff5721db2cc64c0459b4e834b81391c23bfea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21246 zcmZ6z1z43)vo=g9DIndTASK=1CAkHZZiG!YNQWRD(hbtx-3`*+-QBTi{s(>EbI$i) zm&(K1Yd(fX5` z9TXI5*UMk%7+O?9pb_3)N=_Vp4FMVp4L)gNaN}>2xT?LdgT1kpEmVHV;3uHzjXlsL zW@u+%YhrD0Vr2=1iTIuzXh(W!7qzl>wlx78+d~zh4e|i3sDE2+4fS5SzOy&6Foa@< zpdkXEAijK}WMyRkUC-7KO3V8Br91N9mz&rbnCk&uZJ}!0s=|S0gqLO&JzGl?OE6R$ z;kG}}2LJE-4z>n{P*=}B2mkFRYGq+zXlW01Js8^xw86b}`(k2mZU~ikJWd4#^$to( zO!$ja^5K%JJ>gc$&2z2Ydj*&^#d#60kJTt8d0tDgGBQ6zW=m9rhZI{xKF=?SA%}iN zJ>Ym;|5ByEnT>7Xt3_aalPxVBK5j8ELrs>YhTd(6n1^WoE}I?!&WBk+4#u1Ym#Tep ze}$C1k6i8hfzka1Pw$Q@>&4*3pfR2MgXV#9i6*!2TM>l!zHd!rp;eolm>HYzT&f4i zfX2xza>+33(^cp&Vt(Z@w_MqTjzFrEuFbwEWa;m_qyBGDQI(sTY?N~3^?E`QWK(#m zKi7D)6Sg%4CA;ENieAXJaoVJik5TWl|D69uHikM0|hJMg2df)>`_7;j%fgv2t{Rn^-0;{D&jBHFX0qJSAhNo#8;(I|nqyz{A&KUZ8l z9v#(ASU%4XK7;zs@kU5)wVb+YfLWJ$KDPz5+2396srj^S^oFxCy_Hdcr%JWQaBy&- zU}XJNM*Xs}3fMkAK5nP&!k_Zn2C=D8QBatH<@Sb?!s~7iVkWR;yS-0&75rBK*lcWU zUG1>&;J;@>S1-FTSo8QIPPQ0>Q51)3Ou$V39x4foR! zeoyShGqbu1PCdfH1`6awQGz~d2#OacqT$dFT_jvBzJ)#U+Un;)#OwA&f2N|5PklU( za@BU-JuDfGW>pqC9s;V>;zlhQM@+ zT6P~{iYvPLj=e40z$A6#fxbDJ>F5<|6K9*N=Obb4_N}eez^7y9qX@{i!wEQ#-Z0{g z(R5KFUdNDz2A&*1eIZM$udc$o-K_Zs&ai?9>CAv>OJ#HQ zP4JSws6ov77xGt)XaYE>uV&I zt()d8Zp(YgcViO?IZ5&c_tWUrbQx@$sWT+bpq@B`-Y}b+Q@t=^r6g@CQ0gEeAmG!7 z2m|d1?{z@KZh)x-&QK*=!%R3dD8?~lD!>PWPTWFH+;(`gsRs~V1|vnvFTJRCy>g=~ z{2udLtZ~=8C1&UzNw&s{yml+W60(0Acrf|2SYu+PK*3P^^36cV^WcR1TGuQV3av`X zU@Og90_sq;V_Bo-Ph!!WJ^N&4cNX4fN8e1zaO=xcJvd0gh|qDXx0ZblpJ2*JbnBqO z((bYIqBaNP#Nxdnp)>ix+5AW}nV`;k>fWc@2GW&Qda^pw4NuXXRaGnjP*C{ z5>I<;aW`?NNt!dw{v*!cM{iC9WnKkEQRct@vr;@ayyFhq;o49pa&VZW@YuEml{%(f zJEYd|Oxg`K`-?=y_J`oJ+QJ1%h7ql`c|Qiu06JB0^F=Kr%RP_BxVx6Nzjo6h;*SBL$F^IFw9_S( z6c*gw-LcHT{nPYx7)s`)+K2_^HsU3awawwxHh6VireAR|G3W7|aM9E2gzsJ@jFh{- z@%f&EwCRxpHUdE?!-&FFt}!C^rm_;)^*P?zrKOzZjS$7O`tqwcIGI@xw-pJ?%I_>Y z!&C^`EKL>{tk!aKX*lnjnpD-6TP#)@ z9#uD&9RoU@mZoS!se@whv)F1$Hk6y)eHxPdb5F?;({rO{Z}{$Pb(~oVf8nHf^6CEm zemt9rqMoq+;xd1e{Sy(!N&n$N&k?)}2cVg69Nf{p8VH|)Ay0RlaA-uEf7UwPPG@SJ zPe7jQql8v4A54|cIqr$J%Tk)}SJx4ptXOG|_*VwD8z)zbz7mFf-FIGwV6AZn-}W66 zP!CW?U!4d=`&#zA$vLnm;;|2CZ%5P$*po97 z)6Ys3(+z+O^YG!IJ4NIPX{z&vq^?;F$OX*ICqxYgp9cSz8 zN<`vt$SSS?6-<+k`4)4Wd|*G~pFlU;ma@E42p{8+$y!KTss1+1>i7iau+?bT_IK}G z7#JHQw35%8U_%#5WeeO2%E zPRz*hl*##Gu2iK9ZhcGcdDM0S{?@&kic0V0-URp6$(; z(am%(*I{bsJv|j>wd{I1?c_p44x1^$wHVL{gf|Ev;{ss&V4yZLfNzJvWq$jfl(~dn8!$aeg0tVZI4=~-36&cwE6s9ZR z{N0bUAcev_-Lvs}m2$@;byOm*UrulPg*6Hh-qxAXSn+EJ9j&+IB2;?GfMF{I!vl}_ zQYOPcbTsT@1IGTH(+-)o`n}M4_{O>+C~u+hq~qZaqtabkayPqU+-k)EjB<_R4LS6HPJWZa1DA%Xvt}F9X)r6ZGrd zR++MU0guQlcWT86nAuw9v-6?CwXNp`St0_?ece} z&H}O6*1Z*~@7fu7Hin|g!Gcw6TX%)4!lSwh0Q##<^9|4hw$`~qQcd%}u}YUA{1Gun0f zrN8$hG0|I^a-h@mNxY80N!6Slo{kU)6efWiwk19N{q+gyYJASL<9L>o+DrgLZ3cW@ zG`X&9G4tf~N2B@J;#dWXA5U(FG7oeNDQE{IlTWx7SzC9rak~^My4&p6J%VpBd>C4a zZ#!q|HjxIy9|X=;o|IhG>yI&3i@4qPBdowrCyX;s<}6$It+7_UFtKwpHXBpuPZhYc zGb5>4ZFlY?@LvBF(@(vF)4|ToBrS>J~1Me{vh_`bRxWGmS=F?b(tYf;}m;5la|# zpQ)Tdw{>GqbGss3W7dD6CV$5#cX4=p03NyROoIk%H{#g|+$OX8gO2ugP;?=~GfeL6 z%XjRHWUlDAUADq)0pA3i@ugRP}1&6M5O`U&WY{3v*wJiY!$pYTb zPxT48RV>)?xr1>`#5Zo@3&S?+kK4AVMQ>bhWi6xpSEc|Z0( z-v~ZTl$NnQn|58_oSeAjMYCAGLxZ6$2IDFF^$M<#9s;9?{#s2kMSv zb;iq07{O;U*MrZN>pojlOEcYxD`fE#mxTQdf`xCK!^+~CUA^khW`gU;cUJw@jd|zf zlUOM75gS$oLMlr$k7AG9EOts@j-?Q{u3AK&PDH)+b;7J3N7}Q7&d}4Jn*Ak05QYX0 zM+|scS+8Gz4f+wL2o2jZF5})Jnf?XB=NO*ml0*NvTGW(AUkq4glZLK`J9gQX>8A3S zj{_}FZw!gDZ6ArT*@8+iBADv|%0&*cKojTWas||)}{yKtf%kFQDpe+oKbkyr1 zcJoyxY;HRy2KY zn76PF&H2ICeVcSevn%zJ^z&2w#0VMGQtT+CY0Z+VH82{CZ=d{lsWeI85Kn-HH}Ib1 zP0zjQH#Afwz6)28o!aw@V=9cjA4{$2TMzVnF@@XGyu11@Zb#NLeje={nuGEY7jNPF zk^92~4!Nr~=vgn;%#$+VBIH9NQ{)}pkbpn8IgQDL9i>u^tYMJ6mLv6v?pZ=;;&w_i z-=ml>Xm12=cpG!a>}kSt8&Yp3Btbg@A+BhJ{6umT6khTq+AMzN{xdx)oa&AS{3-EJ zTp}e!zq?yFxj0Vplp{b-jB^K}dyM^|8YVmA`|t#JZL#SsSpl(6Lhgdu|SW`@GZxSMvc)Gyk)i^uwIub*m4X;m89W?rGD@d>I`pm>o+v zIUa3q=7ti(=jX9o4&n|Io}Gs`0Ymak0OGHcoFG$%!*&te_#2j}RdStPFC4Di^Yp^O z;}Z}NSh@(<`l{uoba->FtZQvipf*2p^h!>s-}VRdIp5wUBaaepwo_fm&Nz`sOrKdd zomD_c77y6iL$QDH>~XXKagN=!RgrI`?4$eMVxhE6;)nU)Ozc7-@W18`m+OCmhMwj6 zNf*^Lc~<^3XtJxsEq)p(ZS9yzbs9hoP_Znuimdb z3-mtdp(5Ir$rJ~@k{-8g4ViVy9~wd6QhkT$LLZlS1Z z1gv$4FXf)XePo;xv++25>4san33-U*_|d|hcn_Pr(m$dCi*;%ao$zcK6|M+hv#63? z5&cw|ed!6Gu;~(u?7Ym7c{RKShA7om=^Ndjw$R-sJI}$WHu5X5x@{XG&sI9}QtEIg zL4AaH^jvwI%xBHaBQ~Vn50ee0-Y&XBmWnj@7z8SR4yYXo#MvFhwr|l_X{OG$$ElZW z@7o=yPM;%)E~6u!0q&}PXF9zmJij_VCJ0-JY6&i$Ex%;_g2qU()^@8uy*n89V!SZ> zpqGQ->>ZN|ihfIP%);^1g|n&Ud%3=?Ka~v^0ftD6g^$b88rjRPG8b;cjg3j|oXe|^ zf=>}>kfV*$V6?FNd)}h+5y))aPUEiT^oT>DBzK)@NZz6=%hQe_oqyr;7@PhA@%P1u zDlX9`Mpri`nFfI%(=slP89$HB?`!A_VMGFhUXBdnUOe&a2b%?)f<8R3@^U38DI=tw z0@cBWwN~V4hbGw;YR96z_Nm;H)40Yzznr>%f)s)NxM~X z-*c}%lIg(aFn)xWBCmq!t*w z$S-B_$a8N^7RX0M?E`Uqs0UlsUy|t$s6ncBL!PI+;bp5`DKK7$54>Cn*#_cFfW&a= zK>SLrU>PV7tfFOO!and`Y|h@n!KM?1^GhQhz@>0Zro$nL;sh^s)*E8c%idIzJ2&dBKiLL^h5lm0U;s+U|ItD_nPDC8#E@b(zrZ~JZGS$BroA3)u3VwDFluw} zf)9_pVD>mZvI2Cv#;Dc-?BQ320P04*Ar8f6KC0j;h(!i3tM~p zc|F^G+TXRho=cIS!8zZkKx})1NG}SttiF~p@mh1F_Hlzfk~KD0%$SFLEyvOuuete> z_}q*(<@2=&Br95G5SyDG7QswxMtp&Mm?D$E0tx9zTvAKYo+7EV30D!AZhfP;4;C*H zE^LUEpu?K_SX<9dCnP^&F}2*Vg}0(u2S}#5G_W{_LHm=m;8)hhiJr}zT$P(0P;ywz zcjfdx4=%tLs`EuqUCax^!GAvwMQ;}l&?xyS=i>vAeCJI&+$Ay3u{~9TC)LV~{gor@ zO}cgXE;kl&V37cIR^g;{wDQIS;nar%W?dH2=3N5In|-(8(CQ}=Hxpz*2*32oD)Y7Z zJxaLSv4*C*dg4UWY&TjH=)5*uGi*c9a`i!4TcoPjohGzHpOtU4+ay4K$xJols39Lr2X^$hVnDme0Aamzm~_`7XuJhxYDgQ6N`wuP5n zt&nn)S?Fs%jK5DcZj7XoAmR*-0v{w)da~+RwSU<49eMsGP!Ng=YMhMQ04Nc@*)$y;t7>=*Cg zl@fix1aY>Ik>thGxk{u`1-?sO^_{86ygtfxH;!J)7kh=kVgn3dlhT9hL|CB`1+H{X3fU0s z%$@ACqteQC*C4gd_YU}{8g8JGtPiSHwo@MH0i8u16?~Y zhYTFP*S}KE3d!aG))NKV6kCOYzgc*0fz3k3d;UXc)#br|^<|hw@0!s{tvlS~%zPX6 zj${MZoo0bVFp81E_6%}s*j7OL_=Ao+>x>KRVS`@M#Pa7GWtzsBMuTQtTrJH_w}aDD z;m-l$Q1L4tEcULZSh*wz&EIxC9J6z5)WRKgldg<*jGu3oSJel%tNEVKHHYp?IM|bf zQv+>2kWh25vFWmea-1V?uy7&Zh2oK;li}I;J*UQYSRF zU$1^;(-j6PK$k6G|1y#SGE8r2K|~lOe0_Pg%3RI2TFH$7^@<43CE54E@lt$S4F!`` zwW-b|;BUBa zwU)W=gwAFa!i@M=--75G5AKy-9$2_vock$eei~0~zLQ1*=dyhgF&x(oK+=;x@x;?XCFi}0oVtu>A!X|{v zOW_#T4uPMk;Xo*|%soT>?o2C%EH;{&k-FoW^SIINO@j#Y90OBlg`(*iaIX(5T zM18VwKqvYaZsIkuz!$V+$&2}K)o5vJqe+p^F9iX{^8ktIRae6HeWY%I=nu?GC- zNP_OBJ37iln_?&I*P3vOJv~_Oe)O6PVZx3_G4zu!R}p

MkEAVg$Eu^$CucCRw+y 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 KA@Mht+y4ceF^(hv diff --git a/docs/vtune-user-guide/api-support.rst b/docs/vtune-user-guide/api-support.rst deleted file mode 100644 index 5a1b1c60..00000000 --- a/docs/vtune-user-guide/api-support.rst +++ /dev/null @@ -1,28 +0,0 @@ -.. _api-support: - -API Support -=========== - - -Intel® VTune™ Profiler supports two kinds of APIs: - - -- The Instrumentation and Tracing Technology API (ITT API) provided by - the Intel® VTune™ Profiler enables your application to generate and - control the collection of trace data during its execution. - - -- The JIT (Just-In-Time) Profiling API provides functionality to report - information about just-in-time generated code that can be used by - performance tools. You must insert JIT Profiling API calls in the - code generator to report information before JIT-compiled code goes to - execution. This information is collected at runtime and used by tools - like Intel® VTune™ Profiler to display performance metrics associated - with JIT-compiled code. - -.. toctree:: - :maxdepth: 1 - - - support-for-instrumentation-and-tracing-technology-api-itt-api - jit-profiling-api diff --git a/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst b/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst deleted file mode 100644 index eba78093..00000000 --- a/docs/vtune-user-guide/attach-itt-apis-to-a-launched-application.rst +++ /dev/null @@ -1,98 +0,0 @@ -.. _attach-itt-apis-to-a-launched-application: - -Attach ITT APIs to a Launched Application -========================================= - - -You can use the Intel® VTune™ Profiler to attach to a running -application instrumented with ITT API. But before launching the -application, make sure to set up the following environment variable for -the ``ittnotify_collector``: - - -On Windows*: - - -``INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll`` - - -``INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll`` - - -On Linux*: - - -``INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so`` - - -``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` - - -On FreeBSD: - - -.. note:: - - - Header and library files are available from the - ``vtune_profiler_target_x86_64.tgz`` FreeBSD target package. See `Set - Up FreeBSD\* - System `__ for more - information. - - -``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` - - -.. note:: - - - The variables should contain the full path to the library without - quotes. - - -Example -------- - - -On Windows: - - -.. code:: bash - - - set INTEL_LIBITTNOTIFY32=C:\Program Files (x86)\Intel\oneAPI\vtune\latest\bin32\runtime\ittnotify_collector.dll - set INTEL_LIBITTNOTIFY64=C:\Program Files (x86)\Intel\oneAPI\vtune\latest\bin64\runtime\ittnotify_collector.dll - - -On Linux: - - -.. code:: bash - - - export INTEL_LIBITTNOTIFY32=/opt/intel/oneapi/vtune/latest/lib32/runtime/libittnotify_collector.so - export INTEL_LIBITTNOTIFY64=/opt/intel/oneapi/vtune/latest/lib64/runtime/libittnotify_collector.so - - -On FreeBSD: - - -.. note:: - - - You may need to change the path to reflect the placement of the - FreeBSD target package on your target system. - - -.. code:: bash - - - setenv INTEL_LIBITTNOTIFY64 /tmp/vtune_profiler_2021.9.0/lib64/runtime/libittnotify_collector.so - - -After you complete the configuration, you can start the instrumented -application in the correct environment and Intel® VTune™ Profiler will -collect user API data even if the application was launched before the -VTune Profiler. - diff --git a/docs/vtune-user-guide/basic-usage-and-configuration.rst b/docs/vtune-user-guide/basic-usage-and-configuration.rst deleted file mode 100644 index 8fbc7274..00000000 --- a/docs/vtune-user-guide/basic-usage-and-configuration.rst +++ /dev/null @@ -1,72 +0,0 @@ -.. _basic-usage-and-configuration: - -Basic Usage and Configuration -============================= - - -You can control performance data collection for your application by -adding basic instrumentation to your application and by configuring your -environment and your build system to use the Instrumentation and Tracing -Technology (ITT) APIs. - - -User applications/modules linked to the static ITT API library do not -have a runtime dependency on a dynamic library. Therefore, they can be -executed without Intel® VTune™ Profiler. - - -To use the ITT APIs, set up your C/C++ or Fortran application using the -steps provided in `Configuring Your Build -System `__. - - -Unicode Support ---------------- - - -All API functions that take parameters of type ``__itt_char`` follow the -Windows OS unicode convention. If UNICODE is defined when compiling on a -Windows OS, ``__itt_char`` is ``wchar_t``, otherwise it is ``char``. The -actual function names are suffixed with ``A`` for the ASCII APIs and -``W`` for the unicode APIs. Both types of functions are defined in the -DLL that implements the API. - - -Strings that are all ASCII characters are internally equivalent for both -the unicode and the ASCII API versions. For example, the following -strings are equivalent: - - -.. code:: cpp - - - __itt_sync_createA( addr, "OpenMP Scheduler", "Critical Section", 0); - __itt_sync_createW( addr, L"OpenMP Scheduler", L"Critical Section", 0); - - -See Also --------- - - -.. container:: linklist - - - `Minimize ITT API - Overhead `__ - - -`Configure Your Build -System `__ - - -`Task Analysis `__ - -.. toctree:: - :maxdepth: 1 - - - configure-your-build-system - attach-itt-apis-to-a-launched-application - instrument-your-application - minimize-itt-api-overhead - view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler \ No newline at end of file diff --git a/docs/vtune-user-guide/compile-and-link-with-ittapi.rst b/docs/vtune-user-guide/compile-and-link-with-ittapi.rst deleted file mode 100644 index a87b556d..00000000 --- a/docs/vtune-user-guide/compile-and-link-with-ittapi.rst +++ /dev/null @@ -1,51 +0,0 @@ -.. _compile-and-link-with-ittapi: - -***************************** -Compile and Link with ITT API -***************************** - - Before instrumenting your application, configure your build system to be able to reach the API headers and libraries: - - * Add \include to your INCLUDE path - * Add \build_\\bin to your LIBRARIES path - -Include the ITT API Header in Your Application -============================================== - - Add the following #include statements to every source file that you want to instrument: - - .. code-block:: c++ - - #include - - The ittnotify.h header contains definitions of ITT API routines and important macros which provide the correct logic of API invocation from a user application. - - - The ITT API is designed to incur almost zero overhead when tracing is disabled. But if you need fully zero overhead, you can compile out all ITT API calls from your application by defining the INTEL_NO_ITTNOTIFY_API macro in your project at compile time, either on the compiler command line, or in your source file, prior to including the ittnotify.h file. - -Link the libittnotify.lib Static Library to Your Application -============================================================ - - You need to link the static library, libittnotify.lib, to your application. If tracing is enabled, this static library loads the ITT API data collector and forwards ITT API instrumentation data to Intel Analyzer.If tracing is disabled, the static library ignores ITT API calls, providing nearly zero instrumentation overhead. - - - If you do not want to update your version of Visual Studio, you must link the libittnotify.lib static library to your application. - -UNICODE Support -=============== - - All ITT API functions with string arguments follow the Windows OS UNICODE convention, the actual function names are suffixed with A for the ASCII API and W for the UNICODE API. For example: - - .. code-block:: c++ - - __itt_domain_createA( const char* ); - __itt_domain_createW( const wchar_t* ); - - To facilitate cross-platform code development, the ITT API features the C macro __itt_domain_create. If a UNICODE macro is defined when compiling on a Windows OS, the C macro resolves into __itt_domain_createW, otherwise it resolves into __itt_domain_createA. - -Conditional Compilation -======================= - - For best performance in the release version of your code, use conditional compilation to turn off annotations. Define the macro INTEL_NO_ITTNOTIFY_API before you include ittnotify.h during compilation to eliminate all __itt_* functions from your code. - - You can also remove the static library from the linking stage by defining this macro. diff --git a/docs/vtune-user-guide/configure-your-build-system.rst b/docs/vtune-user-guide/configure-your-build-system.rst deleted file mode 100644 index 18630162..00000000 --- a/docs/vtune-user-guide/configure-your-build-system.rst +++ /dev/null @@ -1,204 +0,0 @@ -.. _configure-your-build-system: - -Configure Your Build System -=========================== - - -.. note:: - - - ITT API usage is supported on Windows*, Linux*, FreeBSD*, and - Android\* systems. It is not supported for QNX\* systems. - - -Before instrumenting your application, you need to configure your build -system to be able to reach the API headers and libraries. - - -For Windows\* and Linux\* systems: - - -- Add ``/sdk/include`` to your INCLUDE path for C/C++ - applications or ``/sdk/[lib32 or lib64]`` to your - INCLUDE path for Fortran applications -- Add ``/sdk/lib32`` to your 32-bit LIBRARIES path -- Add ``/sdk/lib64`` to your 64-bit LIBRARIES path - - -.. note:: - - - On Linux\* systems, you have to link the ``dl`` and ``pthread`` - libraries to enable ITT API functionality. Not linking these - libraries will not prevent your application from running, but no ITT - API data will be collected. - - -For FreeBSD\* systems: - - -.. note:: - - - Header and library files are available from the - ``vtune_profiler_target_x86_64.tgz`` FreeBSD target package. See `Set - Up FreeBSD\* - System `__ for more - information. - - -- Add ``/sdk/include`` to your INCLUDE path for C/C++ - applications or ``/sdk/[lib32 or lib64]`` to your - INCLUDE path for Fortran applications -- Add ``/sdk/lib64`` to your 64-bit LIBRARIES path - - -For the Android\* system, add the following libraries to your LIBRARIES -path depending on your device architecture: - - -- Add ``/target/android_v5_x86_64/lib-x86_64`` for the - Intel® 64 architecture -- Add ``/target/android_v5/lib-x86`` for the IA-32 - architecture -- Add ``/target/android_arm/lib-arm`` for the ARM\* - architecture - - -```` is the Intel® VTune™ Profiler installation directory. -The default installation path for the VTune Profiler varies with the -product shipment. - - -.. note:: - - - The ITT API headers, static libraries, and Fortran modules previously - located at ``/include`` and ``/lib32 [64]`` - folders were moved to the ``/sdk`` folder starting the - VTune Profiler 2021.1-beta08 release. Copies of these files are - retained at their old locations for backwards compatibility and these - copies should not be used for new projects. - - -Include the ITT API Header or Module in Your Application --------------------------------------------------------- - - -**For C/C++ Applications** - - -Add the following ``#include`` statements to every source file that you -want to instrument: - - -.. code:: cpp - - - #include - - -The ``ittnotify.h`` header contains definitions of ITT API routines and -important macros which provide the correct logic of API invocation from -a user application. - - -The ITT API is designed to incur almost zero overhead when tracing is -disabled. But if you need fully zero overhead, you can compile out all -ITT API calls from your application by defining the -``INTEL_NO_ITTNOTIFY_API`` macro in your project at compile time, either -on the compiler command line, or in your source file, prior to including -the ``ittnotify.h`` file. - - -**For Fortran Applications** - - -Add the ``ITTNOTIFY`` module to your source files with the following -source line: - - -.. code:: - - - USE ITTNOTIFY - - -Insert ITT Notifications in Your Application --------------------------------------------- - - -Insert ``__itt_*`` (C/C++) or ``ITT_*`` (Fortran) notifications in your -source code. - - -C/C++ example: - - -.. code:: cpp - - - __itt_pause(); - - -Fortran example: - - -.. code:: - - - CALL ITT_PAUSE() - - -For more information, see `Instrumenting Your -Application `__. - - -Link the libittnotify.a (Linux*, Android*, FreeBSD*) or libittnotify.lib (Windows*) Static Library to Your Application ----------------------------------------------------------------------------------------------------------------------- - - -You need to link the static library, ``libittnotify.a`` (Linux*, -FreeBSD*, Android*) or ``libittnotify.lib`` (Windows*), to your -application. If tracing is enabled, this static library loads the ITT -API implementation and forwards ITT API instrumentation data to VTune -Profiler. If tracing is disabled, the static library ignores ITT API -calls, causing nearly zero instrumentation overhead. - - -After you instrument your application by adding ITT API calls to your -code and link the ``libittnotify.a`` (Linux*, FreeBSD*, Android*) or -``libittnotify.lib`` (Windows*) static library, your application will -check the ``INTEL_LIBITTNOTIFY32`` or the\ ``INTEL_LIBITTNOTIFY64`` -environment variable depending on your application's architecture. If -that variable is set, it will load the libraries defined in the -variable. - - -Make sure to set these environment variables for the -``ittnotify_collector`` to enable data collection: - - -On Windows*: - - -``INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll`` - - -``INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll`` - - -On Linux*: - - -``INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so`` - - -``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` - - -On FreeBSD*: - - -``INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so`` - diff --git a/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst b/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst deleted file mode 100644 index c1ae7b8b..00000000 --- a/docs/vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst +++ /dev/null @@ -1,26 +0,0 @@ -.. _instrumentation-and-tracing-technology-api-reference: - -Instrumentation and Tracing Technology API Reference -==================================================== - - -Here are the tools available for use with the Instrumentation and -Tracing Technology API (ITT API) - -.. toctree:: - :maxdepth: 1 - - - domain-api - string-handle-api - collection-control-api - thread-naming-api - task-api - frame-api - histogram-api - user-defined-synchronization-api - event-api - counter-api - context-metadata-api - load-module-api - memory-allocation-apis \ No newline at end of file diff --git a/docs/vtune-user-guide/jit-profiling-api-reference.rst b/docs/vtune-user-guide/jit-profiling-api-reference.rst deleted file mode 100644 index 09b9ceac..00000000 --- a/docs/vtune-user-guide/jit-profiling-api-reference.rst +++ /dev/null @@ -1,12 +0,0 @@ -.. _jit-profiling-api-reference: - -JIT Profiling API Reference -=========================== - -.. toctree:: - :maxdepth: 1 - - - ijit_notifyevent - ijit_isprofilingactive - ijit_-getnewmethodid \ No newline at end of file diff --git a/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst b/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst deleted file mode 100644 index 69bc8642..00000000 --- a/docs/vtune-user-guide/support-for-instrumentation-and-tracing-technology-api-itt-api.rst +++ /dev/null @@ -1,68 +0,0 @@ -.. _support-for-instrumentation-and-tracing-technology-api-itt-api: - -Support for Instrumentation and Tracing Technology API (ITT API) -================================================================ - - -.. note:: - - - The Instrumentation and Tracing Technology API (ITT API) and the - Just-in-Time Profiling API (JIT API) are open source components. - Visit the `GitHub\* repository `__ - to access source code and contribute. - - -The Instrumentation and Tracing Technology API (ITT API) provided by the -Intel® VTune™ Profiler enables your application to generate and control -the collection of trace data during its execution. - - -ITT API has the following features: - - -- Controls application performance overhead based on the amount of - traces that you collect. -- Enables trace collection without recompiling your application. -- Supports applications in C/C++ and Fortran environments on Windows*, - Linux*, FreeBSD*, or Android\* systems. -- Supports instrumentation for tracing application code. - - -To use the APIs, add API calls in your code to designate logical tasks. -These markers will help you visualize the relationship between tasks in -your code relative to other CPU and GPU tasks. To see user tasks in your -performance analysis results, enable the **Analyze user tasks** checkbox -in analysis settings. - - -.. note:: - - - The ITT API is a set of pure C/C++ functions. There are no Java\* or - .NET\* APIs. If you need runtime environment support, you can use a - JNI, or C/C++ function call from the managed code. If the collector - causes significant overhead or data storage, you can pause the - analysis to reduce the overhead. - - -See Also --------- - - -.. container:: linklist - - - `Task Analysis `__ - - -`View Instrumentation and Tracing Technology (ITT) API Task Data in -Intel® VTune™ -Profiler `__ - -.. toctree:: - :maxdepth: 1 - - - basic-usage-and-configuration - instrumentation-and-tracing-technology-api-reference \ No newline at end of file diff --git a/docs/vtune-user-guide/task-api.rst b/docs/vtune-user-guide/task-api.rst deleted file mode 100644 index 02e8a0c4..00000000 --- a/docs/vtune-user-guide/task-api.rst +++ /dev/null @@ -1,176 +0,0 @@ -.. _task-api: - -Task API -======== - - -A *task* is a logical unit of work performed by a particular thread. -Tasks can nest; thus, tasks typically correspond to functions, scopes, -or a case block in a switch statement. You can use the Task API to -assign tasks to threads. - - -Task API is a per-thread function that works in resumed state. This -function does not work in paused state. - - -The Task API does not enable a thread to suspend the current task and -switch to a different task (task switching), or move a task to a -different thread (task stealing). - - -A task instance represents a piece of work performed by a particular -thread for a period of time. The task is defined by the bracketing of -\__itt_task_begin() and \__itt_task_end() on the same thread. - - -.. note:: - - - To be able to see user tasks in your results, enable the **Analyze - user tasks** checkbox in analysis settings. - - -Task API Functions ------------------- - - -Create a task instance on a thread. This becomes the current task -instance for that thread. A call to\ ``__itt_task_end()`` on the same -thread ends the current task instance. - - -``void __itt_task_begin (const __itt_domain *domain,__itt_id taskid, __itt_id parentid, __itt_string_handle *name)`` - - -Trace the end of the current task. - - -``void __itt_task_end (const __itt_domain *domain)`` - - -``ITTAPI__itt_task_*`` Function Parameters ------------------------------------------- - - -The following table defines the parameters used in the Task API -primitives. - - -.. list-table:: - :header-rows: 0 - - * - Type - - Parameter - - Description - * - ``[in]`` - - \ ``__itt_domain``\ - - The domain of the task. - * - ``[in]`` - - \ ``__itt_id taskid``\ - - This is a reserved parameter. - * - ``[in]`` - - \ ``__itt_id parentid``\ - - This is a reserved parameter. - * - ``[in]`` - - \ ``__itt_string_handle``\ - - The task string handle. - - - - -Enable Task APIs ----------------- - - -The following steps are required to begin using task APIs: - - -#. Include ``ittnotify.h`` header. -#. Create domain and string handles for your tasks. -#. Insert task begin and task end marks in your code. -#. Link to ``libittnotify.lib`` (Windows*) or ``libittnotify.a`` - (Linux*). -#. Enable the **Analyze user tasks, events, and counters** option before - profiling. For more information, see `Task - Analysis `__ topic. - - -Usage Example -------------- - - -The following code snippet creates a domain and a couple of tasks at -global scope. - - -.. code:: cpp - - - #include "ittnotify.h" - - - void do_foo(double seconds); - - - __itt_domain* domain = __itt_domain_create("MyTraces.MyDomain"); - __itt_string_handle* shMyTask = __itt_string_handle_create("My Task"); - __itt_string_handle* shMySubtask = __itt_string_handle_create("My SubTask"); - - - void BeginFrame() { - __itt_task_begin(domain, __itt_null, __itt_null, shMyTask); - do_foo(1); - } - - - void DoWork() { - __itt_task_begin(domain, __itt_null, __itt_null, shMySubtask); - do_foo(1); - __itt_task_end(domain); - } - void EndFrame() { - do_foo(1); - __itt_task_end(domain); - } - - - int main() { - BeginFrame(); - DoWork(); - EndFrame(); - return 0; - } - - - #ifdef _WIN32 - #include - - - void do_foo(double seconds) { - clock_t goal = (clock_t)((double)clock() + seconds * CLOCKS_PER_SEC); - while (goal > clock()); - } - #else - #include - - - #define NSEC 1000000000 - #define TYPE long - - - void do_foo(double sec) { - struct timespec start_time; - struct timespec current_time; - - - clock_gettime(CLOCK_REALTIME, &start_time); - while(1) { - clock_gettime(CLOCK_REALTIME, ¤t_time); - TYPE cur_nsec=(long)((current_time.tv_sec-start_time.tv_sec-sec)*NSEC + current_time.tv_nsec - start_time.tv_nsec); - if(cur_nsec>=0) - break; - } - } - #endif - diff --git a/docs/vtune-user-guide/using-jit-profiling-api.rst b/docs/vtune-user-guide/using-jit-profiling-api.rst deleted file mode 100644 index 6d14f9d3..00000000 --- a/docs/vtune-user-guide/using-jit-profiling-api.rst +++ /dev/null @@ -1,195 +0,0 @@ -.. _using-jit-profiling-api: - -Using JIT Profiling API -======================= - - -To include JIT Profiling support, do one of the following: - - -- - - - .. container:: - :name: LI_DB9BBDF5654E49BA9743FA34A8BEFC9C - - - Include the following files to your source tree: - - - - - - - .. container:: - :name: LI_EABD97D44F984162B38420A57167AC5B - - - ``jitprofiling.h``, located under \include - (Windows*) or /include (Linux*) - - - - - - - .. container:: - :name: LI_6E4F12C743D144E4A1515F4829612FB3 - - - ``ittnotify_config.h``, ``ittnotify_types.h`` and - ``jitprofiling.c``, located under - \sdk\src\ittnotify (Windows*) or - /sdk/src/ittnotify (Linux*) - - - .. note:: - - - To locate your see `Installation - Directory <#INSTALL-DIR-JIT>`__. - - -- - - - .. container:: - :name: LI_1B044705871E4F2F90A3733AAB95D071 - - - Use the static library provided with the product: - - - #. - - - .. container:: - :name: LI_EBB0F0A78ADC45FD973DB21B3CEFF629 - - - Include\ ``jitprofiling.h`` file, located under the - \include (Windows*) or /include - (Linux*) directory, in your code. This header file provides - all API function prototypes and type definitions. - - - #. - - - .. container:: - :name: LI_C273EB329F1449B2A460BED51529BC6B - - - Link to ``jitprofiling.lib`` (Windows*) or - ``jitprofiling.a`` (Linux*), located under - \lib32or \lib64 (Windows*) or - /lib32 or /lib32 (Linux*). - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``int iJIT_NotifyEvent( iJIT_JVM_EVENT event_type, void *EventSpecificData );``\ - - Use this API to send a notification of ``event_type`` with the data pointed by ``EventSpecificData`` to the agent. The reported information is used to attribute samples obtained from any Intel® VTune™ Profiler collector. - * - \ ``unsigned int iJIT_GetNewMethodID( void );``\ - - Generate a new method ID. You must use this function to assign unique and valid method IDs to methods reported to the profiler. This API returns a new unique method ID. When out of unique method IDs, this API function returns 0. - * - \ ``iJIT_IsProfilingActiveFlags iJIT_IsProfilingActive( void );``\ - - Returns the current mode of the profiler: off, or sampling, using the ``iJIT_IsProfilingActiveFlags`` enumeration. This API returns ``iJIT_SAMPLING_ON`` by default, indicating that Sampling is running. It returns ``iJIT_NOTHING_RUNNING`` if no profiler is running. - - - - -Lifetime of Allocated Data --------------------------- - - -You send an event notification to the agent (VTune Profiler) with -event-specific data, which is a structure. The pointers in the structure -refer to memory you allocated and you are responsible for releasing it. -The pointers are used by the ``iJIT_NotifyEvent`` method to copy your -data in a trace file, and they are not used after the -``iJIT_NotifyEvent`` method returns. - - -JIT Profiling API Sample Application ------------------------------------- - - -VTune Profiler is installed with a sample application in the -``jitprofiling_vtune_amp_xe.zip`` (Windows*) or -``jitprofiling_vtune_amp_xe.tgz`` (Linux*) that emulates the creation -and execution of dynamic code. In addition, it uses the JIT profiling -API to notify the VTune Profiler when it transfers execution control to -dynamic code. - - -**To install and set up the sample code:** - - -#. Copy the ``jitprofiling_vtune_amp_xe.zip`` (Windows*) or - ``jitprofiling_vtune_amp_xe.tgz`` (Linux*) file from the - \samples\\C++ (Windows*) or - /samples//C++ (Linux*)directory to a writable - directory or share on your system. -#. Extract the sample from the archive file. - - -Build jitprofiling.c in Microsoft Visual Studio\* -------------------------------------------------- - - -#. Copy the ``jitprofiling_vtune_amp_xe.zip`` file from the - \samples\\C++ directory to a writable directory - or share on your system. -#. Extract the sample from the ``.zip`` file. -#. Open the ``jitprofiling.sln`` file with Microsoft Visual Studio. -#. Right-click **jitprofiling** in the **Solution Explorer** and select - **Properties**. The **jitprofiling Property Pages** window opens. -#. Set the **Platform** (top of the window) to **x64**. -#. Select **Configuration Properties** > **C/C++** > **General** and add - the path to the headers (````/include) to **Additional - Include Directories**. -#. Select **Configuration Properties** > **C/C++** > **Linker** > - **General** and add the path to the library (````/lib32 - or ````/lib64) to **Additional Library Directories**. -#. Click **OK** to apply the changes and close the window. -#. Rebuild the solution with the new project settings. - - -Installation Information ------------------------- - - -Follow these instructions in the Installation Guide to install VTune -Profiler on: - - -- `Windows - host `__ -- `Linux - host `__ - - -Whether you download Intel® VTune™ Profiler as a standalone component or -with the Intel® oneAPI Base Toolkit, the default path for your -```` is: - - -.. list-table:: - :header-rows: 0 - - * - Operating System - - Path to - * - Windows\* OS - - - * - Linux\* OS - - - - - - -Make sure that your installation of Intel® VTune™ Profiler has also -installed the `sampling -drivers `__ -necessary for data collection. - diff --git a/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst b/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst deleted file mode 100644 index f7fd6643..00000000 --- a/docs/vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst +++ /dev/null @@ -1,130 +0,0 @@ -.. _view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler: - -View Instrumentation and Tracing Technology (ITT) API Task Data in Intel® VTune™ Profiler -========================================================================================= - - -User task and API data can be visualized in Intel® VTune™ Profiler -performance analysis results. - - -After you have added basic annotations to your application to control -performance data collection, you can view these annotations in the Intel -VTune Profiler timeline. All supported instrumentation and tracing -technology (ITT) API tasks can be visualized in VTune Profiler. - - -Use the following steps to include ITT API tasks in your performance -analysis collection: - - -#. - - - .. container:: - :name: LI_0A72C46E11A64608A344009FE3604A58 - - - Click the |image1| (standalone GUI)/|image2| (Visual Studio IDE) - **Configure Analysis** button on the Intel® VTune™ Profiler - toolbar. - - - The **Configure Analysis** window opens. - - -#. Set up the analysis target in the **WHERE** and **WHAT** panes. - - -#. - - - .. container:: - :name: LI_235EFD2738DB45079C9BA80E38C3EB1B - - - From **HOW** pane, click the |image3| Browse button and select an - analysis type. For more information about each analysis type, see - `Performance Analysis - Setup `__. - - -#. Select the **Analyze user tasks, events, and counters** checkbox to - view the API tasks, counters, and events that you added to your - application code. - - - .. note:: - - - In some cases, the **Analyze user tasks, events, and counters** - checkbox is in the expandable **Details** section. To enable the - checkbox, use the **Copy** button at the top of the tab to create - an editable version of the analysis type configuration. For more - information, see `Custom - Analysis `__ . - - -#. Click the |image4| Start button to `run the - analysis `__. - - -After collection completes, the analysis results appear in a viewpoint -specific to the analysis type selected. The API data collected is -available in the following locations: - - -- - - - .. container:: - :name: LI_5EF5EAB8A8BB4C07BDB94F5795C0709A - - - Timeline view: Each API type appears differently on the timeline - view. In the example below, the code was instrumented with the - task API, frame API, event API, and collection control API. Tasks - appear as yellow bars on the task thread. Frames appear at the top - of the timeline in pink. Events appear on the appropriate thread - as a triangle at the event time. Collection control events span - the entire timeline. Hover over a task, frame, or event to view - the type of API task. - - - .. image:: GUID-EDB262AE-A77B-442B-9592-1EFA506C7128-low.png - - -- - - - .. container:: - :name: LI_A7EED03FA1734E9897CB44961C34A900 - - - Grid view: Set the **Grouping** to **Task Domain / Task Type / - Function / Call Stack** or **Task Type / Function / Call Stack** - to view task data in the grid pane. - - - .. image:: GUID-1ABE0C25-5938-4D25-8D9E-F2004C907256-low.png - - -- - - - .. container:: - :name: LI_DF180FC79C644C788EF43E19B028ED7C - - - Platform tab: Individual tasks are available in a larger view on - the **Platform** tab. Hover over a task to get more information. - - - .. image:: GUID-FCF7E148-45E3-4669-9D09-091ADEA45BBA-low.png - - -.. |image1| image:: GUID-594B6013-D1E9-4593-B9EC-85791339769D-low.png -.. |image2| image:: GUID-3AFC2DCE-141C-4709-9F29-7D143D40EEB9-low.png -.. |image3| image:: GUID-682C1D59-20E8-4428-AF7A-23727182579B-low.png -.. |image4| image:: GUID-05002AF5-830E-43B6-9CA1-A5015F87329D-low.png - diff --git a/docs/vtune-user-guide/vtune-user-guide.rst b/docs/vtune-user-guide/vtune-user-guide.rst deleted file mode 100644 index a6916cfe..00000000 --- a/docs/vtune-user-guide/vtune-user-guide.rst +++ /dev/null @@ -1,31 +0,0 @@ -.. _vtune-user-guide: - -******************** -API Support in VTune -******************** -.. toctree:: - :maxdepth: 1 - - /vtune-user-guide/api-support.rst - /vtune-user-guide/compile-and-link-with-ittapi.rst - /vtune-user-guide/basic-usage-and-configuration.rst - /vtune-user-guide/instrumentation-and-tracing-technology-api-reference.rst - /vtune-user-guide/using-jit-profiling-api.rst - /vtune-user-guide/jit-profiling-api-reference.rst - - -Add-ons -======= -.. toctree:: - :maxdepth: 1 - - /vtune-user-guide/minimize-itt-api-overhead.rst - /vtune-user-guide/view-instrumentation-and-tracing-technology-itt-api-task-data-in-intel-vtune-profiler.rst - /vtune-user-guide/attach-itt-apis-to-a-launched-application.rst - - -API support for other program languages -======================================= - -- `RUST ITT API bindings `_ -- `Python ITT API bindings `_ From 886e3d5a36a144058b7684d3dbcfdf689868dd45 Mon Sep 17 00:00:00 2001 From: eparshut Date: Fri, 23 May 2025 16:00:35 +0200 Subject: [PATCH 3/7] doc: address review comments --- README.md | 22 +- docs/README.md | 4 +- docs/conf.py | 2 +- docs/index.rst | 12 +- docs/src/api-support.rst | 4 +- docs/src/build.rst | 50 +- docs/src/compile-and-link-with-itt-api.rst | 150 +++--- docs/src/instrument-your-application.rst | 94 ++-- docs/src/itt-api-support.rst | 29 +- docs/src/ittapi/clock-domain-api.rst | 47 +- docs/src/ittapi/collection-control-api.rst | 92 ++-- docs/src/ittapi/context-metadata-api.rst | 168 ++++--- docs/src/ittapi/counter-api.rst | 125 +++-- docs/src/ittapi/domain-api.rst | 49 +- docs/src/ittapi/event-api.rst | 65 +-- docs/src/ittapi/frame-api.rst | 96 ++-- docs/src/ittapi/histogram-api-schema.png | Bin 90755 -> 191599 bytes docs/src/ittapi/histogram-api.rst | 177 +++---- docs/src/ittapi/load-module-api.rst | 49 +- docs/src/ittapi/marker-api.rst | 43 +- docs/src/ittapi/memory-allocation-apis.rst | 125 +++-- docs/src/ittapi/metadata-api.rst | 118 ++--- docs/src/ittapi/relation-api.rst | 72 +-- docs/src/ittapi/string-handle-api.rst | 34 +- docs/src/ittapi/task-api.rst | 173 +++---- docs/src/ittapi/thread-naming-api.rst | 50 +- .../user-defined-synchronization-api.rst | 340 ++++++------- docs/src/jit-api-support.rst | 171 +++---- docs/src/jitapi/ijit_-getnewmethodid.rst | 15 +- docs/src/jitapi/ijit_isprofilingactive.rst | 7 +- docs/src/jitapi/ijit_notifyevent.rst | 459 ++++++++++-------- docs/src/minimize-itt-api-overhead.rst | 78 +-- docs/src/overview.rst | 44 +- docs/src/ref_collector.rst | 14 +- docs/src/using-jit-api.rst | 137 ++---- histogram-api-schema.png | Bin 0 -> 191599 bytes 36 files changed, 1562 insertions(+), 1553 deletions(-) create mode 100644 histogram-api-schema.png diff --git a/README.md b/README.md index 53ffbe0e..4f94868d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ -Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API -================================================================================== +Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs +=============================================================================== [![Build Status](https://github.com/intel/ittapi/actions/workflows/main.yml/badge.svg?branch=master&event=push)](https://github.com/intel/ittapi/actions) [![CodeQL](https://github.com/intel/ittapi/actions/workflows/codeql.yml/badge.svg?branch=master)](https://github.com/intel/ittapi/security/code-scanning/tools/CodeQL/status) @@ -8,7 +8,7 @@ Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API [![Package on crates.io](https://img.shields.io/crates/v/ittapi.svg)](https://crates.io/crates/ittapi) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/intel/ittapi/badge)](https://securityscorecards.dev/viewer/?uri=github.com/intel/ittapi) -This ITT/JIT open source profiling API includes: +This ITT/JIT open source profiling APIs includes: - Instrumentation and Tracing Technology (ITT) API - Just-In-Time (JIT) Profiling API @@ -26,12 +26,10 @@ a BSD/GPLv2 dual license with every tool supporting ITT API. ### Build To build the library: - - On Windows, Linux, FreeBSD and OSX: requires [cmake](https://cmake.org) to be set in `PATH` - - Windows: requires Visual Studio installed or requires - [Ninja](https://github.com/ninja-build/ninja/releases) to be set in `PATH` - - To enable fortran support requires + - On Windows*, Linux*, FreeBSD*, and macOS* systems: Set [CMake](https://cmake.org) in `PATH` + - On Windows*: Install Microsoft Visual Studio or set [Ninja](https://github.com/ninja-build/ninja/releases) in `PATH` + - To enable support for Fortran, install the [Intel Fortran Compiler](https://www.intel.com/content/www/us/en/docs/fortran-compiler/get-started-guide/current/overview.html) - installed - To list available build options execute: `python buildall.py -h` ``` usage: buildall.py [-h] [-d] [-c] [-v] [-pt] [-ft] [--force_bits] @@ -50,18 +48,18 @@ optional arguments: ### Documentation -For detailed documentation, please visit the +Find complete documentation for ITT/JIT APIs on the [ITT/JIT API Documentation Page](https://intel.github.io/ittapi) ### License All code in the repo is dual licensed under GPLv2 and 3-Clause BSD licenses -### Contributing +### Make Contributions -To contribute, please see our [contributing guide](CONTRIBUTING.md) +Learn how to contribute using our [contribution guide](CONTRIBUTING.md) To report bugs or request enhancements, please use the "Issues" page on GitHub ### Security -Please refer to the [security policy](SECURITY.md) for reporting vulnerabilties +To report vulnerabilities, refer to our [security policy](SECURITY.md) diff --git a/docs/README.md b/docs/README.md index 4ec2c1e6..28b31df2 100755 --- a/docs/README.md +++ b/docs/README.md @@ -1,8 +1,8 @@ -# ITT/JIT API Documentation +# ITT/JIT APIs Documentation ## Overview -This repository contains the source files for the ITT/JIT API online documentation, +This repository contains the source files for the ITT/JIT APIs online documentation, which is hosted on GitHub Pages. [View the documentation here](link). ## Build Documentation from Sources diff --git a/docs/conf.py b/docs/conf.py index d1fd9023..b6e80398 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -11,7 +11,7 @@ # -- Project information ----------------------------------------------------- -project = 'ITT/JIT API Documentation' +project = 'ITT/JIT APIs Documentation' copyright = '2025 Intel Corporation' author = 'Intel Corporation' diff --git a/docs/index.rst b/docs/index.rst index 509de624..68c095cf 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,13 +1,11 @@ .. _index: -Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API Documentation -============================================================================================ +The Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs +=================================================================================== -.. note:: - - The ITT/JIT API Documentation from the Intel® VTune Profiler and Intel® Graphics - Performance Analyzers User Guides has been consolidated into this repository, - providing a single, unified source of information. +The ITT/JIT API Documentation from the Intel® VTune Profiler and Intel® Graphics +Performance Analyzers User Guides has been consolidated into this repository, +providing a single, unified source of information. .. toctree:: diff --git a/docs/src/api-support.rst b/docs/src/api-support.rst index e3f4aca5..f91cb3cb 100644 --- a/docs/src/api-support.rst +++ b/docs/src/api-support.rst @@ -1,7 +1,7 @@ .. _api-support: -API Usage and Reference -======================= +Use the ITT/JIT APIs +==================== .. note:: diff --git a/docs/src/build.rst b/docs/src/build.rst index 04e8b6a2..54c102ab 100644 --- a/docs/src/build.rst +++ b/docs/src/build.rst @@ -1,45 +1,49 @@ .. _build: -Build from Source -================= - -Requirements for Building from Source -------------------------------------- - -- General development tools, including C/C++ compiler. -- `Python `__ 3.6 or later. -- `CMake `__ 3.5 or later. -- Windows only: - `Microsoft Visual Studio `__ 2015 or later - ether - `Ninja `__ 1.9 or later. -- To enable Fortran support, requires `Intel Fortran Compiler +Build from Source Code +====================== + +Technical Requirements +---------------------- + +Before you build the ITT/JIT APIs, make sure you have the following hardware and software tools: + +- Get general development tools, including C/C++ Compiler +- Install `Python `__ 3.6 or later +- Install `CMake `__ 3.5 or later +- For a Windows* system, install one of these: + + - `Microsoft Visual Studio `__ 2015 or later + - `Ninja `__ 1.9 or later. + +- To enable support for Fortran, install the `Intel Fortran Compiler `__ - installed. -Download the Source Code ------------------------- +Get the ITT/JIT APIs Source Code +-------------------------------- + +To get the source code for the ITT/JIT APIs, do one of the following: -Download `ITT/JIT API source code `__ or clone -`the repository `__. +- Download it from `the latest public Release `__ +- Clone the repository: .. code-block:: console git clone https://github.com/intel/ittapi.git -Build ------ +Build the ITT/JIT APIs +---------------------- -To build the ITT/JIT API static library execute: +To build the ITT/JIT APIs static library, run this command: .. code-block:: console python buildall.py -The ailable build options: +Use these options to configure the build process: .. code-block:: console diff --git a/docs/src/compile-and-link-with-itt-api.rst b/docs/src/compile-and-link-with-itt-api.rst index 9c48f605..0dd188bd 100644 --- a/docs/src/compile-and-link-with-itt-api.rst +++ b/docs/src/compile-and-link-with-itt-api.rst @@ -4,162 +4,162 @@ Compile and Link with ITT API ============================= -Before instrumenting your application, configure your build system to be -able to reach the API headers and libraries: +Step 1: Configure Your Build System +----------------------------------- -- Add ``\sdk\include`` to your ``INCLUDE`` path +Before instrumenting your application with ITT API, configure your build +system to establish access to the headers and libraries of the API: + + +- Add ``\include`` to your ``INCLUDE`` path - Add ``\build_\\bin`` to your ``LIBRARIES`` path -Include the ITT API Header or Module in Your Application --------------------------------------------------------- +Step 2: Include the ITT API Header/Module in Your Application +------------------------------------------------------------- -**For C/C++ Applications** +**C/C++ Applications** -Add the following ``#include`` statements to every source file that you -want to instrument: +For every source file that you want to instrument, add the following +``#include`` statements: -.. code:: cpp +.. code-block:: cpp #include -The ``ittnotify.h`` header contains definitions of ITT API routines and -important macros which provide the correct logic of API invocation from -a user application. +The ``ittnotify.h`` header contains definitions for ITT API routines +and important macros that provide the correct logic to invoke the API +from your application. -The ITT API is designed to incur almost zero overhead when tracing is -disabled. But if you need fully zero overhead, you can compile out all -ITT API calls from your application by defining the -``INTEL_NO_ITTNOTIFY_API`` macro in your project at compile time, either -on the compiler command line, or in your source file, prior to including -the ``ittnotify.h`` file. +When tracing is disabled, The ITT API incur almost zero overhead. To achieve +completely zero overhead, you can compile out all ITT API calls from your +application. To do this, prior to including the ``ittnotify.h`` file, define +the ``INTEL_NO_ITTNOTIFY_API`` macro in your project at compile time. You can +do this from the compiler command line or in your source file. -**For Fortran Applications** +**Fortran Applications** -Add the ``ITTNOTIFY`` module to your source files with the following +Add the ``ITTNOTIFY`` module to your source files. Use the following source line: -.. code:: cpp +.. code-block:: cpp USE ITTNOTIFY -Insert ITT Notifications in Your Application --------------------------------------------- - - -Insert ``__itt_*`` (C/C++) or ``ITT_*`` (Fortran) notifications in your -source code. - - -C/C++ example: - +Step 3: Insert ITT Notifications in Your Application +---------------------------------------------------- -.. code:: cpp +To insert ITT notifications in your application, use: - __itt_pause(); ++-----------+-------------------+-----------------------------+ +| Language | Notification | Example | ++===========+===================+=============================+ +| C/C++ | .. code:: cpp | .. code:: cpp | +| | | | +| | __itt_* | __itt_pause(); | ++-----------+-------------------+-----------------------------+ +| Fortran | .. code:: cpp | .. code:: cpp | +| | | | +| | ITT_* | CALL ITT_PAUSE() | ++-----------+-------------------+-----------------------------+ -Fortran example: +To learn more, open: -.. code:: cpp +- `Instrumenting Your Application `__ +- `ITT API Reference `__ - CALL ITT_PAUSE() +Step 4: Link the libittnotify Static Library to Your Application +---------------------------------------------------------------- -For more information, see `Instrumenting Your Application -`__ and `ITT API Reference -`__. +Once you finish inserting ITT notifications in your application, the next step +is to link the libittnotify static library. This library is ``libittnotify.a`` +in Linux* and FreeBSD* systems and ``libittnotify.lib`` in Windows* systems. +If you have enabled tracing, the static library loads the dynamic collector of +the ITT API data and forwards to the collector instrumentation data from the ITT API. -Link the libittnotify Static Library to Your Application --------------------------------------------------------- +If you have disabled tracing, the static library ignores ITT API calls, resulting in +near-zero instrumentation overhead. -You need to link the static library, ``libittnotify.a`` (Linux*, FreeBSD*) or -``libittnotify.lib`` (Windows*), to your application. If tracing is enabled, -this static library loads the ITT API data dynamic collector and forwards ITT -API instrumentation data to it. If tracing is disabled, the static library -ignores ITT API calls, providing nearly zero instrumentation overhead. +Step 5: Load the Dynamic Library +-------------------------------- -Set the INTEL_LIBITTNOTIFY environment variables to enable data collection --------------------------------------------------------------------------- +After you instrument your application and link the static library, you must +load the dynamic library of the ITT API to your application. To do this, +depending on your system architecture, set the ``INTEL_LIBITTNOTIFY32`` or +the ``INTEL_LIBITTNOTIFY64`` environment variable. -After you instrument your application by adding ITT API calls to your code and -link the ``libittnotify.a/libittnotify.lib`` static library, your application -will check the ``INTEL_LIBITTNOTIFY32`` or the ``INTEL_LIBITTNOTIFY64`` -environment variable depending on your application's architecture to load the -**dynamic** part of the library. If that variable is set, it will load the -libraries defined in the variable. +**Windows OS:** -Make sure to set these environment variables to enable data collection: - - -**On Windows** - - -.. code-block:: console +.. code-block:: bash set INTEL_LIBITTNOTIFY32=\bin32\runtime\ittnotify_collector.dll set INTEL_LIBITTNOTIFY64=\bin64\runtime\ittnotify_collector.dll -**On Linux** +**Linux OS:** -.. code-block:: console +.. code-block:: bash export INTEL_LIBITTNOTIFY32=/lib32/runtime/libittnotify_collector.so export INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so -**On FreeBSD** +**FreeBSD OS:** -.. code-block:: console +.. code-block:: bash setenv INTEL_LIBITTNOTIFY64=/lib64/runtime/libittnotify_collector.so -Unicode Support ---------------- +Additional Information: Unicode Support +--------------------------------------- All API functions that take parameters of type ``__itt_char`` follow the -Windows OS unicode convention. If UNICODE is defined when compiling on a -Windows OS, ``__itt_char`` is ``wchar_t``, otherwise it is ``char``. The -actual function names are suffixed with ``A`` for the ASCII APIs and -``W`` for the unicode APIs. Both types of functions are defined in the -DLL that implements the API. +Windows OS Unicode convention. + +When compilation happens on a Windows system, if the ``UNICODE`` macro is +defined, ``__itt_char`` is set to ``wchar_t``. If the ``UNICODE`` macro is +not defined, ``__itt_char`` is set to ``char``. +The actual function names are suffixed with ``A`` for the ASCII APIs and +``W`` for the Unicode APIs. Both types of functions are defined in the +DLL that implements the API. -Strings that are all ASCII characters are internally equivalent for both -the unicode and the ASCII API versions. For example, the following +Strings that contain only ASCII characters are internally equivalent for both +the Unicode and ASCII API versions. For example, the following strings are equivalent: -.. code:: cpp +.. code-block:: cpp __itt_sync_createA( addr, "OpenMP Scheduler", "Critical Section", 0); diff --git a/docs/src/instrument-your-application.rst b/docs/src/instrument-your-application.rst index 5930b8ec..ba0267dd 100644 --- a/docs/src/instrument-your-application.rst +++ b/docs/src/instrument-your-application.rst @@ -4,29 +4,25 @@ Instrument Your Application =========================== -To get the most out of the ITT APIs when collecting performance data, -you need to add API calls in your code to designate logical tasks. -This will help you visualize the relationship between tasks in your code, -including when they start and end, relative to other CPU and GPU tasks. +When you collect performance data with the ITT/JIT APIs, for optimum results, +add API calls in your code to designate logical tasks. You can then visualize +the relationship between tasks in your code (for example, when they start and +end) relative to other CPU and GPU tasks. -At the highest level a task is a logical group of work executing on a -specific thread, and may correspond to any grouping of code within your +At the highest level, a task is a logical group of work that executes on a +specific thread. A task can correspond to any grouping of code within your program that you consider important. You can mark up your code by identifying the beginning and end of each logical task with -``__itt_task_begin`` and ``__itt_task_end`` calls. For example, to track -"smoke rendering" separately from "detailed shadows", you should add API -tracking calls to the code modules for these specific features. +``__itt_task_begin`` and ``__itt_task_end`` calls. To get started, use the following API calls: - -- ``__itt_domain_create()`` creates a domain required in most ITT API - calls. You need to define at least one domain. -- ``__itt_string_handle_create()`` creates string handles for identifying - your tasks. String handles are more efficient for identifying traces - than strings. +- ``__itt_domain_create()`` creates a domain that is required in most ITT + API calls. Define atleast one domain. +- ``__itt_string_handle_create()`` creates string handles to identify your + tasks. String handles are more efficient than strings to identify traces. - ``__itt_task_begin()`` marks the beginning of a task. - ``__itt_task_end()`` marks the end of a task. @@ -35,8 +31,8 @@ Example ------- -The following sample shows how four basic ITT API functions are used in -a multi threaded application: +This example shows how you use four basic ITT API functions in a +multi-threaded application: - `Domain API `__ @@ -45,7 +41,7 @@ a multi threaded application: - `Thread Naming API `__ -.. code:: cpp +.. code-block:: cpp #include @@ -55,46 +51,52 @@ a multi threaded application: // Forward declaration of a thread function. DWORD WINAPI workerthread(LPVOID); bool g_done = false; + // Create a domain that is visible globally: we will use it in our example. __itt_domain* domain = __itt_domain_create("Example.Domain.Global"); // Create string handles which associates with the "main" task. __itt_string_handle* handle_main = __itt_string_handle_create("main"); __itt_string_handle* handle_createthread = __itt_string_handle_create("CreateThread"); + void main(int, char* argv[]) { - // Create a task associated with the "main" routine. - __itt_task_begin(domain, __itt_null, __itt_null, handle_main); - // Now we'll create 4 worker threads - for (int i = 0; i < 4; i++) - { - // We might be curious about the cost of CreateThread. We add tracing to do the measurement. - __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); - .. code-block:: cppCreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); - __itt_task_end(domain); + // Create a task associated with the "main" routine. + __itt_task_begin(domain, __itt_null, __itt_null, handle_main); + + // Now we'll create 4 worker threads + for (int i = 0; i < 4; i++) + { + // We might be curious about the cost of CreateThread. We add tracing to do the measurement. + __itt_task_begin(domain, __itt_null, __itt_null, handle_createthread); + cppCreateThread(NULL, 0, workerthread, (LPVOID)i, 0, NULL); + __itt_task_end(domain); + } + + // Wait a while,... + cppSleep(5000); + g_done = true; + + // Mark the end of the main task + __itt_task_end(domain); } - - // Wait a while,... - .. code-block:: cppSleep(5000); - g_done = true; - // Mark the end of the main task - __itt_task_end(domain); - } // Create string handle for the work task. __itt_string_handle* handle_work = __itt_string_handle_create("work"); DWORD WINAPI workerthread(LPVOID data) { - // Set the name of this thread so it shows up in the UI as something meaningful - char threadname[32]; - wsprintf(threadname, "Worker Thread %d", data); - __itt_thread_set_name(threadname); - // Each worker thread does some number of "work" tasks - while(!g_done) - { - __itt_task_begin(domain, __itt_null, __itt_null, handle_work); - .. code-block:: cppSleep(150); - __itt_task_end(domain); - } - return 0; + // Set the name of this thread so it shows up in the UI as something meaningful + char threadname[32]; + wsprintf(threadname, "Worker Thread %d", data); + __itt_thread_set_name(threadname); + + // Each worker thread does some number of "work" tasks + while(!g_done) + { + __itt_task_begin(domain, __itt_null, __itt_null, handle_work); + cppSleep(150); + __itt_task_end(domain); + } + + return 0; } diff --git a/docs/src/itt-api-support.rst b/docs/src/itt-api-support.rst index 4c440ce7..ab535e3a 100644 --- a/docs/src/itt-api-support.rst +++ b/docs/src/itt-api-support.rst @@ -1,32 +1,29 @@ .. _itt-api-support: -ITT API -======= +Instrumentation and Tracing Technology API (ITT API) +==================================================== -The Instrumentation and Tracing Technology API (ITT API) enables -your application to generate and control the collection of trace -data during its execution. +Use the Intel® Instrumentation and Tracing Technology API (ITT API) to +generate trace data and control its collection during the execution of +your application. -ITT API has the following features: +Use the ITT API to: - Controls application performance overhead based on the amount of traces that you collect. -- Enables trace collection without recompiling your application. -- Supports applications in C/C++ and Fortran environments on Windows*, - Linux* or FreeBSD* systems. -- Supports instrumentation for tracing application code. +- Enable trace collection without having to recompiling your application +- Enable code annotation for deeper analysis. +You can use the ITT API to collect trace data from C, C++, or Fortran +applications that run on Windows*, Linux* or FreeBSD* systems. -User applications/modules linked to the static ITT API library do not -have a runtime dependency on a dynamic library. Therefore, they can be -executed independently. - -ITT API enables you to manually instrument your application for further -application performance analysis. +The ITT API has **static** and **dynamic** library components. The applications +and modules you link to the static library do not have a runtime dependency +on the dynamic library. Therefore, you can run these components independently. ITT API Usage and Reference diff --git a/docs/src/ittapi/clock-domain-api.rst b/docs/src/ittapi/clock-domain-api.rst index be717f8e..f8382c9c 100644 --- a/docs/src/ittapi/clock-domain-api.rst +++ b/docs/src/ittapi/clock-domain-api.rst @@ -4,44 +4,43 @@ Clock Domain API ================ -Some applications require the capability to trace events with -user-defined timestamps and frequencies different from the timestamps -and frequencies generated by a CPU, for example, to instrument events -that occur on a GPU. For the purpose you can create a clock domain. +Some applications require the capability to trace events with user-defined +timestamps and frequencies that are different from the ones generated by a +CPU. For example, you may want to instrument events that occur on a GPU. +To do this, you can create a clock domain. -To create a clock domain, use the following primitive: +To create a clock domain, use this following primitive: +.. code:: cpp -``__itt_clock_domain * ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data)`` - -**Parameters of the primitive:** + __itt_clock_domain * ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn, void* fn_data) -.. list-table:: - :header-rows: 0 +**Parameters of the primitive:** - * - \ [in]\ - - \ ``fn``\ - - Pointer to a callback function that retrieves alternative CPU timestamps and frequencies and stores the timestamps and frequencies data in the clock domain structure field ``__itt_clock_info``. - * - \ [in]\ - - \ ``fn_data``\ - - Argument of a callback function; can be NULL. ++-------+-------------+-------------------------------------------------------------+ +| [in] | ``fn`` | Pointer to a callback function that retrieves alternative | +| | | CPU timestamps and frequencies and stores them in the | +| | | clock domain structure field ``__itt_clock_info``. | ++-------+-------------+-------------------------------------------------------------+ +| [in] | ``fn_data`` | Argument passed to the callback function. Can be ``NULL``. | ++-------+-------------+-------------------------------------------------------------+ +Tasks issued from different clock domains display on the same timeline. This +happens by the synchronization of a referenced clock domain base timestamp +(captured at the instant when the clock domain was created) and a CPU timestamp +(captured in the same instant). -Tasks issued from different clock domains are shown on the same timeline -by synchronizing a referenced clock domain base timestamp captured at -the moment of clock domain creation and a CPU timestamp captured at the -same time. +To recalculate clock domain base timestamps and frequencies, if necessary, +for example, when a GPU frequency changes, use the following primitive: -To recalculate clock domain base timestamps and frequencies, if -necessary, for example, when a GPU frequency changes, use the following -primitive: +.. code:: cpp -``__itt_clock_domain_reset()`` + __itt_clock_domain_reset() diff --git a/docs/src/ittapi/collection-control-api.rst b/docs/src/ittapi/collection-control-api.rst index 4c69cefc..fac9f632 100644 --- a/docs/src/ittapi/collection-control-api.rst +++ b/docs/src/ittapi/collection-control-api.rst @@ -4,82 +4,74 @@ Collection Control API ====================== -You can use the collection control APIs in your code to control the way -the Intel® VTune™ Profiler collects data for applications. +Use Collection Control APIs in your code to manage how and when Intel® VTune™ +Profiler collects data for your applications. By calling these APIs, you can +pause, resume, or detach data collection to focus analysis on specific code +regions, reduce profiling overhead, or exclude unimportant sections from your +performance results. -.. list-table:: - :header-rows: 0 ++-------------------------------+----------------------------------------------+ +| Use This Primitive | To Do This | ++===============================+==============================================+ +| .. code:: cpp | Run the application without collecting data. | +| | VTune Profiler reduces the overhead of | +| void __itt_pause(void) | collection by collecting only critical | +| | information, like thread and process | +| | creation. | ++-------------------------------+----------------------------------------------+ +| .. code:: cpp | Resume data collection. | +| | | +| void __itt_resume(void) | | ++-------------------------------+----------------------------------------------+ +| .. code:: cpp | Detach data collection. VTune Profiler | +| | detaches all collectors from all processes. | +| void __itt_detach(void) | Your application continues to work but no | +| | data is collected for the running collection.| ++-------------------------------+----------------------------------------------+ - * - Use This Primitive - - To Do This - * - \ ``void __itt_pause (void)``\ - - Run the application without collecting data. VTune Profiler reduces the overhead of collection, by collecting only critical information, such as thread and process creation. - * - \ ``void __itt_resume (void)``\ - - Resume data collection. VTune Profiler resumes collecting all data. - * - \ ``void __itt_detach (void)``\ - - Detach data collection. VTune Profiler detaches all collectors from all processes. Your application continues to work but no data is collected for the running collection. +Pause data collection +--------------------- +When you pause the data collection in any thread, you pause the collection for +the entire program and not just the active thread. Also, pausing a data collection +can reduce the overhead from runtime analysis. -Pausing the data collection has the following effects: - - -- Data collection is paused for the whole program, not only within the - current thread. - - -- Some runtime analysis overhead reduction. - - -- The following APIs are not affected by pausing the data collection: +Unaffected APIs: - Domain API - - - String Handle API - - - Thread Naming API -- The following APIs are affected by pausing the data collection. Data - is not collected for these APIs while in paused state: - +Affected APIs (No Data Collection in Paused State): - Task API - - - Frame API - - - Event API - - - User-Defined Synchronization API .. note:: - The Pause/Resume API call frequency is about 1Hz for a reasonable - rate. Since this operation pauses and resumes data collection in all - processes in the analysis run with the corresponding collection state - notification to GUI, you are not recommended to call it on frequent - basis for small workloads. For small workloads, consider using the - `Frame - APIs `__. + The Pause/Resume API call frequency is about 1Hz for a reasonable rate. + Since this operation pauses and resumes data collection in all processes + in the analysis run with the corresponding collection state notification + sent to the GUI, for small workloads, do not call this operation on a + frequent basis. Use `Frame APIs `__ instead. -Usage Example: Focus on Specific Code Section ---------------------------------------------- +Usage Example: Focus on a Specific Code Section +----------------------------------------------- -The pause/resume calls shown in the following code snippet enable you to -focus the collection on a specific section of code, and start the -application run with collection paused. +In this code example, the pause/resume calls help to focus data collection +from a specific section of code. The application run begins when the collection +is paused. .. code:: cpp @@ -100,8 +92,8 @@ Usage Example: Hide Sections of Code ------------------------------------ -The pause/resume calls shown in the following code snippet enable you to -hide some intensive work that you are not currently focusing on: +This example shows how you use pause/resume calls to hide intensive work that +may not need attention for a brief period. .. code:: cpp diff --git a/docs/src/ittapi/context-metadata-api.rst b/docs/src/ittapi/context-metadata-api.rst index 205d8c6f..f96ce38d 100644 --- a/docs/src/ittapi/context-metadata-api.rst +++ b/docs/src/ittapi/context-metadata-api.rst @@ -4,41 +4,21 @@ Context Metadata API ==================== -Use context metadata to collect counter-based metrics and attribute them -to hardware topology like: +Use the Context Metadata API to define custom counters in your code with +special attributes. You can also get a set of metrics for the collected data +in any classical form of data representation (bandwidth/latency/utilization +metrics) in Intel® VTune™ Profiler. +You can use Context Metadata API to collect counter-based metrics and +attribute these metrics to hardware topology like: + - PCIe devices - Block devices - CPU cores - Threads -With the Context Metadata API, you can define custom counters in your -code with special attributes. You can also get a set of metrics for the -collected data in any classical form of data representation in Intel® -VTune™ Profiler. - - -**Availability:** - - -By default, the Context Metadata API for data collection and -visualization is available in the `Input and Output -analysis `__ only. - - -To see this data when running other analysis types, - - -#. `Create a custom - analysis `__ based on - the predefined analysis type of your interest. -#. In `custom analysis - options `__, enable - the **Analyze all ITT API user data** checkbox. - - **Define and create a counter object** @@ -58,42 +38,53 @@ Use this structure to store context metadata: The structure accepts the following types of context metadata: -.. list-table:: - :header-rows: 0 - - * - \__itt_context_type - - Value - - Description - * - \__itt_context_name - - ASCII string char*/ Unicode string wchar_t\* type - - The name of the counter-based metric. This value is required. - * - \__itt_context_device - - ASCII string char*/ Unicode string wchar_t\* type - - Statistics subdomain to break down the counter samples (for example, network port ID, disk partition, etc.) - * - \__itt_context_units - - ASCII string char*/ Unicode string wchar_t\* type - - Units of measurement. For measurement of time, use the ns/us/ms/s units to correct data representation in VTune Profiler. - * - \__itt_context_pci_addr - - ASCII string char*/ Unicode string wchar_t\* type - - PCI address of device to associate with the counter. - * - \__itt_context_tid - - Unsigned 64-bit integer type - - Thread ID to associate with the counter. - * - \__itt_context_bandwidth_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1, calculate latency histogram and counter/sec timeline distribution. - * - \__itt_context_latency_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1,calculate the throughput histogram and counter/sec timeline distribution. - * - \__itt_context_on_thread_flag - - Unsigned 64-bit integer type (0,1) - - If this flag is set to 1, show the counter on top of the Thread graph as percentage of the CPU Time distribution. - - - - -Before you associate context metadata with a counter, you should create -an ITT API Domain and ITT API Counter Instances. ++-------------------------------+------------------------------------+-----------------------------------------------+ +| __itt_context_type | Value | Description | ++===============================+====================================+===============================================+ +| .. code-block:: cpp | ASCII string char* / | The name of the counter-based metric. | +| | Unicode string wchar_t* | This value is required. | +| __itt_context_name | | | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | ASCII string char* / | Statistics subdomain to break down the | +| | Unicode string wchar_t* | counter samples (for example, network port | +| __itt_context_device | | ID, disk partition, etc.) | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | ASCII string char* / | Units of measurement. For measurement of | +| | Unicode string wchar_t* | time, use the ns/us/ms/s units to correct | +| __itt_context_units | | data representation in VTune Profiler. | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | ASCII string char* / | PCI address of device to associate with | +| | Unicode string wchar_t* | the counter. | +| __itt_context_pci_addr | | | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | Unsigned 64-bit integer type | | +| | | Thread ID to associate with the counter. | +| __itt_context_tid | | | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | Unsigned 64-bit integer type (0,1) | If this flag is set to 1, calculate latency | +| | | histogram and counter/sec timeline | +| __itt_context_bandwidth_flag| | distribution. | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | Unsigned 64-bit integer type (0,1) | If this flag is set to 1, calculate the | +| | | throughput histogram and counter/sec | +| __itt_context_latency_flag | | timeline distribution. | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ +| .. code-block:: cpp | Unsigned 64-bit integer type (0,1) | If this flag is set to 1, show the counter | +| | | on top of the Thread graph as percentage | +| __itt_context_on_thread_flag| | of the CPU Time distribution. | +| | | | ++-------------------------------+------------------------------------+-----------------------------------------------+ + + +Before you associate context metadata with a counter, make sure to create +an ITT API Domain and ITT API Counter Instances first. The domain name provides a heading for the section of metrics for the @@ -113,29 +104,32 @@ Once you have created all objects, you can add context information for the selected counters. Use these primitives: -``__itt_bind_context_metadata_to_counter(__itt_counter counter, size_t length, __itt_context_metadata* metadata);`` - +.. code-block:: cpp -**Parameters of the primitive:** + __itt_bind_context_metadata_to_counter( + __itt_counter counter, size_t length, __itt_context_metadata* metadata); -.. list-table:: - :header-rows: 0 - * - Type - - Parameter - - Description - * - [in] - - \ ``__itt_counter counter``\ - - Pointer to the counter instance associated with the context metadata - * - [in] - - \ ``size_t length``\ - - Number of elements in the array of context metadata - * - [in] - - \ ``__itt_context_metadata* metadata``\ - - Pointer to the array of context metadata +**Parameters of the primitive:** ++--------+-------------------------------+-----------------------------------------------------+ +| Type | Parameter | Description | ++========+===============================+=====================================================+ +| [in] | .. code-block:: cpp | Pointer to the counter instance associated with the | +| | | | +| | __itt_counter counter | context metadata | ++--------+-------------------------------+-----------------------------------------------------+ +| [in] | .. code-block:: cpp | Number of elements in the array of context metadata | +| | | | +| | size_t length | | ++--------+-------------------------------+-----------------------------------------------------+ +| [in] | .. code-block:: cpp | Pointer to the array of context metadata | +| | | | +| | __itt_context_metadata* | | +| | metadata | | ++--------+-------------------------------+-----------------------------------------------------+ To create counter instances and submit counter data, use: @@ -144,7 +138,7 @@ To create counter instances and submit counter data, use: .. code-block:: cpp - __itt_counter_create_v3(__itt_domain* domain, const char* name, __itt_metadata_type type); + __itt_counter_create_v3(__itt_domain* domain, const char* name, __itt_metadata_type type); __itt_counter_set_value_v3(__itt_counter counter, void *value_ptr); @@ -164,10 +158,14 @@ read operation metrics for an SSD NVMe device: // Create domain and counters: - __itt_domain* domain = __itt_domain_create("ITT API collected data"); - __itt_counter counter_read_op = __itt_counter_create_v3(domain, "Read Operations", __itt_metadata_u64); - __itt_counter counter_read_mb = __itt_counter_create_v3(domain, "Read Megabytes", __itt_metadata_u64); - __itt_counter counter_spin_time = __itt_counter_create_v3(domain, "Spin Time", __itt_metadata_u64); + __itt_domain* domain = + __itt_domain_create("ITT API collected data"); + __itt_counter counter_read_op = + __itt_counter_create_v3(domain, "Read Operations", __itt_metadata_u64); + __itt_counter counter_read_mb = + __itt_counter_create_v3(domain, "Read Megabytes", __itt_metadata_u64); + __itt_counter counter_spin_time = + __itt_counter_create_v3(domain, "Spin Time", __itt_metadata_u64); // Create context metadata: diff --git a/docs/src/ittapi/counter-api.rst b/docs/src/ittapi/counter-api.rst index b4235828..83c7e263 100644 --- a/docs/src/ittapi/counter-api.rst +++ b/docs/src/ittapi/counter-api.rst @@ -4,11 +4,12 @@ Counter API =========== -A Counter is a user-defined characteristic or metric of hardware or -software behavior that can be used to collect information about and -correlate with execution breakdown, such as tasks, events, and markers. -For example, system on a chip (SoC) development benefits from several -counters representing different parts of the SoC to count some hardware +A Counter is a user-defined characteristic or metric of hardware or software +behavior that you use to collect information about execution breakdown. You can +also use counters to correlate this information with tasks, events, and markers. + +For example, the development of system-on-a-chip (SoC) benefits from several +counters that represent different parts of the SoC to count some hardware characteristics. @@ -17,53 +18,46 @@ characteristics. Use these primitives: - -``__itt_counter`` - - -``__itt_counter_create(const char *name, const char *domain);`` - - -``__itt_counter_createA(const char *name, const char *domain);`` +.. code-block:: cpp -``__itt_counter_createW(const wchar_t *name, const wchar_t *domain);`` + __itt_counter __itt_counter_create(const char *name, const char *domain); + __itt_counter __itt_counter_createA(const char *name, const char *domain); -``__itt_counter_create_typed (const char *name, const char *domain, __itt_metadata_type type);`` + __itt_counter __itt_counter_createW(const wchar_t *name, const wchar_t *domain); + __itt_counter __itt_counter_create_typed(const char *name, const char *domain, __itt_metadata_type type); -``__itt_counter __itt_counter_create_typedA __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type)`` + __itt_counter __itt_counter_create_typedA(const char *name, const char *domain, __itt_metadata_type type); + __itt_counter __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type); -``__itt_counter __itt_counter_create_typedW __itt_counter_create_typedW(const wchar_t *name, const wchar_t *domain, __itt_metadata_type type)`` + __itt_counter __itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type); -``__itt_counter_create_v3(__itt_domain* domain, const char* name,__itt_metadata_type type);`` - - -A counter name and domain name should be specified. To load a -specialized type of data, specify the counter type. By default the -unsigned int64 type is used. +You must specify a counter name and domain name. To load a specialized type of +data, specify the counter type. The default counter type is ``uint64_t``. **Parameters of the primitives:** -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``domain``\ - - Counter domain - * - [in] - - \ ``name``\ - - Counter name - * - [in] - - \ ``type``\ - - Counter type - - ++--------+--------------------------+-------------------+ +| Type | Parameter | Description | ++========+==========================+===================+ +| [in] | .. code-block:: cpp | Counter domain | +| | | | +| | domain | | ++--------+--------------------------+-------------------+ +| [in] | .. code-block:: cpp | Counter name | +| | | | +| | name | | ++--------+--------------------------+-------------------+ +| [in] | .. code-block:: cpp | Counter type | +| | | | +| | type | | ++--------+--------------------------+-------------------+ **Increment/decrement a counter value** @@ -72,16 +66,16 @@ unsigned int64 type is used. Use these primitives: -``__itt_counter_inc (__itt_counter id);`` - - -``__itt_counter_inc_delta(__itt_counter id, unsigned long long value);`` - - -``__itt_counter_dec(__itt_counter id);`` - - -``__itt_counter_dec_delta(__itt_counter id, unsigned long long value);`` +.. code-block:: cpp + + + void __itt_counter_inc (__itt_counter id); + + void __itt_counter_inc_delta(__itt_counter id, unsigned long long value); + + void __itt_counter_dec(__itt_counter id); + + void __itt_counter_dec_delta(__itt_counter id, unsigned long long value); .. note:: @@ -95,27 +89,28 @@ Use these primitives: Use: - -``__itt_counter_set_value(__itt_counter id, void *value_ptr);`` - - -``__itt_counter_set_value_v3(__itt_counter counter, void *value_ptr);`` +.. code-block:: cpp + + + void __itt_counter_set_value(__itt_counter id, void *value_ptr); + + void __itt_counter_set_value_v3(__itt_counter counter, void *value_ptr); Parameters of the primitive: -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``id``\ - - Counter ID - * - [in] - - \ ``value_ptr``\ - - Counter value - - ++--------+--------------------------+------------------+ +| Type | Parameter | Description | ++========+==========================+==================+ +| [in] | .. code-block:: cpp | Counter ID | +| | | | +| | id | | ++--------+--------------------------+------------------+ +| [in] | .. code-block:: cpp | Counter value | +| | | | +| | value_ptr | | ++--------+--------------------------+------------------+ **Remove an existing counter** @@ -123,8 +118,10 @@ Parameters of the primitive: Use: +.. code-block:: cpp + -``__itt_counter_destroy(__itt_counter id);`` + void __itt_counter_destroy(__itt_counter id); Usage Example diff --git a/docs/src/ittapi/domain-api.rst b/docs/src/ittapi/domain-api.rst index e87e4f0a..3de66fca 100644 --- a/docs/src/ittapi/domain-api.rst +++ b/docs/src/ittapi/domain-api.rst @@ -4,50 +4,49 @@ Domain API ========== -A ``domain`` enables tagging trace data for different modules or -libraries in a program. Domains are specified by unique character -strings, for example ``TBB.Internal.Control``. - +A ``domain`` enables you to tag trace data for different modules or +libraries in a program. You specify domains using unique character +strings. Each domain is represented by an opaque ``__itt_domain`` structure, which you can use to tag each of the ITT API calls in your code. - You can selectively enable or disable specific domains in your -application, in order to filter the subsets of instrumentation that are -collected into the output trace capture file. To disable a domain set -its flag field to 0 value. This disables tracing for a particular domain -while keeping the rest of the code unmodified. The overhead of a -disabled domain is a single if check. +application in order to filter the subsets of instrumentation that are +collected into the output trace capture file. + +To disable a domain, set its flag field to 0. This action disables tracing +for a particular domain without affecting other code portions. The overhead +of a disabled domain is a single ``if`` check. **To create a domain, use the following primitives:** +.. code:: cpp -``__itt_domain *ITTAPI__itt_domain_create ( const char *name)`` + __itt_domain *ITTAPI__itt_domain_create ( const char *name); -For a domain name, the URI naming style is recommended, for example, -com.my_company.my_application. The set of domains is expected to be -static over the application's execution time, therefore, there is no -mechanism to destroy a domain. +To create a domain name, use the URI naming convention. For example, +"com.my_company.my_application" is an acceptable format for a domain name. +The set of domains is expected to be static over the execution time of the +application. Therefore, there is no mechanism to destroy a domain. -Any domain can be accessed by any thread in the process, regardless of -which thread created the domain. This call is thread-safe. +Any thread in the process can access any domain in the code, regardless of +the thread that created the domain. This call is thread-safe. **Parameters of the primitives:** -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *name*\ - - Name of domain - - ++--------+--------------------------+-------------------+ +| Type | Parameter | Description | ++========+==========================+===================+ +| [in] | .. code-block:: cpp | Name of domain | +| | | | +| | name | | ++--------+--------------------------+-------------------+ Usage Example diff --git a/docs/src/ittapi/event-api.rst b/docs/src/ittapi/event-api.rst index 8ff9ac13..8f89f24f 100644 --- a/docs/src/ittapi/event-api.rst +++ b/docs/src/ittapi/event-api.rst @@ -4,15 +4,17 @@ Event API ========= -The event API is used to observe when demarcated events occur in your -application, or to identify how long it takes to execute demarcated -regions of code. Set annotations in the application to demarcate areas -where events of interest occur. After running analysis, you can see the -events marked in the Timeline pane. +Use the event API to: +- Observe when demarcated events occur in your application +- Find out the time taken to execute demarcated regions of code. -Event API is a per-thread function that works in resumed state. This -function does not work in paused state. +Set annotations in the application to demarcate areas where events of +interest occur. After you run the analysis, you can see the events marked +in the Timeline pane. + +The event API is a per-thread function that works in the resumed state. This +function does not work in the paused state. .. note:: @@ -26,40 +28,41 @@ function does not work in paused state. - On Linux\* OS platforms only a single variant of the API exists. -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``__itt_event __itt_event_create(const __itt_char *name, int namelen );``\ - - Create an event type with the specified name and length. This API returns a handle to the event type that should be passed into the following event start and event end APIs as a parameter. The namelen parameter refers to the name length in number of characters, not the number of bytes. - * - \ ``int __itt_event_start( __itt_event event );``\   - - Call this API with your previously created event type handle to register an instance of the event. Event start appears in the **Timeline** pane display as a tick mark. - * - \ ``int __itt_event_end( __itt_event event );``\ - - Call this API following a call to \__itt_event_start() to show the event as a tick mark with a duration line from start to end. If this API is not called, this event appears in the **Timeline** pane as a single tick mark. - ++----------------------------------------------------------+--------------------------------------------------------------------------+ +| Use This Primitive | To Do This | ++==========================================================+==========================================================================+ +| .. code-block:: cpp | Create an event type with the specified name and length. This API | +| | returns a handle to the event type. The handle should be passed into | +| __itt_event __itt_event_create(const __itt_char *name, | the following event start and event end APIs as a parameter. The | +| int namelen ); | namelen parameter refers to the name length in number of characters. | ++----------------------------------------------------------+--------------------------------------------------------------------------+ +| .. code-block:: cpp | Call this API with the event type handle to register an instance of the | +| | event. The Event start appears in the Timeline pane display as a tick | +| int __itt_event_start(__itt_event event); | mark. | ++----------------------------------------------------------+--------------------------------------------------------------------------+ +| .. code-block:: cpp | Call this API after a call to __itt_event_start() to show the event as a | +| | check mark with a duration line from start to end. If this API is not | +| int __itt_event_end(__itt_event event); | called, the event appears in the Timeline pane as a single check mark. | ++----------------------------------------------------------+--------------------------------------------------------------------------+ +Usae Guidelines +--------------- -Guidelines for Event API Usage ------------------------------- - -- An \__itt_event_end() is always matched with the nearest preceding - \__itt_event_start(). Otherwise, the \__itt_event_end() call is - matched with the nearest unmatched \__itt_event_start() preceding it. +- An __itt_event_end() is always matched with the nearest preceding + __itt_event_start(). Otherwise, the __itt_event_end() call is + matched with the nearest unmatched __itt_event_start() preceding it. Any intervening events are nested. - -- You can nest user events of the same or different type within each +- You can nest user events of the same type or different types within each other. In the case of nested events, the time is considered to have been spent only in the most deeply nested user event region. - - You can overlap different ITT API events. In the case of overlapping - events the time is considered to have been spent only in the event - region with the later \__itt_event_start(). Unmatched - \__itt_event_end() calls are ignored. + events, the time is considered to have been spent only in the event + region with the later __itt_event_start(). Unmatched + __itt_event_end() calls are ignored. .. note:: diff --git a/docs/src/ittapi/frame-api.rst b/docs/src/ittapi/frame-api.rst index 888d7fe5..8e1ac52c 100644 --- a/docs/src/ittapi/frame-api.rst +++ b/docs/src/ittapi/frame-api.rst @@ -5,22 +5,20 @@ Frame API Use the frame API to insert calls to the desired places in your code and -analyze performance per frame, where frame is the time period between -frame begin and end points. When frames are displayed in Intel® VTune™ -Profiler, they are displayed in a separate track, so they provide a way -to visually separate this data from normal task data. +analyze performance per frame. A frame is defined as the time period between +the frame begin and frame end points. Frames display in Intel® VTune™ +Profiler as a separate track, so they provide a way +to visually separate this data from typical task data. +The frame API is a per-process function that works in the resumed state. This +function does not work in the paused state. -Frame API is a per-process function that works in resumed state. This -function does not work in paused state. - - -You can run the frame analysis to: +Run the frame analysis to: - Analyze Windows OS game applications that use DirectX\* rendering. -- Analyze graphical applications performing repeated calculations. -- Analyze transaction processing on a per transaction basis to discover +- Analyze graphical applications that perform repeated calculations. +- Analyze transaction processing on a per-transaction basis to discover input cases that cause bad performance. @@ -30,31 +28,32 @@ ITT APIs that enable analyzing code frames and presenting the analysis data. -Adding Frame API to Your Code ------------------------------ +Include Frame API to Your Code +------------------------------ Create a domain instance with the ``__itt_domain_create()`` function: -.. code:: c +.. code:: cpp __itt_domain *ITTAPI__itt_domain_create ( const char *name ); -For a domain name, the URI naming style is recommended, for example, -com.my_company.my_application. The set of domains is expected to be -static over the application's execution time, therefore, there is no -mechanism to destroy a domain. Any domain can be accessed by any -thread in the process, regardless of which thread created the domain. -This call is thread-safe. +Follow the URI naming style to create domain names. For example, +"com.my_company.my_application" is an acceptable format. The set of domains is +expected to be static over the execution time of the application. Therefore, +there is no mechanism to destroy a domain. + +Any thread in the process can access any domain, irrespective of the thread +that created the domain. This call is thread-safe. Define the beginning of the frame instance. An ``__itt_frame_begin_v3`` call must be paired with an ``__itt_frame_end_v3`` call: -.. code:: c +.. code:: cpp void __itt_frame_begin_v3(const __itt_domain *domain, __itt_id *id); @@ -64,18 +63,17 @@ Successive calls to ``__itt_frame_begin_v3`` with the same ID are ignored until a call to ``__itt_frame_end_v3`` with the same ID. -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *domain*\ - - The domain for this frame instance - * - \ ``[in]``\ - - \ *id*\ - - The instance ID for this frame instance. Can be NULL, - in which case the next call to ``__itt_frame_end_v3`` - with NULL as the *id* parameter designates the end - of the frame. ++--------+----------------------+----------------------------------------------------------------+ +| Type | Parameter | Description | ++========+======================+================================================================+ +| [in] | .. code-block:: cpp | The domain for this frame instance | +| | | | +| | domain | | ++--------+----------------------+----------------------------------------------------------------+ +| [in] | .. code-block:: cpp | The instance ID for this frame instance. Can be NULL, in which | +| | | case the next call to ``__itt_frame_end_v3`` with NULL as the | +| | id | *id* parameter designates the end of the frame. | ++--------+----------------------+----------------------------------------------------------------+ Define the end of the frame instance. A ``__itt_frame_end_v3`` call must @@ -85,22 +83,23 @@ with the same ID are ignored, as are calls that do not have a matching ``__itt_frame_begin_v3`` call: -.. code:: c +.. code:: cpp void __itt_frame_end_v3(const __itt_domain *domain, __itt_id *id); -.. list-table:: - :header-rows: 0 - - * - \ ``[in]``\ - - \ *domain*\ - - The domain for this frame instance - * - \ ``[in]``\ - - \ *id*\ - - The instance ID for this frame instance, or NULL for the - current instance ++--------+----------------------+--------------------------------------------------+ +| Type | Parameter | Description | ++========+======================+==================================================+ +| [in] | .. code-block:: cpp | The domain for this frame instance | +| | | | +| | domain | | ++--------+----------------------+--------------------------------------------------+ +| [in] | .. code-block:: cpp | The instance ID for this frame instance, or NULL | +| | | for the current instance | +| | id | | ++--------+----------------------+--------------------------------------------------+ .. note:: @@ -110,8 +109,8 @@ with the same ID are ignored, as are calls that do not have a matching collection are limited to 64 distinct frame domains. -Guidelines for Frame API Usage ------------------------------- +Usage Guidelines +---------------- - Use the frame API to denote the frame begin point and end point. @@ -119,7 +118,8 @@ Guidelines for Frame API Usage points. - VTune Profiler does not attribute the time/samples between ``__itt_frame_end_v3()`` and ``__itt_frame_begin_v3()`` to any - program unit and displays it as ``[Unknown]`` in the viewpoint. + program unit. In the viewpoint for the analysis, this information + displays as ``[Unknown]``. - If there are consecutive ``__itt_frame_begin_v3`` calls in the same domain, treat it as a ``__itt_frame_end_v3``/``__itt_frame_begin_v3`` pair. @@ -140,7 +140,7 @@ The following example uses the frame API to capture the Elapsed times for the specified code sections. -.. code:: c +.. code:: cpp #include "ittnotify.h" diff --git a/docs/src/ittapi/histogram-api-schema.png b/docs/src/ittapi/histogram-api-schema.png index 6895245413564de54a02b9328a029269e2730fe8..d4b8293cdd6f90623bc0c3608e1ed9818102cae3 100644 GIT binary patch literal 191599 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%0ASoJRz zZt`&opn@bW=|mdaYw%O9RD=;L`Ru6ss3vZzRa~0|Fy<{UH|L1F2gT-33jG@_2nEd9qX2_H;14>_1|{@ zz*XJ5aOK0AY?4f=pa}$Cby(c!KBDzFwhEj&xsciqBD4VR!Jic3nv@92UvS0U5;f$LmQ!z(c25}{1IwDu%>?2)sI(0Fnj zI(h<~0gPV@BGRTUjF?^>6yC2yzJJ%-N9v`}qj=M?pH_O<)9C&3RgdtUcrri%hRAW} zdSF(Sdi8~7N;|v3-2@_5kwSdKkMqMY*aRnyH-Y6S!k=0GVE#6*c4Q?VQz#E@iV0d= zT*o2O7O2)F6?EbTTmwu6X?k1apNv1V@YVh7JlZf0!M7sJBmN`lOWF!X^?ZFb=DV6u zUZ0;GNWOHF$2Qgy*5*juZ=o|hr$c2t!GgcP)YfD?hYk*X4N{rV?jYN4iV!uR&n|r z<4}f_LzpW(UuU(T!91g-5!hL2!kdf|p;07$X>rolvFq+qFivzwiUM#ZbwU-(J*K!F z5P-T*D=KZmCd|IuRm#Iy)&5pjQ2d389m8mVoQ7xa3=_lQOLsTB3O-O&R+FTiPcQm- z;X1SrCSrZ@mCG*!CX8*bBuvddl!}~S7FJ49dR)}X>Kk(+tt2Z|)~wO!_>BXbj;<=F zvm^Yl)qObnOUFwt!iY2niJl7Q{y>R)*2%nONZx2pD@Vucs}~-(i=+-NxW`@ug@T3# z=gq{|;6b*r?GQnK7AuB@{E9tht2OUg=Dp!E0c@>1t;)@Is3+cboHkf;jX@cg{hDI3 zKTd7eV>C7Sot=1OWMm%CyI}>h6FwjMKYU+`bH}A{h=euA_V-(Bka6GD=>JeM$Zu!L+n8ufCx@Sz_zJqJh#pAX-qBYgvazWYjNn z$IA`PY%cZ4`Co^WbTtEmQ4g&yE`jfP}yHdFZe9Wgk_)`IJv zS^D$Avvc#jH>-pf!j@?z!$P!i7XVSwNA%oonwwnM++TDMp^sm1AT?l;`y3iD)o;;r z&E$6@jDYC7f}|gfFLkEYYo+m|b!dnSHfUzEiZ@Un`kEhXcn}{R{34c=ywId_hWJY2grradlai!^#a?4D54ZKUT0ik*eShW z?&-p&5Vwf= z`-{Z#KGL}(CyUkb%AYSe*BzmZ3j*Pnmxl1M9y^HCZ58L1rb*`CkC@=UAG`IPIrSDW z_hF|*jx?%{j57$%X0jDtRtfc5InroEu>tQC8@VxFEXfBfUw5x)F<+i=wmeTTpC87r zb}+-vZe|ae;9rO11mVcWNO#0Xc;JVxzj(Dn&vG39oW~55=N(+dNYndGQ_aP;x8`wc zn_YSGTT_Bp_(Z$zaO6PAzh_3?e5irZM7~+uGeCc zK@$w^$MHwX^Eo0BcpHGbRX34r?g-X4!8b|h4efI14;PTAdbAW0Ui2&Xc+!HSAUd82 z>&s$TZF5EqImck#L+&sgBe&!C2k3NNyXH!)A6nr79rs)saDwPD4zS8^9F>?6ZcD-BJ?x z-ZSyOhIf7<=X$sZ5b$b5UqCXAMB@eY?895hcSgH!d%^Yi0nx8=?M3e5)yqBMD`}G{ z(W+3af)LEK;ZaeGP%w=HrAkBPcn9GgK_KF-7Mju=@*h**J3_5 zNPi*xZ;pDR?EQ@~`F+2`wJAcGw$EuZb|+a#jS8k@@7dEkMgFcKxaj@MaX2FD*I~f! zl-YCgA0Hvs(mH?AG27jBi(bqdI9#L7wudV~(5%J0>R<9E>uai#Y~Gp*#t> z=fcnC`48cqa?cyY-!f9PI5W|{=HU6iF{M8UoPV+|yy#Mh9!3hy>>8Mu*=4rgvdQOCi6y;T5GWU_?=zsb?h}&$`L-M%W z^f%jT*QqY_RNWpu+OE|5QZ!$!g>^mg1$q;BV8xwlhrNB19f4^wsC|c_&*cv?PJ4Bz zLvk1?FmL=)sHCaZo9;}=E^v+R_n8&9NXr}dbpN1t?|Bm?H?>RG! zNe5#{kP^FKkte>+m+*440S@V0D=twMTO-F(Bw7eqDeKC?=H2ei*Fgccy$*n0uT=i3 z?^-+_Q@PE)zh3$Va;g6$X)fNAn?XV?3RqKr0WK;8BEH6Or@|T6HC|uH9nHWn{X9dEs>-NURep=#yGBj)$oVZ2;_zZX$l=@R?Ik6z_U$? zl;MJh)&&if0#MGXFOeGJnbW9E3hQ7 zHOZ%jge8kJxXbg!&3o&T-)DF<+aI+-vkBE!6g%{+D407XzZIn+n2e|3W--`~e14GM zyV?GL|NA~oFfB+l!r&X%j7@LnX$NQ|@FY9nfnk#BIJb%23sXj@n5AEMFG zj2t31sL^0Y6WOvIv>E3E8|Qn2bnUJGg4g|Uuf`jHDB*L&(2<*tc1Arc8&V$&mx&spHTDW=w|z0e_-! zgz=q<0`A38EuDk}*)}e85CB^wJ~^w>SoprWW&!U@CGo;V_^H4ZeC*#daq{IqDdBOm z@;?(ymvv7@g;%(Ro;!Ju2IlDPdji4x%&zA@%Sd}$Mrer?&6z28U$adab~ZT}cJln$ ze$w|_*?jKX8!VG(*Ky3oO(;Nzw$m3C)T3hR3q+5RU>t{!2X!1M7MqzETW4bf=k^k6 zsUc@?%rw}N@OSxtU;T7;KnDK^!Xm)$51)rjBvC z1(bKqCE&U=_N}T1O@-c-)wKRBI@0kdWd#^&Gb8e*#Pn5ZGK!ghU&4uFi|{HId)+-d z?-hLe0_Cd4X_SbJVJciA2Di_4_Zf09#k8~@RnW~3Ki1gB>+qs-9d!Hfw_!S#F+kOj{n|ON8DN#lD^vwB85;je_rqV?Ey-$sfp}?)YtPi%WxEi z##e6?JX|4fd*mRyn-zkf=VGjMQSs3St7^E5knC%C1Ot@=-JWMIR`R)1zzbkb$hMZa z4-XvpLt6*FkWO4QDo2Nq;J%M%CW^@s7Yn;Lzn|(6&t21u*qX##8i8v)mK(&0Ke)2FQp2!ClUg8T|v|<{PUC%e77!TRv zk)txK1a-&o*yis`#X}E{G6@VK7Y;6Z;x*epV@Grn1OVt_Z3b|$`M@ru9KL=mC(qq) z*7>ouL~~{ml`H0flrq`}9$b;ap&g~*LEs<9*f{<9<4Eor#aaxfN-n5I`)G!7v4WkN zY%)KYDaW=TCG-VCO|!6*j`o7*(Sj-Rg%o}TN!te#^?hw%)5?}_JX& zI>#6O%@v*tM#vq;I+Hj9+gY#?&KJUk9LR~(Q8vHV%2Z!vb=jIfe$S@*howsmG`U8^=MEP9{*xlt z<7-Gr2-@_7tw$p?2AhP!!)#cY_anlB-s#XuHaOOrBLjgZe$aFcGYOS12J0v=0ohhK z(*j-{+T(SH@UnNsfWgaqco_xP$!jN>1g2?k%_5Ru+FsLsk5;nYGWkTfCeh!mv>B%D zdXrK|#P|5>M96=e@fF&n11XB+M69dnJ2N|CvxlNR+C?}TCZcCow_6@f-uPi3O-*Ou z?X6RCa`Mh@7-6V5i?ggQXzoCoH2?l#yvXRMCD8LdIh+4_brbeZ>*`eP6*SR)zr9@< zD00*vsoTMPL!}@{AYCr2z`B*=#TjN7`gbs*qmTjSTRQpd-b{pV$W&PXqLRMgxTxXKQH3jUPM5IhMk{=X029(OPM zWv95}9a;!!;s{N%5W#x|2&UiN=K&jUP0)2sq~JjKpSN9S3Jf#b;jfX>$$2#czlO|M zUGDR}M`9G?pa^m>YRQPXsi0Ri#WWhY3D?=p3}xLGp3flNHyLK#9wj_JU2qX|<_qey zLmV`~9X&*kgJwug`kbMu&1ASkrnxvZ>4%+wlM%S#u_;iQ0h6(uJ->R`ilM6*Zaz!$)7 zF8W!{ca@I(y3dOFxnicHU+})Teb30{e##u>nyX(2dpao_1{82SAv- zeyzAIBDvWNr~lG$u~J751#1MfPQpU}L^3Kaz>&o;EkpKHRnv|dsz$lzW`#LMLrzf% zPtGPrw^{qy$Hui1ZwYWU^zzcds`S8*x%!JoA#USA^I{z?H96$3u^7>`rG@9&gHD)R zDW+OlMk0jYc=IATu^w7DnN{aJ?1gT2noxpji47DPzd=&abR(ds$WmCm5RBW7c2FUo zTRs<>E!kYr%nrQpL}7urIv`V77@uWd$f1*Xc!?^rt?oYrWsdM3DNc7~vNIaSh7IP# zbjAqZqQ2Gn4r?8lr>D$%s#|$*LbwnPT6{=&y!3BS7#p3rc~g`J)O2t0D!JCx-)s=q9?P{M_1k5>fvW#_rXOYEdV6`ykESW>ZJD%cWQ(-#OfcfxYi-Dn zTAm41-|uwcg(e41^mx$Y382?4M|6&xOk<8!hg@-cCf~Z?bl&PfRqcomKdBwX(H=K? zMA~P{C=hWw<*bV$S*}%j0{M z!^*idihP(_m*siLbNIA4hg($+i*chmwA9xKmi5h(ZS8|jH!hF*ugkxpXoGUCJeVAT zZ>^CNu@eyy5z*a5^Ic)$KHYW!xI3#c+*pRj5d*6I`G|-~#lzJ_~ z9yPo!z?z(fhS;(^u&YP{9NZY=}!vLC(fJ zq^3r}t_2LPPK;hEL+#nKIA76#@}_>Y4UECz^}!nmArJ8`DW8%Ic z62ZtQ7{vz{vq)EHunHsX=h4(LhPo~-hFxle!)mBS8bp$zvBn^fxE8jgRP0=(L0&{Z zdfq*Z@X0TJQ@{M=MfX`>Jk=z!7HjLt4E${K>AKA4fYDGza}R@gKXBbTJm z7<|38=(}_d6{Qz(y6iG)TD#FX=ESHdOTYXa92WcZi+U!?(J?wI>ev_pavI496LdN` z%5HpDa#Z42^BJ_CdIcBS`*FmRgg%EKX~T^Ow>P7vsRx()#xUe|!{hhDEAq|lcEBg< zibrEXz~h9@U5&xkYE)J=;Zk!yI!7EB^?1Z~q8^E|aybKVh<&Pb8W?R>=uLWM1l#x; zWuoj|-EcNtKvQ`sO3P|dR^NdRIXcYehs&>mFQ7sw97H(iQQC~NZv;+<4<4-vUXcca zK?{qhV~mA8*AgN1bpQW3g)c8YHEe5i5>q@Q(mJr_fPfgV&EZaiYot zQ|u^WqI=NQ+$`FACpvo^7gz;(LlauM2QU=S!=o}nCn~ybK2_l+$jaRreh0{27_!N$vtVTt1A6iE|qK^4R8x4sz8iYFJg~#E*Q2z+VoZ|YZGl=#O0fS!D zA(59?gEpdJi~7@7a~74yKEmnK$sjsh3)DI{0di|`yq4|(Osi7fJkHk%$r`+Fsf>e^^)Oe>uym6RA`QZ3SENNfTt?5v`kweW6 zR1A%;x;d#h#(<|X&C2~hINpoT9qz`FZnx5rI_#69r?2vhzq`GjAWHkac(!f~)x*9k zubnR$6qWUD>TSODO?DPP@m?4HzG6s8gG`H4zLA<@GL4r+n?KR(!4IlOl(O*z!`K>s ztTf6vsI9ndea+2ls^9J$0OuWC@ zlem~~&|D=u$$w8A`!CN9%v!#Z{GCkKJ8m&Rquj{_sSv^8DXd4CAaQtIuVR zcfL=Sp&X4kQyS#s+455cP`@GS=>HaNNS41$=S*cac@A=$e;4_8yvKuWb|d1hzS)_R z?A+h>YTK3bl;uzutyh8)lB_r15$Tz%hf~QqDUUD9__s|C@xCE^UHQrK__I@eN?kZP zQ5UAyWqBU59?No&b$GYf$3o6wF{ZZ%dEBq(M@>9CevSCniN0HUjgVN@H(%B=55M?P zw-R8J`<^NP+@2uCOVARzz_zT>d@BOjwVk8y23HAS**y2(IP@`Kv-jk*%S-AMJvwK zf}VkN=xl}9{@`xxd1x=T6|KY0^muGaS0h?AirzC7Xf10(vn><-1zV7tk%R*&CPW)# zE{wq4SB3hwe}i-He~1rTf~ZtwA|`tyHf`C7OjLBB=WVOtb5}79jC|r|wg{}RXE{SdF6?Z=tENFb#M=^J-p%l2*9 zvuO>AQX-Hj(&p}HLS1bO8qlgT-(bPMFvrWzLTZ~94-io;RSS08Hvqp9fco7!o*>>V(oPXoD zc=O|Wyi>2ikU0yPTX&&odkMC0mgkv_Y?B)ij#ji*mZG-$5}G}c=+P#MIu(JmD9uFM z@Wa(pi-G!bbc~Fl#S1ukdf}*OLsyF*ZhIbLH*CiG4QsKbAQfp5W6%xPU~q5@wcToT zG*!Xf^d_2H8gQoHj^2m@

edrVVSbF2#(jNDqA7&1kKyMxRfGk*I8_3^s^r34>-l z{~Vncap8sMapJWPak$Zi8YIAyy$)+P@5Z`K+pt-*nN8x@YmyC!3y#8jxeh(e-Kg%< zpv|R&Ey09@_()~MnUdS1m*MGeL`8!S7g{1=P0PUg-G#_VH6c!%v_9w*hpodvcQ;C# zd}!($6WLlL+D9c?2UO@Yu7ORI;rgxXu(3E@99IjwY78R{_2_KvL{r#`E`2QG%m(Dx zbXTu2-X5U892bwjiy!^;dAxqQ4vnf5I3tq~ZxU_v7S8}CJ6oojPef>y{{jpK{tj{H^95?A?)0{4_|t49}e!`gW~*EqCG?+-Ry^I=ptG^corvKeF;B% zu^w+;RKYFUd0NRnY!lnww`((Yt+gXR)(ur(J?c*#M|Eu*E{JPKSI~llgh(Wrb>k!G zo}JjUb2ZlGm|*ia!qr-Vizgd! z?p!BEwBp*Ik&Q@`xE5(91E=#deS}kge?Lx~IDw9i4#dXB!fal6C*35E$Ai++QdCw} zA|fIJ@$vB!&s=}p=@_WGeYV>pl(nnm=olG{n#)JsZoJa!gi%zq+c_QJY=J7-Df{Sq zoyrIo+0i^7ayz*%*)jaPxz>r_&TV>Kljc+3esy^aUpUf(c9;BHu`se@Sa!r-81!8U zm`s`}PZnxE>6e|xe{s5B>9k%5*@1ny%Y9Rw*D~*908)0e&$oQ%Yo>Gm=bDi#o#OI% zvLjq>H{UXxzEAnO$KUV58*R?(0wePw11d6zkP@jyk*M$Uai-6s)R{^0xH9WxTiN<* z8$K3ocs^u6LYALP{Jb}1JUA`uz=Q8}D*KpkdB{5aMw<%{q(! zJr>ax8H`auqtS}(^f1Im!V;rLxV0U=npT8ja-iM*2v)7%fPKZuSeKUsdt4OEDi?HP zRT#WniX(58;n>-J^hd3NW#dk)DK5gc;?*czy$V^GX~;^9MrxEECb;43X~586Kib{# z7z`vKBiV}8S!S3FR;aZxuJY~NdqHHnGHi!va^5`;QD zjNVfh(Jlj3mNfL_Z$@@{684J^JvP1k0NRC-=1QD+{Ue+y?L?b7AKLsKC|tbF6m~#AQiH+nE}W_kqGiO2jCFZfvndBjRu!T|8K^M=xG$r<;w+B8 zaRg^8`*0cQ2&EJwZ^LG6lEJ05d03m1jPw{IqBK7Ehq}?<+*QT{7F33k-b~>^Xtw=D7Vt4kVx8VW?het7J&Vyg% znH+_eEr%}6+tLQAAo5EW97S_$2TH5!;4?-ce$8&gB_tr-0z_&3Vw+YtS})-I`$us6 zNChf~EEtMei`2Cnux;mNtS>4Md6kZ=1RLz)GqXXiN7j8A!vlTj^hKjT6o)vQ8Cl7q zjwz?=gQvF+1NG<8)-!^JK`k63Y8V1mL`J70W&JwjZ(NJD`I*R1jzOGe2s%d-dI#O8 zZ1bbPuS>MS9(dFi_@dXto>hbmMfoVsO+mKu4Oc&0osH;is>h((h5?aQb5tzW*tM|e z+~Ry%FnH+#PQCgO&X;wd-I@)}>dm6fY`~Uv#VE{Mg;kkiU#W3Oi4kov>_)h^8N-8P zxHJ%np`aO=c_M$Zq9H>AqE-T9GEj9H6?GnzwHRPdPD63Y8lz<8jlzpD+U z4TEUt9YRR$64wDe^r9}?S8YcAnl)Hon1#FyyHf8gqOH0+>o77jfL4DJhQi6nNwlCK z&2)9-rnd{|uf&DZC-KvlKE(MpaXm`g3~Ndb@?teeyv2hlZg-$cCr&&rNrQM@0NU~z zxLb$OoVg9oEe~M-j!pQ&&LXVOUxkF2C?uJ^FsnPzQ*#n0UU?Zuj@990j~zp{Vyxa( zf*t#|VTWj^TULuaPm4mLMFp*E0FL&{=o@mPcGw7KI09K&2}nw{KxU;TGzzqyL}%&y zcnD&}y|X7!1lyr^Q9YBzc3w~B-C{cZ=VPXGpBku|^gB5gJo;|eyvlIuJ|{cfZ#Mn1!~R&08;_-% z=9PcbgBQ|dTUltZQIaEWCIdb)a4~(##rcqV@KKis-z>Pc4lkvd+Jl?|@;{v&xaHRf zmi1MOEo+%xdCbM6dy))jGgw7LL_~CVV4!N5X$)Eztrmm=euR2z;q9qL-K7eYo;#0< zi}k2(=tOJRm@!xK5W zi_?%~HX>G>gh3+%7(?hec>(RE4Y+JdL1*qJWTq!!pAx8Y03(;sTiu8kK6Ho=Xer3t z`ydWJdJjt0W}q<9f&`ltW{VZk@zID&kB3Pcg08y-IynthY#w|TJM!WpkRGjvN~?y> z;Kta68Vro`%?zOvFTb5F4sj zhCsA>k`N55kef0h_SJ;aH%{VGl^gov$5HUW=df>6K1wp9kRE4+#cV-TtR2xwnJ`DF zVRhHRpz@$wl>wJJ9$Beoq$iD!%$c7h4papP0ap*&>RM1!(GH)^4paUP#3ZL8FBXVa zxq;S?(OUj7-u|!~ABp;4DmsYWpM3)R_in(BoCK_jk3x(n$0%DoqLWu4J}D9DHn;cy z?L~VR(9{}$H7*)SxhXJ5%5|^&@by-sul5X@n#WMx6c1=~vGJaR*zw3-Y+j$EOk^jzwIQ1+htSu*60|Kh_Q1 zU@L}o322STM^sD<)@PX!uOAWTQ;N=t8hmtm5DlU%llMP}Z4cj%9Yr}PPO>2>+5)RZ zlv{LyDF1ZC*$haw3`464qNz&{kKcrx!Yric+7YD%B9%Z@13bO;xLE5#X`>DiiK!^s zIYXeTvk9lGE~CD01jd{VNZIiuHg74x{Ts5eAuApU(V{&>+hI${LR3_wXlqSk|6}Or zNW^fT9oeg5#j&HugC^pp^7V^$)`Z&Xdc1S09(`dO;*0kpGdmYW@poUKN}~?JYz#o- z8Nl$7v*^CuhuYN57%kp~J)%q=D@cGnE(Q@s4b0w7s5(xd>i9|g+lzHL+8GbqzTZK~ zXFrQ4?_G!ci<6L_6oc3(8*Fi@qK)Q?witso$r?ne#kJ#7JDekKBxJ8aRB{r;B?gh9 zMsys05oce08*en4a4P0r0in7FYQZ4|vK&`E(R({aHghHrbA9$CDS_SyLM{8XZIvrm&RKisFEY8WRPmQ+44CrO0TRB z)#Vm{Tc>r{%f|}|R>{t4Ig)Coj(?eVU(K`PpG)lc{tmlxY#B^Sh|of#QYpcO>Et>( zLto0dl2&<}$xMN&OT*%NG^OrLJ^$}*kH3HC!DDT5r->zz#hr!vjr^)|eCFzL!` zW%cE}@t)Q#t{pN!IhD-UsUvol+Dz?1=GoM>jc(O7f@OVk zWjz_Bnkg_Q*P{AzuJxMqPqz1dPw2Y#DuY$BJU9&?5fKs5%C_*HEm~TJcxaP0AY=79 zY+sj*b!lNlj5VRZwiGqz&*1Fovp93+G|rtpgL9>&I9GN7WfhgExZH*Mo?-M1IWX$- z!ZWdc)HNSFRPw`B1R_k4h%{&+XVBBBwNM*O(23ufEfMmo^~$E|a2P&c7=E$6DXjo$ zTlQl8jx8wJn1OW(W+X z2>J0)t<^ylDUKsPR7B|HRBht1#t1{CMG0idNj2n}Ei$ksXTiGmBa(xBbsKVoi7p|sl{5SGn<=$8?##$=S+17zN zX95Onn~=M?1PAu#V(02OWW`%ylldPRg-B}x;xgA`?bdDBy{8CUi&BtbR>K+^gDNl# zmuC!vLqUv!S#pNJp-F9p%*@7LL^HGp!hFuqc zP8F0nH6F}d4ssNq-TWfL%F-t6>5;Bmnp#&xSMOkjkL8fLDs)h^bYHY=&{s6i}p~$W* zIX^u_S%rgo1ijHPMrI&;<9e*yn}anuF-WqRVKx{L8D)nhBM++z3XowpA;Q;%a6o)m zkKO=N#%>fBXaOky(h#UWferbgauZ!fx`xF*1sQ5hq;Y1A16~$al*R z%8@Xp6u@4*6UAG%qGWR>iZiT8w8?WZ!W3y1Z7>R!m=tA-&doatu)Zh}aryvMBg62F zdEj&_s}+qC=cClEImvVODb+PHX%!NS_G5Li*nf^)oU=*PJJDt%tuWb=ke0s=8#iWR zW1bc9J{SB=y%_0pU_k7}IleQIk>bO>F&0*PCRVR0Lh+hB4|}q)6DT zCYW^M`Y0Z$H8Qeq7VRtwQP%O!BH6d9^7J6kbQ*27H8|65LX)N#={sd0e>3*)NJV~P zG-Avqn9Wwv&h3avU4!hBgV_7TLEO6|18dYRFt(SW?s7LuTLKvH44VU z#bbkJaX*rdV8jD*d|jPqugY+)US+A6>e=^^Ay!h=`Wn_3z5* zHj{yqXjoG>qTs$S;l3|?6JP(zXYu<_?!rUs5|M8j2D(n7{?v1L|D_+}-+%mn@PGdP zzu|lT|L@}O|JM)j5C8r)e)DlH&i8oGe}jI&$*0DDPW^YBT5m>V`W~cj{X8Ce`Y}B7 zg{`=EV=_`z;zPs4HrI)WMs#u-Qd81kHXFqby$A;V2!^iR_cag1{cE0^i?Xo>Fc_gT zgpq`H*vBf+*HD4;7n@Pn5ytR!JG8)(z5#0<`7-u@{ww(WeVg!faV)Z;C%+Xry*qbe z2Mb7>5*tAfen&3`Ixb_#F#?~+i-^2Dq$HVpiUBi9B|uCve> zph{f@du{;=;zB44UxsR+4fSm!Xdi?qfv^%#L@0!?$%JrLHgvh!h)XabQ5m5$jYiZZ zoe?UvRtb(qnv6(KOGJ9A4YCSfPX-u`h!qJmM+Kn{1rYZ6#DT?6wMcm4CM0Zn5D$Fe zX?)?U58~hkaXt~iwOt`oL`DP2nXo6OiG0$FWcx&$30>c2<|I2LG~#thP^tELBVYVc|YO{;udd0bS!|8TlbPSN+omGylj|E~kBDdsI_{N|72mI$hegy4GV|79 z-KGslHHx-XSB-)CW;FK)(IvLH{yWJxCPz(e+qMmxH*ZE#(s(QMdcCNwu2x1y{ru-Y zSMJ}4obK<%7hhDiJ#*#^1_s7Eq-{1E)~;QPl9CeSE4?X9GWBp0n-BvGm-f#x1DaL zeJ+IT5SPJ>`JDeGxvfmg%l9TJfyMd0c6!JBr0-SEop(1PgEg`~-6$P0|DMRW@ziPa zDGPZVIhtoG83d6*(A({HTq9W4iz{n+J(wC8lVp%e2GOPm#%3a~H8Oxal?+hM=Q=|~ zL_|b)F7_PV5p>X5(_t^X2OIAH44!!EQ~3N7_u-MD8remR$OX#qt`Vx2qQaPWe>PqWH+pYXOvD^*{L5CKc;+X zRi%rBF<~7N3Jze~&MmlacNU7$&Evrq@!GK1M_9ZrBwi#3lE{7eM~2~ZYv2x>5Y(u| zKD=V@0R;Wy-RMe}uXs&R9$R@Zo}RGWhqyQ8@Z*u6>0~59d7b#M6&Z_&C@XT~J;;q{ zg|np`WhYLdw6qeH4Z~;?A5NTZF9Lo)eEuK;DmyHNyRmA=0qoh3i`_XcSsat4t}V!H## z-nbtJN>*c6aXR8nc0@(kkenEUgm@j?{SBx;^ARqTo$cwU~bO4KtL zjR>VALz9{ai)DPo-gPkqxm{R=Kv;v2N`uG^cN}+%#Ur{e@xv=GJ#peAxap1r@tWA$Xym+0Qa&l^$kuzz@m%%X#I8|`^G$QRj zkwCY2UX*8Gyk^di%rCL;uvWY_UgU2EVob3}i`GI82$Ul$uOkkw(MCaMv_WGOm0UXv zf4~iwYhomqe2qr5c56103rg_7qfg=KNAANtMad|RSHm{H^}Sb^@qCnl!trZ?EHm*t zdA*d^tt-=?1>kfHpr`XP2F8XFO3Fl3ej&1w%*YXSX7;WgqsZqBSd&vxoS{cfv=*f+-Lw(&;(<0E;91hA|XPwt^Qg#I@`s5 zg6MaPl+M2rDP%Bd!-fsmv111|ZQ7(vw7%0L zh%7l>pq%pW%{SjfQ&W=?kdo8sEB0JN(x-#DmFqezae9 z@Xj<6?D>O<6OZOc=JoUrWNEI^4zet!jtY@vkZe9ds!4L&>7&bTCP*UpB|F3yL#Ab> zK*U`Ba^3ZTzRRPFZ&R`ie=6GYe0(Ku_TaQE)A^RgPW$!s{mr&3@Z`+TZ_dkgT zKm9d)=6C-HU;Fwu@Qr7_fUo_|WBBxaJF#1Q$Vl;D!qA2H@cyq~#*5D##>Z8Cs1xte zoeS)+yrHlc0ml%=`rFahR*%N2(XrbH}^f-nT&_1#!t%$ufv6bwg83)wD4P^ppB10q)~T+^}}W&zx8N`!IFc_ zE$gwSBnN4cJy2J_hKg7I1;6~^_wbMZ@DKRA|ML_4;O8&nS8trc`{!Cv(-p$d^uU_z zN1oQ1eA@)PfX4xk&yC)2P?=WFDXw`}PvJ9@Tepi1Zb4k8dFJ7Y) zhf!a@v9h^JJg3r*|CFy%g1ySU8xd)94ZtFjb@}@kvdLDC}2r0pLKip&D z7StdZXM;8=2IfeE5)7T4Y}ev?9wFD3)52m6K<#$IKQIcP!vU8+h@LflzkHapMtP^s5uiyEd-@#`-^BJsK zwMzND)9F;!i+c6dSMiHq`~v0W<;u2`bXZ1E;SkOm_ACS zXIcPnA>?Sj`Ig~K$DSnDcbczF;_umXH**e)u@bHkpVYFJ(`rr+ip#VtG$<_3b%*`h z=@2eX+b>LcL;q~`V;>d{$ID4@P)$I<9 zOj~ewDadnD!403&kFhQ_97B2p^hT(y2I!`B&diSiT1y5}Hf}<}-VG?sG9caG0B6k+ zoO$~NyeiJ`x#wQMuMfR}m)|{#_l}j~^!aL3)()agcA$$rD1FpQ!WN(7H^t`x9K&$B zo#+mQ(XZAZq*f`5E~}L3`NaPY71X0@M2GcAjxfNg(@rG(Ml=X(bkM7HFhUDYAc#J3 ztkHl^sUhP5CY87^4`PN)T`ICV$9uiPwl9GspMF13JnmLgjfG=ov5l z>-R4<2>20p4vRX`j;_|rXl=ZNrn*YhR-D7dv&V4k=rO#0_zaGoufX6)6Ex~R1cM%> z%_vI&EvV>Zg5;R8fJj?FSr}W^^chb>7$4mwM`FoG8c`;4wA(~=S)MDa4#UVm&=3t%1Yn$V z!UG67mg~Pla_SaM|2N$So!3tXcqftT z;>?s6f4yPuDY#}bQwOs2eABg4ea%HqW42sm$N79ml`ORc%4^e`pY<0-HYZy z*=a312*-R2k5Kx?vpDp#f5Jcg^AGX;fBqSM^z18m?xpwf?$J{? zTholoy()}^V_}K4BOxgkk!AzJVcDTO-VuJ~{BF9B@@h_LB4QDhy%pIzAH{(uKZVbH z{&76{&|Vzevqp z%5?b<_WBVJc^w#2A*|9srPDw&x1U0YPz1(5ax&grSl_QGZYg8p@dkeag5$qp0F~=(IAZD<00ZTeUd0MhlgCyd!9Q zoimxfsaMN|lT-HP<>le=#~;U2Pd%jsnWV9?F_}bcNQv8Nrr^qZ z9j;q4&EQh`N$vFk#hcCNy-C+k33g#{Vc(*Th)f<0SDyw?I(+P&f|pxfUh6^o@z9ld<`G`_Q&|uv;Tr0 z{_9Wiqn{tbuMZu;n}^TiOm!og27DOPXTqAY9>v9Luw`935@Rh0g;Yw1sSG?^Io{27 zzE4THN*e*KeH{`uJdT5(|2_QvfA~{;>yQ5c-}u6(@x=#r;(>LED2#Q(=%_$f<(oM5 z+Ov4|x4*(K-zme(=ljt(Acw5T{Fra>?ndN^$&TkRG-9_J@wrkJ2#t?gS?oE>X}!!@ zh|1i9O%HwG{lM6wGm9{>g43`l|QFmn^N#2z^QG&B-Wh9^$@|xrmPXxw;P4j8I zVt=wdgu~-?P^}sdnq8@qH$jewlB1!%^rbJMq@)DN$;nCpO9rb>o;-=4{p@G>!4H0b zAOHBrN}#H%t4n#ETT{p_9CC7Ul;0CcN4ng~bbt#Tl{K5`-=M$K$Wb`c zr__>b-F)FlH@+xta@wmqP5lh(;@oV9^-QBXZqx}MW4L}AvdfF;w7)ob{a1G6lxPce zr`NOjkO7;eu-dk=f+Vw(4aS;&_5z*ai3A(muQT)Tea06N|9L0OD zyo7f@IDztZ7dkxRsT=lx${thMX)23OeseAh2}#MwOw}MM){UUgfuUh1TwcG@sXt#~ z-za>oXV6;pKF(J+;asNyW9C)J+_Vc@_wB>JgS)VQ-!AOfz5`pfY{QmKo3OEHHP&Uv zA=hqzHA1C~2w8NHW=3LX*9qLWY+;4Ja`}O zec*l^+_etda|}pT4WM5J3QjlTa>uB$Zqj76UtC;ZGCgW>F9KSV9_HjQB4hl}_&o@X zdEuAQha2$@Av{otuG(`rdbAuz&NQKZ(2J4rf`v*>?WHrrXiY{!c0N|ES%;!c+p)Q1 zFLoce4+rjh2>0yUfrIPpD2#T&*LDe)&tF7cQy*I0z^$2RX>MU>ABH+>F+4B~PdG*7 zO*&#@A`xdBU#%xBBQX(Sgv~*Ws(k46croS=%%dOzPz3|%2 z@{95n*J5W7ezzJvLj-~r6SM|BB1K)cg@<59Cp5khWsND1?7O*Pbr2Ok;6+eeYr=lB z*fa?`O`NDpY8XW$TjXHQE95kNI-O1#S#{ri_u-95FnJ3qQy7#RP zWdF8V30mDLqpU8^5U4WC#T#$JY$IA`J7+l>Wcs>Razxb+s>S=|d6L^sU;8G@qFdDH znwdswES8*#>_49ASIWNlQ0t7-YfimQKZoTu)AVk4vgN!+u&n1Mr{|k)ro5TY?T=6P zP3(b)h=_>p1}p26$6X@~_z|cNZj}P`0{uD z2LGS``@8ttzx@mR)nEQ0zWL18@WrQ}!jli|z`-p!C{B(*s?i6NT8@!f>Oj>z7;P}6 z<|1?bZfraFG#>l>AK`0%{GaiyKl%p#=rcR;XkiqhIy%vPsus;{LueD9joh-@i_BSE z<(DTYrvQ^|Fvge>U8sgF!v~#v48guJxV?cJk7{zX!r$~RYL32ypa1e*{Or|ooNXV2 zs1ess-KRD|ADan#{${M%{Sfwk>g)K-H~uet^N;=%-}%}D`0}1qtO|C(b?H1>8+*_o zb~3OmpLqiq9c)4S<@4z68Ad?63X#$Iu-lD@kB}>H$qd&(Yg0oN7sj9{g_hw_^gBJG z{!Z*-MlvTo2)kXPUHC92c4LV!AlGVAf>j!^-{5Ty^eDknjT!-OKZa{RLSyN194Qar z-0%h@?)WM`{}+FQzx=PF&HVqqga7Y$zJ)*e>R0gfPd|mOudIAH!mYHyl+Z>$+zI-mzi$JaX-nLPY4(5N+0ob|ISB68%Lt zi}cB9{J#G6uVerI{mQg{GKeKdR>^g%Mn*;u2n3XoRC1a>IRZ^h}5ly!*DFTNd zO2xB#5|BB=8ZdVwIjZVAMbQ(Ft|vzp$)J@SWtH%&Mm+g`*Bv)C;8Fx?WRPgOLGSEe z=6NE+G;!~$|8#a>UU?(8k=su9bmrow6k7^1XdwfVn_h0i-&G7Lqv`InzyvJ~mNgL( z5fRbNW1woe$j|P&0D{gwxSMLwUQvm2Wpya6ccI-mzRCQIBIp>xP@e}QLx4tOfY}lW zlU|FdlRzka`5_sfQ9-TIi0zaas3rsu@bqKwQY$(x^q|8Ph0&B^*b6pb`}!P!>!f0R91uXvKF-Txy6~Q5K?QQ(HmfhFu`Q8iF1#EEjk711qCR|OGH+@ z5n7iEW8K3Tb$Hyb$@N z)k9~Dgwbpj=NN@3Ydqp}3z4-Z3k7LWu!LRk4fbJl#Dx(#DnrgDwpbH+E`u?$bAEnY z2oF`EweAwmR&=9rSk#M@EZDO%kYY2yF1FB$yi#dwuq4?KlVX6{If&8fCiJ%tqThdg zow&w>&c>!}JCc&@h>nd#TucmNt&xZ}>0yWwtuinu+I>cs3|v8`W{3{P$Y{hRq>D1NK;6?0M?)RjdYot#&x$MGEaciM?HKFn!lm{AT81NF zG1-un6ptu-B6QJlNVWkv1`h(GJ*a5tL4A*S)s32+$_al@6WTA=Vqh$UaAX!DViOT( zQ^O{%$ycxGH%DHhO(qix3k#J%)&2M1udG?6)m~kAT}}%qpOd4hHg4RA7*WrsK2IdS zng6|QaY~SCee9jH-p}pwKeooB*#LPNv zq8y>}U&{xTfWRbqU;a)$C%2K?P9^hRmcw$8fwMhtv?~G0>FJ`o3(J~_h=_=2X)IB< z7A=_G3fNPSl#+x^30By>BWNf)k29qgacRJh?upHA%mak#;pn`K+OjcRzNCRl8-;|# zXvCNd6M?Gn4@^p+O59YU$YoGQ#((5({P`h-yn`5R2wS{O|6h)v2ubc6+(wpKVV)uXf5jdroY%pKTXxEJ0R zsDBS9p8o}Y_LJxE>d6L_4FP@A4?Ic!UKatq(FCQVJ^xt)unqMh ze5xFMHJxa5Vq!|hnFN8(MhrI8;8MRI7eh&KSrU;LAB9+pynw0ZxmM6pk$D^tHz)kw zVGQ^7VZ`Z0Ff|pXbp=Sxia~}RxPB@9366gBwpOE~P2`zdv>B1l(T+Nexc>cv|sYR{M}4>CHL|C!NiG2x0eiD{Qj}t8K*d-y9>+u z&NI_`cSJ-)M6@!joF3A{`1o8i&eV6J zsl5l?eFNwp8p6=9xDEAVpsxo#?M>*YIgYxIKgOwZ4LH|jMu#d3i76>qn;ngWC>f@@ z+O4e8iCaVno{$Rz1O4dhb7E*j4!x1nQ-u(cBb~H*Xk>86>qKaz2P1vG=p1w^Q#^UR zUidsNc$~v<47FgO;|wa!ox}OsZd7&!FenF9sbmmrB3PmvRZvDy$+d*!)PN)K`uZ_E zG>ram7;@Etz{EN)*SzKm)x;SDp$)s>AL~L_Z5e7#A4h3vInGw~;!?jG17mJ@MfyBm zH+)_X+|Cj7H8rBXt{WY_UW9BmSThq49UTdqsPP85S8+gNFkWfwgg0?~SMEO3s??u%;IxF)0a|+8$U3E~4?`1)Mz7hpJ8&hMXRF{C;>mPWap% z80k8Pnv0ikvciGJ!3da>Q<0vNB+5&JNZ$Y)Ef>&IejMk|oW-&89Vn}Jp>x;?w>&?O zC)oKNd-CTXh6npF*w=-gE>S;gE}-J*M>u-)Bu>?hqSlvq^(6vdOC9A3`h`FT&6lG3*$mUN`$=VQah1SD#QFjjsT zHOD{3(esU{78-n|>!wrx{_S8`n|x;q`|a$*0Q?fB}^9t`{D z9w{(6&7TZVt+aJ*ZY3G8dhfv$^n5;B30ggoVZLF|N=_N}#Cu&UK3L^g#OM;4SNEnw zPCQy1IpyHX_a-fBZK|d4SEU0pj;xWv%D>$dtJH;=g2I!xxklm9or7h4^JE^(lsAjL z$!iD^5fKrsOzcHiHgX>RR3zqaz?R2%W9zmgta8;LaO?$q_@nRR$AABi_`y$}$G^UO z1h0L37AMb_;rzw(C_8@wXFhrvhY$S=e)HoW;``rw4*&XE9X{~opnuhF6mH1H{f2>rPm}13etNoq4(Y)ROvO+ zOMplXHKB)4!U_2N-}hPXIiJq?dae&yEY@|+%-%Dz_v}40zn}SIEuNc1XJ=~qI>CjT zqWsmEboW6*?#u^*ogME#`ZYhj;e7d_egSwBxo~-hJH_soTn%7-eY5?wDtV*caMot0 zzQ+~<u-J0%jwR)=x&|GOud&L2fQEiW_IF-m6HDvl>1Rl*@}kS?7pWQA)A8RYu1N>xAX#2&x@vr+oUI z&+s~9;qOxml0h94%JtKe!NX}rhpvL@Rf|u!QoIPc>AWZ%XbWTl1Rt;cqU-$-8zSJ= z)-wG%R`^+{&5iW}X|VKd_Wl9KZC(oeWkI zd9t&Z3?-_qlw!U*Bi(VulKl9{-&7_a6%}NwwFwP%sQibU!lD`Idu$jcmt3?7MZLU! zBj7>w>MS-YEn%dPGmEA}{I1bZpcJh=@8`~(Z!)Ig>Wp%SfzF8~ne$vNp!C*9u5w^M z@Tu`7Del-CpVAC=_H4!D49y_x&P-ng`qx;qj0)LzMvEN@KLOtbpmF!OaWHUq>*X=9 z$pghZ98|k7GUGcuo0ShZz2CGqS9JnGNPdSjPx-Imqq$i(hRHI;_Bf@d@BL%O3*-^i zG;juZIA(I4ir=Z6k3I}cU2}M5%2GJUK~)`r?g` zkxJ0AkIz2QaEeIy=mGxT?B~bqh1^+5W+gMy>nZO&dqRPc=4E{< z{a{Jj$c5RqprLo5j*;8&wqFtPd~8m=me)O`BK|!0%pN?EFYgN;lQl-WCcRKUTuS-g z=w#`yQ#-0&1zwIUl9ix$P7qlp)z6>!p^G~SgVD~yIwN1ZTOJVjPqdlDU1Jg4-iG)P9t^2YF~2EVcJk4oN(@T$BniD7n0 z)%diojeF|H@u`;1`eeyf)H2Dz5fG|?N9uEAydUmAJfO6tUFWHQ3 z!mM*CMIfI!BRlZcy(#499)HX1B-uZMhK`091J`pXZiox&{MHj8T_0~!Y-RJbN=zR9SGT~NPdzPp8Z69OOB(ET z!;wh9CDO6njDnF(jI^lu<_jpztC#)7hbwneL>)C!dOoCx8Ru3f25Y z>irGYUq`c$;bIJX4eRcn)tP?;=2ECftK;-p0RTFv+m1%=jk!7phI{w!eSG!msbgJa zR&EQhk%7j@zDspWjs+wJE!a})Q-4$as*?OHfXNLX58rw})<-hOpf#|Eta~4Jbm~wq ze7;Zodr8?)(YkO3Z#{NaA6aXP;aF~|I++Fya^N>{MMbEk@o}=Fj|gGwbe;Ivg|et< zhmaT!9;X|&Uw^-%n9?Fw-L%S(`zl~wkCwTH=HVm^^{BEhfA;HP@QRDrDBt$as>Dx` z_m_*h|4>`W>1YBr3vJZ&wSSy867ai+rBB)T!lH=bg*&=XXKoY}Oo)Of2D@6l@7$Vr z0@;4+W)wtv#LlTDK{(D%XplxmR4wqa9QT}>-TL?V@^=ktv%+sPEM1*Et($+O=XsrKF(>@v&F!dmL*=U z8qwe6mC|+AEKUj}pD}4itZdbcEP8%>+?)fiV+W&om{e0xWJI-7;mCJp#CoUVyWOi& zbXH&Ow*L`NJrZ`B3=B?{%`P62S)3GqAzSc~+) zzS8xZOyaBeXe6?L38rUSJ)&#ZwXCYk{DJ^ZS2^&x1-q|~aS=@Y-~tRZZJO%tyMG=k^{#M0zu(q}_)oYomL6++F4}U-!G192@9Zu6 zeBspMp~`Gp?s6kjcxT)(MNA}+QQbt1PP6*T&3jiwA0^}EMLVkGw1^4ZVgBK_TMK3# zb)!XkWvXqmzwvp)drTqA*hPC6sKrkdS&`YK{c}Q?%&9h`Zs$35(eUDDtc*di)k8aT zqIn69UyeWIjiK~n?rWdyQhFhZM|X~c5A*C^Kh3#8RUvBnHt3l5{e5?DreUKezj|V= zEqB;-p*AI!q~@K0FZoY;zT%u*>iCzX)wzqHA@ZEVa*Gt|+$GCL`;GNK9Nu~=TR7jB z5MGuw1i#=FEbdNH7Lk7??HSsSV41Zbw=T5an+#N3CzgFyYRS#()0UJF_N3_M-AENnL(cV5j;=0phQ;M9yzBP?u)}@Ur`DcY z?=(;QAUZtuE9g8dp_W;9$;z!(`>lOx-{kR0n}ztXu@m%JRmjV~dj5R+KBQPWFMRoM zartC@T_&Y;Qznb=UVHXYFZ|#EiNxLmdU3UoC~b9l%2kULqlLP!l>`|E0}e~f4BP^( zh%y5kJa|uRo32q>J;}hLKcB7=FoOmUqX;-rVOg-JMBk4Q(Y9c@r3D$N{WEn&zW24> zqdzjE?pKC6A$xAYoHkuK!avKLc1>S3>wI6^NC7#AqL zN(~t;o>_@=<0w+skCeodvVRHPFC|SInj+;6{qtq2h7Qa7`!MgvKKJm^$|LKsJkj%w zw13Y-g~I`XWGC|mMf-Z5Mw$-1q5C2YL!XCYz@&j*%>tmw$1D~{7I~+O@rbX9Pvr&x z;HOqgBj-MKN-8Ywb~GtP;;^5XQimGjWbj?G+1v4p8Y^8IIc5@Z2h{DAMh1GO5<)68 zfy~Cve0B*}b{0iKt6sBx_?3%ntyr10{!(J@tbow*@)p$be)-LNZyeB7-};n-%6y0DrZ1~*)P7{`CysklYacb= z+_5T@5cbv^8JYZ%_KY%xos)=-CPLQ-@4|OFTT-#Q5c}6Y<&-$wdzYXcJu$fvu|k=) zlyBdU&eVN&KhcWUUjYpJ(RI14OHypabDYf88WlCty6$oJwe<`O4PCsE#p zT0i=RBRM=KNjIeR{{2|?wb^&BSrQvBf`^(9Bgp8UN$eJ6Xexs|_}*|FM_0RY*CM>R z-5l`5!ynY;dFsiicRD{>+@FQdjx6x`gTn6?o=o&kAKegKaOZXlT(%D!dv4xO>1gKO zBJg3YPq3JC@E5c9oq~10EGRMEj^R3utI5lBKVzEPeqAKqPS1Hqmp_IFem8J?huXBR zOCixyWd0n4k{ZDUIKps4^%l|(D>;oU1H@iUPx>DpOC5TY?82uQ?GET^JzVgpCj;%X zFFHITUZc7b?kIxp-aD4~4uIDF`KbQzp2>}>JkruM3YXft%m&T1#Cu#OqDzzXZL{;3 z#kR1C>DK-b{;{`&Cry3WwZkPapVHpDa*J$6&S%tAnM7Gnr#hWJk1u|e9tY$p&ZSi1 zJYO;Q575*;{gvhyQv)w|gxwN8X*2Oy`9mUJ&2zWQ(aY@fKw{t{>rAr5ira}$dg;Dz zK#%ell*uxNRi~$aP}Z_KMXWs%l>SIe6EUq| zRAcYg5`}GMrPs}paT`G*=}Em0J(^=2YZGDm;wBGVKQwi74Sy&Y$PATH88`c(w-VY; zplHDE-2}*T#c>h2Z^4f z`xwBFfVAmwRX{{I=Z0P<9vf)g_KmY94K=iR{eI9+rTfQaKS-CKDj-OeLD$bO(fmc= zMOZv+#Z|fbks{YX1H0D>olk$6 z0P?wPq-^qNP7f!3_8I!UO(xh6cC?N?e}Meqo=w$b?wqp-IJr{Z|=Dfi!lcJWcmUIhMxGmQw;5iBQp3Yj@jd z##vL(2{eg{_xj57%$`XRaAlgOk)RdQT-?%2YRKm=?1}1S(mKtamUwVP?U=tH+$5vl ze(MRm!P!A3KREDKTQht;TRFyDD*xzu~Z3M64FLAO9`xdneHgmdaknd_tIlHyZL);c9!B-Bnz{v*Hs z$=e?0r_7=hdxC({4|N9i5+>uOQL401(hflCI+^Fh$P`QeC~<&lXhiqRO%LB`@WZH4 z4H*$x#&-6O*s(ybv8k_%-NBX&+RK&fl#S~zYsT@0J`suh^M$ZFb4d3A+ial#7gfdGKKV+yrxO&fJ@RQv^4Lej{&eZi>aFuSl`DwH zGs|f;%>LPNkhP1Zi7nB4vP>QUeMT6#$ntG=4iyTG~Mw)_5`y9EVQi6YD z&6#iw=5IA#^9S4v2^1ZlnGG5alW=hfY`q;8A*}K5_?o3|w8ke@WhwLbLDPBp_m{NY z_0NB=IxWWP7)g10iYO>3?Bb8;a%`ClnerU{C}qmSMrZv1>9OFtf1WuOVcs;T6%uj<`NNjg!40!*Z8jy)wp#dz$qbAT27Q5Zn z9O;eNthb+SLO+sO2HS=vd+^sKhH*~)WCuPc#!mU%H?vo5LHvlE3E~-%v zv!gIpxRpD%MA(;&xk6bPDOQ%T37l;QE|YT{BSY1p+x& z_zY$u(f*t&CE1F-iiLO3Ic)S~ietG8Y=b>-D({W*l=hNDUw<&D z5R3;ZHK+c>JMsA+h>H#0uc?MTik-qkO$ey1!F=FlgK{Ev1-4h*dvB}vd9K+DT_~ge z&-{p(i1ns7d@1I}gi`8H7n4foBZmP(7Wz;^&y{Ljryy>Temvw*u3KCG*`>BEx0t!b zz1`m7Ic)LF^SVTdM(HRN2P(-51;>?f~3$^`AEA6d`p zh7`Woi;B?Ag5eLv_AK3;f?64NDmy^)pCb=g#@NJ4S49R6`^8)5Zx%`FkqbDY*%P@E zCC6@A;?dyL-b{uUd<#zO*I3&zeHDfxdbyR%*h=)QjC8E;JaR|Jh;sGF(HitFdWsg? z)YKQL%Zo7cX1VJ0*wAZ+#!P5P%9=xmV#!HBe})L&XxuC;ThUWLek+=Xh2Dh;iTpV< zmbAzxdeW!q)g_|oaw_N6lxwGglgkLHTeqrs68v(O-hKXOc2~rf9?<0Ih;G-3 zT|#75Dy_rxboE+D`7ltDirbr3SMYw*RASV(N@J8_Q^CiH7l}rRNT<^_I8||!lypPs zhznmRNwg=6-$Tv3uhC|#15RxFU+p=s@Sdjv5`DERFZ#DKn{4f>N-252pbiU~g zvuS`}2|QlRSaBKiY38BdT$Fc~h7>m@woSP~9i^n$--S&_rH(2#xP=o@_kNt%ImDB7 z9Z=sDN*#3g;J;s^>hyLwsI9U^WdHPO8F_GD$A;Lxsfs+crmvo5PXLO7v97?i!C*4T4OD zE)~gnGt(QY5?s5RmMF?DHk|z}k;fDFl}QYq9A@^=HQ5J=&xoWx$Y^hTaw~0^ms|Li zi&$^L0Z2nEC<}nv8kTY!wg`4+4I5d`;2+EU$JVKtN+fnlt8y7!K?mbq7XaRSHM55} zz;5G@D})b1(b^=-Z^H>gpCeXc%tyz4&J@y)!d|-TJ&8LSP1s6e^ZUS@x*67Del6zG zU#}AOjs0`FwN(tMN5$f5BIRQI*g4QaUtCUYgpLV68>d`kxn%8nZI+Q4Wq4%NQRPU3NEi%BF)+B zuIMJQYsm`b*7)OstgNhRAoKw?27H3SnTBa+)eQBire|h}sSA3zlQJTj68?XLy->eUJUU7|bLX+=` z_a23?b8y6tX!ELd9TmQ(z;k#$xYK6J%Qhy&%w)Ku6bBpPFATzyW0wc%(5Dk+*@a-GHn!MdYHUK)LXm0i=`dt;mQ}`Vc`CUK(yi;A(q9qrJYz$WQ`qvJnJWl%gL~S5V4WMqwC7|BpYw)@Q)r< z{gU_1EV~Spv&{dC3hPSQF8F%anZ@qKQZ>&`(De|ea&21S2{|+0=0=zkNiC1U4^d}?v@!%c-S<@QD8#SE7%en~tFbCzUUikY|(`tSC zv?M{s8S&p8mSXU=l~B1yQ5|$5o%&y7PJxasn zVR7#N-II-Q{DgHOM>Ty_QJd5IiaPK>LP!@I(9I!yCieV62(JemI6OSk5#g>F_~Q25 znHtx<(AOzGGyMNOsYZ6%@TMO1e6j6LH@iezjyotY4u3{eNc`vEyy|jBURw7u#;(in zhtx_p|Dul_9ZBkDM~;!CPQm|fN2XcF>&GL8FP_lK4m5Ps?;dkJ3Hd404Z#5<4*ZaN zn9K8*xC@5XQ1C^OkB?*7{UKrj58RM~RyENtz@FZJl>^7GJMk+t1+%Zu>;*pWV;C)f z`0eB2U)`Ud4%qwS!}q8npORl)R_$ykE|M3{_@xsl^j5m5@ z@8CphFBT*h|M;n1wra|g3cT+SU#(M;3fB#?fK8?0i+G(qsO+azPe;Y z@BdxZR2BE~N|Q4BK&)kF=V7A!82 zEBWnxDzUEbfV`G1t11|#N#K+wYg zs<45jRKgs@Co$8uNdW%dR#EL7!}V99aq0JJb?+h~v!XgOHa0e^)HljYeZ+FIY}tGC9EE5xF5j1gi;gqabn~)= zCvW8ECcU=^`jk3hfP1^Dmpn=CUSI%!G{{!Nqjdk$lB z7#iu>j-Eeb(ibXD(Jecvr)YIQ8%z}w!t?B?C@U*Bl!WHMtE;QCYikAPq3)`6_5(v{ zw{H{&ED@e!gOjV$E0{QQeyA{~n*uliQpWnCabEo6xi%NM7@;sc3Odk!quzLK{Fq}$ z5BKvP#|N)DcP_dUfMO32xJNMk_T@`p3rv61Koq6e<7G9oH+-shdhn)h6zPo_t_fqi zQHa<7)~7L&!nl~(?LnWzzL3_7cBKSyCUU)a)BV9lC7Ln5`BUPdmP==~V_{pU?Yzjw ze69LSQ25rObn<>QmeMLbj=xXwviIxFTl={}&1`ZE zKo`%8S#~!#iu8ApL4`g1M%!9;MS}p?$5Iw|-dnsMIJlG@?ci7(9v2tm2Wtmx9mF-C zuJ)$JUsySgy|S`50SS2N;V!nD_MPIr2mxCb?=)?a^z^FEBJ4eTS}v*v+Dc;uCfo-! zo%f-HxyS~Q&{f!pN_WpEU<~MSn(=7}dZa-!jBZ58VLHo!dXrY`hE{m`y~&PTI;|2* zw+)i8;pr`OUsv7*N4Uy%+@eKV!o>pE^cW4>wu|9%^iK&aLTD$V!+lfxgE~;M5vU>Iy;GH_DT*4) zIixCci96Cb4KdagT~L(d_BqYBDSi2p~mUUu1lKiqNd$crE@xOra~d%VuJHp zz*1ctrYHfAs5UP8-B;@Aww$NGD#S-UW|-nDD~26S8AEy)z)j*V#_HNNqB4+7ytJAP zsKzZ`;OSw1(#o7OjFZsVCi5aQ??a+1GF#knesCPcE3Dsa({spuQ99XBSqtRjy;yVf z+&s1FEA<=2*maEM=}4c(OcvutZnWi=+$n7Naxrc2rK29{$Ihf(9KN>n!d!Ecz;y`g zKpUq?0xzumJhs=n@&h~V02!9V@zw13bE#BTro}yy(pGeXmpFiSC+UO=6n+KUC&#E> z?j^oVtbVnjcN&8D?$2b(r*)p$oX)mk1W~1}vTNC!&G2Ra&kQ&y%(t%kvXq*55+A+) zJAntQh$u6iEGIt*YxZ6v7Sk4usm9a?_2<`ARBskO;o7YpQyGxN?S=0Dzn#E9F%bbqQF3# z&yCIInC;^%lgf+tfcF)|H*Af9(ydpBmz_|`tqCyQMOYQ6@aM%$Ie}fO5TMJ z8;*Gr51T!1ADgYt3HoTQ%w9e_Wng_UTKy+5q~Tbn0lQswP*n!vG``sEYS?WwUJDN{ z9T3O@r!jyr$ymfeYhoGjq6j-Hf?O%eaZ_mkmW<1;B_nWpvSH_+xK5C%SZza1`t`9K z7Y3Wrs%rNB~Hxn&Xf2D}*2+##jX|k%Kc4B!|wLh5I>E-RkhU^Co1!h`~op^7K6Z zV5mxNje}7xj-ysKOgwMAMZ?;7C>~bNiu5@uJYUxqQryc zc2OW2$G5>pG=|l8W~epv5t2Z;?PR(zQFcNGPqi?wRnUw#ba6%kZl*g$HnYVPu=>X& ze3-0EoLw&Vw7Nz|YgXN}izDo%A$`0~)A6e35RKbF#u;({SARW*uh-5^drh3vmMrLj zwObOUWNZ%@2(%a9=|8`)a9>^6=sT$;Vd7IXL=A=Hb+0y#c(0MF(njAtf}7@*MBPlb z{h-eC${0P4nG=JyV4^*j@jNy0AWXA?(+qMyM~D_uw{qkOFJ)SA&As)|Fny`NL0CXy&7fJumlDZ*5xC3NI z!S2iqUj8X(AcLy*sEud`0l0upL2 zWql8+^qjl z=EL+{)Y^W_b)ESXQjeP~0mgncSXP2feFJL~KGZRIrTacOd5@HHxWz$Oz~QXljLH*r zxdv|aHfr(4d5WN$a(2!&&Wy097_L)OuKGU{*xzvXK6-#yo{p93TJ1kqMd#B?J+}QM z*mGjFGss=Tmblx?N9DT1mnf72CIKCJ9}KIuaIk<6zc*pNlRN(+R2d9p;etyTw1{IF z9eM*Kd|rnEe71;o^y2MHB>ug5RbpYEh~7uO%IeHQ9z_cK_}e1vfGv{#G%-vcs#&u% zLQkvakYJU8rOlG_RAS%<_3g$#||r{-&|&ReUcyVj-JZD00} zd>TX(LeTNFz7s-7Kb;OB(!#;xMJlREwBgv-zz3z{v`GblQ9&->w48KtbB#&pTO0RV zNMbsCP*vc8$E`s2@Ijlwl+m<*wXX!aF~OMsk04*y7vTJ;S@JyZ$?vI^Hb0}dOOef= zP5b%rD`tcY5y0bl?lV*!_!t46aeG~`6Muo35g?>3cXeB6vGAI5RRCJ4{!i!hTy>7d zcddCvy8v6~6@BM%Pvn}kWWx)j!C{Ai$4D1;B%EtFC*CMZk-OnV{L86QR%0X22}&od z>Oz8QTDku5#)Jq^!Ml*t?K-Y`t$hctaRnPiGEP_J_!hr0hZC+D^YHnqgP-%fnd5E< zAV#|y&>!!OYLGsjHc|7pp9cW8L~}}WYG{GieV|5%Uz=P%g>Teu+rGCJ6^O?fCUo&J zn{}Ino6p@MT^k8t81~CK-YuME3}1~NnKEa3CQ zl#_4hHAaReW=ccs7ZjxG1)rj~HT!?dsHCo5^Ynh6O7Hj?8a75cAAg3Xi}jYPsZk%O zJ)>teT!@A`Tv*s&obP|j7rUqJy^!(*&wymlxezJ)6Qgxzk! z&>;FhAkJl5E{@8O$vMYI3TNFyEr|}Pm{#m;FE^48J@<@3oZoZDhH&jML`0C=v*X)L zjdwiJ%bkMKCe^=clftV_)>@$?W8B}gtwqip5$?n9a56`Q?JdY#J5&X-=f%zDvF}7f z#F-!`y@4V}hpNaJOe;Hsj|sBrB2;Wuy9~i`hMEWH3%DrQnT7w=V*p-{O^?R3N@D$q z#80NTT?PZH=A%AsT!1mz8xG67R-ZK2;wGtaq*t$}d;P23wq{nMn4T1!Mwo+XK`ZTa z-b{4vEAd3lUYc&7%Oq;(!KWwhUcLO4{ejlae0GA9B4y>}C8abGAt9lm{$@T3 zQx)f}S@gZ@_lWT^n=Lj@JX&0oJ$xuF2Ar)(kDB1*Otn^+^0{+8=d_}otJ}=81qwcB zG^Qj`ks=}kK*wX}JA{&hFfQmzN@I{G7e~#&B^;D8P1s#v3fJTTtGY=!(w*$g@X%;Hw{4tjDu>W%=_q>-D#cV>1 z;G_c)bO9Cti;R_9rBI8yc{lxx&|VZ29ZBZBlQ@q7dyjV9&T|#RHP{2jf*aQJBw;Y{duyH8Sy&l+T~R4}4dk-P2a6Bc zj6uiC3~L8Ht}P6JO&TX^vm2PKKIpMdjHZmcDA<%`Z19_gAJX%)UO->W$E|7JE4=Ej>j=YkQjZ0Z zRG|Y&LZlr{`fN(0`!BtFy!XT0n_1AF80bM-U8?|E1b54GYeRByPtxb9PIwX|x8Lo$ z1T6@D)D@4%6lLfs*r`w>C1d2|5K+mfQ+NBuv-S|sZoBwtFXQU5{0KepC8^}08ht&c zcJ2aA<8-z@(s0orlK6hs>sfU=>ER@`UYmjO;Z`lx{CdXB{^9@No| zt92dPu)yRQ)9RPbKp0K-U*j)x;9)|Njfu5Il(R~4`r(aZnW4~!7 zmo^TQctwQ_FD>mGOf+)2thuJl{>wIu>RDGQ*eRGxz`4oM9%i+A9<~x5hc`uV6Tm8I zm{Z>4@tnnoDKnT5Bua-!Sh#1NkFkRxC8j|!Nx}OaHC*&>QP*Cms(g+D#tM@P2gUjh|wTr@Vzc|Vwsk+{KIDLJZNU^ zr#teG4t<)?HX;0}%n<`U+n1fTi(Afph-M#m#h`>83@&Pch{ zOS&5Au$e4XFZbg;!mA?H?1snxNzOU_CTG_64KZx90Mcv06&UW9-h%XxfpH+v@ekEC z4vUl|m=9{uXDNhXl|!$)mAIThBl|hPQIPYMeFL`{vxcQS$$>6P zkdUz_THO;-+E;4G0oN+7=eSngRhn?RX=0p(_|{m-W%+jbLFtS$3{cra?`?{icZbn? zqY~$3iC`-FM+1}dQK%ZbZkdy{JfvbwE_Pae6=beRqWZ&=jRONqaRu+FgaKs z_oNc5V+-XR@Yn4+%B|)f9%|ZynQk(Mn=hSMB??QjxpMNYTnCzMxmPZ0_I+`-*Kv5F z+oMC=-t6@F#ee>kz$ix}t50$nm+F=mtu}V|(HHiaD zW*ia^^@4)(Zhj*?*qz1>{Ls5sbgh~~MSPR?^=K%~_cY@z=IHW}$Z(auItrhs_XAoO zjm4diKDMn38wl5#@XAJwtyF&rZ}V_+$v7RKRdNxZ_;)j_C~osPJ4qNfJp`g}{vveX zhyHcJT7Gz)uLy7_rhdR&GMV7^2IeGMp4A-#c>In}!PxN(v6b}<;*A+ke8Edzm~qTB z6TErT&=b4C(5Fr)w9+;M9`q%=jBK43U~`ukNfHSqz+Eqk^REoiT^qI<87m`RCKEJO z437|9$|p|3wbX!}6h;gx7Ig$8U8vjEdOu)PRzMd;N8(|1EV7?qTa)b`caFm;VUZ?O zt>rxT6}N)RuG{+B72nIsx+Vq6O3urNNCKT-sf zeo}08vD%51a!nnDR_CV3HMiXXt!fLn=BPGGZB);PQBD6Ag9~sgAw=$vjgLmj*t z$G6B`7sXmw>Y|?9$Q4=uJAc{tYmjZeF@1d2H-8CoTvNjC6)UkRI+3S1HB6PlwSmat zA{G!>C2gae{u>jADqWSasc84ndh0CvlEj41vXd@x>?l$E6_00Wb#CpPMFCQ=D2}_5 zU1BYlS(Co+`=nKayS#Ka$$HXojljkSy{dDGYfY`o;}>(}?>psz8gNhf+WE_Z?JtL} zi8B{1bNg-Q;=CCpJ^Ok(cM8~f!=}+E=ONR6VNmYlPgM$)_gQU)_*)O@c=3lXC z(lj^h+)@NFHY(II6-{=cY4LO5S>B~rH{A6 zc(~Ul@d^k?Uije7yTK?6tB z-2?YQvG4^U2ML!mqHT>%t-nJ%8ej6EYoV$aD$z(fd^ik_j%+3rGKD7*lon^$(8TYvt*C}ofdnk6?hXW3Hv!ltbn*Vk4A%5NSEvY*9 z*@pPj3-?)0@8;8b+P#*k)g6a!a@8D9x(X9nxFe19>56{%b8ZUzi?goy2n+dQHAO_rrNz; z;(Z)@ezl(6G9u0iyIxvf|Ks}IE5CC6#|^C?>GuS0+3?kk>cKj+Y(MTZ|CQvm+TY21 z73!rcB&{hA76)7=^*FSMg0UUk2f>$T+Bo!P(ZLqt;#q6`#fZVdVWv1wU5SG-yo=hB z^T;sbC5UT`zFCaa026S&tkXJ(248HQSGr(}uGXd40m;=($fX##5tS$|4l**2cU!1l z`>Vwpf={F#YxVtlm$g3#8SXP~asE6kvdk#5!N@QmCvn*Bb3SIV(#e2h%bOP$0Vn^~ z-IzB&Vmz#gnXNWG&KEyMavTi6(&8L|C)qxy%M36%iMM$K<6k$a6kOosl4uas3j$5lNvinlgdU;KX6MkY5&AG&1z?khy=GdSq>O@@ZlZHLe+MYgbK54Raeyqp=a=1A! z*6fXWSyQ?(lI2XjDH<#J@1wtI2sL6~_H|1bAOY)s@e&r|DOl%l)c(@rBHVdjhZ{B_ z+5A%SazgdM??58H3@yosPToy@*?>{ScCCwG&+1Lpoz2cDHU8B;SbO1&G>nhe2hclw-d;gf+Fh6Fo>WLGOV^>r_c#-!g9)m2NX=u#{`&1;-y5;hOu_THGB z`J^^=$ZDqnWrkj7Q@;}9jWbrY5_VSEqqvab&QPzt(4@&*URqgM>`h=NBo0T{ z7*n4e4rTFKn9ps`SlM%~LG(g1Gp%tcgAf3dqBTvl6hIRJ)o*N46Nq!XycRA0q10oS z@+5lw91uL-ya=DNlY+YqEC8eZ`x`5nTno^3uBUdbib>wb{f9s9^V*E~RzG?+Ze5Mf zwNoXE*%(j=!Bq0nQZ=V?1XHPX`0Ufm|3;_yC{`-qL&x5c^=1@T>R5v}P;bjRsyp|k zy|qzQiDD`RS3<;xD*Aq3Ce5+g-<*bC$Es*lO)SX(`*FQL=6WG@L+~Gb+Y$sg^sVg- zV+PaWJ;&B^+#D4*8~L;4q>-b^u1D~?T(F)0(VCLDK%Z@sJku4d0VRM{_ec$ilmT|{FGJdem`B^FbM9Z0NkP0lB^kq{gSCk zhs z+7H)SYnr}`uQaagvvsN@XBGO~Fs*)hs=?&9Tf@N+M1E+otXE3E&OCWG8+AK4Ev|Gs zW^%22e3AutEdG*l!P9)<_($-5$$d}+2iKW>Y12ut$c0^i`PLb#Z(6Zzcpb_ByEq6I zEe*|UXb>qW@u$G!LEgCW(ae`Uzc4A=Op5oYR_V#n!TF*j-vQi0Hrp-vmh-kcK12Zc zXUidxIJIL@3CaiyoURWG6MVGpa zIIT?CO#)PE)~Re5qH6s0l1GKX@8e#kK$u(sqjSH73`N})!W;WfU-lNuT_!<6C#!Rq z&T;WCe-aA-D<|i$G=S6G@4p+cblys^M2ob<*2@dDm8GS8JeMK6&HIwv+?_oE0Rgkc zUq4m{-u(AYq}h#+7o4`XeZ4f@t8>ZB*=C>(Z~MAS&_RIfn8vB6tGe?k@p@EQv$>^; zgp0gcSMG8J+kNL#hMtvK_3M4+IsUExi@o=bYI^I|g>Bo0!uC}x)NMoQ(mPQRQ4xYb zXrZWdLO=+;1QmrXNKtx6qy`8zbP|;fNDa~<0i-2T0|W>GLhdhNzxSMbzI(>G_k3l1 zcZ}m-n6iE=tIau|`OIe(teYn1#`DQGfV+dHOZlp-OWMQc>;HRV(Sw)=n=_%T?+VI( zQ#S31O{1hC=5n#`YWOxK z<;;#ie8OU#!KRgbwpp-ZEuYd*e-5_wrH5cm;P&QH#=)FGRY863x*UUQ^c*1wd2~G^ zDP+5)Qg$FGXMJawL-`P_k_r+MQqYlIX%DP?b$FX4cTr`&nc zv9Cd@?X&UB+z)2w+bF(|R^oJrNX7X9`sR*TccIsU(VStKP>@*l(Pu`c9~>~1*@(R4 zQvjew*r0s0v=Ch|dPYw3?k0nn^j+ZkB0NxclB6x!=z%G|xL5LvIV%~YboKuG{KfsF zD;+onI4d5H_BZ^2$nclvQdO1k*2!-pB13H!8ZBe4a*nEmx(-CYf~lE-VNS~84`Ce* zotIRkV(v$@#oF83c_GTPdq0b}CC4{c*pbUlFsQ?^&k88Lk{Y4c0{tpCOybhjfDlV< z^ZTbzfn>n^TstNhu;N6(?kuN_0U7WH9UPJ&;?FkOFUi2x{VdLt@VM?em%5a^Rbx=K z`OrG5fhw*wyCXQF*1FtN+glK*DP_3x)}Sj#UZyKtutNjXC^Qtf)k|E7sh4p=O6L@7 zv}Ng6KS@#`jqEOOo~hj)H@4C38XWO8kuLSm>9}9&vpQ8- z3>mPR7Z@GnaA!|Ve$GNhrO7GJcCeBxja(dl@4q?no?k%%ubY}&)?}fRWz$|3%T!jaZ*&k``ToYyjR5zNzsPa0!gsk0WIL5FTE4Q} zA-&^0(al7z_NNByzN7cN6KoF!D+}KUTzQk~v8J_#mE8S9aC?%!c51>v+VSBNZ8=HD zfIrSM0})922n;b|&rBlR2e)ta+des(ho*9lkeU3^pK&$NqqI5@S1Pr@d@sG4WFV-l zPT5*9rh+oI?UC!%&6oTZvA%e6#G-fa!I5V}gR)WE_UYJ-mR)KHjueuj zHCyue0_j~XfWSyKQLAXqae<+7*-*MA8vwiATIeWVV18^+ziSq3h{iaoxh1q?AW+q% zSDnaBL0>y!rK%ztA%xdWPKNf5nmNU(JGwlc=P9qDNz642ERVQWFRiVOZQI>uyw)e5 zNLpJdA|j?=i#>>1TuJ7y==u{mJGoOAtB`Kx6eGPEdCZ*&5^S$AMMyV(LI4t`k6<0q z&W+QNN-K$h<am-9d- z*l#%cRd?<^AYMqhaEF^WH8bqO)jQmhLcqe5zl`Moyd~!2nm^+RW7=-k*AbS~l5*01 zYUHUk+m~YEdo=)`%wJ>2!PeI zU;7_J8TLyrQ9!DJ{g)m$(2Lam{-oq;XgM67e9|L8bst2Z>--b)?jNE|eh^6ot>W6U{^MSOqRF30-%%gqz0 z1B2f|d&1<& zDi-RdTTLUX7L=a{TKU-w06L}TH#YO9>AF3Ej1f9BadjS#7J<_UYY6*jqL)Nk2S zncH0hGs_ioMvGyDNlnTK5W)cN(7Z4NcoH3$oeAkmc4G(R!N8DX^o~GoEcO1U&H0jagva>Lb8%QgFqt)~+FXr`z-5{dJF8F+Av-z|06+Swz)#3>vTcouhqf+%X|~ zb!Oa{`4(yq@pDzwJODivY`Pfai3hK$x`c%d!RHpB#0gtU(5g=uA$(&XfSrVmhxD20 z*K!u+O#L-cZU!dixWlPcmj#D@0g>t`knYM&aS@ROyk(WET9KW?d8zuA;~&or=mQJj zsx_&2B-K!}#&ZzKkS?+hoQ;o!r2ZvA$}=;PlKnXmNyshl$6mR2Q+GzPFu$jclvvzO zFovFy-L>m%P_2kZ1as3E-!zV)y^zIItGGE=eDS&dM*qC@+WGI7<8tH-jvO6QRVgX& zw*z)VEmK?r7eJre$^R?CM!4sUm@Nn{GpSNzu zVVNPZ@8TiJVyLb7quHWJFYdt^YN3w{a<89ARI+_C8!u;|%FGZ|Q=o`6ZWi{92SRxz zJp#D#1YjR0sXU?uHBYa-JvDEZ0*+0ums}#0xO1dbyp0gQfiUKveWfZ-2i0p zi?Wk2Be^DDiE-4UZOBqa_J&}c*Tl5)H*16Qq;*ha8|Jf!hL}QsmBqI@k-+%e^~Uwg z$w2o#-q6`neq&~<1OIHV$_+BdP()W{uUkehZN=k%df3Wc92Gbqe}3Za0r}{&A+&ZG zS3x6mx!GA`RjEAHpn(yZZV9ostlOD9UK< zH9dnax_Ipzpi zJCdjr;Bq2z5jqP7=f3>t%y@Csl>X*GKD0pvH5+1?uh;e!>P><#+^)fFW7iGwf&PajbkLMO_h=Ba-vnGS7d!(!v+}nL8ulx$hiR znzEJFj@NOU2)pHOeKUP}^X}IvIk9i~&-aR_HlXr)=G&uVtJ_QMU$y-|{YVzstf)kl z4!f?_gqN7Uan~j{nxT9e!wJZsb)(vu*8Le?`X{V}jL+-(-#B*O;TTWiZ1IBi2 zaxd%;2OU&L7#Y{t;{ZPgd8_%w;EmxD|FI?ELyemx;d&S1ZaXH@fNw!F)8vSAGqp@8 zYzXHwZnR!~f}Kct37|KJe%;ozg-G%JOzyOjgFV#tRs8aN5B1#POGJ*MBO^U6p`=Lo zoJNayv4}`W1=KCSZYp~(IsGE#W;4UIuk@K|#+d!=fz<*fnEVmzGm*uLv7@Mv1I`p* zvDfH`4b^T}=VEjJ@#G`7`9CREp?$q(pXTL@n3eS|yge64P(cp$*9o+0`czLX?0FpH zB-9ppp7=+2YvYuE&hgWynXHtEhwL5h+s8zK!+}(?-S#Ya$Y&3ArAQ>?Fwul+%-!^= z*r&Hq(b2-Nq4L7bbKGJV1nSm$Y*PxS-Y~+Vg4RyH>P4NqGvRGjzJ_>m>R`>{L*{eE zFH=>v+)X9i8f}diE%t^}<4^@*)2PPF%SL&P)74iOEiTEwDB#xkt}}+r!Dn%+DKESY zZD9GH!#%(bfVh8Kv1GCitaHFrQ;pLCDX7pms9^I7LR91s>a0srgMOx7XLyBF2&ypm ztHr#?&}b*j{y`l?808oCD3d#IyPF&ec6L?#QX){g#%Ih+;OP3?|G_1#p%ieqTAeF4 z2VQ9NE9b*z%~~%Jbrq}XYP;mGYxs)=bzTU2qzm-pWu)QXCVC&0F?j5QyKb`TRyHS$ zDp#-d&u|~cTwY?-m-#*=ad63)7^2Tn&%+%@{TE?7>EkR+-o#4@ z`Y0@fG^3%=h!1Ja73-V};){W4LH2HCf0{0YjeLt$*EZOu&-{x$Q~(5~BpVU#*cW5N zk45=u!h0sU20FHeUIYppD0dH}d;(?}SjH^xF_`n% zR+@&9)!4?n2-%F@_{{uhk&qJTAOwt7ov}J|%k$pF9?NLcBaX++WhCs0a>Y&qpynY9 zscexVyt&1KK?LjUyS<3Z*#G}MdLWS8;A}h*zQPW!vJKZNY|hHCJd${ zY7}-WJMoxf|9bN*J=e%scre}57o4$MB3!%mV{Oyh{l$2*^h+A?XiVVg@K0wbNmYvAF2~M31TW!qzvTmrC@QSB z2Q8=oqTx+GwuL7T`i+ZmLsBHUAS<;h*2Ol zGp_J;{5DZNP;^M%Li0A{jg00%PqkoT67LNOle}mr3&t>|W32a7KdE{=J5$MxH`Ri=MV5N5-o@|CpX0U*Eq!X28Zu1)xg~WyV(KJmdw6*{)M9h z#nJ?^Pfm0p2c&JXiZNet)u0@Ll5wVWuAO0V`%tv28Y7Dc1 z)D6Lr8t=|s9$>jB58s@|`Q|b{oelrvQ%%OeN>1QTT1J50vgU1;uM8Y1X$4Yt&EKiRk&Mo-+M6TcCqY=3YVWpdN#bIeOdK=jEw zU3P9%<*4N^IrD)4=jK4)jjFNs%PSm^GgUP8x$jD-u%VKRs27@=0A^ZE`JlGrh5Wix zetG$D3May_>}%3zAaX|-u0DSr`S*%4Yy&L+cTu!p25mywH{vcTr)f9P36JHK%O2(9 zrg9Wt)H}zm0Rp){@ExwtO3uGZdMhI0f$i6QQCc*GL@qC1SnhigM$Yj;lK623^jg2Z zO|{YDO27p>)9(B@=7JmqU0lEUx*Z}+nsk!P-tM#v?097=b#FRXy?>TQxRhL`*d5+p z`y5>$eT z@V2*4kKPeI(U9v)Z$X;3%L}@ghN{NRZeIA5DwsllJ!yo_>wNsnnLs175Om@)@6aX| zqo8X2M8_~f>90Y}C$-g62qVMS++SJ5rY|G_;^?^(hAJ>%s)_Gd$jGytZ}$b1xC$5K zj8~}>SEq@3_RSD=D8cFDM)5D(gu6E&jw!Hs&GPE|Khn z4}IP!_$6G$Bn8TdYQw|+AgP2_LdfSJ%FTSHfJaO{QT-S#2KU=su67^j15N;7UU2;W zgT`nz*T7AyP7Fq#q<~h{B#&}((fiF#$<=)75+(JReC-i{c@sfWd44n&#pkK8J?Nl( zRt{BP8=cH3mIOi|idx-(w_sA~IU^@X)69N0`)%pc#amcXHozS)>7 zYIKJCYiAoXS>M#pP03?r?W@J4>)D~==Y_{lQifk%9! zc%B}RM|m0XbnaFVD@Z0b9E}s`;H26Mpf(g--}X3oq66H=f>Bo-{GO85n!a;4kyt05 z2=MzaZ>U#;CxGAw?dR^|i~ZE~b#QDD{ha)E7sqcT&|RMI1WovfzIfk_AjyY z`}Eocj!^&)F+};aU@*^t4yG z&S?sO2vqALKx5;&Z+k;dJqdTJ*bEtk5`LnOn;WI_I_p#_R8A%v4FbNjPE-lR(KQ`C zr6{)9C}gA>c@n0)`)qZ0@8^fvC>9lo&GU5rLpzl2&n%7^$}fKg3>WE>S&+(xnQ!7> z;ECGpvwNBkHtxP^nn(EqI1;eHFC;JIH(ovv{UZ0H&yGHetuDW+!M?AQU{U882>PQqfl6gG8-G(ZK|LS z)krVoEWOcb#)gw|KD&~Y8P-*%^oydF69a0lnhzkVxI)xz(L?PUrze449~cag`Fvo( zv6I-+z>II3_07Kzwqo>HXhPa4QRD5mf_Qscy(kv7n+*Wi!yhD<%O@u0{|%@3#OjD1 zV4(bJ&#s9Y*>ZdB~jweR`!x^YkuV zI__b!wfLdvsj_oXLCqzQBFXf^=Yjrrnpah5D09M#u-laEGom;z%|FX!&3ER1UFsOi zu%(d8Up+aqw^VwbTE|^ta0V-0xK#&u7wFyHqJ<%`?Z~aJirHy9&+(c-T03Tzd*`MA zvzKwM_&9$8gimYfx2$Hb=CWF6h?(2&1-$iY0Jgp|!&U>ei8>RGY#t&;x3bS26aan> z{^<41->kQDM*BS9&N7&Y`bScmALhN;yHuUdM^*$$eD zPgIRXyQ?8Lzr9CrxdbUTZ9qC_F{qQ3S4x$r>2u7}x|Y9?=O?YAxJ3qx$emtyo3H#O zoSq@aNLDGwkG6`DSGG)G%DK$SiHjM-sdF zu71;uV$BK$o(3vHPnO1qiJ+b*;-skYf}6!^|2)>5)kGvsWHf(1NnN+P%E-VxiFWK7GG{NLrl?)rN z`h=Gl-?Su5T@;R-w8goU;gF{fiLrj?^gojzQrW%#i+CXMT%4ii1E5@Xpx<<7L)2LB z$7&cV4~XbRtHGABd1U!L1rrh7zbL~M>i)EaQ~75+;d@gdAxIYWeusvcHnJ z68iQ^>O~?(erLn=rtzr9z1sun&mEd^VDrR0lB|RRal8e|2z$8#81|0V&T_oYYQwo_ zv!d0@X6SFDh5%|On4XrA2cUK%^uDm4n2TAZJ{AgtzegHQd~1n+-|)=5yV3Ek8A;)K z;caB#7fcE5DakU>{}V2s4O2JuB);%!nrU;YeO& zWVfg1Tv`nE?Lv#4*<1~H^_YB`lL+i7zqrFA9a>!~azTh4l?=jYtgK{b79GJVw0@kXEZ3K-BZ|3{vrr*} z7(^Q)7H&}Z`3;IKl@#~?|TsEE* zEVzyAR;Reu&b5ss8P1RPSMC2i7T2xn_u0|>`0H(zZjQcNpi7J>94P@u*FiTfkM3>{ z;W~htFT(CB*AOWgw%iH2uhYq>(6)%!Ws^2wJ*V5x2qMreU~GCA)dxw0SEX27BlqCR54Lp&NEng>-yF5oqDeJajm6zwQVoF?yTJP#ws1J zF<}BHfAknno_$^${+bNQ#>{b`;kg=nSUqk5!+OR^yEtfGnG&lu?&)C3z-f_wR-fwn z(px-RTi70UqM%AQka<}tYvLo{5d8j8G1FAjikRR2wL%8Rk5Mx}m7)GTtiMLxCgo$u zvghm;DmM{}`kvpe4N$Z&(4$^X?U|(C3SiEiSuNRR4Fc@PvxO{vm%}IMikH+da0_OA zqrCt(BU!d;FgE^?Xc*HNBfh_A?g5LYm!a?ms3G!KM%aVDUmdF_{kWsiOU#2F^?X=Y z?Kyl?*?T!vH!Yx_{f$y-`>4t0=U>-neh}7(TRUq*uL2QG>HgWi1mvZ0wb|Mt`FONN z{mK0VqeDVP>q=J7#}=}X&0-gLW_2geeq5fA-JwnU{$**~_Jt#yT%}uB`Sj~+RmOT> zEkNg|{tV_K0b~U;xc^$)4H@L_7SW&5n55?KWeaBaV5K2>@MF8@Q}KVTsZofXiWrlh zpUBepmp{Abr;YUA6r`>Y1x(kmTsFU?Bs+M$7UK{5C#ZvMh7U!SAwTHarpCH#l^Vb3_Z(nzyMARP%OUED#7HO$bduC`E4 zwiJWB?K55GbfUS6lNsUkX$(A}6b+n#j!tcNns#P(6*xPdscfQ(^0C^K)Kp1x1^K>5 zt$}s%ksG=~Ja%gT<^*i4z}X(l^b5G~THKIOBCgZ6d!u}76-xaT2)0=tMkb9YUpcm1 zt`SMdgL*mN$acb4I`+9wM<|f02rg{pfn9)j0x*^Kwil>*Ack=D1ac=xLxeq`CM?;L zTljxY+uS2wZ73DAa8w)Up(rW4WDAH;{@ul7Q1iK9H#pJYV%E#xwhs!Yz{2DBV zhMeX#!djl18v>Y|axND2UgBH_kF&cXDy_v`6sqGCi6Y;~5lQ+`ps;r(%7PJ2RQqIb zpQiW+gG*6N3p+c!sFdYjCAyJsg$$l8+Nx>6)j?gbbdoByQ)afO0I2TpoS&a>XQcbh z7p(pM60Af)k;#F|& z&s-RzlG2_Oh3rX=3wAV(s;(c0KfX%q;J4}t2{8Yx71iySmlmJmQdiI*mVfBwX|P`N z(Hnr-d7ua2N0}#I>ikK$Tl$+LJS{`XdN2M4bGPrY^Kxv9LPqj4imFnHvNM4Xvw^yc zx>7jqoIVLS=Cx3{x9=RGtN z7B1O_muS3sfw^+5cI6ufwUGlG(}CVH-P_H`b7#KqjgNr)k6e5&!NQyld;uKgr`kPc zhGJ?7gQj?!(b$Zzq(d*ZbC1`_vQq@LSIG?L4rWxP9P83Vkku zYsM<(fKXj%!RkKvLX|Gn-uc61iB=Z0>WpWmhUPJGw0!Ub8@>Xhpwv?JL=mU)x-C3XAipMpU2?dDeu#(|&_=4xeenCQ!+JAyt!EW&1vH0xw{&#p9|JB(4KDXun zq%nIM(_>caJi$?7F+RF3E-G)b5W(*LQ^pC@&t`P4`#!~xAE3;n0GrSDVR9bvgA$k_ z6{X5}v7B6b&6+G!Tnvl3j)~vy2A|jY-XF?L+u2)5A#PC%*A@y(x*^6^afKy&rs%qP z@7lF60(A$Z8h5O1}-ugOQTFm>=I$mB5mVWy4%PGDd$-~Ds9x$;My~POl{G$}%eZCV5TJQN0 z_S3O;#StmJm;AVqHov5U*TDyI>UQWx* zyeXMMTriLAKsQ`TF!$4x!0i&~BM`yPYTW8t!}7~lBe|8P301}WzX4D@%lypUW}pKz z<00EmzIRKK-i}vYqdlqJsIsR5_XA5~Fxot@1%sgiAy1gae1CFhN(@O!MyBGEcP=I1 zfuG>^JWxhp?LKo*vTIUOMKzS)?Lnlf(@?`q=H*Munc8&;@&y(WitGdTWh7vfQ4XCA zZq=lB6Y0qy^B216{>$sBwAN>H(%IhQTOoss@>v-8Ib7}|njFNr@~IaIpZxJUM*HI( zwZ2;8A=!o=WcycB!oF2v)oJC2T{l&A)z4K|62Ys=3vq#YJ_;B6+mX|@Xa8iFl{0>l z+)4fY=5yE(vknbr*Y{M@>GB$1UFD5@uth>$zdU+2lD#@vYCV}va`B^6+2rnmvFWQL z(_I-|dHB7IfLZD>lAJ%SqbfWFDDV&av1QiI7`p5D`7MW#-DXj!bWmG=rM!o>1|B&# z&{);`%(U6~=6>OYAy8+pY%axVrR}t{m^!|b8XY*k^&w#E?6H}dv!UeZXKH=^NXM~n zRew6ct+NMvu@}S=(@kYsY@Za^4$g=r$_wLllAvZIi7m|>6%Ie9#2lU2wE)Z(L25~E zOU-L`*DC=N%a2C)*X6*f)kpjY2S>c>yJw;L6T+ArZyQ4F6M!4sKdLOrasHajjT;eM z#F#;xWnw*Yy*YKG7EC^SBS=h8i9W5g(-6K!*b$n2)nbFRt&cD@9jLI!_YcGgUS>Z= z3@AL{M`Qcz@?aVXrF**F+{pRu$gp0w(dUO$9KNAt>-A(zVgF8em~hS)QM0X8SR zHwUg|3&^9{M>&2!tw4;vkr7aC&W{n|*5BCJm__1MsgHdLQ{_GN-jw%zO450$?vH#g z9WV*v;Dt)Bg}5ova!)uWO~iT_banaxOre06p`UiK&PjlNeLkfqET40TZ(DOyd|N#zj#$ zs@OnpAlLCnjPHzn2L9IqGDc+^D*+Z%ln!0QKy`;3<(mA|6FM)Y?YIP71F4Z$-zSaV z*h#0O`BtzAHuzqOm4@ifO~7e&;gz~>pXzqs1;^N2TN^z!YaH+wAnX?_$-&}St{eeU zlCMQ9-yeZABm#)#@Ed>~4~^EvsP%a#TrKYtok&X%WVAHw<zeML)5xpND z6^MSO0*~R}j(Rwu>uoz#>E`=10G8WX2vjd@ug}E7JBuacMkFJ@JRct{5-`gFGg_11%`0)*Nw_M^klBj4~PN;`v>^+jvQO|e$o>H zB9!K2&L`ue$%FBO{X-t@KP|^(DuWW%=gmy3&vd3JNCL`=ao5?O_DKh#q2t8`1*RVd zin7_@YE5$VN_MelcpM$2zT$OzeY$3)pK{@Pjli4$y71MA?Mtc7gmo4jqeyO?di zj^)}vUPw<;`1R*He~o9zpipB6l-+Aq)!tX3EDYwlxHc)z@rm|%3Cmczwpn?$Z*!@W zUHR7D;~Hx2?!={_cH4|brRvD^*wuortW&yyWd3prlP~czuE9TK9SfpmP}|Ib^w*5R z4Xh-SI*C}T0yAVlb#87|K^s`#i3^e6pY6ED6>IyC{b{gIF8(3{c;jcE^cARks#QH2 z!XEC!fpMpnpQNOxg^QqU#dVYO?Dt~d`Oc%ueAg%Nw!Q1WC0UtOK@ln;b1dX59IRzYy65+ z{pkl8jo{Ai5>=Jf#@$~H)_9i@@27J*b>{j5qI0UM!JF!et!aMu#{K4BjRf7pof0XY z)3>zpkbw7lXPg3&mV7%d;9|k4zINF4xDQIO8S>g}1t``4Bzn4r;s=)6WV%-N-5NoTUGe4L7Y;G4A!)sZofCC3u22uXE z;tu>hOqT6X6``W0tUT(%cwhNo!wvQaoKFGB&p9zGdCbRu_kH#U5Byg+0?3v9ue0OX zgZ5uz_HV|l^ewEoGOjY-1@66%9ebPtw%(*uuelRP1?vWhnwW#nC ze44i1%&NrcBx3^L(_!|Z3G_p9U4NY4*8aB1Ois-U0qV67Hw-8 zRoBv-J{}B=`9#Qu(ze${#|%@H+Ol%R99%dGoE}-Q`~K8`B?qWuVbR-Dn`%0c;OZce zpcf}v(B5&K|DutctZcTy4MDk-lg%Cnc;oS`n8XCsEzoqnr0%-mYn0A=8I;G%sau7c zzkg2o7Wh;1n;WYbdLbtllkLuLq7BpmJgFVb-T2EwWJvxxUI?K@2H||<69OIWNVHL9 zE#?XYs1#bNuyBNzROxn@uDW#v?igJHAp=OANioUE$#N&t!(O5sm~?#5+870?;5`xO zP2U`E^tYe+{y}Lr)}Xz^qk+`hx;IlBktAPI=Al*~Cva_{0JCoO1T&I@HV9cqfhW)a zRy?5K>V`;9sklZ3YTZS3U?{%v3OcM{_ZP7mYEd;mpp*tvh_H70H&sZzjNlFZfKti- z6vSLbBj|gY|C5=gm~p!1&j_8_TD2hEV04gPI1~b2Q@hu1mlL z@ajI_Gx=m1z_vOYV=73b1lC%AIYkk48k5#r+x??^TUcE|B@T<@uYgg2rT2BV)CpJ< z|0bWuLTV?Q|6w?W-Kh+i)3$2YQ5ZAiMAdmMnVC|*g=M0Ey#&Z)OIV#h0vS;7e`e5K zvpHh!-uK4lSw&1z5iU#C^@)L>^O)L&21gU!fVQ7Nf$C1j=Zdw}3AMC5fsC~N1SDO8 zrzlD@2jA8E%)@+6kvX2?{k{9J5wn$-|IYseFq4?cUKu()I9)7u{K6iS^gC zd7%3Dw2J?ksRE=gN}CIX8CEH}o`4R3enR(Y&sim#Fa_K}I=kU~Kx@r;)lX=nN%}=~ zqx)Ycj?LzKFU4C_FC`&!awoeQ=-&OJYOusdoJbUF+hwZ?64orG>o0SvAa@esBDOcstl8RnZmnidXZ%<56@{Os3R zXw`pjhyBNYt_E(uvHuV9y!(CpFaHD3;{6|r5dVKW0r?*XANfCns~JsDd|`dn&Rxs< zsV!DCpZ^iinEUtMOMd&XFD7YkCW1a22l}pLbt$Q$TUC^7@!|>6yS1s-6)F9>7tzI? z^91qnH?ZAq+7Ou(F7X{=#dPXswkWI(xCV$@FX8W@K`)TlfKAg&^nnlbc|bEWV~>s|Dysv6R{gHUEex12LqM_-LKj|4VXoK_}5OG&b}mK%^%f^YN|AW zTUSmqVC8UMTV|!#rPyMv_if|Hm}(aO>gi?EF%JG=;RSK8IUsIK{tb zuI!nVx@r(_Gx|Q;_w;K30~xIB%!pU2NC*79k%GDL=xrB^-ar0iclYU80MCdVERZiK z2E%po`sL(us>+1L#l;;_Md*UL4+4$#xwJ1f58>A7DRK%jr0e1^X;mv24A6l|9AW9e zG{^LrO+S6&~9(4thlZ=%)kjy$Hk)MF$Hu=N|{hvUk?UR zx1RqHkw@w@t+~l@z8a!ktP6u#pBGC^GwsW>`!OTch5*};`nYDlYPH&o_rLRX*{yk; zDtle#LhLpsc5~vO^`7VajP?Ff+f)iZ#SfossO(Hkq-)#d)dtb}PtT_;pWY}aE^-my zgSI};8|>_O{Z=kXO3AT~336=QRHniWke3VlJr}@#z-&ggmXfL6G1KaEXCbrFr<`>(;(Bp_4Wi3w`Ftgtstsa*}>b?-<6 z+w@zvAu7Tn!qjjp<0&aA6)z^g0Z5o@1k}KQ@H8YwNT+?OIlNl&FlDr^d#=Ag0*GZC;bM0S$)V%W>hGv>hz{J5wgH48Lcuhp zEB*`|cvd`POJ6-`Fo8-h0d7)5G7RV|3tZjuU}8cWKvEK@qr6kSrI0jQwIQODcHaR*JwR009<*cH62WWyPi+@gBA{5C=CL57XtCg*>oxdV z7Mv0Dn>LTAC`Vdv0pRGVIznK{P_vGv1L!s}{WK>)DKEXG%cTUQR-(FGOb;j0(hJ;dnH_ z?n_|!85+fJfVE4;M|^Qfm#~xy(|%=fa3nN(uJ8nEeqo^x7sULVPvCqJnDQ5zYleOc z1O0XnVHP|FP`?{qB75Snt|>9g(wiLQ%3O4g!M4{zynw|c3!@k#Ow~E&V77q;x!-FU zNGYcE=|N-aX60cI;0fJxBi47eH&YEpU10^_gxI>qOh9^NM#t69V0^QxdNz#`U>^zE z+Zw3i3ix@L-V>@GJA~WYm|famewwW1r;re)TD43 zn0s$+t#;KiL5AUX{thIk30340sHu(6ju#US#Kec3njes9Iy#u=UESUexhU^!qP|%c zHT#-F;yaz3k>QG@rU28O=54u03t}p;@(x}=$##1>`)K*;%X<8n-?hU>bBy5zAyG_l zRp9n`XA)NNY`bWR{)DVdU(05f0oPJ&E*)x5xa@gp7-#OWamY;HpyHOePM@@If0OSb zjoB7M)BTRnX?y)Bs>&4IV!K-DNXN%$xDQoa?bV+E5nR*O7X}8cApqmbTwvREp}4x+ z2nvS)dhZqsglbnH&`D179#>NH6I0mxgWWYi)IIaF+&Z|5KmD>rvU~sMA)5@qu9MS~ zlb#^L6P=u-UG;_3)y23Xm4(7dl;lr@YZ`UeF)Yz12~3is<=Q=g#%(aY;|4MnXW?tS zoEE1#H2BFzxBO>%r{Da@?j%}mt?*b>cf%;WysxV5Wyqt1h^IjK=jh~w`kMem1y<#x zU;Jp#DS>iGa%MX2Df93^k1T^;Zv47tvPn=R&}*J)}w$Zc6+dk#oGj3>xkv!5$tH0L)i5C+qWm z{8}#%+XUJhT=ZM4@|}qfN370Ky0pMskJUH2tVrod%*b+|mfc@c^|lUk@X`88O+t#N zUHQ!3dmL4ej>GQ>C#1U}TzJ)l&pv{Y?Vkd)zEs8pwU>|9#VB9O45h9ZgOV~D$l~<= zV-qRWfm<+oP~M*Cg^B*uN!MWoLFI)~KDRGMIsPA=|N0xSF}V(?@@c}Qeez`aHrh|A zOl6*$>-&gC+^`#5f16a7uf4rk=DDfp^3;ncK8G=v(%0^-Q`F(OV6)uso22G>=e(HH zBWp(;-xrN_2j?0HE+dm&J9eRJJ307oj*dxN&bjIeQq#Ge_zHwyUcr!;(ytYM#GdH?;LRm!V=I}_iW8@RCVw@o4*1(t-?8XuI&oeGx{rNffH+d7;<*QAS)RDR z&7WETndz{2-hmPeQJRBy%2Z2om0aNjSsymOFX<%@kY)G#{a^9e|1t5{zbrKNU;i&s zvi~1g8c((R%xcZkvL=!@*)YY+2mr5uCMQp249em&l7BlZ*o^?cZ*SrvCOqL%OZtKD z{2pU)!QRpu2F1Bsu{*%V!9VcGFyG-w1%;p_s|?0wz;AFY>G2zDUjQa<+0OmhPfTL6zW`sHmQdIC zetmrIn*9DZfjcLLKUP*=>sxNi3N68l$3PLLc$(c{A-*#Yx6KHkty@#)8eQAY6dRM? z#Sb^Pz!a#`1Dez&@4cqT&HOH0L>b2b5L zeJ5J?SmPQL{o%x&ueY85@$Haxv{8SUR48oH!9gQfx=pNa|4v`_Rh%IggGI8QXdW&$ z;!5Kz)!?WYI2z9V;sF!MBmTR<`#*k36=a__pq@VNT%LaiQn>xE@1FdW<95@W_AWm` zc0sphSxLzy^=F+zf3_<~rYJXHMxB0S6SsGUhh)XU@T5H*{p*(4yF=d&qYiW+XK;v< z%$m>tX!iVJvO6OpR)ge`jx%m8piIj~Pb_S$PS?!FLrdMJ?{Byn8lDsI`FW7&MS#yw zfBmCgF5*61>%OH)9HC^qsR(!YLFe!H0+qU+Q4_1TG@AOvaaVWD|`gEbOP)+(ZtJ3aQe>(gus|s;2 zjLt-z;qUvo|DDkjAoG0t*q2Di^a2S~I2$fE;pidku)IA(-I4E*MLE7;aSBcMx z{BAx$^)}t=D$N|^J6#M?!0Xyn!I;4 zE`ENk7LaU9Q5fHLN5o(Cv{F7*Q149+YFL%OtzevFjO47h=JBlU7Q5=&utD+4(zR+kk*4kB=={5>d9AK$2%lTYez*y(e3Djy~^ak-tL)zsAHESpcODFOll zPHli)wKajD?pQn?*Wb^7f;eD`oM&k?sHD1DPVcC&ka+Ff_1C@UYO+(>l0hhhrPBIB zEQZ_a?qHCMU}ug7f!p}~u~KD_vj2gs=(C!N@2WNXVVWp;*+)Wr_o^% z2PdGP91VfBcly3%oq`wS7YqTJFQ--GhQPMluD5J%XRRS$k=#J<*E$~5kYlPc-lO+$ z-B7Eco+R=vu9NcCx#@206si@A(e!jP#i`4|0Rpq@o~r_%gROR^DuXF75@IPqBKW&xq)nG<;T ztA40@vq^L|^Up9a4ss`%FVvz%^WhyG+^dc9hyt&Sz_yO`t3~}vT3Qi1Zx?Qwy}sR! z__ji#Lsx*B5rX2_9zCx48g@-XjvLWxozo5_Ur0!hf&#}-SWKN9G@euHeNUdKDh9nz z1H^aXF!SZZ6AJea)NWgHPFe7BbQA1W-}=_*)_og-pp}5P4d;ce!=)$R(BmY$gg3S$ z=A=00<|jYK_kC)vS&bXk+j2(F0%M!#*`j`NwQaSf1cHP>6$BdVowT%*Q=!HloJu#Be$Tp;f*XNMT?*b+& zlpn5LORBPd99WL9^ddTY>X{F^NW!g()Gn6|M{%=c$W9Om^Q6-0gaVJaU;s-mPI5%V zg#iQkk!1v-3W{VD$MPteAOPMQWl zq?TbaN?y5NCH0(|>ggPsOvY8ure$rOR2iG%_g)327}b1ZkS|}9>c(~bRqHYmQacCz zh@C}RT4rv}QcPGhzM)rMMW^UTaR^M#5&g>7ERkx`)^)RJ(A6a0!i$X*vv_oJhMWcd=S*FOUax=!^7o^=gI*JmRgP%8|REV=a%g^ZXRw)X7f}K z1_M6{%?N7wOWzf84>)zTK~+^%^BelZ!v$j;Ws_o&4l(s6xGTYD$jx*I{MJV&71pm` z8rM4gE(4QI+<>2lVKz;-xfoKH2FzLWo0`5%pU)hpsD&oCK{vBSzdQzHA4*RsXEns7 zz46vMon+pv5eqFZl*l*$JARm4Y_``>iHfo+0?qaP;1x{8!Ri{Ql@9*{-y1YS*Bia% z*EdAgRo?LI2qR5w*kCACs>U;kcb?L#I38*xU5uDvg_?mtKq--mhfDTvetDo?eYd){ zT=h{lVnE~Vaeh1AZXSC@Q6E>RT&@V!1>OxVDI=p&iipk?&+Gfz<{3ylNjzy^qtY7Q zKz{%(Pwjd@sxc$-B+if*Zee1aJiC3orC~udb7}RySeTSbTrsah*Gc$Al89`C!F%rL$>p;Y6hlA16YK=b^f*WS<}tEntC-CLY?_T*I+gJij+6LZY;0wBl7=1ihb$qDI8$4gZ$w0mLa!Pf7dLt^o`j5tcb+LMDhd`Ngr+0_mzO^= zZpj}q$nb#@#{LFXvTy5eahR0OPlQX84l@Xgc&7+uODExDlgt~ z^MmqOr!4f;Yy9FHqx^43fX~ThlhGjL>n{lbVPj)reeY|rsSK7;wh(jYgeVx_t0021 zL){T%@3Z<*U6pY0yjlJiIF21}76e?*eEyl4nUN#~{)kD2UR@tqR_t-k`USIPvoyW$ z7l1=z+`{>?;$qRQQ6Ri@RK}5+D*Nnv2o~5n1XrP zKx((N)UzLn;ykl&T#whz^zlBO$u7@SFW!ao(i5#blJ@)jxscc*)Ig;+oF8en4l&+8}U=IX2;&YnCg{gJmEl8Pa`r8zD}UG`>WY zo@jzIdlgw$t9dLa%6j$3ktPNKL6*cyimkfNC}RV;JmU<(qew|o<_i6+DlaZ0Agpum zhn$zMafB5%RA%1t{eR8aiF=I{#aJUH7120ciAUtKAUf5fil82L=K^@Yu!F**m5lLt zV5;4hj7i7#d7zFG(?v1?JEs4ao)LkL_&li~VsTzr8CIH+d?q?Z*2-Z0_3G1Px4_`J zpF7y2H#@>54ug>T5vR9@Ct<@+-CC0W{rn9W&{7vg+$G`i3Mh_(}o3q<$dnWYq5!+`4*K$Z8mczt= z56Yh6@2m>v?Ob({Y}1hSTNTp7SuvzR8?IM=Ro<0?e-nf z>$KE!LYg=4LkGG>gnpPj*mN3TF)NpBxDI-VemESqL#PV80l$8kZ+aZ(09p0j>ht`s zh0V=qV5@7~EOwiLWetOvEV~{oPoLF&ER-12PS^7R6$QSK%}rgP(+l*zcK@8dOl2^* z$P6;S(`vQF`@84!1Pu7TOUcSQ%MoGgeTIcy_IW*;&H^gD_=JQ29NRXKRediyR&4$1 z69wK6yd2WxABv{-eB364+WWXxmZO{SWQ^M9HQ%z)$stW%&`xS3SdrEWE4-|g*q;8F zB(NarQ-&JAUTsYc!tn6$+==tp)D)20!GET2+^nsns#=`-40I2ROG`-z{bMdIoGmRa zg{7n-eyaqBg;kpIv$L!JQ86hgDFt0!xJpV&r%ZB&hWUU0pE+a6rwey+&6*t?3W|h{ z4ULM5s)lRK!2Nxrkq)hTP2<~0RU09#42%mOPnT4B)7_S`YL+!{wkRS^Yn~q1aO+S3T+K#hRkHQ4miRM=3t>s%$5;cVv z`-^=G)}Q>jGh}=zR;gYeKcDR$ZFjVy1diF-@P*(jb2|y8-ncfUF#KC>YaRHw_a~z5 zyXqV4h_2=GH1^kvW}+gwjoq0!F;!jSgqC;r%^H9_(I11c)}W~8Z6_nf&hY%<=ky^D z{Odbmbs2Z4s&H;rcL64cb+xcj)bRb;6{%5ZuySs(OrM{p>cxw(iU*DU#N{hD3?ybY z(!Fe;L_25xzD=8nqL`@Y5^U8_@qBmzZH^44`h0uni#vCkJ%IvAO0cq?$Ga#?gFfAm z-Q!YwE>1>3L(bv$0QAtg|qTx?;xa3C)#;6y5`h`PuR_u zTK@0I@(-K-a_il#MO#ae>}I{&)GzLQi^RIn!=SOK6A?Z9`D z)7Ia*vOr7i)!?S>1WQKeT;R*2z}gs1qyJ=vKkMK>*S_kx$uT^$_F@XVyn=OXBAJ>H9n2~$+w{*Ks=3qEQdknqQZ1LbRP;kAu65D;khBirh=0esuetW@L9WFK{!ZTEhMHy zQidn)x7M{p|88&tFPp`Ig(@6?dCykWUy3|s1g8Dar`kbq>8Bqa=VWEX*hEZ83cV7H z3vQYlr?uE{wald?dAlHoI$uWE3+2)|udWg7W|ed$rh|U;efVeO^&a$sC9-6^nk}UXOf{fZy-;>;yL7_(pXx9gDaeLny#$f>4QvK*>~r{S zME)R8;-+%>jZ)QhsG!+n$$!8}N+Rl$X?|xqM z*G)ZU96&Y3-pg&{)$w5jG@>b#$a~+d!Om7sqdI)GH*$6I@hArA?(Yb`)-i1A1?E#8 z{f-wvjqyi?9NO9+)#{i?|KV6GtI>&uYpZ@)DPdcUMUh2UX4zQy!_-O6f!@tE7=NGm zJ{^Z3xU<_if)iV6t?fdSg}<7)Kw66+w_yJ+oscxdeEI(7zRJD|7xgrgx#{AET2!~o zM2kvl?LPAarj=AbH?92Vk#ny3Zz-Jt&=m)dKf6SCg84V&HCeZP)E?2Skzyiq>} zA*+T&zeDY>C8vbuswEgMC&p*LbfLnuH=K zIyhIj5=ud~Bf_+4!8R>|>j&AN`~CqrBCq8?StB)+UEU9^qCc#ni#vOO5@pOz=Yh`+XBAh_Z8wRIdfTI!j%8f;D%y7z~qcaJ0?eLVq2f9bRpELV4fAM zTFicJ&=8>wdfozK_f>|%s2@T~5+R@?@0jh8wLvmOf=^cLdF^H4>)Cn(!AoEhr8Kli z_(~*aCzi{-crwR&0=El4eb;XuPP-A&15uEA&to2>81Ds?VNk0>AzZI#g(q*ou{-mX z3@7Uz&r=>O#XiI2K5~El1Ow2#@GMO4poU>zzryT{6enJQ<*CFPd1GB#Qo2{JVK6Yr zTr9=xsD$A-03NVci&*fpaX6}k@ypBn-2K2>G+O)3@2i)y;y)d%l+W|~qy>CFGu5iy z)SS2ATBVg%>@>eSpj-Q8sjq;d_-5&*S9*960ghuZ3pYw~8}?mo_m2rFc}34_%>h?> zoQhRj^)d*e*5W|Cs2&wJ^Kyn`@gm-Morq@43#_a0UG*&Le5(id`k-QU{=DJ|3>{UX zP`&9}UngZnMT>K%R{D(?2KK5c>YoW*>M&;qIWF9xdp|}O-H%QT_Kr1Z#Ro2uC_VN} zvbmK4ln>FmdB91qXEOa;P&r>O(5*dg_`H=IK*i>Y$mroRKgBr4rQEZkNPVH92ohJt zr5fswp-4{TM^CbQq3gMya?*TTGPrK-eMO$-^J2Joo;OR^_5GXz&>!fpez6zinx%2; z2Adx55jk-wsw4 z295MezN8~kRREgFRg3QNW4&7I)$KMD37gWxWW(XK-ExjiJ@yCoViXi_Ue7uq`0)cD z$f&MX?~z7{EYIe1($|E`l~uDObvGxD6x-5b;$;7MBB_DVLYVkyq?m-;jGnpSCnLM1K;g9k zE2~<8B$xcvc?Wx;(S&X2i0WsN>(aH3XR_DB6ThD^MJb#pc_6Tf31ztCBiv_}Zi>oU zv!A`N+d+{NlLLk_V1buN@*c>J3(BL!qn8KK^Wuf)L`_|?82$O6TNvO z&YD>@vx*u6c@CNX%Va6X9Y?LYxeP%@$g0liuK&}0Tb{XT0{z?Po{W=QP1OZZ8o;vf ztLyA~K)gUzF3xd>Td1nL%&&cNkmzq@J>YC8Yj7ASjQ6d>k@1WY+V?=#<+Nu!I>!MqE897kV=amH4Xp*=DYP!O zLzBUTRzUa@kISf&l~cq z4YElx&i?|WDqI{zu1@)kf|%6_hW>qB`t?`DZT)MZdr7hzQg-kG)h$vg7nYei&F9Qh zqo${0X}!XJLkk;Wmu(43o>zpadW2xw?5MseIG4=93f#wAVsPvN-(1w7&=0II0L2qK z`tq9>U>RL~mf&%REOlWxuj%J?Q^8nSOH2HOH;f^#l;UFEwFl&nX_ca-nlS> zI;qweyw#{pw_1!@bdw#No!;y84yWm_mqt;IR^9e48N97IRWGp{^7=a)=q3x;bGKd{ z0xB!hBQh$pzjaSgZf8!IPCIUwvf>@{#~$L%?n$?v#~mkbTy=e)`ERz} zQU7k70orOAS@U^|d0adg6L;u9mkSz$fqX<*v4yp-L#3((CEZvh%YrhGqp6~US-R`X z3$dRX(TN-~!tiJho3Xw6U-{W4}%qs*GP=+`z0zn5h1MX81MNOxHW>u6JtFe z0AlIp?^TNnaB}nK@YW7FyiECB%_C?rys!04UoBf~#SNp+D;2-T6`Im3b=Vn=L3+?B znXcqw)AD<(n1*jQUM%+okSJ>1%{y(y;p@k>dEmL!T(hF1P;J%a^30(LPz9AxKrzOB z`k~2IcG9MQ(Bsve{agGyw)L22ilBMjNLga4*S5AYoh+RC=&PrRnRICl(qVm-*ShPr zaN2eo$>{U;4W3yyW)Fw_o2(W`?j_xZ#7a;Vk6qqNoGs`#t?k%?gv~Ap{oGsUE)SAw zY%<-XtY9}3_6gUd!#i4qhN+uw(++P91(dt{FAX>5$-wZ!+-2_9{oG``RVRdY6omRq z2C7y!KU_jR5p?WI!TLhz#E2^RqREr(;0;BgN2R^w$?_=3Iiw$HnAG^Kt<4k&Y zo-S{A0%}~QfssEC1WQn}yxAtv>^Vh2c5OitI1Y-Xv6N)4}IY=ES*54x?=Enr~LT7R!eKO$9Kqm4IM19QBg2!`@PtBk~>K=w7_F^DeVI ze>a0NvYkax`}C)*5lA_6!aE_)_K|HiuzZ*~B1TOpy*kLRS!m);JPOVhrm%_#%t47r ziL6*G7_#{%xPEy1m6B_gY3!vj^uX*|<>%Eh9;26Qfe4{AvWst-zy5 zzOrSrzVtQ}hX|~6Oe-<(x<)doFaR)+gm827zgfiao3Rp{`pCh(x%gDF@Vn!BtMylc zpm<=$UKNK?P?opbth5)5yXWbtA1YLMRJt3n6a z9o&Mc4{tB)`284%0-gNTkC38TUY*ou=?;-QQaaMG%wU^s;nLh!$FIje3*$!@Ixfs* zz?_XEB^1MSvw1m#NR~R+noO*iqBSWo=*(+IvXl0Bqp5m~c#!|6m`jXPRCo!YiGD{* zW@if%q{=TY$9o-)yH-wpg~0OPt@4Q0j75{r^?Nn5>wR{@bVep&&Wdvspzp~aY z=33vOfJ^^c-I$X+dPK*DZ;4vuwrjmvNnr78O6HmMubo(WTiymj4Z?qAm%7@ld==HP zBB2Fg=Oh*>fQ1#Z@5{iJ&KR{#vz^mTdBldNVYDz^q=t&wGnxwy6O_*i#GQyp90bjp z2BEQX_=TH)F%Yxd*Mmp7Wg_XTAK~unRVqSJb zd0erFi+KdGdQaP76TR_!r3a`_5bVoFY7=*daLVUWQz?p;*RC2RqQ0PD{+8AT@o)v9 zq-)6KK0A|^>i|ur2jNMyw<=pbVUIJr!Z;zW{UJl?*l9IYw%y^dFbAc!4Jy75&7-97 znZI)rhc{4F;SXcNg9kyvwh+SLl!@ueNy8oGh=~i8glEp>^LDh1EM`V~dhG-+U~v+X z@q*M^tNH>V_7iGkQ}!C3-TcLQfi)!5Oc>Lup$5C1h_Lr3@OQ`6wCiIr3Z~I6EWq{~ z=%X!XM7LT`Oo|XI?|3?%#QfY`ph8sYepE#z5=KI($H}>5Y*X3R+q!oxB02VTO&+F) z=PR{=q?mS6-p;T>FgO*8R&&_e9Xt*S$*AKC{;H!7N%5A*81(L zslbXWMJ5IE8JG$k;mH;EO~4a!1;ApmDZYLpbw70JvdZ zMV&7eNaY6X>^S4sR!`dK_BsA~yiVONLhft`P!t-L;)ZyZ%Tl^jTc zuT&N{({Ne1IaxXX=C=HphH7`{nF`jUTLz@Nsp~8_QKC6#`DB0<%Q6s14iQNod%hzJh~9%`ZJyu?0Q1Q(&R)_5w2`F zeGB&nl^s4!OR(>X`Y^iwbObMvA4H4tSIuxgwOBgeh&1>zI|#cXbF~PO@iYm6N4!4M zOUN3IsTzYjsVtnW2Q7ZL8IsRHI@RWAB33Fmtde@;QQ9;ASSj?PGvbK~F8SzqnS$w% z--D-Sqh6~w?NZ7>G+O`NmDZ=VX=Ap7nFQCaD!H+B`$R^OY?8%IL@I4Vt;1P28#A!| zT1eyvd_n7_T=D1*hx3Fm6SPBZ7Xtwk%l2m4b8K|1AZ{nd*C zPS;TW>=guK_I39R5F8;Mn)<`@%Wz&CF3G{4 zb{rrul(lv?;wx&4VLQA!V7y6xd70~H1Lk*=4z;{|jZ3c^H%+@GX^OoZ0Z8uyQq2&l z(WQro+aoXlc)P=84HU(3x3sJ#>g4MoU=;hD1g?s*Bt`lBs~__I<&LcQ6y{HzCLIm% z@h%0man?5fffu3b%ERi4C94Z1A;@U`L-3dLw;A1PcGPG&@+KN6RHNU7LlVKn!P7F~ z;h`LHJtRM@9t!S)C>#jga2~$Wi7ZxJn)E|7I*7&M@AJ)^@aaplf^y2(q?xTc1!^Ih z$dJm~B+NmaAmKtDQihw8CP-guW75PH81CbrdGFD6H6Jm(zCAwf_Z#el8EpFq__iPM z@&2~Nf9QUsznW)xI&1dZ`{=%dc)u4zo8W;|7hRHaHvEJ=&Hm+~QCN?^bMQ}4G zI}`?upO+swOI!)Q*^(f(;G(R4B27Lo7c=!^`h$3Y0eEv@td<8;kJqsqlK@`0 z7+R*Q&4ATowTN#H`nK(})7J7)*9lL)zei0+_5Q5hcUO{#Pm~&FpO>MB5)QxE}a+ zHq5&PtKSC`Sn&j2rge222$3Blun}#{4-_YOEEV5|@o}|23~*-{gmUrAKF9mCBGfer zFX}>@$lxI~2j`O#;z^;Rn_P66wYkrmdILL3Hw-|2eZ{+hA1%XvFGgGTX*9XM&3=#5 zqzs5`y-wyGRZL7J-yW$wop$F9lIy5UN)^m4Hd|AhcpQ&_Idi3@fH5g1Q=ZrcuA%Y4iz;U@QFW1Msf-@IQ_`}E+uG#g}W2WPJ!ye2y2oD3;G&vRGN`y9)o-c%WJ*@a6qnUu{Oby0Mokd1@kL9`hcUjgk zpp~IqX**^D;$7i3WE-!wrnbiLfvse7P{XSjSK+n{6~#y*+tJH5gCkK(?Ki%gdn+bI z=+pr1wr*-D&}LJ*V;yE)^! z-K1?DIQi=jk_i?jTd)H7~HvHJ#l0JW8*g`Oei@? zNOFbofk?6Ia0JS}Z+1Q5$E&YsfcG0e_x(nZGRd6aD>4jXIzFtE2^x8gC!`p3ghSF5 zqoC@oK-Vw`^hU>>0$#GDY$v1`!De$_kI&DS8hg7hUiEIk>%)4?NZ5Pc3A~&3(7N7F zJ-c3SCf!elkFO^xKSnk-5cV34S)}3o^{AfU%FRV#=D>)?=fZ|fgx$f&wcQHcj{)xQ zc^^ZQcGi8rHQr;IYtILE9*1`0eW<@q;e@HlB=2Xo^&le2A8;U;A)e0(;e3hQUE>rb zCnKh3LXNn0kPJr27?dy`*N{?$mbY z25zvs_yBDY9u)_8_Fl}u^rVAli8iHn7HlmPTLQvp2vNi>m(i9!CBi*G>)A+ zkxk#@+N<3tg1zT%$TO9hOR_RzY^6IT!Jo>a3fd7m^w5I@-;ae`0T!Dtw|RRbR<*-6 z93RjEeqS*z1Y99v!?yf!j;H%-k0p$R;dow)kR=iJIy*D_3SZ&P*$dYV1INw5qv_1q zS_YQt8|piOxm?B&I`qxD=FgKmG=n`IGu7(6(~+>sox4f#(iezdU{vvc?6fb(HSwR+ zB)*gn!&qMZl+q4)cIv9APRXG;>rGziT#+6QeUFQvFoE!JC803!8TY)!MU~dBmxRsV zlhihs+TA-5eCxB>cSy+TbUD9#xvaf>cAJnJkejt>retcuhY3HkYNI}$6OwG&5IMHMIsc!YYCex1`#oc;T^ zQe#yh8*VGc5241qe!}z%C%H|Tp58)T*ox!sN?>x@x9;i-GVu#49B#@H zA5Vecz{*82+ale@%muq0B^K>BKMW>z-Q$kqEY#_(xcMbim>k~G&xtk^{Q*@R7Uf4$ z9p$%fR!ueTu)JL^Fl!pjU(-w9yLyAg`C=NEmAaqL(A@`gXlgH~ zu7_WKRW$;w$d+x8Ize&ri*xWO83~avVtbqBAg~INsN6TrR)=${sJk4vz|BIdPUHOJ z(^`;mK)C79s3$X{Q%@{Ob-jbJ^NC)CyPvn8Yl(&tRCP+wE zE4v4wAR}==WT+hPdzWN081(2;0Wf|JKrA}!ErH9*IE1Lu9;sUqyWoz}QFBE54D zPom!T)h$Wsj15IoXTHJvtEgJ5-9W4#&^#_@S-PvQ zFaBC`8ULD5nqWaFO)n!5!`n^U{AUICigj8S7Qv2gw{FYdKU9_tQ)K<$2I4Ko_l{W9&j&ZDN}Jy`W`IX7}2FV5K|$N*=VOr^DAutu%ge z>oAXFyW>-GpGk9CofYBOi?r66&C|Y(M*|e6;M?I8=4v;KC(h>h;|)8zrb3rZp3QPk z3fAMdhqP9Qj&~LFD-Ruy(BXyqg4(@|CP;t`=j5MNlm+F^YI&&39225@VV7&VMud;S zzI)^+h=W!f$8nGV3?QDI^hM(6JU2nq`Z*e}ZnJ059>C-VKF>0FlbR>?l`|B3H5hon zU>~p?G=?rzEY0YZNQHDeU#{T6ly|^#wWzha=v*@x#U68tEf}B1q)^pJy@vZZ|3lc#xBDOW`jBkBO3_sKxO|J_SVTKHy1a&f3EB>vnBH*b{R#B4elKNK z6xC37Lphz1+I46nSZq1VsXv|6z>}FjxdjN>I2>~IHYr}?vW!jNzKmJ@sjE{RczS3x zC~Q%F?bTkRI{Rf2U9cUi)cor_QC=uBI0@x!ItEc$r_cp1vN+qCp2NsQ%c}H}Z0lW3 zFYDZs)!x)gl5xMXuZQ@}v0)`jBY}Kxj1P5Sf#nj()}U} z6zr~>7P-!!?EAlR8^^PqRXAM zi>)rKsonb0RGXf7`=i+GU-ALg3LC{7LJ1VlQ_aT|p72q@42K1keTz7DFD4cs4~~d* zwH?I0MZofcvzB}pgxcBfxPS8nzM5m&$BD3ciPS3)sf{|6g)$eTFo!07BWqJt6!?>F zFY_Y}Ph2s|Jz%L_-}K?I1d~b?5e9p^EbipD2q3O@_axr)|JFuS5K>E&60fd- zBJJV%V6GCU*Yhmgv$!(3*yUQiiqpVZkG^@cl;IQ-23@bRfy~o;Qz2>I zc<&zGRVMSKT?^T=nfo%Yo2|pQV%iBuci8Fb+km#N7B*4hb)kpB(T8}|^kf8BFKGk6ezycJS)-NE?-qMtaG$Oq&O44R1HS23F@ZeyK;|VS~g_I9kUtxbz_w# z+pN~>bo6ifF2L^?AaLxNHXc^FkO0VZo~JVEh1&Qieme`YZMLm$v{bOWbhqm$OZ$^e zGHl%cj!5wNOt|fk>Td7Myr1R z*75hbDX$s3Y~9ZAA^cH%n99iWWq%NfV{u=H8#4I+jg_NQY(>Xi)JgwZoYkv9FLOJ| zsVXWe65_=HOd0%sACkn+|Bue$5}{w~G7>HZAj7~^)I4fZ+-%~|s4T@tnkXU9n~(m{ zQ2(V@Ymo$ym(wXrnhGt4erq8y(POy(D^S2gml)B9|K}uR_!z@q5aWLV*~ke7e~mcx2((;V+3{Cn=|+H;wH(FN}sna6Im=zD&te~ z&-5h0-bhiX<2fe$%gMrmzg`27=b`H6%<+8is3OD;az;exIh2AXHaItU3rq&z5Mn?e zi}0r91Ve9rRF=jL-kjNsf?Mc0-G!oqbP$4z2a|9zgZ2w?gHwMK1HoQ3{W~%-w({Tl z4^T;li_v@|HbFwY=qujcm+Y5n!roA_y0Ts;Mbs{^s1(u@gO-*r7P6ZeiN2$hm4*oH z#9XMbnqigJHnwo)2LIIrJ!hUgdO@XcFKX~_(n9}#(wb$CQGxt3!SPsO1+z0@>+`WK z=zXs0JATZNYFu;5(G&X-oQa*Er<++4605`XQuX1 zGj@(M{)w(Q$A1|;bihgqT2S9FnQa-y-V98HfXSOu-LBWY14V$0jQ`w$WLk7wZ}?k4EW1b@M5$O#$bIdzbwvyu71 zu@cS5fQeQ&B^AbFy?-L%gsk%iF%1lX4ZtNz4P_skgGZu;#N=2aWvGo9o7=yGB4lB; z+z>CJ;fpyXW1UB-AhVKTF>yzPW+rd=s$y6V_TzQdSmD}ch!TO@j4;cop|JCnLlLmO0dlN zV=D@IyBhbw^*8ilUpv^dZL1CyQ#%jAWnTnF$8$E~JAD{j2{@y>UmlEhE_89%I$=9o z3HoA94%bSj^!L5dfM<995ce@KBmS2@!lMKDO;AvZ78wiXBkPyx=2|Kv5+}Y|iF>Rg ze>prRUa{@FnF68=qJ;DHGc-RSD%km=2R#Uk6=uZD-&O|Oj(P<4Bf{|eb}o9+AAK%` zWmUHUbG)JR#(Lhyoh>Mqh^bbdyU=gPy1F9_1$F<-{438X+-B(<3Cv;AOR1p zLy*Qu7@HD*&5TZ8Q-um^*W;d3;j)%1qpp@XsV65*Z`Mr34$CGLtjr$Pw4_n;Go`@R z#+h%qo0RN1q4(a$;Mgy1-3q|@cM<DEdQXS}|e}#oR?Z09p z5TR;o0gVVV(zXjqY7tvBV<;Ga%qSUc!d6(~igG$ZA27p?Y=UwY?$Cn-0>hHfbmhn7 zbB$PMX-$gG>2(iwRxPMUCktO~-Z+W604fcY^VMI$m-Qy}CRRPa2jyYnb9VI9z|6XV zkk5l?@rgCG+e|qlP3yJbn(0*a>Rw8%i<~UanK6yk6Ma-X}PG zpDX>Uo(~Y-s~3r@tKV_gVS3A)N@l6<&{!Rx?vrMsec1$;d_N8Z4p(eLzn_reQgHl? za$7MvC#k%?D(W2#s?^wbL;L_iER0F?^wD<8`~99y=2>y&JVQtqN!pdnh}pe{wSSL1)O5N2tm{1QNNeEB zluFkLXVCFV)AsXp@@krZexUF~N^%v{2#ntz{qOYW$ABlV|7|E~jMU)tXti*8y-;aU z;@XxkVV_$HYwmi}3+?(f78l}CaiCvLmdeoB4oB;b7vmIFR->Oab^>+Y?-+Q0KWbdX z^}b@&ZrGf~5kf8=2*zR-U-}HVJlL z33$Vo75HL$yXz2UYkbhH^7NvAi5S@V&?YZyaB}uD)f7M-5#xvHi#JoXY=- zv0upOC#*$e)Rgdgu@|KGXNt93DOCQ6n6P2&s0=J@)1l5IH7z4{_QIM%@M%aAXBaKX zT=bZAmHmW7b`T{8n=wX$;9=bWVROZz`Tl|gS7rT7hMbwAWD5iuYjrT%Sn)rHhU=}C z$GKe^kjwa@zjv6_wcr%YbC#BuswOBwhewDNP6tQ-b}Y6CLT0n&9T_SiHnApWW*#M$ z8CjEFDkvX_E|Q2TvuWuoP-|rPs~!rSu>a#n-_-U&6EdMP^|M#~xcz+8-Hy+*6E|wm zsvDv*GLD(`T^50lX9)%x+F!mhWZhUqOAl4r5~PTG7yN6ksVoLu z*o`sP&M9l$lr%{k9{O5!v$+J8_C~ZhQ|0B+l73J}V4R}T71Pvr?!(*rnN`VXwDbV~ zyZSMUu|eQTWTB@P#Ork>LJgk+#qF`*Ow4HlOS~tpWxS3mEF=h6z zd7T&BQWLVmWTy3RR=QXqbKETN;I#738&jV%%KZJqEOY;Zq*<Ubzp+V@OsNZH;CTum!<~ChBV;Ql>L{{9lJM4IomGG+< zf>IaSS{{^zm~VNomVf)>&*uMo&)=_RwJt7Ss8-4J=J7rj-+6MLM^jHo%mcv(%sT92#qprgly>B?G9IQYchA6=clue&@hvcLa+ zt*m?h+!kF8=A*MBf9y%)5fEygT0F@>TbHTvg5zRNr<^2>N9t~i7VZ=J9aqh4eeZ|; zp6xGv_iTDt{3qL)^;`IH<;UKq3toN|Pq_Lg#i#GeDnVIDcHh~f3+Yy7L|kz1alBKx zc|vWZSz5dm<74sT%Ep!w4^M6J)9p_(5-@q|l;Sg|^-F;E7v1Fn(Pc8Ms#jO=&ud!H z8Si>-PUQ{_Tei!`UkGHCmpy*&V8FC^l7M-xR8Y~f1fL{{N6id#!)8htiWL^CKiU%- zDKUFp!z@_Lhlf zNza~;e!`{OOg8w^Vna>MCvQG3Z8^*`<8?rISfBnUuE3y3{?%98F1(Ofa&}(xk|`xG z`lmYw2Qd2nl3;m~qO7IGurb3iy3$aqsQ+LBZ%gv0N)BItw;%}t&CD4)CAR%idh#^< z@q?3UCfjE%yqr04!i0{Vo}3#@%7J&@H0Wt?T;7~yU}omxwz4QQJdbyUWsT6!YX1eR zZg!~c%fk?MEy7`XWDI9Cemu}Mt0Jn3HVjVr&yOODoh znHaox1GnT{_9a8dBA%q%#aKT#?B-wp0(klLa`A5mO5e_ZpKmL{?Fd$BVzki}t?v$P ipF>Je;J6>dfBBzcoYjGuUIJl}fj7L-C*EX87tgb5@9CpvYAAG;lPYXD>mm)by z@lRijj@ppLh?d%KUshk9R{eHYUB~%Ruresz=on2*&8Z`E8S?@I#fzhYR#?6UO|87A ziE;Dv^z12rNpIs@Qu^8t0?+M^3KCmejhEJ0ji#Sk&!(rn(0-)GeS?G$B=-8)sz9s- z{jUZR!W|Pl3-*6|{=M)lF9r$u_u7Bnj_<&qfc>w=zoAI~e+_-SV?H^>|IoIEU;}mzCdgdBETI1%YMr`r=Kqnqbqa4k z`(LtsHFBZi)VKqlD7>HlJFxxzf0nc*h?v3i-*Ib%HsII3^Q@pzvi~mI3H?9oyc_GZ z!uk(y2KbQmfUkYN)+RM5|7Bwa!hiVI&Q+=VUxuA41p!cB`_@S3OJ6_vI``d=|1dND z6!ZTRIp5dtG;#m-WEqau@oX0rLBo)dk?*1j0RTWsvewKW9uLpBbp~6}JA9Ky#Md3O z`rkxao~a>6f%thvI49QrEbC+^q~VgDoE~m&pBx;(6#Jpjh0)Q`>3%-;4i0Ny3dC2Rzsa96BWI!M#87&!tM1NCCGD=D?f|)w8*y{#HiAG#J zZ?Lgre_L3*lMK-0sjaK? ztmEUIO9E{FDE9k8MYOjY;x^r+VIOxbsN!Ut^YbWfdu6k>Y`g~t+f!uo`@f_2=W*TY z*a_u-q|1uK_>(v-L9>rtwM#zYqi{k{qHIHY3#6o_L0i?$z+27V%fZmxRldTpX} z07R)m4eMv<3rD$cZduezKm2U>0Ucv1e^a7W*kE~iIiAV~?(PB|J#uX1_sM<+^~5z- zMg_X(->t#LbDN3=>oLP7=Z&LG?9*ZX<(Sp|I|Vmi9xrhUG0VNt*9<**Cl@ue&` zua|1vxAEeqvd4z+INDQ=owDi#Jy%a)VHhes)rtD;DRB4?C3@#;)_-t#Fei7!p1)lZ z@)fo=`8}Pd)mXD-c6gtZ);RfU3TF!i{CR2lXm`l$eQF+n#vgYyX4v{=Ls!yKp2=Z@ z3di=Fkiob8)64aleT7_#FGr_;^YTz%klC#CA}j1>pErY?`2Hh;7Jv&$qR@@1*`wA_ zYGZ9}3)Q!E3Zo3{?3^?l#lP!Q{-!;1hYp^V|88EsZT#B_N5xjiHa7jb-3y~kom{jH zKfRn&>lc~Z>6d9@5@iVJ*eDmD;sRVA>$i$?o~Z;Y_8cQx|9UT;H|_1e_wek^=Y2d? zd3ijZE9!WBT>HJ-aLbFW!YS!g`0cle526;JJ>dDV!r0%ad8^?M?-Vf zsbcErD;t=>G>;EO6&7lH3>M`jte>7u8=MOjEJQoku^WjoM@?NoYHZTgO+(Tep!lM3 z+n!MG%j)ej?7J!-$;eq%4R$qc1SJETe*kB=IY(hbcC?OZ=V$U&E|sp}+$Oc9F&_a! ze|-oY{sR*k40sA$sMJi=H7m+Abaqe{bs*hhlk?M=h4`tP`Ht9^E;G`2Xt5-sM(q>4 z3<9+ENL^M^Q5%9|LShmrLZq1tF1^$w^=~7%Rxi#rElF40kL-^aF~6EGSV1UmI1l?e z)aLf*xIg3mN2?~)fgO6AEJD$qMy>Xq)Q$aK} zDJxzNZgdFDzWgxH-ud<^fGvDs{XtLm`wK(KK{Pr#Z2S^QxoUlKhGaeN5h^G?DWic#- z23>VksQy$ThZn7FVBi}IfX@~6mtNzXf8*ylW6|pMQD5>MLxk_;UTtCUceckpvRkxy zk$GmFwC9rXA2H4Jsa8&z0#x=vL(y;5h*?_C?%?*3L{SF|cGLBKUw#jPJ(b@TS)(5X zgF9w&xDa@ecLMKbh&p?9tN|!n*jvF>znPyK{wcR&Q;$y^tNK}q1P2G3+Z*!xQ5SzN zv2Io4b@}dza3U|`>UXWB?oqvb;NlRM+F^@lA6Xcf-!mpqlG5JtkEq-T8S?mH{Ya ztHH@OAmANFB!M3S)5KhwMqi-vgtn1MI#;80ZDW`Qf`@~XsOwI&t#k#&dQB4|K_wow zXiZ*4Wgyg#_mmpm7-uJ2Q}KY}fzNwtefL zd6pBGriR>p@=;u(GJ?r+xu7JXA;993t@Y->T!fzF`4?+LE&EKW^T5oOh>RBNTy0q` zx!v_Q4q@+KmG_+pph0ZrDGC0rm?I7G)X#CRy3&;v&|hs}5jL`&S}woHiT=`*_u{$p zKx9vGZm{fG-`JsEr$b%#UFw4MMI`NQ!h^hgJ`gx&bMT=w9=Eg7Id{Tl-MMos7s?VD zhKzs2s(X%Q5X)gClZVTYhdM#Mp1nfDwFI+5x->!dHb$Q(oToOYS~<#@W{DLE%9?6` zV-72SN8MPA4tL8okIj?SDbdBcX9jo8gZSGrh^W)5t9?({+=ST87-2dyT+X;T5US>> z#3FFtN1BL5UuknTp&>O+XdV=3z(xNcxSb*ZuV0`~d&_Sg!Sa;K`NKiF+&Y6K_2W2U zDqw(kp6B1uAxb6HbSp$E48Lonrt-dUcExxTIl@T#7IO;V&r*Q3P;@4;+6jYmT+KF8 zldD@%;xenPK=W+ZHeTM-F;*}%ay0eu@KE+pR#vt(*M3lZK=R1}Qth4C+5Rl~z``;# zIE=`&v$eAWAWTWo`ZLE}=Xo6$HyVw`(C59V&nY@9Dbi?Ps+a)cCKfEoP2H-J$;+0r z4D-5M(2a2~>oIrjt(JV0RZ;o;(N9X(mQsgJkdLjSvbH+^M_rSvvrU2uJAOa?y}tgz z&`^SKP;WA!HZQLS7M9wS9NFRiuhI7`17kxH$w@pn?y>6rQbCgGB#ulaY=cNmBV$9% zrS?CmsPWD|Zni01ZA;yG@i*N`L5Z&1j}e~=qJO~;o*X-TF0Ei@Lmd1;sIIJRY6`ZM zaxna;|I#_1=`>CgkM^|Up0us2YjQj?@(p%gPkEq`l!)lZa)p&7^)8G$f&UJgl!RrN z^$|&EQ|m9?$1J57O(`g{?f~BVUq64I+8k%y+U3#W^`qSDAKDFHU|iI=xLkB5Gm#4{ zp)#)hvWXo48?-|4A~*f0>0&f3EuqNN2@4CzcgWjGe_}?n5D_;o)}*`Q6t8DKeFsXWvbQG5zc@>WvvY%TXqta1kp7ca;Bs+O@)c1}u466);x z5=WZ@O0v{V@E_Yi0~|MQ?wRBiA|gWSBw!{H^4*;!k!GEHnXuu7R{Lbt>W-f3^Y@E4 z!2YQpC#1WR7RH+TSas5tmPwzs>*8WnIX?nVP8`e2Sy>p7>fW_f<~COUt|~Kkb_ojB zee>9BMXubqHAHv;VMc2tdyk-X|8VFifU-|A*mkUqo!;eIJ${G32E~LsVqt=q#RP1U zUbEK;Y_5WP(G`l8dleCsfyS|$0k+hg86jyJ)ah>2&wU@=;3}2wr}!_Bh2q=0Gu_et zxvmx?_KFuh!Ua#l?{gwtU9VnnvuD}4kCz;&yZho|HqfGTG%^tJaeqh2b>Buuy4U`0 z;}#(CVjn~Nl385rq@(2{$LBy3^G`13T){+jr>D9QNO{*^6E80$acyGr7w5Pb;3JisN!jOdpm}uVflv###Biw5xi7ylO=d@-4h`V1EmS6 zCgyjX@9Xp9uE|vc==Bdp?r)bx&C9B^1PzOXGqlk$FwXuC$X2Ke ze(4>1wv?1KWokpRp3<11G%GD)?CBb0dCNRhby}Y0v_kzi`^OA(4mq*XjHcz=!pZ#Z z{1y)~gC=Y zX}-+8s||be*32jRnakY6AD)Jikl4Gp{I&$v`pj|u<)drU4w74s#4yuZ(81-y z>s|Fbn?^gDJ^XpyNt%SheylMQyc> zH!$ZrBzd}}c>6^SYi*Xb*?spYP9T;X@BMf5Jc_hAM^UE`bjl!D&jP7D*;?d0s@^7ptw zs%eZvGMPcl1Q+7~S4Z{0Vo_SKW9N?VCR5E}@!H)>y0djSw2Bi=zT(gMPX)t0crMy1 z{$+i2#k8m-2O|hm8Frg@G(_We?p+6qes}js?eq7;P2Xl{5Rc$zGvkgL!TdJQ{#o~u zLaDpkiBh0F^9VC@X=$l}4!luS68>ji2hHVx`Rl=}iM~ZVyR={`-tTR~0o!x$x`%aB z3L0(EBcP@nB!sBsf=f;#BaHzs7qw?GnIEJfK4iTPSmH%k6-|vXBaiKUg7P21{ZMs#gwxw-ctCJhc2~UD^g9;ZIE;X*~RaMn6 zXIjpZdYjYffTL8cq|_ZEtASQI=RpzM`c=?7g|5to({x3;m6AwJWo=wfXKQvGKba zubk$=6=EvE-@CVkn*$aK(wBY;f)r9vC8i=I{-)&ThqYJd`<1f+kEbszPwu4QDsEwy z%?|oJ%vYy2>VqH3D1HL@-;WGIiarZrn@`=sljjIG(=$bW{+TjBJ@oW1c%(S-gjuRu7;lXFi zvt5znI%(9ia&JE;&+BqZr_%@iGABR{mHwZ_DL!Jq)*~#0D3svjhB$~W_iJRIdfF{K zv_Gzvhlu_ya&sfUU`yB!KgOdIGTO1`U1jR%y82IrefQ0c9qw0eVpV?b*;96_Na+^l zoh$~+R^U4E@%@8mSZH_6b#WYMlANr;M?m{W*i;Lvw+P1Q(D>lU$Ve*ot*4feoI&X+ zi;r5Kl07iqy$A+1+uA+6~b&bDfo za{;IcByKUcqm-nbQ!gf^394Vl9jJ1Gun?cdrRH~@Zc(;Xx zy@IY_M*>WDk00ngnFUrf{5U_9RDIDK>h2npg0~NeiE-brHeN`1rf*nyyjzH9pul3+ zFKSHHod*lGe&y@Q8nz*a!)3^Dp?tsKXowwbROz$efKCPgplYKHRlT5u;>!UrP;+j7 zd{ovw)$ckW*lO?9i7;=T%3QWr9G;X2c3JZLeWE=#A(Y$h^peezq4gErwW?q~<)zsm z)VggUZSTh;{DJ>Z%!CJXUuNth-LYZj0Gqj)^z}d&G)$tP zNzK51cp)|A?6}F~5=6_iv%rE#>XjY9tlL)`otBk_2#u0(buCamQUo5ADwZg@QNGoT z9=n1RPpAgwX03I*kgXGfZ}yxPMKH=% zP-%P9{zQg~1N>Fjym&ngR8q zf*Ijl21oEap{KuTj@`#E*BCsuct;iMr35-`EztXXYiWC1Eg1hG-Jy;SeSlV zHpToX`OZFI%y*34xPRE51Uay3Ep8IF6GFKF8F~2;zvckGqQ}SxpI1dD$~KK|YOM_ejuoHZq%x>k(k&7Xh+!(cXt9FS-wJ{$5?i$dw=1XMYWo z_F4R}>DT?VZ1^6q3;dpL5ZHU0bL#=<58K1V?jP>&@9)6%ZEcl(AqG6OFgq4l+ch@$wUy?Sz=Up@ z5umIbWZ99$)gf#N?%jEAZQx5P;yZKBWgk#wAJVdI$qPJ!G{1Ai)}rAL6TX>(*^y*h z6^JpqptUtCMCPFGdx*hhh$C#iZ)|MhV2lp_epxRpuY(5WW>^XaMD*oP0Wun?5oesCNxY_uOWy*j7&K%d!3Ou3(Ld@aWfSC+y$YN0G&U)4SHj6p=)5= z_xaV!kwo_57o!P&OS5Dugu71l{dWkw0@(iX!&iFN4VEpDa2DTc5WvoFR~#GB@g81^ zS3>U1EfuBFQ6JV+i6!5e36fY?VOdutb~r%{fh94&^?s_pveo6%SvccEN_r_i0*Td+ zZ3(71TOoOj5+ErmQ4mN(jrig$Eb0e!2cuvmb1$kkiLemyns68B@*cvB9hTWbUDqnK zzMScSR2<70n3&}bNuBZAJsRU(qzA|dSAsNc@kT`X`D9Nz9+=w*LPIwxs5ZxBZH8Xq z&1N(mU}bf?SA^Y!N%X)jWO09F7xR+EclO=R62;~#YNmoolExPHDUeUS!(N(dp5G_k z@J)vkUKZ5Cffq8!ypFn?GGyk$ZG69vX0%o7eEk}N+8XZ~nPrc+0vnyM=5a{5|IsiM z>#Yjv3XbeGx#1g&?DJ}D@%nP_9r2c)uy$^`kBPR;`N|87Mk69}G5}!|7B*N}Ze4AX zDV}w6Q`e?RWVjbd*Feli5HeWCh4>JselwVm(3jp`(gj9dCETV%vO==l{paWB`I`d0 z1HU}n=q$_1gqI9UFH1A`b7HgNdJg?eBVBX5z(U8tiGvFbyGLyk@KH0CGIC3VQGWEx z7}f@^B3bawOrSfsRaWH-F;ZWxAb(z===>!X`W0qEjEg7gHn<<9V*lyOCs|cBBQGj< zwqu)KpE)G>9@TJ4<7U zj`n>kCKGM!_C`!nr!k5Q?~1UMZiS z<;#PQaW6L)=PwV&wqfRMYg%{_Hu?ydGvV1j`CZKPfu_4AQl{@x>jJ(eA7CSsp*XSET|npUp{w{~2J5 zML=NW=`2H|#dF|I0Vu&8l$QF|W1kAk{?|#yiZMUm+s8fGt`OqnjCTtQ?8_vqtXk`e z-&&$EkJmuRl3}4z(h+y}9nE$XRc2X?yH2G8ONU@rJs>!G`HAB(Jt!GTm6BVK0V7=o zj-j~7^<=@dBXXj$@@8G^i-?c^#(Iz@E$y&Q6$v4^AkMhA@ODI#91EtN$O_DPITHwM zJ$lsFbf8?jij2m@fuOni_-VfEN%MmJO?Er|Cm8*i8JMWpmhK&-J=xl^upyW}RQng# z_uz|T5Qje|10ONj=y-Rt%!8SYo2b|KEnsGQAWo?w~6Q7dGhPOWY)((#Y*1{2Yk-A1VdqJ&N?0+5sN@)Srf2! zN4>%hHPin?LPz%TqemKAD)11ccNAy>pD)6S7sCEN048-6XRT^dM-cp-{eLmj%Ul%Y zWUospW5k_@y+({hQ7?2e8!{9m4Rk+JygQKTjN81*Svt5ru!fUOTrG4=~k% zm3y|08yy3EjgdrD=Dn*CAhW>{2pD(p$0Uc8ij#7TDb~5&b7!N(Q%!Bbo#-itSJ+ak z(=6Z5k@dC+ehXB))1sTR_SXrX(h;D{3akjs&Agt}r%B*R#7wZVc0Gs8)eAPrpZ_(D zSLRWsKXI3i<(r}pw{4>h*?MN=)3AJ3zb&N0O#GFIftIQ5Wv8t2;9Ldl?CBX40g0OO zSHqn~MDB8N^&f*xbaH~gzWHW)*w>~GhP9e|m$AG7fB6LbT^i2el?-|Q9O5ire2~@9 zgmlYxJ;}CgtJB(ODPud96CEkAF10b=eR{Ie0ir--h+z2IlZ|*s#!6J>OEXlST@sc& z;b8EBqC;(qE$}-eB=9xnu^y=m)%mA1XVfun;HYd$-|&%Z%ze1AEaifoL(?+&v{Yt2L#4Zgo)E2vZbI! zzDaK;dh0%s%!VSN;b>mnpzrJDxcg}vzSwr@HKee%Qu?%zdT~q-x#9Z|jd$m(CYW`X z8Pp!Oz{(MF=W)Yh);Zw&z7S{Y;YzzOk_6RNJ@3WYgGO~XV4qgt|1imtpj$TWm(w?b zYac!TMbC&WtUeEzfH%NJS9LkvHb`dHQVP*G;IEp>|6WRxFt6~wu72i_K{ZEkgA4X#D`q1Mkos=%aNr~@1f!|Jxk z?j;i^-}Z4Bg5Sm!iF(wnME040RQIHGfZ>T)EY#J5vn7w4(MprK-{FJMi{9E?*kW$2 zV%6!lBj^B81^Mid1&8Y}oaD(xG&}YI{m`Lz^y6N=7fM=!I;M6Sep_Sg48lcO!#d8L z6O9X?J3bSScIOcrt1nmwj0y30rDcUR-_gF{@d*+fYOw?nhv`y4j)rKIF^TBs9Y7!Y zktF=M`2-<jJ>WB>NR=$BWZyH`tSNFn3A! z2Ajq~BxWOdYd$d_)glO**ZHf~x1{WRGxNvV3UNfYGdS1lb`}_rKsh|Gk26x$)xS9; z&Z|sFj2>fVy+HsF-HRtfkAA_RrfEtuLX&w7Ykea%Cc9M+C^(lIhfbpIj5?!u+dP|R zLo#Skq9-)EQza_t4iwo(uSq``-+3h7g`!rbmX2C+q#-}9KdS30#_lM*&|V<_a}(ZM z)raRue`-dN+Wqrs-InfyEiMCn^8wjZ&noJdcGo=YGPj${^E0#<%*z{$zhcW{Jw2l< zD;SIh_R5+{FZ0oRUs@~LL>Abl)>ho@BrVmSJ;~LgK2qXHRB==>8wXdq@hT)g*4vX3 zFpby_DJ?2QL7%Cww66LW0?Z=5**d>rg)7k|gj z9F|995$1J!-)iSHCd_DZXj4sDc&g2YWJT~@R5}O#%=%1v|JQ0|J(@7}*}%VM(Qn*)3b^wpBmTsuG_>oDOFl@{32bmwTHS3{Y~*Y2l+R*}NkD+; zFuJ|4fOk^C_M2*$9zkTZiIesgIdu~65J+yKsof!$0>oH!6F zF)9OUa)xz---Q1Cu!N{C5R?nzrI$m_T5|e5*cR>XRB1tdeRQIv9@%Wpp2&!*+Qv0vZ%YciMNkAsGY+UX2B9^^8n|{oCznXVU)sBCM>0P*}ZR z5flurEZf>{XeEwWRxk^crBs3hm^CMcD8NBS#j8Mn7~Ti*)IvMRZNQMQ=Rc=wyH0L< zj`e@{>PW&*y}1Ms1FLqeO#v6NLw7pSa3i)n*Vj3BGzCNc34fR?Bgf3Dc{8LI$6lS* z|7ysPX8D(6Unl9;Lm1yd#--n5qM{<&3lmx~^y{83L4PP-Rg;U5q;5$0V zvrMv`CBkhmdbEW;#?qqe>MB0&YGY;GZQeRjv8d!dz!P5vpr&Da9&I zi@Ibd3oLB3-BCSY1i=UTS4MR;r^UVOFI`^mBf6nkNI3RkkRxKVauD*7Lt)n$MX~nPFccYwZRp4Eo{aJRY~D$& z{K&;Dy!`q`g*A;M-sNjl*Vxx1)p2UJ#S|2wHDaqz%08pp+F^pzERF{yYsjazcnFqa zn+!k6W|uS$F0Q$ZpNs}z1EJzB)2KNZEjR-l=IjGYWbfB;*-3!0sC9NV%l;Y~51z`C zM92=Cu9ptX-LSts4m^~H4l~I$!6f88gVhFxjv?a@u?hQ@d{F0M)y%R#;-nT1%zTIE zN{5~+7v))S{!#}+@4ab$wk0J+Ws%>)O{@2;=&7Y4!A2T%Xlv(WMB8HeN;lRmbfckF zM}&Bu=d36DMJzdp64vg1M;W_wm)NKA2~v4pc-9%CyDYIW?oIRIE8Ze8y3^U=2t4J~ zUAMWUP*~%9+WcIJ38iH}FQ=7bI&@O{lYbDj4l}9QV1{K-1zeWUv+6S|3+Tj&v;BGR8&6VbclJ)@gXXIZ5*9M_rtW%4zwMM9|AoV@tH&NAMN|} z54f$RUp=-WEa!gJh$BN>7rN&KG=#;iof%3$)IK1*MeyQ$*mPy0z-Cpm0SDNUgt*`( zG)cvBoS?oQ8P&W)q`$SPB#VmDomQlxOTy-bYjctCbQt=hnd#{23Z4q=e*atHK`j7( zLoO67Ir#OcpQ0NO0nX3JUkU#w*o~F=B-HI|WBhdeMj?)6FQapuNN={}XWx4SNj?a3=TR4@CJ9#kA6uyB{bF%`ypC;5CaA;p@D990ksd-gl}HTLk!Gi9W;VUyylcYb{V;c&~#XR|`?M*^1QLBC` zSpQ8j6SGz>F;ygIm+K1+`a_b0qIi8>TjaI}vGRc;K=zpFKiB9gTEUBgIzF|Zn*{xa zrlM4KXYl15kk{3#Uet;GlK7Wz6_r+IdgpW6D8|ND$Tha|N09SvUaem=yC*eb_pjKg zp*XdKXA?tDVrt9hgalhlSM0*VN&V$i0$5z@D*hwF&zt}YacgMpmkXauD3SDdGs}RO zlT+GhOT|8<;Ny`k+t(N$&(l>~t`ItbMY4zMlB4A&%dFPupCBr}um1vHY$J@~&n)3T zV)r@z5adYwa{^2Y3nl}`2N9P?fHv~RnO~2>JxxdHTx0EMvFa{mGIW9QM%bA+!=u%b zrafZ}&q@TcY`UJ}cjOB_=#05EgpldAGSUPQaWh{x`>%Zme;;-yNl39-XTw-x$?te6 z4u|~mlM~LALb&9^y4PjRgX2aiEzxE=QmWZ&oMF9lr7NFJ-0n~4QvMEP-Z$g9Xs`Cz zJZ!7yL%drCspg31cn!9_WQ;s6I1eJ_tw>ic7&arkcf46+4ahT}6?OHZbHe=YwL20l zugZR5dq_xpPF;BK2hMa!W-Bj@BiNx-TbNA0JV#?2@B4+9WI)e0x>=lUk=X+?*r{r) z*n=RZuVvs~sounMgG5R@ShoAt3+IkzC#qV#E-X`xrRA;$Y_u=>adstnW-F^z*BsAB znX#{-Pk!(m+y$1S{P0w%)1-SNdleZ@=^V-5hP1!JXWgmG=7{bh6$ZD14|?DD?b!d) zG5LRDqH|Qt)X7{HE@Nmja{sConAmH0fFszW(dV8;LMJ;ruw&wH@vA(mJl6JdK{L9_ zq_3*w2oF!1RF?mRX$ei((v}}@Kulf|w)`aIx5=gFZ7s5J#j`O+^%+K`E>4zAV!n$8!Zn`UB-Z-B+ zTV~)n_^UEtOgn1*;lQqyJN7*WM-AAtl5xlKf$#L}c7iX;4enaA?%|O1Llm2}ly9Kd zLOTVjkePQR*C#SlW~RCAOL%VS&_swi2Y{i3)ti(4msj~}*XrZ!gsYtkz74>G8>Jsg zU%N4o^*QS42{R7udUqL(zhU0<(=!+_$F~SL^B5*e+GaK&!Tg#fCAp$E-cglxE%I!O zN!%oDWLP5+8sXmO3YPuh(<0xR1A#DBRt7Dbsb<<_WuVZEZqBG2jTe@)o_9%6X8$?L zv^QA)X*!p4=KEdPJ^Kk4LKow9Ev26`X#_>GBMi^TlG3wl+a7J4bqOyJp2;NfQ~#9p z94l`Fj`mfmxxPV(Tt>)yiKUpAv zq&Ufn*(v>59)D7$j*jtcm?7Ru(c+o8ju|7zNbDO#+=j|+bY(ks!i1I$SNtSe*HUIY z;@Bm<2>&4pH9A0K*zK*eij$AIf`*@NzUQ8M9ZPjLv%NhDx5xW__^U+m_jDF|IP=U9 zf&>G1j#}0@4*Y(c1g2Gi^!E_v-Ci1T-iF8#%FRG&>FENl$z(#i_r>+!ATb2J(?=Zx zBo6KI20YSHG7)6`qVuG`%brQ^rr^S}qO8llL7xmH4v+e;KCB`eF1!o(<;^0mlZ6QK zG(cmty^2;+bl6@YYs>!Ju=&(DQX{!r+1vmcI8(+`qux8w4yaP}O;H4;p`WY`DFay# z7P`*$z>k{u$e49sK4^U8$WXLf9Dc)NQ72pKgPUTBs_@ma1L;1 z&27T@fQvJwUO4ugKdN~+e+rx;I5aO!bJjbeC+2b-crcjrYyJ;M{Z0!N1CAH@14)5% zaBtuc;?#cvdlXi6;e|hbz_v)(wAqF#WpGrS_&RXpkYmc|E|@T)6oDip{TfCVqI^g& zRSlo6hg51RKH^t}3@Oo;HLw7y+zgab@4tFSqC>BuONYq9QWsXVKq{r_poBR6h?K`x z(tVc;^WNCDr;gsSyp!^JL95t<&!s1f+}!GWg{^8+=bIWECo@YGCGeS8o_<%87#kvR zf7vs?qzDOVRebCm0i}6K_0Cax`r_-Z2sm(W^-A{lV^RrTDEV><9c7A9&3{31J0Xi` zz*fz1>h(-4$*S0YAIVNfrMYQlOxx;RvKSLu38M)gUGEo^*D%VgR0qJiP52X1uS@P> z_ZZnynJ>D^!H~2N#2A3NuK&|zVl{6i@}f)VSm@`IaK&%IHoUCAp@tpnpHO0#azV0!ZY2pf`7X+WA@M0xlkf_U^lKRVg1#XPe3CxKkjL|NrGf)@z1^p znYPyPp4|!34PJfI(Nb1sPL8v@!*e+N8I8uN#Af3MUbO$-4k8r9=$J?UBZJnZNkCmr zaY&URWZ5 zlOo(TiTkec1Bs(C&?q$1c9HL=#9zKN(&&+7XMEyhS4{t7jeMK#yep$;fcNfzusk3-Vncc2#aulWx5MSAagc znTFoAT;f*O?SOtiVJhe@$Sbc2-0Ev~=;^4THa#<;v2c7jQt~@#(e)27>qXuNhmEWz zGzk$4A3_wb(?)irOmU>Bps^X)_q-ywU8IE`#7@%F^+=v>EU~zL-10qnKPQCzFskk1 ze(!?^tD_Y*ATQ1*C1g*D9Bpd-mY zG7+1}hdQ7p)lMf45M^n6=`!G*rF-F`jjb(kzPPYe(<+IYiV77KFj^JuUNmF$aQMEB zC;G|%6{DhmI2LjNNsECUrE?CboqpuUQkUu1cFiO3$_26)bcfV1{@{_(o`uATJZ)ntonXgoXr zJ<(EJUlzY@Wo6j@Jt`?HEG)|F?zQ$T+23q%%5peOTxfi(uR92~k)Wy7cC*^@ebPg$ zP$%Kxx-hAelZF)=KnRHG%bo8+dAU1eJ9@b=rk7zYBGT|K9Vm>=s}^H$jR~m^?zXW~ zR`$@+va;~h5HzSpI{F$G788<16bAUdlIwRMZ(%64R@(C?BmMYuL6ur2)hM)kEJ_0G zQpr(6J@|awVC?^Vm$Kba`KDsA-q5sv=Z{V)99hp*5`a%{DdBoVQc4dAOTt1KJGRJ7 z|N2z)^uCYnE$#Bs!yUB7F8}atV;cKotC-28!E)rqUb?8_XxH?^;WIZN0(gCPVlck0 zvGiRFZrcKRyC3;^xZ0N=^d=WB;OW)nO?f_Ns`z;%jl7+8czY+=$gk?E0}SN;bVTf< zt>HS1&LR1C0W`0ZnwHF>FCmz!kix3phZIYX!NiarBcmn1aI#erS46jE%Z7W;;lxLJ zdN|(nF!0HUtPKc-4pwJst9~h7+)s&H?p}?!M`bXO=T2hiski&78seCaeaj|skdyE5lXXpei;CV;iToFp zY?Q61;X1YLa7i2cnt`3f7FTuL0UXl_v#)2}grPv|bD=@*GGDoN5>u z%xz?RiHKI{HSu~oTb8)?t5PaZ1s`kY%%ytp^Aaj@!?%9h{-8-1yFK%;H3lJO$k;dF4%z3a~1HYdU|$0u#)UXJhH z*9XN!A@USM;pt@rIW;IL__TE1h4-DG(PrGcalem9MD35k(;IELItuHo_U$tQeaK;s z#VQ@Iwr{WSU;Cj4bT0N{E^p-88S48Ji8WRa8rqv{M)1rSM$g1Y01TmL%Z>7S=@}Ri+g3(D8r23la=oe{&G4OykdNc$V1>?EkedBb&ci{& zo4K31##g}Mzt!=Nx@n@nsbf{#KJi+}gn75Lw5YdiEw2c-3i%-fcjxEBz9mk%UMT$j zaImD`j4IvVN8gVUalfcX_L~WE?lS$2z}idXZ%#pC=|*^Pg_=972xI@ zG$-h<)cBE%A&y?!XlC`PL$vDUe(B|D?WOW8l2KqQY;HPvTuMcys)Y{a-OJ1KX|ZvD z?)hoJQ_AlZtF^ujTY$DYk*{1%Qrb;%z|+Ori{ANCh0AMUtxHg;dJ6uV9u^8q+h5|b zDivfTC8w)Z>IT4u(4_r_*OE(z{VB^16X@h;563@3j$r8Edv3vk_J#m&YLzgM>e9EJ z^OMXU*H+@qqI#9SyNYnB6r&}?Vu06U0v7TU^8$z#VM>LB_$3G&A7&ipR?9%iHdy0Sjp8Nd8rq`hTS9AVS0n?QmD3lQ8A2=4Cg z5FofiaCi3r!CeM-cXt>F!8O=mGXueW26x%K=iBGJ>-^pOe|N9$UiEZ8RdwH2Js-S$ z&+)h8si5HPKG@04$;;Vð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 diff --git a/docs/src/ittapi/histogram-api.rst b/docs/src/ittapi/histogram-api.rst index 9dbc09f9..de840351 100644 --- a/docs/src/ittapi/histogram-api.rst +++ b/docs/src/ittapi/histogram-api.rst @@ -5,18 +5,13 @@ Histogram API Use the Histogram API to define histograms that display arbitrary data -in histogram form in Intel® VTune™ Profiler. +in Intel® VTune™ Profiler. - -The Histogram API enables you to define custom histogram graphs in your -code to display arbitrary data of your choice in VTune Profiler. - - -Histograms can be especially useful for showing statistics that can be +Histograms are particularly useful to display statistics that can be split by individual units for cross-comparison. -For example, you can use this API in your workload to: +You can use the Histogram API to: - Track load distribution @@ -24,36 +19,20 @@ For example, you can use this API in your workload to: - Identify oversubscribed or underutilized worker nodes -Any histogram instance can be accessed by any thread in the process, -regardless of which thread created the histogram. The Histogram API call -is thread-safe. - - -.. note:: +Any thread in the process can access any instance of a histogram, regardless +of the thread that created it. The Histogram API call is thread-safe. - By default, Histogram API data collection and visualization are - available in the `Input and Output - analysis `__ only. To - see the histogram in the result of other analysis types, `create a - custom analysis `__ - based on the pre-defined analysis type you are interested in, and - enable the **Analyze user histogram** checkbox in the `custom - analysis options `__. +Define and Create a Histogram +----------------------------- -Define and Create Histogram ---------------------------- - - -Before creating the histogram, an `ITT API -Domain `__ must be -created. The pointer to this domain is then passed to the primitive. - - -The domain name provides a heading for the histogram section on the -**Summary** tab of VTune Profiler result. +Before you create a histogram, you must create an `ITT API Domain +`__ . The pointer to this domain is then passed +to the primitive. +In the result display in VTune Profiler, the domain name provides a heading +for the histogram section in the **Summary** tab. One domain can combine any number of histograms. However, the name of the histogram must be unique within the same domain. @@ -62,23 +41,25 @@ the histogram must be unique within the same domain. **Parameters of the primitives:** -.. list-table:: - :header-rows: 0 - - * - [in] - - ``domain`` - - Domain controlling the call - * - [in] - - ``name`` - - Histogram name - * - [in] - - ``x_axis_type`` - - Type of X axis data - * - [in] - - ``y_axis_type`` - - Type of Y axis data - - ++--------+--------------------------+-----------------------------------------+ +| Type | Parameter | Description | ++========+==========================+=========================================+ +| [in] | .. code-block:: cpp | Domain controlling the call | +| | | | +| | domain | | ++--------+--------------------------+-----------------------------------------+ +| [in] | .. code-block:: cpp | Histogram name | +| | | | +| | name | | ++--------+--------------------------+-----------------------------------------+ +| [in] | .. code-block:: cpp | Type of X axis data | +| | | | +| | x_axis_type | | ++--------+--------------------------+-----------------------------------------+ +| [in] | .. code-block:: cpp | Type of Y axis data | +| | | | +| | y_axis_type | | ++--------+--------------------------+-----------------------------------------+ .. container:: fignone @@ -91,19 +72,33 @@ the histogram must be unique within the same domain. **Primitives:** -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - ``__itt_histogram* _itt_histogram_create(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Linux\* and Android\* OS. - * - ``__itt_histogram* _itt_histogram_createA(__itt_domain* domain, const char* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for ASCII strings (``char``). - * - ``__itt_histogram* _itt_histogram_createW(__itt_domain* domain, const wchar_t* name, __itt_metadata_type x_axis_type, __itt_metadata_type y_axis_type);`` - - Create a histogram instance with the specified domain, name, and data type on Windows\* OS for UNICODE strings (``wchar_t``). - - ++----------------------------------------------+--------------------------------------------------------------------------+ +| Use This Primitive | To Do This | ++==============================================+==========================================================================+ +| .. code-block:: cpp | Create a histogram instance with the specified domain, name, and data | +| | type on Linux* and Android* OS. | +| __itt_histogram* _itt_histogram_create( | | +| __itt_domain* domain, | | +| const char* name, | | +| __itt_metadata_type x_axis_type, | | +| __itt_metadata_type y_axis_type); | | ++----------------------------------------------+--------------------------------------------------------------------------+ +| .. code-block:: cpp | Create a histogram instance with the specified domain, name, and data | +| | type on Windows* OS for ASCII strings (char). | +| __itt_histogram* _itt_histogram_createA( | | +| __itt_domain* domain, | | +| const char* name, | | +| __itt_metadata_type x_axis_type, | | +| __itt_metadata_type y_axis_type); | | ++----------------------------------------------+--------------------------------------------------------------------------+ +| .. code-block:: cpp | Create a histogram instance with the specified domain, name, and data | +| | type on Windows* OS for UNICODE strings (wchar_t). | +| __itt_histogram* _itt_histogram_createW( | | +| __itt_domain* domain, | | +| const wchar_t* name, | | +| __itt_metadata_type x_axis_type, | | +| __itt_metadata_type y_axis_type); | | ++----------------------------------------------+--------------------------------------------------------------------------+ Submit Data to Histogram @@ -113,35 +108,41 @@ Submit Data to Histogram **Parameters of the primitives:** -.. list-table:: - :header-rows: 0 - - * - [in] - - ``histogram`` - - Histogram instance to submit data to - * - [in] - - ``length`` - - Number of elements in submitted axis data array - * - [in] - - ``x_axis_data`` - - Array containing X axis data (may be ``NULL``). If ``x_axis_data`` is ``NULL``, VTune Profiler uses the indices of the ``y_axis_data`` array. - * - [in] - - ``y_axis_data`` - - Array containing Y axis data. - - ++--------+--------------------------+-------------------------------------------------+ +| Type | Parameter | Description | ++========+==========================+=================================================+ +| [in] | .. code-block:: cpp | Histogram instance to submit data to | +| | | | +| | histogram | | ++--------+--------------------------+-------------------------------------------------+ +| [in] | .. code-block:: cpp | Number of elements in submitted axis data array | +| | | | +| | length | | ++--------+--------------------------+-------------------------------------------------+ +| [in] | .. code-block:: cpp | Array containing X axis data (may be ``NULL``). | +| | | If ``x_axis_data`` is ``NULL``, VTune Profiler | +| | x_axis_data | uses the indices of the ``y_axis_data`` array. | ++--------+--------------------------+-------------------------------------------------+ +| [in] | .. code-block:: cpp | Array containing Y axis data. | +| | | | +| | y_axis_data | | ++--------+--------------------------+-------------------------------------------------+ **Primitives:** -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - ``void _itt_histogram_submit(__itt_histogram* histogram, size_t length, void* x_axis_data, void* y_axis_data);`` - - Submit user statistics for the selected histogram instance. Array data for the Y-axis is mapped to array data for the X-axis, similar to coordinates of a point on a 2D plane. Data submitted during workload run is summarized into one common histogram for all calls of this primitive. It is recommended to determine an efficient interval between data submissions to lower collection overhead. ++-------------------------------------+--------------------------------------------------------------------------+ +| Use This Primitive | To Do This | ++=====================================+==========================================================================+ +| .. code-block:: cpp | Submit user statistics for the selected instance of the histogram. | +| | Just like the coordinates of a point on a 2D plane, the array | +| void _itt_histogram_submit( | data for the Y-axis is mapped to the array data for the X-axis. | +| __itt_histogram* histogram, | Data submitted during a workload run is summarized into one common | +| size_t length, | histogram for all calls of this primitive. To lower collection overhead, | +| void* x_axis_data, | determine an efficient interval between data submissions. | +| void* y_axis_data); | | ++-------------------------------------+--------------------------------------------------------------------------+ @@ -183,5 +184,5 @@ statistics: .. |image1| image:: histogram-api-schema.png - :width: 800px + :width: 600px diff --git a/docs/src/ittapi/load-module-api.rst b/docs/src/ittapi/load-module-api.rst index 1a00d933..cdc2055e 100644 --- a/docs/src/ittapi/load-module-api.rst +++ b/docs/src/ittapi/load-module-api.rst @@ -4,36 +4,45 @@ Load Module API =============== -You can use the Load Module API in your code to analyze a module that -was loaded in an alternate location that cannot otherwise be tracked by -Intel VTune Profiler. For example, this would allow you to analyze code -that is typically executed in an isolated environment to which there is -no visibility of the code. This API allows you to explicitly set the +Use the Load Module API in your code to analyze a module that +was loaded in an alternate location, and cannot otherwise be tracked by +Intel® VTune™ Profiler. For example, you could use the Load Module API to analyze code +that is typically executed in an isolated environment that contains +no visibility of the code. Use this API to explicitly set the module location in an address space for analysis by VTune Profiler. -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``void __itt_module_loadW (void* start_addr,void* end_addr, const wchar_t* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - * - \ ``void __itt_module_loadA(void* start_addr, void* end_addr, const char* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - * - \ ``void __itt_module_load(void* start_addr, void* end_addr, const char* path)``\ - - Call this function after the relocation of a module. Provide the new start and end addresses for the module and the full path to the module on the local drive. - - ++-----------------------------------------------+------------------------------------------------------------------------+ +| Use This Primitive | To Do This | ++===============================================+========================================================================+ +| .. code-block:: cpp | Call this function after the relocation of a module. Provide the new | +| | start and end addresses for the module and the full path to the module | +| void __itt_module_loadW(void* start_addr, | on the local drive. | +| void* end_addr, | | +| const wchar_t* path); | | ++-----------------------------------------------+------------------------------------------------------------------------+ +| .. code-block:: cpp | Call this function after the relocation of a module. Provide the new | +| | start and end addresses for the module and the full path to the module | +| void __itt_module_loadA(void* start_addr, | on the local drive. | +| void* end_addr, | | +| const char* path); | | ++-----------------------------------------------+------------------------------------------------------------------------+ +| .. code-block:: cpp | Call this function after the relocation of a module. Provide the new | +| | start and end addresses for the module and the full path to the module | +| void __itt_module_load(void* start_addr, | on the local drive. | +| void* end_addr, | | +| const char* path); | | ++-----------------------------------------------+------------------------------------------------------------------------+ Usage Example ------------- -.. code:: +.. code-block:: cpp #include "ittnotify.h" - __itt_module_load(relocatedBaseModuleAddress, relocatedEndModuleAddress, '/some/path/to/dynamic/library.so'); + + __itt_module_load(relocatedBaseModuleAddress, relocatedEndModuleAddress, "/path/to/dynamic/library.so"); diff --git a/docs/src/ittapi/marker-api.rst b/docs/src/ittapi/marker-api.rst index c5d6f92f..2d20f070 100644 --- a/docs/src/ittapi/marker-api.rst +++ b/docs/src/ittapi/marker-api.rst @@ -4,34 +4,39 @@ Marker API ========== -Marker is an instant event on a timeline that can be associated with a +A marker is an instant event on a timeline that can be associated with a particular process, a thread, or specified in a global scope. **To create a marker, use the following primitive:** +.. code-block:: cpp -``void __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope scope)`` - -**Parameters of the primitive:** + void __itt_marker(const __itt_domain *domain, __itt_id id, + __itt_string_handle *name, __itt_scope scope); -.. list-table:: - :header-rows: 0 - - * - [in] - - \ ``domain``\ - - Marker domain - * - [in] - - \ ``name``\ - - Marker name - * - [in] - - \ ``id``\ - - Optional parameter. Marker ID, or ``__itt_nullNOTEMarkers`` with different domains cannot have same IDs. - * - [in] - - \ ``scope``\ - - Marker scope: process, thread, and global +**Parameters of the primitive:** ++--------+-----------------------+---------------------------------------------------------+ +| Type | Parameter | Description | ++========+=======================+=========================================================+ +| [in] | .. code-block:: cpp | Marker domain | +| | | | +| | domain | | ++--------+-----------------------+---------------------------------------------------------+ +| [in] | .. code-block:: cpp | Marker name | +| | | | +| | name | | ++--------+-----------------------+---------------------------------------------------------+ +| [in] | .. code-block:: cpp | Optional parameter. Marker ID, or ``__itt_null``. | +| | | Markers with different domains cannot have the same IDs.| +| | id | | ++--------+-----------------------+---------------------------------------------------------+ +| [in] | .. code-block:: cpp | Marker scope: process, thread, and global | +| | | | +| | scope | | ++--------+-----------------------+---------------------------------------------------------+ diff --git a/docs/src/ittapi/memory-allocation-apis.rst b/docs/src/ittapi/memory-allocation-apis.rst index b402a766..101fdbcb 100644 --- a/docs/src/ittapi/memory-allocation-apis.rst +++ b/docs/src/ittapi/memory-allocation-apis.rst @@ -4,72 +4,111 @@ Memory Allocation APIs ====================== -Intel® VTune™ Profiler provides a set of APIs to help it identify the +Intel® VTune™ Profiler contains a set of APIs that help identify the semantics of your ``malloc``-like heap management functions. +Annotating your code with these APIs enables VTune Profiler to correctly +determine memory objects as part of the **Memory Access Analysis**. -Annotating your code with these APIs allows VTune Profiler to correctly -determine memory objects as part of `Memory Access -Analysis `__. +Usage Guidelines +---------------- -Usage Tips ----------- - -Follow these guidelines when using the memory allocation APIs: - - -- Create *wrapper* functions for your routines, and put the - ``__itt_heap_*_begin`` and ``__itt_heap_*_end`` calls in these - functions. - - -- Allocate a unique domain for each pair of allocate/free functions - when calling ``__itt_heap_function_create``. This allows the VTune - Profiler to verify a matching free function is called for every - allocate function call. +When using the Memory Allocation APIs, follow these guidelines: +- Create *wrapper* functions for your routines. Put ``__itt_heap_*_begin`` + and ``__itt_heap_*_end`` calls in these functions. +- When your application calls ``__itt_heap_function_create``, allocate a + unique domain for each pair of allocate/free functions. This enables + VTune Profiler to verify that a matching free function gets called for + every allocate function call. - Annotate the beginning and end of every allocate function and free function. - - -- Call all function pairs from the same stack frame, otherwise the - VTune Profiler assumes an exception occurred and the allocation +- Call all function pairs from the same stack frame. Otherwise, + VTune Profiler assumes that an exception occurred, and that the allocation attempt failed. - - -- Do not call an end function without first calling the matching begin - function. +- Do not call an end function without calling the matching begin + function first. Using Memory Allocation APIs in Your Code ----------------------------------------- -.. list-table:: - :header-rows: 0 - - * - Use This - - To Do This - * - - - Declare a handle type to match begin and end calls and domains. - * - - - Identify allocation functions. - * - - - Identify deallocation functions. - * - - - Identify reallocation functions. Note that ``itt_heap_reallocate_end()`` must be called after the attempt even if no memory is returned. VTune Profiler assumes C-runtime ``realloc`` semantics. - - ++----------------------------------+-----------------------------------------------------------------+ +| Use This | To Do This | ++==================================+=================================================================+ +| .. code-block:: cpp | Declare a handle type to match begin and end calls and domains. | +| | | +| typedef void* | name = Name of the function you want to annotate. | +| __itt_heap_function; | domain = String identifying a matching set of functions. | +| | | +| __itt_heap_function | For example, if there are three functions that all work with | +| __itt_heap_function_create( | my_struct, such as alloc_my_structs, free_my_structs, and | +| const __itt_char* , | realloc_my_structs, pass the same domain to all three | +| const __itt_char* | __itt_heap_function_create() calls. | +| ); | | ++----------------------------------+-----------------------------------------------------------------+ +| .. code-block:: cpp | Identify allocation functions. | +| | | +| void | h = Handle returned when this function's name was passed | +| __itt_heap_allocate_begin( | to __itt_heap_function_create(). | +| __itt_heap_function , | | +| size_t , | size = Size in bytes of the requested memory region. | +| int | | +| ); | initialized = Flag indicating if the memory region will be | +| | initialized by this routine. | +| void | | +| __itt_heap_allocate_end( | addr = Pointer to the address of the memory region this | +| __itt_heap_function , | function has allocated, or 0 if the allocation failed. | +| void**, | | +| size_t , | | +| int | | +| ); | | ++----------------------------------+-----------------------------------------------------------------+ +| .. code-block:: cpp | Identify deallocation functions. | +| | | +| void | h = Handle returned when this function's name was passed | +| __itt_heap_free_begin( | to __itt_heap_function_create(). | +| __itt_heap_function , | | +| void* | addr = Pointer to the address of the memory region this | +| ); | function is deallocating. | +| | | +| void | | +| __itt_heap_free_end( | | +| __itt_heap_function , | | +| void* | | +| ); | | ++----------------------------------+-----------------------------------------------------------------+ +| .. code-block:: cpp | Identify reallocation functions. | +| | | +| void | Note that itt_heap_reallocate_end() must be called after | +| __itt_heap_reallocate_begin( | the attempt even if no memory is returned. VTune Profiler | +| __itt_heap_function , | assumes C-runtime realloc semantics. | +| void*, | | +| size_t , | h = Handle returned when this function's name was passed | +| int | to __itt_heap_function_create(). | +| ); | | +| | addr = Pointer to the address of the memory region this | +| void | function is reallocating. If addr is NULL, the VTune Profiler | +| __itt_heap_reallocate_end( | treats this as if it is an allocation. | +| __itt_heap_function , | | +| void*, | new_addr = Pointer to a pointer to hold the address of the | +| void** , | reallocated memory region. | +| size_t , | | +| int | size = Size in bytes of the requested memory region. If | +| ); | new_size is 0, the VTune Profiler treats this as if it is | +| | a deallocation. | ++----------------------------------+-----------------------------------------------------------------+ Usage Example: Heap Allocation ------------------------------ -.. code:: cpp +.. code-block:: cpp #include diff --git a/docs/src/ittapi/metadata-api.rst b/docs/src/ittapi/metadata-api.rst index 4200ca91..a07f83d3 100644 --- a/docs/src/ittapi/metadata-api.rst +++ b/docs/src/ittapi/metadata-api.rst @@ -4,66 +4,72 @@ Metadata API ============ -Metadata is extra information, generic data which can be attached to a +Metadata is additional information or generic data that can be attached to a task, a thread, a process, etc. Metadata has a type, name, and value. -The value encoding depends on a metadata type. It may contain either -string data or a number of integer or floating point values. +The value encoding depends on the metadata type. The encoding may contain +either string data or a number of integer or floating point values. To create metadata, use the following primitives: -``void __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)`` - - -``void __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const char *data, size_t length)`` - - -``void __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, const wchar_t *data, size_t length)`` - - -``void __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)`` - - -``void __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const char *data, size_t length)`` - - -``void __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, __itt_string_handle *key, const wchar_t *data, size_t length)`` - - -The following table defines the parameters used in the Metadata API -primitives. - - -.. list-table:: - :header-rows: 1 - - * - Type - - Parameter - - Description - * - [in] - - ``__itt_domain* domain`` - - Metadata domain - * - [in] - - ``__itt_scope scope`` - - Metadata scope: task, thread, process, and global. If a scope is undefined, metadata belongs to the last task in the thread. - * - [in] - - ``__itt_string_handle* name`` - - Metadata name - * - [in] - - ``__itt_metadata_type type`` - - Metadata type; used only for numeric metadata - * - [in] - - ``size_t count`` - - Number of numeric metadata items ``[in] size_t``\ length - * - [in] - - ``size_t length`` - - Number of symbols a metadata string - * - [in] - - ``void *data`` - ``const char *data`` - ``const wchar_t *data`` - - Actual metadata (array of numerics or string) - - +.. code-block:: cpp + + + void __itt_metadata_add(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, + __itt_metadata_type type, size_t count, void *data); + + void __itt_metadata_str_addA(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, + const char *data, size_t length); + + void __itt_metadata_str_addW(const __itt_domain *domain, __itt_id id, __itt_string_handle *key, + const wchar_t *data, size_t length); + + void __itt_metadata_add_with_scope(const __itt_domain *domain, __itt_scope scope, + __itt_string_handle *key, __itt_metadata_type type, + size_t count, void *data); + + void __itt_metadata_str_add_with_scopeA(const __itt_domain *domain, __itt_scope scope, + __itt_string_handle *key, const char *data, size_t length); + + void __itt_metadata_str_add_with_scopeW(const __itt_domain *domain, __itt_scope scope, + __itt_string_handle *key, const wchar_t *data, size_t length); + + +The following table defines the parameters used in the Metadata API primitives. + + ++--------+------------------------------+----------------------------------------------------+ +| Type | Parameter | Description | ++========+==============================+====================================================+ +| [in] | .. code-block:: cpp | Metadata domain | +| | | | +| | __itt_domain* domain | | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Metadata scope: task, thread, process, and global. | +| | | If a scope is undefined, metadata belongs to the | +| | __itt_scope scope | last task in the thread. | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Metadata name | +| | | | +| | __itt_string_handle* name | | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Metadata type; used only for numeric metadata | +| | | | +| | __itt_metadata_type type | | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Number of numeric metadata items | +| | | ``[in] size_t`` length | +| | size_t count | | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Number of symbols a metadata string | +| | | | +| | size_t length | | ++--------+------------------------------+----------------------------------------------------+ +| [in] | .. code-block:: cpp | Actual metadata (array of numerics or string) | +| | | | +| | void *data | | +| | const char *data | | +| | const wchar_t *data | | ++--------+------------------------------+----------------------------------------------------+ diff --git a/docs/src/ittapi/relation-api.rst b/docs/src/ittapi/relation-api.rst index 803acad1..d10f94ac 100644 --- a/docs/src/ittapi/relation-api.rst +++ b/docs/src/ittapi/relation-api.rst @@ -4,49 +4,53 @@ Relation API ============ -Relation API binds two named instances, for example, tasks, with a -reasonable relation attribute. Relations can be added before or after -the actual instances are created and persist independently of the -instances. +The Relation API binds two named instances, like tasks, with a +reasonable relation attribute. You can add relations before or after +the actual instances are created. These relations exist independently +outside the instances. +To group a bunch of tasks logically, you can use different types of relations: -To logically group a bunch of tasks, you can use different types of -relations: +.. code-block:: cpp -``void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, __itt_relation relation, __itt_id tail)`` + void ITTAPI __itt_relation_add(const __itt_domain *domain, __itt_id head, + __itt_relation relation, __itt_id tail); -``void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id head, __itt_relation relation, __itt_id tail)`` + void ITTAPI __itt_relation_add_ex(const __itt_domain *domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp, __itt_id head, + __itt_relation relation, __itt_id tail); **Parameters of the primitives:** -.. list-table:: - :header-rows: 1 - - * - Type - - Parameter - - Description - * - [in] - - ``__itt_domain* domain`` - - Relation domain - * - [in] - - ``__itt_relation relation`` - - User-defined logical relation between two named instances - * - [in] - - ``__itt_id head`` - - Metadata name - * - [in] - - ``__itt_id tail`` - - IDs of two named related instances ``size_t`` count - * - [in] - - ``__itt_clock_domain* clock_domain`` - - User-defined clock domain - * - [in] - - ``unsigned long long timestamp`` - - User-defined timestamp for the corresponding clock domain - - ++--------+-------------------------------------+---------------------------------------+ +| Type | Parameter | Description | ++========+=====================================+=======================================+ +| [in] | .. code-block:: cpp | Relation domain | +| | | | +| | __itt_domain* domain | | ++--------+-------------------------------------+---------------------------------------+ +| [in] | .. code-block:: cpp | User-defined logical relation between | +| | | two named instances | +| | __itt_relation relation | | ++--------+-------------------------------------+---------------------------------------+ +| [in] | .. code-block:: cpp | Metadata name | +| | | | +| | __itt_id head | | ++--------+-------------------------------------+---------------------------------------+ +| [in] | .. code-block:: cpp | IDs of two named related instances | +| | | ``size_t`` count | +| | __itt_id tail | | ++--------+-------------------------------------+---------------------------------------+ +| [in] | .. code-block:: cpp | User-defined clock domain | +| | | | +| | __itt_clock_domain* clock_domain | | ++--------+-------------------------------------+---------------------------------------+ +| [in] | .. code-block:: cpp | User-defined timestamp for the | +| | | corresponding clock domain | +| | unsigned long long timestamp | | ++--------+-------------------------------------+---------------------------------------+ diff --git a/docs/src/ittapi/string-handle-api.rst b/docs/src/ittapi/string-handle-api.rst index 22dea063..e5efc6f5 100644 --- a/docs/src/ittapi/string-handle-api.rst +++ b/docs/src/ittapi/string-handle-api.rst @@ -5,34 +5,36 @@ String Handle API Many API calls require names to identify API objects. String handles are -pointers to names. They enable efficient handling of named objects in -run time and make collected traces data more compact. +pointers to these names. String handles enable efficient handling of named +objects during runtime. The handles also make the collected trace data more +compact. **To create and return a handle value that can be associated with a string, use the following primitive:** -``__itt_string_handle *ITTAPI__itt_string_handle_create ( const char *name)`` +.. code-block:: cpp -Consecutive calls to ``__itt_string_handle_create`` with the same name -return the same value. The set of string handles is expected to remain -static during the application's execution time, therefore, there is no -mechanism to destroy a string handle. Any string handle can be accessed -by any thread in the process, regardless of which thread created the -string handle. This call is thread-safe. + __itt_string_handle* __itt_string_handle_create(const char *name); -**Parameters of the primitive:** - +Consecutive calls to ``__itt_string_handle_create`` with the same name return +the same value. The set of string handles is expected to remain static during +the execution time of the application. Therefore, there is no mechanism to +destroy a string handle. Any thread in the process can access any string handle, +irrespective of the thread that created the string handle. This call is thread-safe. -.. list-table:: - :header-rows: 0 - * - \ ``[in]``\ - - \ *name*\ - - The input string +**Parameters of the primitive:** ++--------+------------------------+-------------------+ +| Type | Parameter | Description | ++========+========================+===================+ +| [in] | .. code-block:: cpp | The input string | +| | | | +| | name | | ++--------+------------------------+-------------------+ diff --git a/docs/src/ittapi/task-api.rst b/docs/src/ittapi/task-api.rst index 02eb74da..a208ec8e 100644 --- a/docs/src/ittapi/task-api.rst +++ b/docs/src/ittapi/task-api.rst @@ -4,101 +4,104 @@ Task API ======== -A *task* is a logical unit of work performed by a particular thread. +A task is a logical unit of work that is performed by a particular thread. Tasks can nest; thus, tasks typically correspond to functions, scopes, -or a case block in a switch statement. You can use the Task API to -assign tasks to threads. +or a case block in a switch statement. +Use the Task API to assign tasks to threads -The Task API does not enable a thread to suspend the current task and -switch to a different task (task switching), or move a task to a -different thread (task stealing). +The Task API does not enable a thread to perform: + +- Task switching, where a thread suspends the current task and switches to + a different task. +- Task stealing, where a thread moves a task to a different thread. A task instance represents a piece of work performed by a particular thread for a period of time. The task is defined by the bracketing of -\__itt_task_begin() and \__itt_task_end() on the same thread. - - -Tasks can be of two types: simple or overlapped. - - -Simple tasks implicitly support a concept of embedded execution. This -means that the call \__itt_task_end() finalizes the most recent -\__itt_task_begin() call. For example, the following metacode is a valid -sequence, and execution time of "a" tasks incorporates the execution -time of "b" tasks: +``__itt_task_begin()`` and ``__itt_task_end()`` on the same thread. -``__itt_task_begin(a)`` +Tasks can be simple or overlapped. -``__itt_task_begin(b)`` +Simple tasks implicitly support the concept of embedded execution. The call +``__itt_task_end()`` finalizes the most recent ``__itt_task_begin()`` call. +For example, the following metacode is a valid sequence, and the execution time +of "a" tasks incorporates the execution time of "b" tasks: -``__itt_task_end(b)`` +.. code-block:: cpp -``__itt_task_end(a)`` + __itt_task_begin(a); + __itt_task_begin(b); + __itt_task_end(b); + __itt_task_end(a); -Execution regions of overlapped tasks may intercept. For example, the -following metacode is a valid sequence, and a "b" task started after an +The execution regions of overlapped tasks may intercept. For example, the +following metacode is a valid sequence. A "b" task that started after an "a" task can finish upon completion of the "a" task: -``__itt_task_begin_overlapped(a)`` +.. code-block:: cpp -``__itt_task_begin_overlapped(b)`` - - -``__itt_task_end_overlapped(a)`` - - -``__itt_task_end_overlapped(b)`` + __itt_task_begin_overlapped(a); + __itt_task_begin_overlapped(b); + __itt_task_end_overlapped(a); + __itt_task_end_overlapped(b); Task API Functions ------------------ -**To create a simple task instance on a thread, use the following -functions:** - - -``void ITTAPI __itt_task_begin (const __itt_domain -*domain,__itt_id taskid, __itt_id parentid, __itt_string_handle -*name)`` +**To create a simple task instance on a thread, use the following functions:** -``void ITTAPI __itt_task_begin_fn (const __itt_domain *domain,__itt_id taskid, __itt_id parentid, void* address)`` +.. code-block:: cpp + + + void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id taskid, + __itt_id parentid, __itt_string_handle *name); + void ITTAPI __itt_task_begin_fn (const __itt_domain *domain,__itt_id taskid, + __itt_id parentid, void* address); -``void ITTAPI __itt_task_end (const __itt_domain *domain)`` + void ITTAPI __itt_task_end (const __itt_domain *domain); **To create a simple task instance in a different clock domain, use the following functions:** - -``void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` +.. code-block:: cpp -``void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, void* fn)`` + void ITTAPI __itt_task_begin_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp, __itt_id taskid, __itt_id parentid, + __itt_string_handle* name); + void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp, __itt_id taskid, + __itt_id parentid, void* fn); -``void ITTAPI _itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp)`` + void ITTAPI _itt_task_end_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp); **To create an overlapped task instance on a thread, use the following functions:** -``void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` +.. code-block:: cpp -``void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid)`` + void ITTAPI __itt_task_begin_overlapped(const __itt_domain* domain, __itt_id taskid, + __itt_id parentid, __itt_string_handle* name); + + void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain, __itt_id taskid); The argument ``taskid`` is mandatory for these functions. @@ -108,22 +111,23 @@ The argument ``taskid`` is mandatory for these functions. the following functions:** -``void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid, __itt_id parentid, __itt_string_handle* name)`` - +.. code-block:: cpp -``void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, unsigned long long timestamp, __itt_id taskid)`` + void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp, __itt_id taskid, + __itt_id parentid, __itt_string_handle* name); -The argument ``taskid`` is mandatory for these functions. + void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* domain, __itt_clock_domain* clock_domain, + unsigned long long timestamp, __itt_id taskid); +The argument ``taskid`` is mandatory for these functions. .. _task-api-IJIT_NOTIFYEVENT_FUNCTION: - - ITTAPI__itt_task_* Function Parameters ------------------------------------------ @@ -132,33 +136,38 @@ The following table defines the parameters used in the Task API primitives. -.. list-table:: - :header-rows: 1 - - * - Type - - Parameter - - Description - * - [in] - - \ ``__itt_domain``\ - - The domain of the task. - * - [in] - - \ ``__itt_id taskid``\ - - User-defined ID optional for all task instances, except for overlapped task instances. \ ``__itt_null`` can be used as default for undefined task instances. Task ID is used to define relations between task instances. - * - [in] - - \ ``__itt_id parentid``\ - - Optional parameter. Parent instance ID, to which the task belongs, or \_\ ``_itt_null``. - * - [in] - - \ ``__itt_string_handle``\ - - The task string handle. - * - [in] - - ``void* fn`` - - Function address that can be used instead of the name. For example, the function address can be resolved into the function name by using debug symbol information. - * - [in] - - ``__itt_clock_domain`` - - User-defined clock domain. - * - [in] - - ``unsigned long long timestamp`` - - User-defined timestamp for the corresponding clock domain. ++--------+---------------------------------+---------------------------------------------------------------------+ +| Type | Parameter | Description | ++========+=================================+=====================================================================+ +| [in] | .. code-block:: cpp | The domain of the task. | +| | | | +| | __itt_domain | | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | User-defined ID optional for all task instances, | +| | | except for overlapped task instances. | +| | __itt_id taskid | ``__itt_null`` can be used as default for undefined task instances. | +| | | Task ID is used to define relations between task instances. | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | Optional parameter. Parent instance ID, to which | +| | | the task belongs, or ``__itt_null``. | +| | __itt_id parentid | | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | The task string handle. | +| | | | +| | __itt_string_handle | | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | Function address that can be used instead of the name. | +| | | For example, the function address can be resolved | +| | void* fn | into the function name by using debug symbol information. | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | User-defined clock domain. | +| | | | +| | __itt_clock_domain | | ++--------+---------------------------------+---------------------------------------------------------------------+ +| [in] | .. code-block:: cpp | User-defined timestamp for the corresponding clock domain. | +| | | | +| | unsigned long long timestamp | | ++--------+---------------------------------+---------------------------------------------------------------------+ Usage Example @@ -169,7 +178,7 @@ The following code snippet creates a domain and a couple of tasks at global scope. -.. code:: cpp +.. code-block:: cpp #include "ittnotify.h" @@ -232,9 +241,11 @@ global scope. clock_gettime(CLOCK_REALTIME, &start_time); while(1) { clock_gettime(CLOCK_REALTIME, ¤t_time); - TYPE cur_nsec=(long)((current_time.tv_sec-start_time.tv_sec-sec)*NSEC + current_time.tv_nsec - start_time.tv_nsec); + TYPE cur_nsec=(long)((current_time.tv_sec-start_time.tv_sec-sec)*NSEC + + current_time.tv_nsec - start_time.tv_nsec); if(cur_nsec>=0) break; } } #endif + diff --git a/docs/src/ittapi/thread-naming-api.rst b/docs/src/ittapi/thread-naming-api.rst index 277c9fdc..9844f72a 100644 --- a/docs/src/ittapi/thread-naming-api.rst +++ b/docs/src/ittapi/thread-naming-api.rst @@ -4,43 +4,45 @@ Thread Naming API ================= -By default, each thread in your application displays in the **timeline** -track with a default label generated from the process ID and the thread -ID, or with the OS thread name. You can use the Thread Naming API in -your code to give meaningful names to threads. +By default, each thread in your application displays in the **timeline** track. +The threads use a default label that uses the OS thread name or gets generated +from the process ID and the thread ID. To give meaningful names to your +threads, use the Thread Naming API. - -Thread Naming API is a per-thread function that works in all states +he Thread Naming API is a per-thread function that works in all states (paused or resumed). You must call this API from within the thread. - To set thread name using a char or Unicode string, use the primitive: +.. code-block:: cpp -``void __itt_thread_set_name (const __itt_char *name)`` - - -**Parameters of the primitive:** + void __itt_thread_set_name (const __itt_char *name); -.. list-table:: - :header-rows: 0 - * - \ ``[in]``\ - - \ ``name``\ - - The thread name +**Parameters of the primitive:** ++--------+------------------------+---------------------+ +| Type | Parameter | Description | ++========+========================+=====================+ +| [in] | .. code-block:: cpp | The thread name | +| | | | +| | name | | ++--------+------------------------+---------------------+ **To indicate that this thread should be ignored from analysis:** +.. code-block:: cpp -``void __itt_thread_ignore (void)`` + void __itt_thread_ignore (void); -It does not affect the concurrency of the application. It does not be -visible in the **Timeline** pane. + +Calling ``__itt_thread_ignore()`` does not affect the application's +concurrency. After this call, the current thread will not be visible in the +**Timeline** pane. If the thread name is set multiple times, only the last name is used. @@ -50,11 +52,10 @@ Usage Example ------------- -You can use the following thread naming example to give a meaningful -name to the thread you wish to focus on and ignore the service thread. - +This example shows how you set a meaningful name to a specific thread +and ignore the service thread. -.. code:: cpp +.. code-block:: cpp DWORD WINAPI service_thread(LPVOID lpArg) @@ -75,10 +76,9 @@ name to the thread you wish to focus on and ignore the service thread. int main(int argc, char* argv[]) { - ... CreateThread(NULL, 0, service_thread, NULL, 0, NULL); CreateThread(NULL, 0, thread_function, NULL, 0, NULL); - ... + return 0; } diff --git a/docs/src/ittapi/user-defined-synchronization-api.rst b/docs/src/ittapi/user-defined-synchronization-api.rst index e591ff95..e73f2a64 100644 --- a/docs/src/ittapi/user-defined-synchronization-api.rst +++ b/docs/src/ittapi/user-defined-synchronization-api.rst @@ -4,26 +4,21 @@ User-Defined Synchronization API ================================ -While the Intel® VTune™ Profiler supports a significant portion of the -Windows\* OS and POSIX\* APIs, it is often useful for you to define your -own synchronization constructs. Any specially built constructs that you -create are not normally tracked by the VTune Profiler. However, the -VTune Profiler includes the synchronization API to help you gather -statistical information related to user-defined synchronization -constructs. - +Although Intel® VTune™ Profiler supports several Windows* OS and POSIX* APIs, +you may find it useful to define your own synchronization constructs. VTune +Profiler does not typically track the custom constructs that you create. +However, you can use the Synchronization API to collect statistical information +about the synchronization constructs you have defined. The User-Defined Synchronization API is a per-thread function that works -in resumed state. This function does not work in paused state. - - -Synchronization constructs may generally be modeled as a series of -signals. One thread or many threads may wait for a signal from another -group of threads telling them they may proceed with some action. By -tracking when a thread begins waiting for a signal, and then noting when -the signal occurs, the synchronization API can take a user-defined -synchronization object and give you an understanding of your code. The -API uses memory handles along with a set of primitives to gather +in the resumed profiling state only. + +Synchronization constructs may generally be modeled as a series of signals. +One or several threads may wait for a signal from another group of threads to +inform them to proceed with specific action. The synchronization API tracks +from the instant when a thread begins to wait for a signal and then notes the +arrival of the signal. This information can help you understand your code +better. This API uses memory handles along with a set of primitives to gather statistics on the user-defined synchronization object. @@ -34,118 +29,118 @@ statistics on the user-defined synchronization object. analysis type. -- `Using User-Defined Synchronization API in Your - Code <#USING_USER-DEFINED_SYNC>`__ - - -- `Usage Example: User-Defined - Spin-Waits <#EXAMPLE_USER-DEFINED_SPIN-WAITS>`__ - - -- `Usage Example: User-Defined Synchronized Critical - Section <#EXAMPLE_USER-DEFINED_CRITICAL_SECTION>`__ - - -- `Usage Example: User-Level Synchronized - Barrier <#EXAMPLE_SYNCHRONIZED_BARRIER>`__ - - Using User-Defined Synchronization API in Your Code --------------------------------------------------- -The following table describes the user-defined synchronization API -primitives, available for use on Windows\* and Linux\* operating -systems: - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``void __itt_sync_create (void *addr, const __itt_char *objtype, const __itt_char *objname, int attribute)``\ - - Register the creation of a sync object using char or Unicode string. - * - ``void __itt_sync_rename (void *addr, const __itt_char *name)`` - - Assign a name to a sync object using char or Unicode string, after it was created. - * - \ ``void __itt_sync_destroy (void *addr)``\ - - Track lifetime of the destroyed object. - * - \ ``void __itt_sync_prepare (void *addr)``\ - - Enter spin loop on user-defined sync object. - * - \ ``void __itt_sync_cancel (void *addr)``\ - - Quit spin loop without acquiring spin object. - * - \ ``void __itt_sync_acquired (void *addr)``\ - - Define successful spin loop completion (sync object acquired). - * - \ ``void __itt_sync_releasing (void *addr)``\ - - Start sync object releasing code. This primitive is called before the lock release call. - - - - -Each API call has a single parameter, addr. The address, not the value, -is used to differentiate between two or more distinct custom -synchronization objects. Each unique address enables the VTune Profiler -to track a separate custom object. Therefore, to use the same custom -object to protect access in different parts of your code, use the same -addr parameter around each. - - -When properly embedded in your code, the primitives tell the VTune -Profiler when the code is attempting to perform some type of -synchronization. Each prepare primitive must be paired with a cancel or -acquired primitive. - - -Each user-defined synchronization construct may involve any number of -synchronization objects. Each synchronization object must be triggered -off of a unique memory handle, which the user-defined synchronization -API uses to track the object. Any number of synchronization objects may -be tracked at one time using the user-defined synchronization API, as -long as each object uses a unique memory pointer. You can think of this -as modeling objects similar to the WaitForMultipleObjects function in -the Windows\* OS API. You can create more complex synchronization -constructs out of a group of synchronization objects; however, it is not -advisable to interlace different user-defined synchronization constructs -as this results in incorrect behavior. +The following table describes the user-defined synchronization API primitives +that are available for use on Windows* and Linux* operating systems: + + ++------------------------------------+-------------------------------------------+ +| Use This Primitive | To Do This | ++====================================+===========================================+ +| .. code-block:: cpp | Register the creation of a | +| | sync object using char or Unicode string. | +| void | | +| __itt_sync_create( | | +| void *addr, | | +| const __itt_char *objtype, | | +| const __itt_char *objname, | | +| int attribute) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Assign a name to a sync object using char | +| | or Unicode string, after it was created. | +| void | | +| __itt_sync_rename( | | +| void *addr, | | +| const __itt_char *name) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Track lifetime of the destroyed object. | +| | | +| void | | +| __itt_sync_destroy( | | +| void *addr) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Enter spin loop on user-defined | +| | sync object. | +| void | | +| __itt_sync_prepare( | | +| void *addr) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Quit spin loop without acquiring | +| | spin object. | +| void | | +| __itt_sync_cancel( | | +| void *addr) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Define successful spin loop completion | +| | (sync object acquired). | +| void | | +| __itt_sync_acquired( | | +| void *addr) | | ++------------------------------------+-------------------------------------------+ +| .. code-block:: cpp | Start sync object releasing code. | +| | This primitive is called | +| void | before the lock release call. | +| __itt_sync_releasing( | | +| void *addr) | | ++------------------------------------+-------------------------------------------+ + + +Each API call has a single parameter called addr. The address is used to +differentiate between two or more distinct custom synchronization objects. +Each unique address enables VTune Profiler to track a separate custom object. +Therefore, to use the same custom object to protect access in different parts +of your code, use the same addr parameter around each API call that operates +on that object. + +When properly embedded in your code, the primitives inform VTune Profiler +when the code attempts to perform some type of synchronization. Each prepare +primitive must be paired with a cancel or acquired primitive. + +A synchronization construct you define may involve any number of +synchronization objects. Each synchronization object must be triggered off +of a unique memory handle, which the user-defined synchronization API uses +to track the object. Any number of synchronization objects may be tracked +simultaneously using the user-defined synchronization API, as long as each +object uses a unique memory pointer. This action is similar to modeling +objects in the WaitForMultipleObjects function in the Windows* OS API. + +You can create more complex synchronization constructs out of a group of +synchronization objects. However, avoid interlacing different user-defined +synchronization constructs as this may cause incorrect behavior. API Usage Tips -------------- - The user-defined synchronization API requires proper placement of the -primitives within your code. Appropriate usage of the user-defined -synchronization API can be accomplished by following these guidelines: - +primitives within your code. Follow these guidelines: - Put a prepare primitive immediately before the code that attempts to obtain access to a synchronization object. - - Put either a cancel primitive or an acquired primitive immediately after your code is no longer waiting for a synchronization object. +- Use the releasing primitive immediately before when the code signals + that no synchronization object is held. -- The releasing primitive should be used immediately before the code - signals that it no longer holds a synchronization object. - +- When using multiple prepare primitives to simulate any construct that waits + for multiple objects, the result is determined by the last cancel or + acquired primitive called for any object in the group of objects. -- When using multiple prepare primitives to simulate any construct that - waits for multiple objects, the last individual cancel or acquired - primitive on an object related to the group of prepare primitives - determines if the behavior of the construct is a cancel or acquired - respectively. +Key Considerations and Performance Impact: - The time between a prepare primitive and an acquired primitive may be - considered impact time - + considered as impact time. - The time between a prepare primitive and a cancel primitive is considered blocking time, even though the processor does not necessarily block. - - Improper use of the user-defined synchronization API results in incorrect statistical data. @@ -154,58 +149,52 @@ Usage Example: User-Defined Spin-Waits -------------------------------------- -The prepare API indicates to the VTune Profiler that the current thread +The prepare API indicates to VTune Profiler that the current thread is about to begin waiting for a signal on a memory location. This call must occur before you invoke the user synchronization construct. The prepare API must always be paired with a call to either the acquired or cancel API. -The following code snippet shows the use of the prepare and acquired API -used in conjunction with a user-defined spin-wait construct: +This example shows the use of the prepare and acquired API in conjunction +with a user-defined spin-wait construct: -.. code:: cpp +.. code-block:: cpp long spin = 1; - . . . . - . . . . + __itt_sync_prepare((void *) &spin ); while(ResourceBusy); // spin wait; __itt_sync_acquired((void *) &spin ); -Using the cancel API may be applicable to other scenarios where the -current thread tests the user synchronization construct and decides to -do something useful instead of waiting for a signal from another thread. -See the following code example: +You may want to use the cancel API in scenarios where the current thread tests +the user synchronization construct and chooses to focus on a different task +instead of wait for a signal from another thread. See this example: -.. code:: cpp +.. code-block:: cpp long spin = 1; - . . . . - . . . . + __itt_sync_prepare((void *) &spin ); while(ResourceBusy) { -     __itt_sync_cancel((void *) &spin ); -      - + __itt_sync_cancel((void *) &spin );     //     // Do useful work     // -     . . . . . -     . . . . . -     // +  // ... + //     // Once done with the useful work, this construct will test the     // lock variable and try to acquire it again. Before this can     // be done, a call to the prepare API is required.     // -     __itt_sync_prepare((void *) &spin ); + __itt_sync_prepare((void *) &spin ); } __itt_sync_acquired((void *) &spin); @@ -215,12 +204,11 @@ current thread releases the lock. The following example shows how to use the releasing API: -.. code:: cpp +.. code-block:: cpp long spin = 1; - . . . . - . . . . + __itt_sync_releasing((void *) &spin ); // Code here should free the resource @@ -229,60 +217,55 @@ Usage Example: User-Defined Synchronized Critical Section --------------------------------------------------------- -The following code snippet shows how to create a critical section -construct that can be tracked using the user-defined synchronization -API: +This example shows how to create a critical section construct that can be +tracked using the user-defined synchronization API: -.. code:: cpp +.. code-block:: cpp CSEnter() { -   __itt_sync_prepare((void*) &cs); -   while(LockIsUsed) -   { -     if(LockIsFree) -     { + __itt_sync_prepare((void*) &cs); + while(LockIsUsed) + { + if(LockIsFree) + {     // Code to actually acquire the lock goes here -     __itt_sync_acquired((void*) &cs); -     } -     if(timeout) -     { -     __itt_sync_cancel((void*) &cs ); -     } -   } + __itt_sync_acquired((void*) &cs); + } + if(timeout) + { + __itt_sync_cancel((void*) &cs ); + } + } } CSLeave() { if(LockIsMine) -     { -         __itt_sync_releasing((void*) &cs); + { + __itt_sync_releasing((void*) &cs);         // Code to actually release the lock goes here -     } + } } -This simple critical section example demonstrates how to use the -user-defined synchronization primitives. When looking at this example, -note the following points: +This critical section example demonstrates how to use the user-defined +synchronization primitives. Note the following points: - Each prepare primitive is paired with an acquired primitive or a cancel primitive. - - The prepare primitive is placed immediately before the user code begins waiting for the user lock. - - The acquired primitive is placed immediately after the user code actually obtains the user lock. - - The releasing primitive is placed before the user code actually releases the user lock. This ensures that another thread does not - call the acquired primitive before the VTune Profiler realizes that + call the acquired primitive before VTune Profiler realizes that this thread has released the lock. @@ -290,21 +273,20 @@ Usage Example: User-Level Synchronized Barrier ---------------------------------------------- -Higher level constructs, such as barriers, are also easy to model using -the synchronization API. The following code snippet shows how to create -a barrier construct that can be tracked using the synchronization API: +You can use the synchronization API to model higher level constructs, like +barriers. This example shows how to create a barrier construct that you can +track using the synchronization API: -.. code:: cpp +.. code-block:: cpp Barrier() { teamflag = false; __itt_sync_releasing((void *) &counter); - InterlockedIncrement(&counter); // use the atomic increment primitive appropriate to your OS and compiler - - + InterlockedIncrement(&counter); // Use the atomic increment primitive + if( counter == thread count ) { __itt_sync_acquired((void *) &counter); @@ -315,44 +297,40 @@ a barrier construct that can be tracked using the synchronization API: else { __ itt_sync_prepare((void *) &teamflag); - Wait for team flag + // Wait for team flag __ itt_sync_acquired((void *) &teamflag); } } -When looking at this example, note the following points: +Note the following points: - There are two synchronization objects in this barrier code. The counter object is used to do a gather-like signaling from all the - threads to the final thread indicating that each thread has entered - the barrier. Once the last thread hits the barrier it uses the - teamflag object to signal all the other threads that they may + threads to the final thread, indicating that each thread has entered + the barrier. + Once the last thread hits the barrier, the thread uses the + teamflag object to signal to all the other threads that they may proceed. - -- As each thread enters the barrier it calls \__itt_sync_releasing to - tell the VTune Profiler that it is about to signal the last thread by +- A thread entering the barrier calls ``__itt_sync_releasing()`` to + inform VTune Profiler that it is about to signal the last thread by incrementing counter - -- The last thread to enter the barrier calls \__itt_sync_acquired to - tell the VTune Profiler that it was successfully signaled by all the +- The last thread to enter the barrier calls ``__itt_sync_acquired()`` to + inform VTune Profiler that it was successfully signaled by all the other threads. +- The last thread to enter the barrier calls ``__itt_sync_releasing()`` to + inform VTune Profiler that it is going to signal the barrier + completion to all the other threads by setting teamflag. -- The last thread to enter the barrier calls \__itt_sync_releasing to - tell the VTune Profiler that it is going to signal the barrier - completion to all the other threads by setting teamflag - - -- Each thread, except the last, calls the \__itt_sync_prepare primitive - to tell the VTune Profiler that it is about to start waiting for the - teamflag signal from the last thread. - +- With the exception of the last thread, every other thread calls the + ``__itt_sync_prepare()`` to inform VTune Profiler that it is about to + start waiting for the teamflag signal from the last thread. - Finally, before leaving the barrier, each thread calls the - \__itt_sync_acquired primitive to tell the VTune Profiler that it - successfully received the end-of-barrier signal. + ``__itt_sync_acquired()`` primitive to inform VTune Profiler that it + received the end-of-barrier signal successfully. diff --git a/docs/src/jit-api-support.rst b/docs/src/jit-api-support.rst index 8838df79..facc547d 100644 --- a/docs/src/jit-api-support.rst +++ b/docs/src/jit-api-support.rst @@ -1,28 +1,32 @@ .. _jit-api-support: -JIT API -======= +Just-In-Time API (JIT API) +========================== -The JIT (Just-In-Time) Profiling API provides functionality to report -information about just-in-time generated code that can be used by -performance tools. You must insert JIT Profiling API calls in the code -generator to report information before JIT-compiled code goes to -execution. This information is collected at runtime and used by tools -like Intel® VTune™ Profiler to display performance metrics associated +Use the Just-In-Time(JIT) Profiling API to enable performance tools to collect +information about just-in-time generated codes. You must insert JIT Profiling +API calls in the code generator to report information before the JIT-compiled +code goes to execution. This information is collected at runtime and used by +tools like Intel® VTune™ Profiler to display performance metrics associated with JIT-compiled code. +You can use the JIT Profiling API to profile scenarios like: + +- Dynamic JIT compilation of JavaScript code traces +- JIT execution in OpenCL™ applications +- Java*/.NET* managed execution environments +- Custom ISV JIT engines You can use the JIT Profiling API to profile such environments as dynamic JIT compilation of JavaScript code traces, JIT execution in -OpenCL™ applications, Java*/.NET\* managed execution environments, and +OpenCL™ applications, Java*/.NET* managed execution environments, and custom ISV JIT engines. - -The JIT engine generating code during runtime communicates with a profiler -object (Collector) through the static part. During runtime, the JIT engine -reports the information about JIT-compiled code stored in a trace file by -the profiler object. After collection, profiling tool uses the generated +The JIT engine generates code during runtime and communicates through the +static part with a profiler object (Collector). During runtime, the JIT engine +reports the information about JIT-compiled code that is stored in a trace file +by the profiler object. After collection, the profiling tool uses the generated trace file to resolve the JIT-compiled code. @@ -31,38 +35,30 @@ Use the JIT Profiling API to: - :ref:`Profile trace-based and method-based JIT-compiled code` - - :ref:`Analyze split functions` - - :ref:`Explore inline functions` -JIT profiling is supported with the **Launch Application** target option -for event based sampling. - - Environment Variables in the JIT Profiling API ---------------------------------------------- -The JIT Profiling API contains two environment variables, which in turn -contain paths to specific runtime libraries. - +The JIT Profiling API contains two environment variables: - ``INTEL_JIT_PROFILER32`` - ``INTEL_JIT_PROFILER64`` +In turn, these variables contain paths to specific runtime libraries. These variables are used to signal the replacement of the stub implementation of the JIT API with the JIT API collector. -Once you instrument your code with the JIT API and link it to the -JIT API stub (``libjitprofiling.lib/libjitprofiling.a``), your code -loads the libraries defined in these environment variables, once the -variables are set. +After you instrument your code with the JIT API and link it to the +JIT API stub (``libjitprofiling.lib/libjitprofiling.a``), when the +environment variables are set, your code loads the libraries defined +in the variables. - -Make sure to set these environment variables for the ittnotify_collector +Make sure to set these environment variables for the ``ittnotify_collector`` to enable data collection: On Windows*: @@ -96,7 +92,7 @@ This is the most common scenario for using JIT Profiling API to profile trace-based and method-based JIT-compiled code: -.. code:: cpp +.. code-block:: cpp #include @@ -106,7 +102,6 @@ trace-based and method-based JIT-compiled code: return; } - iJIT_Method_Load jmethod = {0}; jmethod.method_id = iJIT_GetNewMethodID(); jmethod.method_name = "method_name"; @@ -115,35 +110,30 @@ trace-based and method-based JIT-compiled code: jmethod.method_load_address = code_addr; jmethod.method_size = code_size; - - iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, - (void*)&jmethod); + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&jmethod); iJIT_NotifyEvent(iJVM_EVENT_TYPE_SHUTDOWN, NULL); **Usage Tips** -- If any ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an - already reported method, then such a method becomes invalid and its - memory region is treated as unloaded. - - -- If supplied line number information contains multiple source lines - for the same assembly instruction (code location), then profiling - tool picks up the first line number. +- If any ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites a method + that has already been reported , that method becomes invalid. The memory + region of the method is treated as unloaded. +- If the line number information that was provided contains multiple source + lines for the same assembly instruction (code location), the profiling tool + selects the first line number. -- Dynamically generated code can be associated with a module name. Use - the ``iJIT_Method_Load_V2`` structure. +- You can associate dynamically generated code with a module name. Use the + ``iJIT_Method_Load_V2`` structure for this purpose. +- If you register a function with the same method ID multiple times and you + specify different module names, the profiling tool selects the module name + that was registered first. If you want to distinguish the same function + between different JIT engines, provide different method IDs for each + function. Other symbolic information, like source file, can be identical. -- If you register a function with the same method ID multiple times, - specifying different module names, then profiling tool picks - up the module name registered first. If you want to distinguish - the same function between different JIT engines, supply different - method IDs for each function. Other symbolic information (for - example, source file) can be identical. .. _Analyze split functions : @@ -151,15 +141,12 @@ Analyze Split Functions ----------------------- -You can use the JIT Profiling API to analyze split functions (multiple -joint or disjoint code regions belonging to the same function) including -re-JITting with potential overlapping of code regions in time, which is -common in resource-limited environments. - - -.. code:: cpp +You can use the JIT Profiling API to analyze split functions. This scenario +often occurs in resource-limited environments, where code for the same function +is generated or updated in separate segments, sometimes with overlapping lifetimes. +.. code-block:: cpp #include @@ -187,35 +174,32 @@ common in resource-limited environments. **Usage Tips** -- If a ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites an - already reported method, then such a method becomes invalid and its - memory region is treated as unloaded. - - -- All code regions reported with the same method ID are considered as - belonging to the same method. Symbolic information (method name, - source file name) will be taken from the first notification, and all - subsequent notifications with the same method ID will be processed - only for line number table information. +- If a ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` event overwrites a method + that was already reported, that method becomes invalid and its memory + region is treated as unloaded. +- All code regions that are reported with the same method ID are + considered to belong to the same method. Symbolic information + (method name, source file name) is taken from the first notification. + All subsequent notifications with the same method ID are processed only + for the information in the line number table. - If you register a second code region with a different source file - name and the same method ID, this information will be saved and - will not be considered as an extension of the first code region, - but profiling tool will use the source file of the first code - region and map performance metrics incorrectly. - + name and the same method ID, this information is saved and is not + considered as an extension of the first code region. However, the + profiling tool uses the source file of the first code region and + can map performance metrics incorrectly. - If you register a second code region with the same source file as - for the first region and the same method ID, the source file will - be discarded but profiling tool will map metrics to the source - file correctly. - + the one used for the first region and you use the same method ID, + the source file is discarded but the profiling tool maps metrics to + the source file correctly. - If you register a second code region with a null source file and the same method ID, provided line number info will be associated with the source file of the first code region. + .. _Explore inline functions: Explore Inline Functions @@ -223,21 +207,21 @@ Explore Inline Functions You can use the JIT Profiling API to explore inline functions including -multi-level hierarchy of nested inline methods that shows how -performance metrics are distributed through them. +the multilevel hierarchy of nested inline methods that shows the distribution +of performance metrics. -.. code:: cpp +.. code-block:: cpp #include - // method_id parent_id - // [-- c --] 3000 2000 - // [---- d -----] 2001 1000 - // [---- b ----] 2000 1000 - // [------------ a ----------------] 1000 n/a + // method_id parent_id + // [-- c --] 3000 2000 + // [---- d -----] 2001 1000 + // [---- b ----] 2000 1000 + // [------------ a ----------------] 1000 n/a iJIT_Method_Load a = {0}; @@ -271,27 +255,22 @@ performance metrics are distributed through them. - Each inline (``iJIT_Method_Inline_Load``) method should be associated with two method IDs: one for itself; one for its immediate parent. - - Address regions of inline methods of the same parent method cannot overlap each other. +- Execution of the parent method must not start until the parent method + and all its inline methods are reported. -- Execution of the parent method must not be started until it and all - its inline methods are reported. - - -- In case of nested inline methods an order of - ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` events is not - important. - +- For nested inline methods, the order of + ``iJVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED`` events is not important. - If any event overwrites either inline method or top parent method, - then the parent, including inline methods, becomes invalid and its + then the parent, including inline methods, becomes invalid and their memory region is treated as unloaded. -See Also --------- +Learn More +---------- .. toctree:: diff --git a/docs/src/jitapi/ijit_-getnewmethodid.rst b/docs/src/jitapi/ijit_-getnewmethodid.rst index 46155b07..b9dcca6b 100644 --- a/docs/src/jitapi/ijit_-getnewmethodid.rst +++ b/docs/src/jitapi/ijit_-getnewmethodid.rst @@ -1,7 +1,7 @@ .. _ijit_-getnewmethodid: -iJIT\_ GetNewMethodID -===================== +iJIT GetNewMethodID +=================== Generates a new unique method ID. @@ -10,20 +10,19 @@ Generates a new unique method ID. Syntax ------ -.. code:: cpp +.. code-block:: cpp - unsigned int iJIT_GetNewMethodID(void); + unsigned int iJIT_GetNewMethodID(void); Description ----------- -The\ ``iJIT_GetNewMethodID`` function generates new method ID upon each -call. Use this API to obtain unique and valid method IDs for methods or -traces reported to the agent if you do not have your own mechanism to -generate unique method IDs. +Upon each call, the ``iJIT_GetNewMethodID`` function generates new method ID. +Use this API to obtain unique and valid method IDs for methods or traces reported +to the agent if you do not have your own mechanism to generate unique method IDs. Input Parameters diff --git a/docs/src/jitapi/ijit_isprofilingactive.rst b/docs/src/jitapi/ijit_isprofilingactive.rst index a86191f6..2cf0911f 100644 --- a/docs/src/jitapi/ijit_isprofilingactive.rst +++ b/docs/src/jitapi/ijit_isprofilingactive.rst @@ -10,18 +10,17 @@ Returns the current mode of the agent. Syntax ------ -.. code:: cpp +.. code-block:: cpp - iJIT_IsProfilingActiveFlags JITAPI iJIT IsProfilingActive ( void ); + iJIT_IsProfilingActiveFlags JITAPI iJIT IsProfilingActive(void); Description ----------- -The ``iJIT_IsProfilingActive`` function returns the current mode of the -agent. +The ``iJIT_IsProfilingActive`` function returns the current mode of the agent. Input Parameters diff --git a/docs/src/jitapi/ijit_notifyevent.rst b/docs/src/jitapi/ijit_notifyevent.rst index b12263b5..9e9c4096 100644 --- a/docs/src/jitapi/ijit_notifyevent.rst +++ b/docs/src/jitapi/ijit_notifyevent.rst @@ -10,75 +10,75 @@ Reports information about JIT-compiled code to the agent. Syntax ------ -.. code:: cpp +.. code-block:: cpp - int iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void EventSpecificData); + int iJIT_NotifyEvent(iJIT_JVM_EVENT event_type, void EventSpecificData); Description ----------- -The ``iJIT_NotifyEvent``\ function sends a notification of +The ``iJIT_NotifyEvent`` function sends a notification of ``event_type`` with the data pointed by ``EventSpecificData`` to the agent. The reported information is used to attribute samples obtained -from any profiling tool collector. This API needs to be called -after JIT compilation and before the first entry into the JIT-compiled -code. +from any profiling tool collector. Make sure to call this API after +JIT compilation and before the first entry into the JIT-compiled code. Input Parameters ---------------- -.. list-table:: - :header-rows: 0 - - * - Parameter - - Description - * - \ ``iJIT_JVM_EVENT event_type``\ - - Notification code sent to the agent. See a complete list of - `event types <#EVENT_TYPE>`__ below. - * - \ ``void *EventSpecificData``\ - - Pointer to `event specific data <#STRUCTURE>`__. - - - - -The following values are allowed for ``event_type``: - - -.. list-table:: - :header-rows: 0 - - * - - - Send this notification after a JITted method has been loaded into - memory, and possibly JIT compiled, but before the code is executed. - Use the ``iJIT_Method_Load`` structure for ``EventSpecificData``. - The return value of ``iJIT_NotifyEvent``\ is undefined. - * - \ ``iJVM_EVENT_TYPE_SHUTDOWN``\ - - Send this notification to terminate profiling. Use NULL for - ``EventSpecificData``. ``iJIT_NotifyEvent`` returns 1 on success. - * - \ ``JVM_EVENT_TYPE_METHOD_UPDATE``\ - - Send this notification to provide new content for a previously reported - dynamic code. The previous content will be invalidated starting from the - time of the notification. Use the ``iJIT_Method_Load`` structure for - ``EventSpecificData`` with the following required fields: - * - - - Send this notification when an inline dynamic code is JIT compiled and - loaded into memory by the JIT engine, but before the parent code region - starts executing. Use the ``iJIT_Method_Inline_Load`` - structure for ``EventSpecificData``. - * - - - Send this notification when a dynamic code is JIT compiled and loaded into - memory by the JIT engine, but before the code is executed. Use the - ``iJIT_Method_Load_V2`` structure for ``EventSpecificData``. - - - - -The following structures can be used for ``EventSpecificData``: ++-------------------------------+--------------------------------------------+ +| Parameter | Description | ++===============================+============================================+ +| .. code-block:: cpp | Notification code sent to the agent. | +| | See a complete list of event types below. | +| iJIT_JVM_EVENT event_type | See a complete list of event types below. | ++-------------------------------+--------------------------------------------+ +| .. code-block:: cpp | Pointer to event specific data. | +| | | +| void *EventSpecificData | | ++-------------------------------+--------------------------------------------+ + + +The following values are acceptable for ``event_type``: + + ++---------------------------------------------+---------------------------------------------------------------+ +| Value | Description | ++=============================================+===============================================================+ +| .. code-block:: cpp | Send this notification after a JITted method has been loaded | +| | into memory, and possibly JIT compiled, but before the code | +| iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED | is executed. Use the iJIT_Method_Load structure for | +| | EventSpecificData. The return value of iJIT_NotifyEvent is | +| | undefined. | ++---------------------------------------------+---------------------------------------------------------------+ +| .. code-block:: cpp | Send this notification to terminate profiling. Use NULL for | +| | EventSpecificData. iJIT_NotifyEvent returns 1 on success. | +| iJVM_EVENT_TYPE_SHUTDOWN | | ++---------------------------------------------+---------------------------------------------------------------+ +| .. code-block:: cpp | Send this notification to provide new content for a dynamic | +| | code that was reported previously. The previous content is | +| JVM_EVENT_TYPE_METHOD_UPDATE | invalidated, starting from the time of the notification. | +| | Use the iJIT_Method_Load structure for EventSpecificData | +| | with the following required fields: | ++---------------------------------------------+---------------------------------------------------------------+ +| .. code-block:: cpp | Send this notification when an inline dynamic code is JIT | +| | compiled and loaded into memory by the JIT engine, but before | +| JVM_EVENT_TYPE_METHOD_INLINE_LOAD_FINISHED| the parent code region starts executing. Use the | +| | iJIT_Method_Inline_Load structure for EventSpecificData. | ++---------------------------------------------+---------------------------------------------------------------+ +| .. code-block:: cpp | Send this notification when a dynamic code is JIT compiled | +| | and loaded into memory by the JIT engine, but before the code | +| iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2 | is executed. Use the iJIT_Method_Load_V2 structure for | +| | EventSpecificData. | ++---------------------------------------------+---------------------------------------------------------------+ + + +You can use the following structures for ``EventSpecificData``: **iJIT_Method_Inline_Load Structure** @@ -90,41 +90,55 @@ as an event type to report it. The\ ``iJIT_Method_Inline_Load`` structure has the following fields: -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must - either use the API function ``iJIT_GetNewMethodID`` to get a valid - and unique method ID, or else manage ID uniqueness and correct - range by yourself. - * - \ ``unsigned int parent_method_id``\ - - Unique immediate parent’s method ID. Method ID may not be smaller - than 999. You must either use the API function iJIT_GetNewMethodID - to get a valid and unique method ID, or else manage ID uniqueness - and correct range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name - and appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, - then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` - is 0. See ``LineNumberInfo`` structure for a description of a single entry - in the line number info array. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - - ++------------------------------+------------------------------------------------+ +| Field | Description | ++==============================+================================================+ +| .. code-block:: cpp | Unique method ID. | +| | The Method ID cannot be smaller than 999. | +| unsigned int method_id | Use the API function | +| | ``iJIT_GetNewMethodID`` to get a valid and | +| | unique method ID, or choose to manage the | +| | uniqueness and range of the ID. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Unique immediate parents method ID. | +| | The Method ID cannot be smaller than 999. | +| unsigned int | Use the API function | +| parent_method_id | ``iJIT_GetNewMethodID`` to get a valid and | +| | unique method ID, or choose to manage the | +| | uniqueness and range of the ID. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The name of the method, optionally prefixed | +| | with its class name and appended with its | +| char *method_name | complete signature. This argument cannot be | +| | set to NULL. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The base address of the method code. | +| | Can be NULL if the method is not JITted. | +| void *method_load_address | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The virtual address on which the method is | +| | inlined. If NULL, then data provided with | +| unsigned int method_size | the event are not accepted. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The number of entries in the line number | +| | table. 0 if none. | +| unsigned int | | +| line_number_size | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Pointer to the line numbers info array. | +| | Can be NULL if ``line_number_size`` is 0. | +| pLineNumberInfo | See ``LineNumberInfo`` structure for a | +| line_number_table | description of a single entry in the line | +| | number info array. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Class name. | +| | Can be NULL. | +| char *class_file_name | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Source file name. | +| | Can be NULL. | +| char *source_file_name | | ++------------------------------+------------------------------------------------+ **iJIT_Method_Load Structure** @@ -135,45 +149,65 @@ compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED`` as an event type to report it. The\ ``iJIT_Method_Load`` structure has the following fields: - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must - either use the API function ``iJIT_GetNewMethodID`` to get a valid - and unique method ID, or else manage ID uniqueness and correct - range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name - and appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, - then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` - is 0. See ``LineNumberInfo`` structure for a description of a single entry - in the line number info array. - * - \ ``unsigned int class_id``\ - - This field is obsolete. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - * - \ ``void *user_data``\ - - This field is obsolete. - * - \ ``unsigned int user_data_size``\ - - This field is obsolete. - * - \ ``iJDEnvironmentType env``\ - - This field is obsolete. - - ++------------------------------+------------------------------------------------+ +| Field | Description | ++==============================+================================================+ +| .. code-block:: cpp | Unique method ID. | +| | Method ID cannot be smaller than 999. | +| unsigned int method_id | You must either use the API function | +| | ``iJIT_GetNewMethodID`` to get a valid and | +| | unique method ID, or else manage ID | +| | uniqueness and correct range by yourself. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The name of the method, optionally prefixed | +| | with its class name and appended with its | +| char *method_name | complete signature. This argument cannot be | +| | set to NULL. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The base address of the method code. | +| | Can be NULL if the method is not JITted. | +| void *method_load_address | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The virtual address on which the method is | +| | inlined. If NULL, then data provided with | +| unsigned int method_size | the event are not accepted. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The number of entries in the line number | +| | table. 0 if none. | +| unsigned int | | +| line_number_size | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Pointer to the line numbers info array. | +| | Can be NULL if ``line_number_size`` is 0. | +| pLineNumberInfo | See ``LineNumberInfo`` structure for a | +| line_number_table | description of a single entry in the line | +| | number info array. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | This field is obsolete. | +| | | +| unsigned int class_id | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Class name. | +| | Can be NULL. | +| char *class_file_name | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Source file name. | +| | Can be NULL. | +| char *source_file_name | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | This field is obsolete. | +| | | +| void *user_data | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | This field is obsolete. | +| | | +| unsigned int | | +| user_data_size | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | This field is obsolete. | +| | | +| iJDEnvironmentType env | | ++------------------------------+------------------------------------------------+ **iJIT_Method_Load_V2 Structure** @@ -184,39 +218,52 @@ compiled method, use ``iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED_V2`` as an event type to report it. The\ ``iJIT_Method_Load_V2`` structure has the following fields: - -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int method_id``\ - - Unique method ID. Method ID cannot be smaller than 999. You must either - use the API function ``iJIT_GetNewMethodID`` to get a valid and unique - method ID, or else manage ID uniqueness and correct range by yourself. - * - \ ``char *method_name``\ - - The name of the method, optionally prefixed with its class name and - appended with its complete signature. This argument cannot be set to NULL. - * - \ ``void *method_load_address``\ - - The base address of the method code. Can be NULL if the method is not JITted. - * - \ ``unsigned int method_size``\ - - The virtual address on which the method is inlined. If NULL, - then data provided with the event are not accepted. - * - \ ``unsigned int line_number_size``\ - - The number of entries in the line number table. 0 if none. - * - \ ``pLineNumberInfo line_number_table``\ - - Pointer to the line numbers info array. Can be NULL if ``line_number_size`` - is 0. See ``LineNumberInfo`` structure for a description of a single entry - in the line number info array. - * - \ ``char *class_file_name``\ - - Class name. Can be NULL. - * - \ ``char *source_file_name``\ - - Source file name. Can be NULL. - * - \ ``char *module_name``\ - - Module name. Can be NULL. The module name can be useful for - distinguishing among different JIT engines. - - ++------------------------------+------------------------------------------------+ +| Field | Description | ++==============================+================================================+ +| .. code-block:: cpp | Unique method ID. | +| | Method ID cannot be smaller than 999. You must | +| unsigned int method_id | either use the API function | +| | ``iJIT_GetNewMethodID`` to get a valid and | +| | unique method ID, or else manage ID | +| | uniqueness and correct range by yourself. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The name of the method, optionally prefixed | +| | with its class name and appended with its | +| char *method_name | complete signature. This argument cannot be | +| | set to NULL. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The base address of the method code. | +| | Can be NULL if the method is not JITted. | +| void *method_load_address | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The virtual address on which the method is | +| | inlined. If NULL, then data provided with | +| unsigned int method_size | the event are not accepted. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | The number of entries in the line number | +| | table. 0 if none. | +| unsigned int | | +| line_number_size | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Pointer to the line numbers info array. | +| | Can be NULL if ``line_number_size`` is 0. | +| pLineNumberInfo | See ``LineNumberInfo`` structure for a | +| line_number_table | description of a single entry in the line | +| | number info array. | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Class name. | +| | Can be NULL. | +| char *class_file_name | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Source file name. | +| | Can be NULL. | +| char *source_file_name | | ++------------------------------+------------------------------------------------+ +| .. code-block:: cpp | Module name. | +| | Can be NULL. The module name can be useful for | +| char *module_name | distinguishing among different JIT engines. | ++------------------------------+------------------------------------------------+ **LineNumberInfo Structure** @@ -225,66 +272,58 @@ following fields: Use the ``LineNumberInfo`` structure to describe a single entry in the line number information of a code region. A table of line number entries provides information about how the reported code region is mapped to -source file. Profiling tool uses line number information to attribute -the samples (virtual address) to a line number. It is acceptable to -report different code addresses for the same source line: - - -.. list-table:: - :header-rows: 0 - - * - \ **Offset**\ - - \ **Line Number**\ - * - 1 - - 2 - * - 12 - - 4 - * - 15 - - 2 - * - 18 - - 1 - * - 21 - - 30 - - +source file. The Profiling tool uses line number information to attribute +the samples (virtual address) to a line number. You can report different +code addresses for the same source line: + + ++------------+-----------------+ +| **Offset** | **Line Number** | ++============+=================+ +| 1 | 2 | ++------------+-----------------+ +| 12 | 4 | ++------------+-----------------+ +| 15 | 2 | ++------------+-----------------+ +| 18 | 1 | ++------------+-----------------+ +| 21 | 30 | ++------------+-----------------+ Profilers construct the following table using the client data: -.. list-table:: - :header-rows: 0 - - * - \ **Code sub-range**\ - - \ **Line Number**\ - * - 0-1 - - 2 - * - 1-12 - - 4 - * - 12-15 - - 2 - * - 15-18 - - 1 - * - 18-21 - - 30 - - ++-------------------+-----------------+ +| **Code sub-range**| **Line Number** | ++===================+=================+ +| 0-1 | 2 | ++-------------------+-----------------+ +| 1-12 | 4 | ++-------------------+-----------------+ +| 12-15 | 2 | ++-------------------+-----------------+ +| 15-18 | 1 | ++-------------------+-----------------+ +| 18-21 | 30 | ++-------------------+-----------------+ The ``LineNumberInfo`` structure has the following fields: -.. list-table:: - :header-rows: 0 - - * - Field - - Description - * - \ ``unsigned int Offset``\ - - Opcode byte offset from the beginning of the method. - * - \ ``unsigned int LineNumber``\ - - Matching source line number offset (from beginning of source file). - - ++------------------------------+----------------------------------------------+ +| Field | Description | ++==============================+==============================================+ +| .. code-block:: cpp | Opcode byte offset from the | +| | beginning of the method. | +| unsigned int Offset | | ++------------------------------+----------------------------------------------+ +| .. code-block:: cpp | Matching source line number offset | +| | (from beginning of source file). | +| unsigned int LineNumber | | ++------------------------------+----------------------------------------------+ Return Values diff --git a/docs/src/minimize-itt-api-overhead.rst b/docs/src/minimize-itt-api-overhead.rst index 876fa0b6..e248b50c 100644 --- a/docs/src/minimize-itt-api-overhead.rst +++ b/docs/src/minimize-itt-api-overhead.rst @@ -4,65 +4,61 @@ Minimize ITT API Overhead ========================= -The ITT API overhead and its impact on the overall application -performance depends on the amount of instrumentation code added to the -application. When instrumenting an application with ITT API, you should -balance between application performance and the amount of performance -data that you need to collect, in order to minimize API overhead while -collecting sufficient performance data. +The extent of instrumentation you add to your application determines the +amount of overhead introduced by the ITT API and its impact on application +performance. To minimize this overhead, aim for a balance between desired +application performance and the amount of performance data you want to collect. +Use these guidelines: -Follow these guidelines to achieve good balance between overall -performance of the instrumented application and instrumentation detail: - - -- Instrument only those paths within your application that are +- Add instrumentation to only those paths in your application that are important for analysis. - Create ITT domains and string handles outside the critical paths. - Filter data collection by different aspects of your application that can be analyzed separately. The overhead for a disabled API call (thus filtering out the associated call) is always less than 10 clock - ticks, regardless of the API. + ticks. Conditional Compilation ----------------------- -For best performance in the release version of your code, use -conditional compilation to turn off annotations. Define the macro -``INTEL_NO_ITTNOTIFY_API`` before you include ittnotify.h during compilation -to eliminate all \__itt_\* functions from your code. +In the release version of your code, use conditional compilation to turn off +annotations. Before you include ``ittnotify.h`` during compilation, define the +macro ``INTEL_NO_ITTNOTIFY_API`` to eliminate all ``__itt_*`` functions from +your code. +By defining this macro, you can also remove the static library from the +linking stage. -You can also remove the static library from the linking stage by -defining this macro. +Usage Example: +-------------- -Usage Example: Using Domains and String Handles ------------------------------------------------ +The ITT APIs include a subset of functions that create domains and string +handles. These functions always return identical handles for the same domain +names and strings. This action requires the subset of functions to perform +string comparisons and table lookups. These comparisons and lookups can incur +serious performance penalties. Additionally, the performance of these functions +is proportional to the log of the number of created domains or string handles. +A good practice is to create domains and string handles in the global scope, +or during application startup. -The ITT APIs include a subset of functions which create domains and -string handles. These functions always return identical handles for the -same domain names and strings. This requires these functions to perform -string comparisons and table lookups, which can incur serious -performance penalties. In addition, the performance of these functions -is proportional to the log of the number of created domains or string -handles. It is best to create domains and string handles at global -scope, or during application startup. +The following code section creates two domains in the global scope. You can use +these domains to control the level of detail that is written to the trace file. -The following code section creates two domains in the global scope. You -can use these domains to control the level of detail that is written to -the trace file. +.. code-block:: cpp -.. code:: cpp - + #include "ittnotify.h" + // Create domains at global scope. __itt_domain* basic = __itt_domain_create(L"MyFunction.Basic"); __itt_domain* detailed = __itt_domain_create(L"MyFunction.Detailed"); + // Create string handles at global scope. __itt_string_handle* h_my_funcion = __itt_string_handle_create(L"MyFunction"); void MyFunction(int arg) @@ -72,6 +68,7 @@ the trace file. FooEx(); __itt_task_end(basic); } + __itt_string_handle* h_foo = __itt_string_handle_create(L"Foo"); void Foo(int arg) { @@ -80,6 +77,7 @@ the trace file. // Do some work here... __itt_task_end(detailed); } + __itt_string_handle* h_foo_ex = __itt_string_handle_create(L"FooEx"); void FooEx() { @@ -88,12 +86,18 @@ the trace file. // Do some work here... __itt_task_end(detailed); } + // This is my entry point. int main(int argc, char** argv) { if(argc < 2) - //Disable detailed domain if we do not need tracing from that in this - //application run - detailed ->flags = 0; - MyFunction(atoi(argv[1])); } + { + // Disable detailed domain if we do not need tracing from that + // in this application run. + detailed ->flags = 0; + } + + MyFunction(atoi(argv[1])); + return 0; + } diff --git a/docs/src/overview.rst b/docs/src/overview.rst index 935b8bd9..64063939 100644 --- a/docs/src/overview.rst +++ b/docs/src/overview.rst @@ -3,25 +3,35 @@ Overview ======== -The Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) API is an open -source feature of Intel's Analyzers tools that allows applications to generate and control -trace data during their execution. It enables developers to pinpoint and measure specific areas -of their code, providing valuable insights into performance bottlenecks and resource utilization. +When you use Intel analyzer tools to improve the performance of your software +application, during execution, use the Intel® Instrumentation and Tracing +Technology (ITT) and Just-In-Time (JIT) APIs to instrument your code to generate +trace data and control its collection. You use the ITT/JIT APIs to identify and +measure specific areas of code to get insights into performance bottlenecks and +resource utilization. -The ITT/JIT API includes: -- Instrumentation and Tracing Technology (ITT) API. - It enables your application to generate and control the collection of trace data during - its execution across different Intel tools. -- JIT (Just-In-Time) Profiling API. - It provides functionality to report information about just-in-time generated code that - can be used by performance profiling tools. +Components +---------- -The ITT/JIT API consists of two parts: a **static** part and a **dynamic** part. -- The **dynamic** part is specific for a tool and distributed only with a particular tool as - a dynamic(shared) library. The reference implementation of the **dynamic** part is provided - `here `__ as a Reference Collector. -- The **static** part is a common part shared between tools. Currently, the static part is - distributed as an open source static library: `ittapi `__ +- **ITT API**: Powers your application to generate and control the collection + of trace data during its execution, seamlessly integrating with Intel tools. +- **JIT API**: Reports detailed information about just-in-time (JIT) compiled + code, enabling you to profile the performance of dynamically generated code. + + +Architecture +------------ + + +The ITT/JIT APIs consist of two parts: + +- **Static Part**: An open-source static library + (`ittapi `__) that you compile and link + with your application to enable tracing features. +- **Dynamic Part**: A tool-specific shared library that collects and writes + trace data. You can find the reference implementation of the dynamic part + as a *Reference Collector* `here `__. + diff --git a/docs/src/ref_collector.rst b/docs/src/ref_collector.rst index 1978a8b1..5afa5da8 100644 --- a/docs/src/ref_collector.rst +++ b/docs/src/ref_collector.rst @@ -8,7 +8,7 @@ This is a reference implementation of the ITT API **dynamic** part that performs tracing data from ITT API function calls to log files. -To use this solution, it is required to build it as a shared library and the +To use this solution, build the collector as a shared library and point the full library path to the ``INTEL_LIBITTNOTIFY64`` or ``INTEL_LIBITTNOTIFY32`` environment variable: @@ -16,7 +16,7 @@ environment variable: **On Linux** -.. code-block:: console +.. code-block:: bash make export INTEL_LIBITTNOTIFY64=/libittnotify_refcol.so @@ -25,20 +25,20 @@ environment variable: **On FreeBSD** -.. code-block:: console +.. code-block:: bash make setenv INTEL_LIBITTNOTIFY64 /libittnotify_refcol.so -Temp directory is used by default to save log files. To change the log directory, +By default, log files save in the Temp directory. To change the location, use the ``INTEL_LIBITTNOTIFY_LOG_DIR`` environment variable: **On Linux** -.. code-block:: console +.. code-block:: bash export INTEL_LIBITTNOTIFY_LOG_DIR= @@ -47,7 +47,7 @@ use the ``INTEL_LIBITTNOTIFY_LOG_DIR`` environment variable: **On FreeBSD** -.. code-block:: console +.. code-block:: bash setenv INTEL_LIBITTNOTIFY_LOG_DIR @@ -58,7 +58,7 @@ logging of other ITT API function calls is welcome. The solution provides 4 functions with different log levels that take ``printf`` format for logging: -.. code-block:: c +.. code-block:: cpp LOG_FUNC_CALL_INFO(const char *msg_format, ...); LOG_FUNC_CALL_WARN(const char *msg_format, ...); diff --git a/docs/src/using-jit-api.rst b/docs/src/using-jit-api.rst index 1fa72d42..8302d21c 100644 --- a/docs/src/using-jit-api.rst +++ b/docs/src/using-jit-api.rst @@ -1,119 +1,56 @@ .. _using-jit-api: -Using JIT API -============= +Compile and Link with JIT API +============================= To include JIT Profiling support, do one of the following: -- +- Include the following files to your source tree: + #. ``jitprofiling.h``, located under ``\include`` directory, + in your code. This header file provides all API function prototype + and type definitions. + #. ``ittnotify_config.h``, ``ittnotify_types.h`` and ``jitprofiling.c``, + located under ``/src/ittnotify`` directory. - .. container:: - :name: LI_DB9BBDF5654E49BA9743FA34A8BEFC9C +- Link the jitprofiling Static Library: - - Include the following files to your source tree: - - - - - - - .. container:: - :name: LI_EABD97D44F984162B38420A57167AC5B - - - ``jitprofiling.h``, located under \include - (Windows*) or /include (Linux*) - - - - - - - .. container:: - :name: LI_6E4F12C743D144E4A1515F4829612FB3 - - - ``ittnotify_config.h``, ``ittnotify_types.h`` and - ``jitprofiling.c``, located under - \sdk\src\ittnotify (Windows*) or - /sdk/src/ittnotify (Linux*) - - - .. note:: - - - To locate your see `Installation - Directory <#INSTALL-DIR-JIT>`__. - - -- - - - .. container:: - :name: LI_1B044705871E4F2F90A3733AAB95D071 - - - Use the static library provided with the product: - - - #. - - - .. container:: - :name: LI_EBB0F0A78ADC45FD973DB21B3CEFF629 - - - Include\ ``jitprofiling.h`` file, located under the - \include (Windows*) or /include - (Linux*) directory, in your code. This header file provides - all API function prototypes and type definitions. - - - #. - - - .. container:: - :name: LI_C273EB329F1449B2A460BED51529BC6B - - - Link to ``jitprofiling.lib`` (Windows*) or - ``jitprofiling.a`` (Linux*), located under - \lib32or \lib64 (Windows*) or - /lib32 or /lib32 (Linux*). - - -.. list-table:: - :header-rows: 0 - - * - Use This Primitive - - To Do This - * - \ ``int iJIT_NotifyEvent( iJIT_JVM_EVENT event_type, void *EventSpecificData );``\ - - Use this API to send a notification of ``event_type`` with the data pointed by - ``EventSpecificData`` to the agent. The reported information is used to attribute - samples obtained from any profiling tool collector. - * - \ ``unsigned int iJIT_GetNewMethodID( void );``\ - - Generate a new method ID. You must use this function to assign unique and valid - method IDs to methods reported to the profiler. This API returns a new unique - method ID. When out of unique method IDs, this API function returns 0. - * - \ ``iJIT_IsProfilingActiveFlags iJIT_IsProfilingActive( void );``\ - - Returns the current mode of the profiler: off, or sampling, using the - ``iJIT_IsProfilingActiveFlags`` enumeration. This API returns - ``iJIT_SAMPLING_ON`` by default, indicating that Sampling is running. - It returns ``iJIT_NOTHING_RUNNING`` if no profiler is running. + #. ``jitprofiling.h``, located under ``\include`` directory, + in your code. This header file provides all API function prototype + and type definitions. + #. Link to ``jitprofiling.lib`` (Windows*) or ``jitprofiling.a`` (Linux*), + located under ``\build_\\bin`` + directory. ++----------------------------------------------------------------+-------------------------------------------------------------------------------+ +| Use This Primitive | To Do This | ++================================================================+===============================================================================+ +| .. code-block:: cpp | Use this API to send a notification of ``event_type`` with the data pointed | +| | by ``EventSpecificData`` to the agent. The reported information is used to | +| int iJIT_NotifyEvent( iJIT_JVM_EVENT event_type, | attribute samples obtained from any profiling tool collector. | +| void *EventSpecificData ); | | ++----------------------------------------------------------------+-------------------------------------------------------------------------------+ +| .. code-block:: cpp | Generate a new method ID. You must use this function to assign unique and | +| | valid method IDs to methods reported to the profiler. This API returns a new | +| unsigned int iJIT_GetNewMethodID( void ); | unique method ID. When out of unique method IDs, this API function returns 0. | ++----------------------------------------------------------------+-------------------------------------------------------------------------------+ +| .. code-block:: cpp | Returns the current mode of the profiler: off, or sampling, using the | +| | ``iJIT_IsProfilingActiveFlags`` enumeration. This API returns | +| iJIT_IsProfilingActiveFlags iJIT_IsProfilingActive( void ); | ``iJIT_SAMPLING_ON`` by default, indicating that Sampling is running. | +| | It returns ``iJIT_NOTHING_RUNNING`` if no profiler is running. | ++----------------------------------------------------------------+-------------------------------------------------------------------------------+ Lifetime of Allocated Data -------------------------- -You send an event notification to the agent (Collector) with -event-specific data, which is a structure. The pointers in the structure -refer to memory you allocated and you are responsible for releasing it. -The pointers are used by the ``iJIT_NotifyEvent`` method to copy your -data in a trace file, and they are not used after the -``iJIT_NotifyEvent`` method returns. +You send an event notification to the agent (Collector) with event-specific +data, which is a structure. The pointers in the structure refer to memory that +you allocated. You are responsible for releasing the allocated memory. The +``iJIT_NotifyEvent`` method uses these pointers to copy your data in a trace +file. The pointers are not used after the ``iJIT_NotifyEvent`` method returns. diff --git a/histogram-api-schema.png b/histogram-api-schema.png new file mode 100644 index 0000000000000000000000000000000000000000..d4b8293cdd6f90623bc0c3608e1ed9818102cae3 GIT binary patch literal 191599 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%0ASoJRz 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 ipF>Je;J6>dfBB Date: Wed, 28 May 2025 14:54:56 +0200 Subject: [PATCH 4/7] doc: code cleanup --- docs/conf.py | 5 ++--- docs/index.rst | 10 +++++++--- docs/src/api-support.rst | 8 ++++---- docs/src/build.rst | 2 +- docs/src/itt-api-support.rst | 11 +++++------ docs/src/jit-api-support.rst | 19 ++++++++++--------- 6 files changed, 29 insertions(+), 26 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index b6e80398..831c7b99 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -34,6 +34,5 @@ html_theme_options = { 'style_external_links': True, } -# TODO: change before merge to the main repo -# html_baseurl = 'https://intel.github.io/ittapi/' -html_baseurl = 'https://eparshut.github.io/ittapi/' + +html_baseurl = 'https://intel.github.io/ittapi/' diff --git a/docs/index.rst b/docs/index.rst index 68c095cf..971bf227 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,9 +3,13 @@ The Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs =================================================================================== -The ITT/JIT API Documentation from the Intel® VTune Profiler and Intel® Graphics -Performance Analyzers User Guides has been consolidated into this repository, -providing a single, unified source of information. + +The Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs +are open source profiling APIs that you use with Intel software tools, to collect +and manage trace data during performance analysis. You can profile with ITT/JIT APIs +when you use Intel® VTune Profiler and Intel® Graphics Performance Analyzers (Intel® GPA). + +This repository contains documentation that explains the use of these APIs. .. toctree:: diff --git a/docs/src/api-support.rst b/docs/src/api-support.rst index f91cb3cb..57c78903 100644 --- a/docs/src/api-support.rst +++ b/docs/src/api-support.rst @@ -3,11 +3,11 @@ Use the ITT/JIT APIs ==================== -.. note:: - The ITT API is a set of pure C/C++ functions. There are no Java* or .NET* - APIs. If you need runtime environment support, you can use a JNI, or C/C++ - function call from the managed code. +This section describes how you use ITT/JIT APIs with various environments. +The ITT/JIT APIs are a set of C/C++ functions and use no Java* or .NET* code. +For support with your runtime environment, use a Java Native Interface (JNI) +or C/C++ function call from the managed code. C/C++ API Usage and Reference: diff --git a/docs/src/build.rst b/docs/src/build.rst index 54c102ab..62f6999f 100644 --- a/docs/src/build.rst +++ b/docs/src/build.rst @@ -14,7 +14,7 @@ Before you build the ITT/JIT APIs, make sure you have the following hardware and - For a Windows* system, install one of these: - `Microsoft Visual Studio `__ 2015 or later - - `Ninja `__ 1.9 or later. + - `Ninja `__ 1.9 or later - To enable support for Fortran, install the `Intel Fortran Compiler `__ diff --git a/docs/src/itt-api-support.rst b/docs/src/itt-api-support.rst index ab535e3a..f27f1dbd 100644 --- a/docs/src/itt-api-support.rst +++ b/docs/src/itt-api-support.rst @@ -1,18 +1,17 @@ .. _itt-api-support: -Instrumentation and Tracing Technology API (ITT API) -==================================================== +Instrumentation and Tracing Technology (ITT) API +================================================ -Use the Intel® Instrumentation and Tracing Technology API (ITT API) to -generate trace data and control its collection during the execution of -your application. +Use the Intel® Instrumentation and Tracing Technology (ITT) API to generate +trace data and control its collection during the execution of your application. Use the ITT API to: -- Controls application performance overhead based on the amount of +- Control application performance overhead based on the amount of traces that you collect. - Enable trace collection without having to recompiling your application - Enable code annotation for deeper analysis. diff --git a/docs/src/jit-api-support.rst b/docs/src/jit-api-support.rst index facc547d..e0a25873 100644 --- a/docs/src/jit-api-support.rst +++ b/docs/src/jit-api-support.rst @@ -1,10 +1,10 @@ .. _jit-api-support: -Just-In-Time API (JIT API) -========================== +Just-In-Time (JIT) API +====================== -Use the Just-In-Time(JIT) Profiling API to enable performance tools to collect +Use the Just-In-Time (JIT) Profiling API to enable performance tools to collect information about just-in-time generated codes. You must insert JIT Profiling API calls in the code generator to report information before the JIT-compiled code goes to execution. This information is collected at runtime and used by @@ -142,30 +142,31 @@ Analyze Split Functions You can use the JIT Profiling API to analyze split functions. This scenario -often occurs in resource-limited environments, where code for the same function -is generated or updated in separate segments, sometimes with overlapping lifetimes. +often occurs in resource-limited environments where the code for the same +function is generated or updated in separate segments. Sometimes this code +generation can happen with overlapping lifetimes. .. code-block:: cpp #include - + unsigned int method_id = iJIT_GetNewMethodID(); - + iJIT_Method_Load a = {0}; a.method_id = method_id; a.method_load_address = 0x100; a.method_size = 0x20; - + iJIT_Method_Load b = {0}; b.method_id = method_id; b.method_load_address = 0x200; b.method_size = 0x30; - + iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&a); iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, (void*)&b) From e7dd2a57de8dbaf4448b6e1aad95d645329a4dcc Mon Sep 17 00:00:00 2001 From: eparshut Date: Wed, 28 May 2025 15:01:24 +0200 Subject: [PATCH 5/7] ci: update deploy-docs workflow --- .github/workflows/deploy-docs.yml | 1 - README.md | 44 ++++++++++++++++++------------- 2 files changed, 26 insertions(+), 19 deletions(-) diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml index 760dba95..a7916244 100755 --- a/.github/workflows/deploy-docs.yml +++ b/.github/workflows/deploy-docs.yml @@ -4,7 +4,6 @@ on: push: branches: - master - - docs # TODO: delete before merge to the main repo paths: - 'docs/**' # Trigger only when the source docs files are modified diff --git a/README.md b/README.md index 4f94868d..ecf44941 100644 --- a/README.md +++ b/README.md @@ -8,29 +8,36 @@ Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs [![Package on crates.io](https://img.shields.io/crates/v/ittapi.svg)](https://crates.io/crates/ittapi) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/intel/ittapi/badge)](https://securityscorecards.dev/viewer/?uri=github.com/intel/ittapi) -This ITT/JIT open source profiling APIs includes: +This repository contains the following profiling APIs: - - Instrumentation and Tracing Technology (ITT) API - - Just-In-Time (JIT) Profiling API +- **Instrumentation and Tracing Technology (ITT) API**: + Powers your application to generate and control the collection of trace data + during its execution, seamlessly integrating with Intel tools. +- **Just-In-Time (JIT) Profiling API**: + Reports detailed information about just-in-time (JIT) compiled code, enabling + you to profile the performance of dynamically generated code. -The Instrumentation and Tracing Technology (ITT) API enables your application -to generate and control the collection of trace data during its execution -across different Intel tools. +The ITT/JIT APIs consist of two parts: -ITT API consists of two parts: a _static part_ and a _dynamic part_. The -_dynamic part_ is specific for a tool and distributed only with a particular -tool. The _static part_ is a common part shared between tools. Currently, the -static part of ITT API is distributed as a static library and released under -a BSD/GPLv2 dual license with every tool supporting ITT API. +- **Static Part**: An open-source static library that you compile and link with your application. +- **Dynamic Part**: A tool-specific shared library that collects and writes trace data. You can + find the reference implementation of the dynamic part as a *Reference Collector* + [here](./src/ittnotify_refcol/README.md). ### Build To build the library: - - On Windows*, Linux*, FreeBSD*, and macOS* systems: Set [CMake](https://cmake.org) in `PATH` - - On Windows*: Install Microsoft Visual Studio or set [Ninja](https://github.com/ninja-build/ninja/releases) in `PATH` - - To enable support for Fortran, install the - [Intel Fortran Compiler](https://www.intel.com/content/www/us/en/docs/fortran-compiler/get-started-guide/current/overview.html) - - To list available build options execute: `python buildall.py -h` + +- Get general development tools, including C/C++ Compiler +- Install [Python](https://python.org) 3.6 or later +- Install [CMake](https://cmake.org) 3.5 or later +- For a Windows* system, install one of these: + - [Microsoft Visual Studio](https://visualstudio.microsoft.com) 2015 or later + - [Ninja](https://github.com/ninja-build/ninja/releases) 1.9 or later +- To enable support for Fortran, install the + [Intel Fortran Compiler](https://www.intel.com/content/www/us/en/docs/fortran-compiler/get-started-guide/current/overview.html) +- To list available build options execute: `python buildall.py -h` + ``` usage: buildall.py [-h] [-d] [-c] [-v] [-pt] [-ft] [--force_bits] @@ -49,7 +56,7 @@ optional arguments: ### Documentation Find complete documentation for ITT/JIT APIs on the -[ITT/JIT API Documentation Page](https://intel.github.io/ittapi) +[ITT/JIT APIs Documentation Page](https://intel.github.io/ittapi) ### License @@ -58,7 +65,8 @@ All code in the repo is dual licensed under GPLv2 and 3-Clause BSD licenses ### Make Contributions Learn how to contribute using our [contribution guide](CONTRIBUTING.md) -To report bugs or request enhancements, please use the "Issues" page on GitHub + +To report bugs or request enhancements, please use the [Issues page on GitHub](https://github.com/intel/ittapi/issues) ### Security From c227397fd24874df5c74480fc2befcf91db0971a Mon Sep 17 00:00:00 2001 From: eparshut Date: Wed, 28 May 2025 15:12:38 +0200 Subject: [PATCH 6/7] doc: update reference collector readme --- src/ittnotify_refcol/README.md | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/src/ittnotify_refcol/README.md b/src/ittnotify_refcol/README.md index 4905a7bf..ecfabf31 100644 --- a/src/ittnotify_refcol/README.md +++ b/src/ittnotify_refcol/README.md @@ -1,27 +1,31 @@ -# Instrumentation and Tracing Technology API (ITT API) Reference Collector +# Instrumentation and Tracing Technology (ITT) API Reference Collector -This is a reference implementation of the ITT API _dynamic part_ -that performs tracing data from ITT API functions calls to log files. +This is a reference implementation of the ITT API *dynamic* part that +performs tracing data from ITT API function calls to log files. -To use this solution it is required to build it like a shared library and add -full library path to the `INTEL_LIBITTNOTIFY64/INTEL_LIBITTNOTIFY32` environment variable: +To use this solution, build the collector as a shared library and point the +full library path to the `INTEL_LIBITTNOTIFY64` or `INTEL_LIBITTNOTIFY32` +environment variable: **On Linux** + ``` make export INTEL_LIBITTNOTIFY64=/libittnotify_refcol.so ``` **On FreeBSD** + ``` make setenv INTEL_LIBITTNOTIFY64 /libittnotify_refcol.so ``` -Temp directory is used by default to save log files. -To change log directory use the `INTEL_LIBITTNOTIFY_LOG_DIR` environment variable: +By default, log files save in the `temp` directory. To change the location, +use the `INTEL_LIBITTNOTIFY_LOG_DIR` environment variable: **On Linux** + ``` export INTEL_LIBITTNOTIFY_LOG_DIR= ``` @@ -31,10 +35,10 @@ export INTEL_LIBITTNOTIFY_LOG_DIR= setenv INTEL_LIBITTNOTIFY_LOG_DIR ``` -This implementation adds logging of some of the ITT API functions calls. -Adding logging of the other ITT API functions calls are welcome. -The solution provides 4 functions with different log levels -that takes printf format for logging: +This implementation adds logging of some of the ITT API function calls. Adding +logging of other ITT API function calls is welcome. The solution provides 4 +functions with different log levels that take `printf` format for logging: + ``` LOG_FUNC_CALL_INFO(const char *msg_format, ...); LOG_FUNC_CALL_WARN(const char *msg_format, ...); From adf84ef5a43833a147abadbe717eee33a7ec5043 Mon Sep 17 00:00:00 2001 From: eparshut Date: Wed, 28 May 2025 15:30:53 +0200 Subject: [PATCH 7/7] doc: update readme --- README.md | 13 +++++++------ src/ittnotify_refcol/README.md | 2 +- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index ecf44941..37ea32fe 100644 --- a/README.md +++ b/README.md @@ -10,17 +10,19 @@ Intel® Instrumentation and Tracing Technology (ITT) and Just-In-Time (JIT) APIs This repository contains the following profiling APIs: -- **Instrumentation and Tracing Technology (ITT) API**: +- **Instrumentation and Tracing Technology (ITT) API** Powers your application to generate and control the collection of trace data during its execution, seamlessly integrating with Intel tools. -- **Just-In-Time (JIT) Profiling API**: +- **Just-In-Time (JIT) Profiling API** Reports detailed information about just-in-time (JIT) compiled code, enabling you to profile the performance of dynamically generated code. The ITT/JIT APIs consist of two parts: -- **Static Part**: An open-source static library that you compile and link with your application. -- **Dynamic Part**: A tool-specific shared library that collects and writes trace data. You can +- **Static Part** + An open-source static library that you compile and link with your application. +- **Dynamic Part** + A tool-specific shared library that collects and writes trace data. You can find the reference implementation of the dynamic part as a *Reference Collector* [here](./src/ittnotify_refcol/README.md). @@ -64,8 +66,7 @@ All code in the repo is dual licensed under GPLv2 and 3-Clause BSD licenses ### Make Contributions -Learn how to contribute using our [contribution guide](CONTRIBUTING.md) - +Learn how to contribute using our [contribution guide](CONTRIBUTING.md) To report bugs or request enhancements, please use the [Issues page on GitHub](https://github.com/intel/ittapi/issues) ### Security diff --git a/src/ittnotify_refcol/README.md b/src/ittnotify_refcol/README.md index ecfabf31..ee30fc53 100644 --- a/src/ittnotify_refcol/README.md +++ b/src/ittnotify_refcol/README.md @@ -21,7 +21,7 @@ make setenv INTEL_LIBITTNOTIFY64 /libittnotify_refcol.so ``` -By default, log files save in the `temp` directory. To change the location, +By default, log files save in the `tmp` directory. To change the location, use the `INTEL_LIBITTNOTIFY_LOG_DIR` environment variable: **On Linux**