Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Light culling crashes, so i remove it for now

Browse Source
This commit is contained in:
Dynamitos
2023-11-17 16:53:37 +01:00
parent 1b2760a4ef
commit a36939eab8
15 changed files with 31 additions and 3476 deletions
Download Patch File Download Diff File Expand all files Collapse all files
external/aftermath/LICENSE
Vendored
-601
View File
@@ -1,601 +0,0 @@
Copyright (c) 2017-2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property and proprietary
rights in and to this software, related documentation and any modifications thereto. Any
use, reproduction, disclosure or distribution of this software and related documentation
without an express license agreement from NVIDIA CORPORATION is strictly prohibited.
LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT KITS
This license agreement, including exhibits attached ("Agreement") is a legal agreement
between you and NVIDIA Corporation ("NVIDIA") and governs your use of a NVIDIA software
development kit ("SDK").
Each SDK has its own set of software and materials, but here is a description of the types
of items that may be included in a SDK: source code, header files, APIs, data sets and
assets (examples include images, textures, models, scenes, videos, native API input/output
files), binary software, sample code, libraries, utility programs, programming code and
documentation.
This Agreement can be accepted only by an adult of legal age of majority in the country in
which the SDK is used.
If you are entering into this Agreement on behalf of a company or other legal entity, you
represent that you have the legal authority to bind the entity to this Agreement, in which
case "you" will mean the entity you represent.
If you don’t have the required age or authority to accept this Agreement, or if you don’t
accept all the terms and conditions of this Agreement, do not download, install or use the
SDK.
You agree to use the SDK only for purposes that are permitted by (a) this Agreement, and
(b) any applicable law, regulation or generally accepted practices or guidelines in the
relevant jurisdictions.
1. License.
1.1 Grant
Subject to the terms of this Agreement, NVIDIA hereby grants you a non-exclusive,
non-transferable license, without the right to sublicense (except as expressly provided in
this Agreement) to:
(i) Install and use the SDK, and
(ii) Distribute those portions of the SDK that are identified in this Agreement as
distributable, as incorporated in object code format into a software application that
meets the distribution requirements indicated in this Agreement.
1.2 Distribution Requirements
These are the distribution requirements for you to exercise the distribution grant:
(i) Your application must have material additional functionality, beyond the included
portions of the SDK.
(ii) The distributable portions of the SDK shall only be accessed by your application.
(iii) The following notice shall be included in modifications and derivative works of
sample source code distributed: "This software contains source code provided by NVIDIA
Corporation."
(iv) Unless a developer tool is identified in this Agreement as distributable, it is
delivered for your internal use only.
(v) The terms under which you distribute your application must be consistent with the
terms of this Agreement, including (without limitation) terms relating to the license
grant and license restrictions and protection of NVIDIA’s intellectual property rights.
Additionally, you agree that you will protect the privacy, security and legal rights of
your application users.
(vi) You agree to notify NVIDIA in writing of any known or suspected distribution or use
of the SDK not in compliance with the requirements of this Agreement, and to enforce the
terms of your agreements with respect to distributed SDK.
1.3 Authorized Users
You may allow employees and contractors of your entity or of your subsidiary(ies) to
access and use the SDK from your secure network to perform work on your behalf.
If you are an academic institution you may allow users enrolled or employed by the
academic institution to access and use the SDK from your secure network.
You are responsible for the compliance with the terms of this Agreement by your authorized
users. If you become aware that your authorized users didn’t follow the terms of this
Agreement, you agree to take reasonable steps to resolve the non-compliance and prevent
new occurrences.
1.4 Pre-Release SDK
The SDK versions identified as alpha, beta, preview or otherwise as pre-release, may not
be fully functional, may contain errors or design flaws, and may have reduced or different
security, privacy, accessibility, availability, and reliability standards relative to
commercial versions of NVIDIA software and materials. Use of a pre-release SDK may result
in unexpected results, loss of data, project delays or other unpredictable damage or loss.
You may use a pre-release SDK at your own risk, understanding that pre-release SDKs are
not intended for use in production or business-critical systems. NVIDIA may choose not to
make available a commercial version of any pre-release SDK. NVIDIA may also choose to
abandon development and terminate the availability of a pre-release SDK at any time
without liability.
1.5 Updates
NVIDIA may, at its option, make available patches, workarounds or other updates to this
SDK. Unless the updates are provided with their separate governing terms, they are deemed
part of the SDK licensed to you as provided in this Agreement.
You agree that the form and content of the SDK that NVIDIA provides may change without
prior notice to you. While NVIDIA generally maintains compatibility between versions,
NVIDIA may in some cases make changes that introduce incompatibilities in future versions
of the SDK.
1.6 Third Party Licenses
The SDK may come bundled with, or otherwise include or be distributed with, third party
software licensed by a NVIDIA supplier and/or open source software provided under an open
source license. Use of third-party software is subject to the third-party license terms,
or in the absence of third party terms, the terms of this Agreement. Copyright to
third-party software is held by the copyright holders indicated in the third-party
software or license.
1.7 Reservation of Rights
NVIDIA reserves all rights, title and interest in and to the SDK not expressly granted to
you under this Agreement.
2. Limitations.
The following license limitations apply to your use of the SDK:
2.1 You may not reverse engineer, decompile or disassemble, or remove copyright or other
proprietary notices from any portion of the SDK or copies of the SDK.
2.2 Except as expressly provided in this Agreement, you may not copy, sell, rent,
sublicense, transfer, distribute, modify, or create derivative works of any portion of the
SDK.
2.3 Unless you have an agreement with NVIDIA for this purpose, you may not indicate that
an application created with the SDK is sponsored or endorsed by NVIDIA.
2.4 You may not bypass, disable, or circumvent any encryption, security, digital rights
management or authentication mechanism in the SDK.
2.5 You may not use the SDK in any manner that would cause it to become subject to an open
source software license. As examples, licenses that require as a condition of use,
modification, and/or distribution that the SDK be (i) disclosed or distributed in source
code form; (ii) licensed for the purpose of making derivative works; or (iii)
redistributable at no charge.
2.6 Unless you have an agreement with NVIDIA for this purpose, you may not use the SDK
with any system or application where the use or failure of the system or application can
reasonably be expected to threaten or result in personal injury, death, or catastrophic
loss. Examples include use in nuclear, avionics, navigation, military, medical, life
support or other life critical applications. NVIDIA does not design, test or manufacture
the SDK for these critical uses and NVIDIA shall not be liable to you or any third party,
in whole or in part, for any claims or damages arising from such uses.
2.7 You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their
respective employees, contractors, agents, officers and directors, from and against any
and all claims, damages, obligations, losses, liabilities, costs or debt, fines,
restitutions and expenses (including but not limited to attorney’s fees and costs incident
to establishing the right of indemnification) arising out of or related to your use of the
SDK outside of the scope of this Agreement, or not in compliance with its terms.
3. Ownership.
3.1 NVIDIA or its licensors hold all rights, title and interest in and to the SDK and its
modifications and derivative works, including their respective intellectual property
rights. This SDK may include software and materials from NVIDIA’s licensors, and these
licensors are intended third party beneficiaries that may enforce this Agreement with
respect to their intellectual property rights.
3.2 You may, but don’t have to, provide to NVIDIA suggestions, feature requests or other
feedback regarding the SDK, including possible enhancements or modifications to the SDK.
For any feedback that you voluntarily provide, you hereby grant NVIDIA and its affiliates
a perpetual, non-exclusive, worldwide, irrevocable license to use, reproduce, modify,
license, sublicense (through multiple tiers of sublicensees), and distribute (through
multiple tiers of distributors) it without the payment of any royalties or fees to you.
NVIDIA will use feedback at its choice. NVIDIA is constantly looking for ways to improve
its products, so you may send feedback to NVIDIA through the developer portal at
https://developer.nvidia.com.
4. No Warranties.
THE SDK IS PROVIDED BY NVIDIA "AS IS" AND "WITH ALL FAULTS." TO THE MAXIMUM EXTENT
PERMITTED BY LAW, NVIDIA AND ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT,
OR THE ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO WARRANTY IS MADE ON
THE BASIS OF TRADE USAGE, COURSE OF DEALING OR COURSE OF TRADE.
5. Limitations of Liability.
TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR
ANY SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS OF
USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS,
ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF
WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR
THEORY OF LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES TOTAL CUMULATIVE
LIABILITY UNDER OR ARISING OUT OF THIS AGREEMENT EXCEED US$10.00. THE NATURE OF THE
LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT.
These exclusions and limitations of liability shall apply regardless if NVIDIA or its
affiliates have been advised of the possibility of such damages, and regardless of whether
a remedy fails its essential purpose. These exclusions and limitations of liability form
an essential basis of the bargain between the parties, and, absent any of these exclusions
or limitations of liability, the provisions of this Agreement, including, without
limitation, the economic terms, would be substantially different.
6. Termination.
6.1 This Agreement will continue to apply until terminated by either you or NVIDIA as
described below.
6.2 If you want to terminate this Agreement, you may do so by stopping to use the SDK.
6.3 NVIDIA may, at any time, terminate this Agreement if: (i) you fail to comply with any
term of this Agreement and the non-compliance is not fixed within thirty (30) days
following notice from NVIDIA (or immediately if you violate NVIDIA’s intellectual property
rights); (ii) you commence or participate in any legal proceeding against NVIDIA with
respect to the SDK; or (iii) NVIDIA decides to no longer provide the SDK in a country or,
in NVIDIA’s sole discretion, the continued use of it is no longer commercially viable.
6.4 Upon any termination of this Agreement, you agree to promptly discontinue use of the
SDK and destroy all copies in your possession or control. Your prior distributions in
accordance with this Agreement are not affected by the termination of this Agreement. Upon
written request, you will certify in writing that you have complied with your commitments
under this section. Upon any termination of this Agreement all provisions survive except
for the licenses granted to you.
7. General.
If you wish to assign this Agreement or your rights and obligations, including by merger,
consolidation, dissolution or operation of law, contact NVIDIA to ask for permission. Any
attempted assignment not approved by NVIDIA in writing shall be void and of no effect.
NVIDIA may assign, delegate or transfer this Agreement and its rights and obligations, and
if to a non-affiliate you will be notified.
You agree to cooperate with NVIDIA and provide reasonably requested information to verify
your compliance with this Agreement.
This Agreement will be governed in all respects by the laws of the United States and of
the State of Delaware as those laws are applied to contracts entered into and performed
entirely within Delaware by Delaware residents, without regard to the conflicts of laws
principles. The United Nations Convention on Contracts for the International Sale of Goods
is specifically disclaimed. You agree to all terms of this Agreement in the English
language.
The state or federal courts residing in Santa Clara County, California shall have
exclusive jurisdiction over any dispute or claim arising out of this Agreement.
Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive
remedies or an equivalent type of urgent legal relief in any jurisdiction.
If any court of competent jurisdiction determines that any provision of this Agreement is
illegal, invalid or unenforceable, such provision will be construed as limited to the
extent necessary to be consistent with and fully enforceable under the law and the
remaining provisions will remain in full force and effect. Unless otherwise specified,
remedies are cumulative.
Each party acknowledges and agrees that the other is an independent contractor in the
performance of this Agreement.
The SDK has been developed entirely at private expense and is "commercial items"
consisting of "commercial computer software" and "commercial computer software
documentation" provided with RESTRICTED RIGHTS. Use, duplication or disclosure by the U.S.
Government or a U.S. Government subcontractor is subject to the restrictions in this
Agreement pursuant to DFARS 227.7202-3(a) or as set forth in subparagraphs (b)(1) and (2)
of the Commercial Computer Software - Restricted Rights clause at FAR 52.227-19, as
applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas Expressway, Santa Clara, CA
95051.
The SDK is subject to United States export laws and regulations. You agree that you will
not ship, transfer or export the SDK into any country, or use the SDK in any manner,
prohibited by the United States Bureau of Industry and Security or economic sanctions
regulations administered by the U.S. Department of Treasury’s Office of Foreign Assets
Control (OFAC), or any applicable export laws, restrictions or regulations. These laws
include restrictions on destinations, end users and end use. By accepting this Agreement,
you confirm that you are not a resident or citizen of any country currently embargoed by
the U.S. and that you are not otherwise prohibited from receiving the SDK.
Any notice delivered by NVIDIA to you under this Agreement will be delivered via mail,
email or fax. You agree that any notices that NVIDIA sends you electronically will satisfy
any legal communication requirements. Please direct your legal notices or other
correspondence to NVIDIA Corporation, 2788 San Tomas Expressway, Santa Clara, California
95051, United States of America, Attention: Legal Department.
This Agreement and any exhibits incorporated into this Agreement constitute the entire
agreement of the parties with respect to the subject matter of this Agreement and
supersede all prior negotiations or documentation exchanged between the parties relating
to this SDK license. Any additional and/or conflicting terms on documents issued by you
are null, void, and invalid. Any amendment or waiver under this Agreement shall be in
writing and signed by representatives of both parties.
(v. July 22, 2019)
NSIGHT AFTERMATH SUPPLEMENT TO SOFTWARE LICENSE AGREEMENT FOR NVIDIA SOFTWARE DEVELOPMENT
KITS
The terms in this supplement govern your use of the NVIDIA Nsight Aftermath SDK under the
terms of your license agreement ("Agreement") as modified by this supplement. Capitalized
terms used but not defined below have the meaning assigned to them in the Agreement.
This supplement is an exhibit to the Agreement and is incorporated as an integral part of
the Agreement. In the event of conflict between the terms in this supplement and the terms
in the Agreement, the terms in this supplement govern.
1. Distribution.
The following portions of the SDK are distributable under the Agreement: the .dll / .so files.
2. Usage.
Please read the accompanying usage guidelines document (nsight-aftermath-usage-guidelines.txt)
for information on how Nsight Aftermath is intended to be used.
(v. October 30, 2019)
------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------
The Nsight Aftermath SDK makes use of third-party libraries. The licensee's use of the
SDK is subject to the following additional terms and conditions:
JSON for Modern C++ (https://nlohmann.github.io/json/)
The class is licensed under the MIT License:
Copyright (c) 2013-2019 Niels Lohmann
Permission is hereby granted, free of charge, to any person obtaining a copy of this
software and associated documentation files (the "Software"), to deal in the Software
without restriction, including without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the
MIT License (see above). Copyright (c) 2008-2009 Björn Hoehrmann bjoern@hoehrmann.de
The class contains a slightly modified version of the Grisu2 algorithm from Florian
Loitsch which is licensed under the MIT License (see above). Copyright (c) 2009
Florian Loitsch
FlatBuffers: Memory Efficient Serialization Library (http://google.github.io/flatbuffers/)
Apache License Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution
as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner
that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that
control, are controlled by, or are under common control with that entity. For the
purposes of this definition, "control" means (i) the power, direct or indirect, to
cause the direction or management of such entity, whether by contract or otherwise, or
(ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii)
beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions
granted by this License.
"Source" form shall mean the preferred form for making modifications, including but
not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or
translation of a Source form, including but not limited to compiled object code,
generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made
available under the License, as indicated by a copyright notice that is included in or
attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is
based on (or derived from) the Work and for which the editorial revisions,
annotations, elaborations, or other modifications represent, as a whole, an original
work of authorship. For the purposes of this License, Derivative Works shall not
include works that remain separable from, or merely link (or bind by name) to the
interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of
the Work and any modifications or additions to that Work or Derivative Works thereof,
that is intentionally submitted to Licensor for inclusion in the Work by the copyright
owner or by an individual or Legal Entity authorized to submit on behalf of the
copyright owner. For the purposes of this definition, "submitted" means any form of
electronic, verbal, or written communication sent to the Licensor or its
representatives, including but not limited to communication on electronic mailing
lists, source code control systems, and issue tracking systems that are managed by, or
on behalf of, the Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise designated in
writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom
a Contribution has been received by Licensor and subsequently incorporated within the
Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License,
each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable copyright license to reproduce, prepare
Derivative Works of, publicly display, publicly perform, sublicense, and distribute
the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each
Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
royalty-free, irrevocable (except as stated in this section) patent license to make,
have made, use, offer to sell, sell, import, and otherwise transfer the Work, where
such license applies only to those patent claims licensable by such Contributor that
are necessarily infringed by their Contribution(s) alone or by combination of their
Contribution(s) with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a cross-claim or
counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated
within the Work constitutes direct or contributory patent infringement, then any
patent licenses granted to You under this License for that Work shall terminate as of
the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative
Works thereof in any medium, with or without modifications, and in Source or Object
form, provided that You meet the following conditions:
(a) You must give any other recipients of the Work or Derivative Works a copy of this
License; and
(b) You must cause any modified files to carry prominent notices stating that You
changed the files; and
(c) You must retain, in the Source form of any Derivative Works that You distribute,
all copyright, patent, trademark, and attribution notices from the Source form of the
Work, excluding those notices that do not pertain to any part of the Derivative Works;
and
(d) If the Work includes a "NOTICE" text file as part of its distribution, then any
Derivative Works that You distribute must include a readable copy of the attribution
notices contained within such NOTICE file, excluding those notices that do not pertain
to any part of the Derivative Works, in at least one of the following places: within a
NOTICE text file distributed as part of the Derivative Works; within the Source form
or documentation, if provided along with the Derivative Works; or, within a display
generated by the Derivative Works, if and wherever such third-party notices normally
appear. The contents of the NOTICE file are for informational purposes only and do not
modify the License. You may add Your own attribution notices within Derivative Works
that You distribute, alongside or as an addendum to the NOTICE text from the Work,
provided that such additional attribution notices cannot be construed as modifying the
License.
You may add Your own copyright statement to Your modifications and may provide
additional or different license terms and conditions for use, reproduction, or
distribution of Your modifications, or for any such Derivative Works as a whole,
provided Your use, reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any
Contribution intentionally submitted for inclusion in the Work by You to the Licensor
shall be under the terms and conditions of this License, without any additional terms
or conditions. Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed with Licensor
regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names,
trademarks, service marks, or product names of the Licensor, except as required for
reasonable and customary use in describing the origin of the Work and reproducing the
content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing,
Licensor provides the Work (and each Contributor provides its Contributions) on an "AS
IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
including, without limitation, any warranties or conditions of TITLE,
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely
responsible for determining the appropriateness of using or redistributing the Work
and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort
(including negligence), contract, or otherwise, unless required by applicable law
(such as deliberate and grossly negligent acts) or agreed to in writing, shall any
Contributor be liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a result of this
License or out of the use or inability to use the Work (including but not limited to
damages for loss of goodwill, work stoppage, computer failure or malfunction, or any
and all other commercial damages or losses), even if such Contributor has been advised
of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or
Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of
support, warranty, indemnity, or other liability obligations and/or rights consistent
with this License. However, in accepting such obligations, You may act only on Your
own behalf and on Your sole responsibility, not on behalf of any other Contributor,
and only if You agree to indemnify, defend, and hold each Contributor harmless for any
liability incurred by, or claims asserted against, such Contributor by reason of your
accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following boilerplate notice,
with the fields enclosed by brackets "[]" replaced with your own identifying
information. (Don't include the brackets!) The text should be enclosed in the
appropriate comment syntax for the file format. We also recommend that a file or class
name and description of purpose be included on the same "printed page" as the
copyright notice for easier identification within third-party archives.
Copyright 2014 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under
the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
ANY KIND, either express or implied. See the License for the specific language
governing permissions and limitations under the License.
The LLVM Compiler Infrastructure (http://llvm.org/)
==============================================================================
LLVM Release License
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2003-2018 University of Illinois at Urbana-Champaign.
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyrights and Licenses for Third Party Software Distributed with LLVM:
==============================================================================
The LLVM software contains code written by third parties. Such software will
have its own individual LICENSE.TXT file in the directory in which it appears.
This file will describe the copyrights, license, and restrictions which apply
to that code.
The disclaimer of warranty in the University of Illinois Open Source License
applies to all code in the LLVM Distribution, and nothing in any of the
other licenses gives permission to use the names of the LLVM Team or the
University of Illinois to endorse or promote products derived from this
Software.
The following pieces of software have additional or alternate copyrights,
licenses, and/or restrictions:
Program Directory
------- ---------
Google Test llvm/utils/unittest/googletest
OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex}
pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT}
ARM contributions llvm/lib/Target/ARM/LICENSE.TXT
md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h
external/aftermath/Readme.md
Vendored
-889
View File
@@ -1,889 +0,0 @@
# Nsight Aftermath SDK
Aftermath is a compact, easy to use C/C++ library aimed at developers of D3D12
or Vulkan based applications on Microsoft Windows or Linux, enabling post-mortem
GPU crash analysis on NVIDIA GeForce based GPUs.
## Key Features
The Nsight Aftermath SDK is an easy to use C/C++ API (shared libraries + header
files), which provides support for three major use cases:
* GPU crash dump creation
* GPU crash dump analysis
* Application instrumentation with light-weight GPU event markers
Nsight Aftermath's GPU crash dump collection performance footprint is low
enough to include in a shipping application - allowing developers to mine
details on why the GPU crashed in the wild, and gather GPU crash dumps for
further analysis (should the required cloud infrastructure already exist).
## Application Instrumentation with Event Markers
In its basic form, this works by allowing programmers to insert markers into
the GPU pipeline, which can be read post-TDR, in order to determine what work
item the GPU was processing at the point of failure. Nsight Aftermath also
includes a facility to query the current device state, much like the
conventional graphics APIs, but reporting a finer grained reason.
One of the key principles of Aftermath is for the marker insertion to be as
unobtrusive as possible. Avoiding situations common with other similar
debuggers, where their associated performance cost changes timing enough to
make a bug repro vanish: a "Heisenbug". Aftermath avoids this problem by
design, while simultaneously not compromising on functionality: a catch-all
solution for post-mortem GPU crash analysis.
For Vulkan the Aftermath event marker functionality is exposed as a Vulkan
extension: `NV_device_diagnostic_checkpoints`.
## GPU Crash Dump Creation
In addition to event marker-based GPU work tracking and device state queries,
Nsight Aftermath also supports the creation of GPU crash dumps for in-depth
post-mortem GPU crash analysis.
Integrating GPU crash dump creation into a graphics application allows
collecting and processing the GPU crash dumps by already established crash
handling workflows and infrastructure.
## GPU Crash Dump Inspection and Analysis
There are two possibilities for a developer to inspect and analyze GPU crash
dumps collected from an application enabled with Nsight Aftermath's GPU crash
dump creation feature:
* Load the GPU crash dump into Nsight Graphics and use the graphical GPU crash
dump inspector. This option allows for quick and easy access to the data
stored in the GPU crash dump for visual inspection.
* Use the Nsight Aftermath GPU crash dump decoding functions to
programmatically access the data stored in the GPU crash dump. This allows
for automatic processing and binning of GPU crash dumps in a user-defined
fashion.
## Distribution
The following portions of the SDK are distributable: all .dll / .so files in the
`lib` directory.
NOTE: Redistribution of the files is subject to the terms and conditions listed
in the LICENSE file, including the terms and conditions inherited from any
third-party component used within this product.
## Support
* Microsoft Windows 10 (Version 1809, Version 1903, Version 1909)
* Linux (kernel 4.15.0 or newer)
* D3D12, DXR, D3D11 (basic support), Vulkan
* NVIDIA Turing GPU
* NVIDIA Display Driver R440 or newer (for D3D)
* NVIDIA Display Driver R445 or newer (for Vulkan on Windows)
* NVIDIA Display Driver R455 or newer (for Vulkan on Linux)
# Usage Examples
In this section some code snippets can be found that show how to use the Nsight
Aftermath API for collecting and decoding crash dumps for a D3D12 or Vulkan
application.
The code samples cover the following commonly required tasks:
1. Enable GPU crash dump collection in an application
2. Configure what data to include in GPU crash dumps
3. Instrument an application with Aftermath event markers
4. Handle GPU crash dump callback events
5. Disable GPU crash dump collection
6. Use the GPU crash dump decoding API
## Enabling GPU Crash Dumps
An application enables GPU crash dump creation by calling
`GFSDK_Aftermath_EnableGpuCrashDumps()`. To use the Nsight Aftermath API
functions related to GPU crash dump collection include the
`GFSDK_Aftermath_GpuCrashDump.h` header file.
GPU crash dump collection should be enabled before the application creates any
D3D12, D3D11, or Vulkan device. No GPU crash dumps will be generated for GPU
crashes or hangs related to devices that were created before the
`GFSDK_Aftermath_EnableGpuCrashDumps()` call.
Besides enabling the GPU crash dump feature, this call allows the application
to register a callback function that will be invoked once a GPU crash is
detected. In addition, the application can also provide two optional callback
functions that will be invoked if debug information for shaders is available or
the application intends to provide additional description or context for the
exception, such as the current state of the application at the time of the
crash, to be included with the GPU crash dump.
The following code snippet shows an example of how to enable GPU crash dumps
and how to setup the callbacks for crash dump notifications, for shader debug
information notifications, and for providing additional crash dump description
data. Only the crash dump callback is mandatory. The other two callbacks are
optional and can be omitted by passing a NULL pointer if the corresponding
functionality is not needed. In this example, GPU cash dumps are only enabled
for D3D12 and D3D11 devices. For watching Vulkan devices the
`GFSDK_Aftermath_EnableGpuCrashDumps()` functions must be called with
`GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_Vulkan`. It is also possible to
combine both flags, if an application uses both the D3D and the Vulkan API.
```C++
void MyApp::InitDevice()
{
[...]
// Enable GPU crash dumps and register callbacks.
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_EnableGpuCrashDumps(
GFSDK_Aftermath_Version_API,
GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_DX,
GFSDK_Aftermath_GpuCrashDumpFeatureFlags_Default, // Default behavior.
GpuCrashDumpCallback, // Register callback for GPU crash dumps.
ShaderDebugInfoCallback, // Register callback for shader debug information.
CrashDumpDescriptionCallback, // Register callback for GPU crash dump description.
&m_gpuCrashDumpTracker)); // Set the GpuCrashTracker object as user data passed back by the above callbacks.
[...]
}
// Static wrapper for the GPU crash dump handler. See the 'Handling GPU crash dump Callbacks' section for details.
void MyApp::GpuCrashDumpCallback(const void* pGpuCrashDump, const uint32_t gpuCrashDumpSize, void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnCrashDump(pGpuCrashDump, gpuCrashDumpSize);
}
// Static wrapper for the shader debug information handler. See the 'Handling Shader Debug Information callbacks' section for details.
void MyApp::ShaderDebugInfoCallback(const void* pShaderDebugInfo, const uint32_t shaderDebugInfoSize, void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnShaderDebugInfo(pShaderDebugInfo, shaderDebugInfoSize);
}
// Static wrapper for the GPU crash dump description handler. See the 'Handling GPU Crash Dump Description Callbacks' section for details.
void MyApp::CrashDumpDescriptionCallback(PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription addDescription, void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnDescription(addDescription);
}
```
Enabling GPU crash dumps in an application with
`GFSDK_Aftermath_EnableGpuCrashDumps()` will override any settings from an
already active Nsight Aftermath GPU crash dump monitor for this application.
That means the GPU crash dump monitor will not be notified of any GPU crash
related to this process nor will it create any GPU crash dumps or shader debug
information files for D3D or Vulkan devices that are created after the function
was called. Also, all configuration settings made in the GPU crash dump monitor
will be ignored.
## Configuring GPU Crash Dumps
Which data will be included in GPU crash dumps is configured by the Aftermath
per-device feature flags. How to configure Aftermath feature flags differs
between D3D and Vulkan.
For D3D, the application must call the appropriate
`GFSDK_Aftermath_DX*_Initialize()` functions to initialize the desired Aftermath
feature flags.
For Vulkan, Aftermath feature flags are configured at logical device creation time
via the `VK_NV_device_diagnostics_config` extension.
The following sample code shows how to use `GFSDK_Aftermath_DX12_Initialize()`
to enable the following features for a D3D12 device:
* _Aftermath event markers_ - this will include information about the Aftermath
event marker nearest to the crash. Using event markers should be considered
carefully. Injecting markers in high-frequency code paths can introduce hight
CPU overhead.
* _Resource tracking_ - this will include additional information about the
resource related to a GPU virtual address seen in the case of a crash due to
a GPU page fault. This includes, for example, information about the size of
the resource, its format, and the current deletion status of the resource
object.
* _Call stack capturing_ - this will include call stack and module information
for the draw call, compute dispatch, or resource copy nearest to the crash.
Using this option should be considered carefully. Enabling call stack
capturing can cause considerable CPU overhead.
* _Generating shader debug information_ - this instructs the shader compiler to
generate debug information (line tables) for all shaders. Using this option
should be considered carefully. It may cause considerable shader compilation
overhead and additional overhead for handling the corresponding shader debug
information callbacks.
``` C++
void MyApp::InitDevice()
{
[...]
D3D12CreateDevice(hardwareAdapter.Get(), D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device)));
// Initialize Nsight Aftermath for this device.
const uint32_t aftermathFlags =
GFSDK_Aftermath_FeatureFlags_EnableMarkers | // Enable event marker tracking.
GFSDK_Aftermath_FeatureFlags_EnableResourceTracking | // Enable tracking of resources.
GFSDK_Aftermath_FeatureFlags_CallStackCapturing | // Capture call stacks for all draw calls, compute dispatches, and resource copies.
GFSDK_Aftermath_FeatureFlags_GenerateShaderDebugInfo; // Generate debug information for shaders.
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_DX12_Initialize(
GFSDK_Aftermath_Version_API,
aftermathFlags,
m_device.Get()));
[...]
}
```
The same kind of Aftermath feature selection for a Vulkan device could look like
this:
``` C++
void MyApp::InitDevice()
{
std::vector<char const*> extensionNames;
[...]
// Enable NV_device_diagnostic_checkpoints extension to be able to
// use Aftermath event markers.
extensionNames.push_back(VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME);
// Enable NV_device_diagnostics_config extension to configure Aftermath
// features.
extensionNames.push_back(VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME);
// Set up device creation info for Aftermath feature flag configuration.
VkDeviceDiagnosticsConfigFlagsNV aftermathFlags =
VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV | // Enable tracking of resources.
VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV | // Capture call stacks for all draw calls, compute dispatches, and resource copies.
VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV; // Generate debug information for shaders.
VkDeviceDiagnosticsConfigCreateInfoNV aftermathInfo = {};
aftermathInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
aftermathInfo.flags = aftermathFlags;
// Set up device creation info.
VkDeviceCreateInfo deviceInfo = {};
deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceInfo.pNext = &aftermath_info;
deviceInfo.queueCreateInfoCount = 1;
deviceInfo.pQueueCreateInfos = &queueInfo;
deviceInfo.enabledExtensionCount = extensionNames.size();
deviceInfo.ppEnabledExtensionNames = extensionNames.data();
// Create the logical device.
VkDevice device;
vkCreateDevice(physicalDevice, &deviceInfo, NULL, &device);
[...]
}
```
## Inserting Event Markers
The Aftermath API provides a simple and light-weight solution for inserting
event markers on the GPU timeline.
Here is some D3D12 example code that shows how to create the necessary command
context handle with `GFSDK_Aftermath_DX12_CreateContextHandle()` and how to
call `GFSDK_Aftermath_SetEventMarker()` to set a simple event marker with a
character string as payload.
```C++
void MyApp::PopulateCommandList()
{
// Create the command list.
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_commandAllocator.Get(), m_pipelineState.Get(), IID_PPV_ARGS(&m_commandList)));
// Create an Nsight Aftermath context handle for setting Aftermath event markers in this command list.
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_DX12_CreateContextHandle(m_commandList.Get(), &m_hAftermathCommandListContext));
[...]
// Add an Aftermath event marker with a 0-terminated string as payload.
std::string eventMarker = "Draw Triangle";
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_SetEventMarker(m_hAftermathCommandListContext, (void*)eventMarker.c_str(), (unsigned int)eventMarker.size() + 1));
m_commandList->DrawInstanced(3, 1, 0, 0);
[...]
}
```
For reduced CPU overhead, use `GFSDK_Aftermath_SetEventMarker()` with
`dataSize=0`. This instructs Aftermath not to allocate and copy off memory
internally, relying on the application to manage marker pointers itself.
For Vulkan, similar functionality is provided via the
`NV_device_diagnostic_checkpoints` extension. When this extension is enabled for
a Vulkan device event markers can be inserted in a command buffer with the
`vkCmdSetCheckpointNV()` function.
```C++
void MyApp::RecordCommandBuffer()
{
[...]
// Add an Aftermath event marker pointing to a null-terminated string.
vkCmdSetCheckpointNV(commandBuffer, "Draw Cube");
[...]
}
```
## Handling GPU Crash Dump Callbacks
When Nsight Aftermath GPU crash dumps are enabled, and a GPU crash or hang is
detected, the necessary data is gathered and a GPU crash dump is created from
it. Then the GPU crash dump callback function that was registered with the
`GFSDK_Aftermath_EnableGpuCrashDumps()` will be invoked to notify the
application. In the callback the application can either decode the GPU crash
dump data using the GPU crash dump decoding API or forward it to the crash
handling infrastructure.
In the simple example implementation of a GPU crash dump callback handler is
shown below the GPU crash dump data is simply stored to a file. This file could
then be opened for analysis with Nsight Graphics.
```C++
// Handler for GPU crash dump callbacks (called by GpuCrashDumpCallback).
void GpuCrashTracker::OnCrashDump(const void* pGpuCrashDump, const uint32_t gpuCrashDumpSize)
{
// Make sure only one thread at a time...
std::lock_guard<std::mutex> lock(m_mutex);
// Write to file for later in-depth analysis.
WriteGpuCrashDumpToFile(pGpuCrashDump, gpuCrashDumpSize);
}
```
Note that all callback functions are free-threaded, and that the application is
responsible for providing thread-safe callback handlers.
It is also important to note that `DXGI_ERROR` error notification is asynchronous
to the NVIDIA display driver's GPU crash handling. That means applications
should check the return value of IDXGISwapChain::Present() and give the Nsight
Aftermath GPU crash dump processing thread some time to do its work before
releasing the D3D device or terminating the process.
## Handling GPU Crash Dump Description Callbacks
An application can register an optional callback function that allows it to
provide supplemental information about a crash. This callback is called after
the GPU crash happened, but before the actual GPU crash dump callback. This
presents the opportunity for the application to provide information such as
application name, application version, or user defined data, for example,
current engine state. The data provided will be stored in the GPU crash dump.
Here is an example of a basic GPU crash dump description handler. Data is added
to the crash dump by calling the `addDescription()` function provided by the
callback.
```C++
// Handler for GPU crash dump description callbacks (called by CrashDumpDescriptionCallback).
void GpuCrashTracker::OnDescription(PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription addDescription)
{
// Add some basic description about the crash.
addDescription(GFSDK_Aftermath_GpuCrashDumpDescriptionKey_ApplicationName, "Hello Nsight Aftermath");
addDescription(GFSDK_Aftermath_GpuCrashDumpDescriptionKey_ApplicationVersion, "v1.0");
addDescription(GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined, "This is a GPU crash dump example");
addDescription(GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined + 1, "Engine State: Rendering");
}
```
Note that all callback functions are free-threaded; the application is
responsible for providing thread-safe callback handlers.
## Handling Shader Debug Information Callbacks
If the device was configured with the `GenerateShaderDebugInfo` feature flag,
the generated shader debug information will be communicated to the application
through the (optional) shader debug information callback function that was
registered when the `GFSDK_Aftermath_EnableGpuCrashDumps()` was called. This debug
information will be required to map from shader instruction addresses to
intermediate assembly language (IL) instructions or high-level source lines when
analyzing a crash dump in Nsight Graphics or when using the GPU crash dump to
JSON decoding functions of the Nsight Aftermath API. If this functionality is
not required, an application can omit the `GenerateShaderDebugInfo` flag when
configuring the device and pass `nullptr` for the shader debug information
callback. This might be desirable, because generating shader debug information
incurs overhead in shader compilation and for handling the callback.
Here is a simple example implementation of a callback handler that writes
the data to disk using the unique shader debug info identifier queried from the
opaque shader debug information blob.
```C++
// Handler for shader debug information callbacks (called by ShaderDebugInfoCallback)
void GpuCrashTracker::OnShaderDebugInfo(const void* pShaderDebugInfo, const uint32_t shaderDebugInfoSize)
{
// Make sure only one thread at a time...
std::lock_guard<std::mutex> lock(m_mutex);
// Get shader debug information identifier.
GFSDK_Aftermath_ShaderDebugInfoIdentifier identifier = {};
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_GetShaderDebugInfoIdentifier(GFSDK_Aftermath_Version_API, pShaderDebugInfo, shaderDebugInfoSize, &identifier));
// Write to file for later in-depth analysis of crash dumps with Nsight Graphics.
WriteShaderDebugInformationToFile(identifier, pShaderDebugInfo, shaderDebugInfoSize);
}
```
By default, the shader debug information callback will be invoked for every
shader that is compiled by the NVIDIA display driver. It is the responsibility
of the implementation to handle those callbacks and store the data in case a GPU
crash occurs. To simplify the process the Nsight Aftermath library can handle
the caching of the debug information and only invoke the callback in case of a
GPU crash and only for the shaders referenced in the corresponding GPU crash
dump. This behavior is enabled by passing the
`GFSDK_Aftermath_GpuCrashDumpFeatureFlags_DeferDebugInfoCallbacks` flag to
`GFSDK_Aftermath_EnableGpuCrashDumps()` when enabling GPU crash dumps.
Note that all callback functions are free-threaded; the application is
responsible for providing thread-safe callback handlers.
## Disable GPU Crash Dumps
To disable GPU crash dumps simply call `GFSDK_Aftermath_DisableGpuCrashDumps()`.
```C++
MyApp::~MyApp()
{
[...]
// Disable GPU crash dump creation.
GFSDK_Aftermath_DisableGpuCrashDumps();
[...]
}
```
Disabling GPU crash dumps in an application with
`GFSDK_Aftermath_DisableGpuCrashDumps()` will re-enable any Nsight Aftermath GPU
crash dump monitor settings for this application, if it is running on the
system. After this, the GPU crash dump monitor will be notified of any GPU crash
related to this process and will create GPU crash dumps and shader debug
information files for all active devices.
## Reading GPU Crash Dumps
The Nsight Aftermath library provides several functions for decoding GPU crash
dumps and for querying data from the crash dumps. To use these functions
include the `GFSD_Aftermath_GpuCrashDumpDecoding.h` header file.
The first step in decoding a GPU crash dump is to create a decoder object for
it by calling `GFSDK_Aftermath_GpuCrashDump_CreateDecoder()`:
```C++
// Create a GPU crash dump decoder object for the GPU crash dump.
GFSDK_Aftermath_GpuCrashDump_Decoder decoder = {};
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_GpuCrashDump_CreateDecoder(
GFSDK_Aftermath_Version_API,
pGpuCrashDump,
gpuCrashDumpSize,
&decoder));
```
Then one or more decoder functions can be used to read data from a GPU crash
dump. The data in the GPU crash dumps varies depending on the type of GPU crash
and the feature flags used when initializing Aftermath. For example, if the
application does not use Aftermath event markers, querying Aftermath event
marker information will fail. The decoder will return
`GFSDK_Aftermath_Result_NotAvailable` if the requested data is not available.
An implementation should be aware of that and handle the situation accordingly.
Here is an example of how to query GPU page fault information from a GPU crash
dump using a previously created decoder object:
```C++
// Query GPU page fault information.
GFSDK_Aftermath_GpuCrashDump_PageFaultInfo pageFaultInfo = {};
GFSDK_Aftermath_Result result = GFSDK_Aftermath_GpuCrashDump_GetPageFaultInfo(decoder, &pageFaultInfo);
if (GFSDK_Aftermath_SUCCEED(result) && result != GFSDK_Aftermath_Result_NotAvailable)
{
// Print information about the GPU page fault.
Utility::Printf("GPU page fault at 0x%016llx", pageFaultInfo.faultingGpuVA);
if (pageFaultInfo.bHasResourceInfo)
{
Utility::Printf("Fault in resource starting at 0x%016llx", pageFaultInfo.resourceInfo.gpuVa);
Utility::Printf("Size of resource: (w x h x d x ml) = {%u, %u, %u, %u} = %llu bytes",
pageFaultInfo.resourceInfo.width,
pageFaultInfo.resourceInfo.height,
pageFaultInfo.resourceInfo.depth,
pageFaultInfo.resourceInfo.mipLevels,
pageFaultInfo.resourceInfo.size);
Utility::Printf("Format of resource: %u", pageFaultInfo.resourceInfo.format);
Utility::Printf("Resource was destroyed: %d", pageFaultInfo.resourceInfo.bWasDestroyed);
}
}
```
Some decoding functions require the caller to provide an appropriately sized
buffer for the data they return. Those come with an additional function to
query the size of the buffer. For example, querying all the active shaders at
the time of the GPU crash or hang could look like this:
```C++
// First query active shaders count.
uint32_t shaderCount = 0;
GFSDK_Aftermath_Result result = GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfoCount(decoder, &shaderCount);
if (GFSDK_Aftermath_SUCCEED(result) && result != GFSDK_Aftermath_Result_NotAvailable)
{
// Allocate buffer for results.
std::vector<GFSDK_Aftermath_GpuCrashDump_ShaderInfo> shaderInfos(shaderCount);
// Query active shaders information.
result = GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfo(decoder, shaderCount, shaderInfos.data());
if (GFSDK_Aftermath_SUCCEED(result))
{
// Print information for each active shader
for (const GFSDK_Aftermath_GpuCrashDump_ShaderInfo& shaderInfo : shaderInfos)
{
Utility::Printf("Active shader: ShaderHash = 0x%016llx ShaderInstance = 0x%016llx Shadertype = %u",
shaderInfo.shaderHash,
shaderInfo.shaderInstance,
shaderInfo.shaderType);
}
}
}
```
Finally, the GPU crash dump decoder also provides functions for converting a GPU
crash dump into JSON format. Here is a code example for creating JSON from a GPU
crash dump including, information about all the shaders active at the time of
the GPU crash or hang. The infomration also includes the corresponding active
shader warps, including their mapping back to intermediate assembly language
(IL) instructions or source, if available. The later requires the caller to also
provide a couple of callback functions the decoder will invoke to query shader
debug information and shader binaries (dxc shader object outputs or SPIR-V
shader files). These are optional and implementations not interested in mapping
shader instruction addresses to IL or source lines can simply pass
`nullptr`. However, if shader instruction mapping is desired, the implementation
needs to ensure that it can provide the necessary information to the decoder.
```C++
// Flags controlling what to include in the JSON data
const uint32_t jsonDecoderFlags =
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_INFO | // Include information about active shaders.
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_WARP_STATE_INFO | // Include information about active shader warps.
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO; // Try to map shader instruction addresses to shader lines.
// Query the size of the required results buffer
uint32_t jsonSize = 0;
GFSDK_Aftermath_Result result = GFSDK_Aftermath_GpuCrashDump_GenerateJSON(
decoder,
jsonDecoderFlags, // The flags controlling what information to include in the JSON.
GFSDK_Aftermath_GpuCrashDumpFormatterFlags_CONDENSED_OUTPUT, // Generate condensed out, i.e. omit all unnecessary whitespace.
ShaderDebugInfoLookupCallback, // Callback function invoked to find shader debug information data.
ShaderLookupCallback, // Callback function invoked to find shader binary data by shader hash.
ShaderInstructionsLookupCallback, // Callback function invoked to find shader binary shader data by instructions hash.
ShaderSourceDebugDataLookupCallback, // Callback function invoked to find shader source debug data by shader DebugName.
&m_gpuCrashDumpTracker, // User data that will be provided to the above callback functions.
&jsonSize); // Result of the call: size in bytes of the generated JSON data.
if (GFSDK_Aftermath_SUCCEED(result) && result != GFSDK_Aftermath_Result_NotAvailable)
{
// Allocate buffer for results.
std::vector<char> json(jsonSize);
// Query the generated JSON data taht si cached inside the decoder object.
result = GFSDK_Aftermath_GpuCrashDump_GetJSON(
decoder,
json.size(),
json.data());
if (GFSDK_Aftermath_SUCCEED(result))
{
Utility::Printf("JSON: %s", json.data());
}
}
```
Possible implementations for the shader debug information and shader binary
lookup callbacks:
```C++
// Static callback wrapper for OnShaderDebugInfoLookup
void MyApp::ShaderDebugInfoLookupCallback(
const GFSDK_Aftermath_ShaderDebugInfoIdentifier* pIdentifier,
PFN_GFSDK_Aftermath_SetData setShaderDebugInfo,
void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnShaderDebugInfoLookup(*pIdentifier, setShaderDebugInfo);
}
// Static callback wrapper for OnShaderLookup
void MyApp::ShaderLookupCallback(
const GFSDK_Aftermath_ShaderHash* pShaderHash,
PFN_GFSDK_Aftermath_SetData setShaderBinary,
void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnShaderLookup(*pShaderHash, setShaderBinary);
}
// Static callback wrapper for OnShaderInstructionsLookup
void MyApp::ShaderInstructionsLookupCallback(
const GFSDK_Aftermath_ShaderInstructionsHash* pShaderInstructionsHash,
PFN_GFSDK_Aftermath_SetData setShaderBinary,
void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnShaderInstructionsLookup(*pShaderInstructionsHash, setShaderBinary);
}
// Static callback wrapper for OnShaderSourceDebugInfoLookup
void MyApp::ShaderSourceDebugInfoLookupCallback(
const GFSDK_Aftermath_ShaderDebugName* pShaderDebugName,
PFN_GFSDK_Aftermath_SetData setShaderBinary,
void* pUserData)
{
GpuCrashTracker* pGpuCrashTracker = reinterpret_cast<GpuCrashTracker*>(pUserData);
pGpuCrashTracker->OnShaderSourceDebugInfoLookup(*pShaderDebugName, setShaderBinary);
}
// Handler for shader debug information lookup callbacks.
// This is used by the JSON decoder for mapping shader instruction
// addresses to IL lines or source lines.
void GpuCrashTracker::OnShaderDebugInfoLookup(
const GFSDK_Aftermath_ShaderDebugInfoIdentifier& identifier,
PFN_GFSDK_Aftermath_SetData setShaderDebugInfo) const
{
// Search the list of shader debug information blobs received earlier.
auto i_debugInfo = m_shaderDebugInfo.find(identifier);
if (i_debugInfo == m_shaderDebugInfo.end())
{
// Early exit, nothing found. No need to call setShaderDebugInfo.
return;
}
// Let the GPU crash dump decoder know about the shader debug information
// that was found.
setShaderDebugInfo(i_debugInfo->second.data(), i_debugInfo->second.size());
}
// Handler for shader lookup callbacks.
// This is used by the JSON decoder for mapping shader instruction
// addresses to IL lines or source lines.
// NOTE: If the application loads stripped shader binaries, Aftermath
// will require access to both the stripped and the non-stripped
// shader binaries.
void GpuCrashTracker::OnShaderLookup(
const GFSDK_Aftermath_ShaderHash& shaderHash,
PFN_GFSDK_Aftermath_SetData setShaderBinary) const
{
// Find shader binary data for the shader instruction hash in the shader database.
std::vector<uint8_t> shaderBinary;
if (!m_shaderDatabase.FindShaderBinary(shaderInstructionsHash, shaderBinary))
{
// Early exit, nothing found. No need to call setShaderBinary.
return;
}
// Let the GPU crash dump decoder know about the shader data
// that was found.
setShaderBinary(shaderBinary.data(), shaderBinary.size());
}
// Handler for shader instructions lookup callbacks (D3D-only).
// This is used by the JSON decoder for mapping shader instruction
// addresses to DXIL lines or HLSL source lines.
// NOTE: If the application loads stripped shader binaries (-Qstrip_debug),
// Aftermath will require access to both the stripped and the non-stripped
// shader binaries.
void GpuCrashTracker::OnShaderInstructionsLookup(
const GFSDK_Aftermath_ShaderInstructionsHash& shaderInstructionsHash,
PFN_GFSDK_Aftermath_SetData setShaderBinary) const
{
// Find shader binary data for the shader instruction hash in the shader database.
std::vector<uint8_t> shaderBinary;
if (!m_shaderDatabase.FindShaderBinary(shaderInstructionsHash, shaderBinary))
{
// Early exit, nothing found. No need to call setShaderBinary.
return;
}
// Let the GPU crash dump decoder know about the shader data
// that was found.
setShaderBinary(shaderBinary.data(), shaderBinary.size());
}
// Handler for shader source debug info lookup callbacks.
// This is used by the JSON decoder for mapping shader instruction addresses to
// source lines, if the shaders used by the application were compiled with
// separate debug info data files.
void GpuCrashTracker::OnShaderSourceDebugInfoLookup(
const GFSDK_Aftermath_ShaderDebugName& shaderDebugName,
PFN_GFSDK_Aftermath_SetData setShaderBinary) const
{
// Find source debug info for the shader DebugName in the shader database.
std::vector<uint8_t> sourceDebugInfo;
if (!m_shaderDatabase.FindSourceShaderDebugData(shaderDebugName, sourceDebugInfo))
{
// Early exit, nothing found. No need to call setShaderBinary.
return;
}
// Let the GPU crash dump decoder know about the shader debug data that
// was found.
setShaderBinary(sourceDebugInfo.data(), sourceDebugInfo.size());
}
```
Last, the decoder object should be destroyed, if no longer needed, to free up
all memory allocated for it:
```C++
// Destroy the GPU crash dump decoder object.
AFTERMATH_CHECK_ERROR(GFSDK_Aftermath_GpuCrashDump_DestroyDecoder(decoder));
```
# Shader Compilation for Source Mapping
## D3D12
The following variants of generating source shader debug information for HLSL
shaders are supported:
1. Compile and use full shader blobs
Compile the shaders with the debug information. Use the full (i.e. not
stripped) shader binary when running the application and make it accessible
through `ShaderLookupCallback` and `ShaderInstructionsLookupCallback`. In
this case there is no need to provide a `ShaderSourceDebugDataLookupCallback`.
Compilation example:
```
dxc -Zi [..] -Fo shader.bin shader.hlsl
```
2. Compile and strip
Compile the shaders with debug information and then strip off the debug
information. Use the stripped shader binary data when running the
application. Make the stripped shader binary data accessible through
`ShaderLookupCallback` and `ShaderInstructionsLookupCallback`. In addition,
make the non-stripped shader binary data accessible through
`ShaderSourceDebugDataLookupCallback`.
Compilation example:
```
dxc -Zi [..] -Fo full_shader.bin shader.hlsl
dxc -dumpbin -Qstrip_debug -Fo shader.bin full_shader.bin
```
The shader's DebugName required for implementing the
ShaderSourceDebugDataLookupCallback may be extracted from the stripped or
the non-stripped shader binary data with
`GFSDK_Aftermath_GetShaderDebugName()`.
3. Compile with separate debug information (and auto-generated debug data file name)
Compile the shaders with debug information and instruct the compiler to store
the debug meta data in a separate shader debug information file. The name of
the file generated by the compiler will match the DebugName of the shader.
Make the shader binary data accessible through `ShaderLookupCallback` and
`ShaderInstructionsLookupCallback`. In addition, make the data from the
compiler generated shader debug data file accessible through
`ShaderSourceDebugDataLookupCallback`.
Compilation example:
```
dxc -Zi [..] -Fo shader.bin -Fd debugInfo\ shader.hlsl
```
The debug data file generated by the compiler does not contain any reference
to the shader's DebugName. It is the responsibility of the user providing
the `ShaderSourceDebugDataLookupCallback` callback to implement a solution to
lookup the debug data based on the name of the generated debug data file.
4. Compile with separate debug information (and user-defined debug data file name)
Compile the shaders with debug information and instruct the compiler to
store the debug meta data in a separate shader debug information file. The
name of the file is freely choosen by the user. Make the shader binary data
accessible through `ShaderLookupCallback` and
`ShaderInstructionsLookupCallback`. In addition, make the data from the
compiler generated shader debug data file accessible through
`ShaderSourceDebugDataLookupCallback`.
Compilation example:
```
dxc -Zi [..] -Fo shader.bin -Fd debugInfo\shader.dbg shader.hlsl
```
The debug data file generated by the compiler does not contain any reference
to the shader's DebugName. It is the responsibility of the user providing
the `ShaderSourceDebugDataLookupCallback` callback to implement a solution
that performs the lookup of the debug data based on a mapping between the
shader's DebugName the debug data file's name that was chosen for the
compilation. The shader's DebugName may be extracted from the shader binary
data with `GFSDK_Aftermath_GetShaderDebugName()`.
## Vulkan (SPIR-V)
For SPIR-V shaders, the Aftermath SDK provides support for the following variants
of generating source shader debug information:
1) Compile and use a full shader blob
Compile the shaders with the debug information. Use the full (i.e. not
stripped) shader binary when running the application and make it accessible
through `ShaderLookupCallback`. In this case there is no need to provide
ShaderInstructionsLookupCallback` or ShaderSourceDebugInfoLookupCallback`.
Compilation example using the Vulkan SDK tool-chain:
```
glslangValidator -V -g -o ./full/shader.spv shader.vert
```
2) Compile and strip
Compile the shaders with debug information and then strip off the debug
information. Use the stripped shader binary data when running the application.
Make the stripped shader binary data accessible through shaderLookupCb.
In addition, make the non-stripped shader binary data accessible through
`ShaderSourceDebugInfoLookupCallback`.
Compilation example using the Vulkan SDK tool-chain:
```
glslangValidator -V -g -o ./full/shader.spv shader.vert
spirv-remap --map all --strip-all --input full/shader.spv --output ./stripped/
````
The (decoder) application then needs to pass the contents of the
`full/shader.spv` and `stripped/shader.spv` pair to
`GFSDK_Aftermath_GetDebugNameSpirv()` to generate the shader DebugName to
use with `ShaderSourceDebugInfoLookupCallback`.
# Limitations and Known Issues
* Nsight Aftermath covers only GPU crashes. CPU crashes in the NVIDIA display
driver, the D3D runtime, the Vulkan loader, or the application cannot be
captured.
* Nsight Aftermath is only fully supported on Turing or later GPUs.
## D3D
* Nsight Aftermath is only fully supported for D3D12 devices. Only basic support
with a reduced feature set (no resource tracking and no shader address
mapping) is available for D3D11 devcies.
* Nsight Aftermath is fully supported on Windows 10, with limited support on
Windows 7.
* Nsight Aftermath event markers and resource tracking is incompatible with the
D3D debug layer and tools using D3D API interception, such as Microsoft PIX
or Nsight Graphics.
* Shader line mappings for active warps are only supported for DXIL shaders,
i.e. Shader Model 6 or above.
* Due to a known driver bug the captured GPU state may be incomplete for
drivers < R440. This can affect the capturing of shader instruction addresses
for active warps.
## Vulkan
* On Linux, due to a driver limitation the device status reported by
`GFSDK_Aftermath_GpuCrashDump_GetDeviceInfo` is always
`GFSDK_Aftermath_Device_Status_Unknown`. This will be fixed in an upcoming
Linux display driver release.
# Copyright and Licenses
See LICENSE file.
external/aftermath/include/GFSDK_Aftermath.h
Vendored
-483
View File
@@ -1,483 +0,0 @@
/*
* Copyright (c) 2017-2021, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
/*
* █████ █████ ██████ ████ ████ ███████ ████ ██████ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██████ ████ ██ ████ █████ ██ ██ ██ ██████ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ ██ DEBUGGER
* ██ ██
* ████████████████████████████████████████████████████████ ██ █ ██ ████████████
*
*
* HOW TO USE AFTERMATH for DX11 and DX12
* --------------------------------------
*
* Call 'GFSDK_Aftermath_DXxx_Initialize', to initialize the library and to enable
* the desired Aftermath feature set. See 'GFSDK_Aftermath_FeatureFlags' below for
* the list of supported features.
* This must be done before any other library calls are made, and the method must
* return 'GFSDK_Aftermath_Result_Success' for initialization to be complete.
*
* Initialization of Aftermath may fail for a variety of reasons, including:
*
* o) The initialization function was already called for the device:
* GFSDK_Aftermath_Result_FAIL_AlreadyInitialized.
*
*
* o) Aftermath isn't supported on the GPU associated with the device or the NVIDIA
* display driver version installed:
* GFSDK_Aftermath_Result_FAIL_InvalidAdapter,
* GFSDK_Aftermath_Result_FAIL_DriverInitFailed,
* GFSDK_Aftermath_Result_FAIL_DriverVersionNotSupported,
* GFSDK_Aftermath_Result_FAIL_NvApiIncompatible.
*
*
* o) A D3D API debug layer, such as PIX, was detected that is incompatible with
* Aftermath:
* GFSDK_Aftermath_Result_FAIL_D3dDllInterceptionNotSupported
*
*
* o) Aftermath was disabled on the system by the current user setting the
* 'HKEY_CURRENT_USER\Software\NVIDIA Corporation\Nsight Aftermath\ForceOff'
* Windows registry key:
* GFSDK_Aftermath_Result_FAIL_Disabled
*
*
* After detecting D3D device lost (TDR):
*
* o) To query the fault reason after TDR, use the 'GFSDK_Aftermath_GetDeviceStatus'
* call. See 'GFSDK_Aftermath_Device_Status', for the full list of possible
* status.
*
*
* o) In the event of a GPU page fault, use the'GFSDK_Aftermath_GetPageFaultInformation'
* method to return more information about what might of gone wrong. A GPU VA is
* returned, along with the resource descriptor of the resource that VA lands in.
* NOTE: It's not 100% certain that this is the resource which caused the fault,
* only that the faulting VA lands within this resource in memory.
*
*
* Optionally, instrument the application with Aftermath event markers:
*
* 1) For each commandlist/device context you expect to use with Aftermath,
* initialize them using the 'GFSDK_Aftermath_DXxx_CreateContextHandle',
* function.
*
*
* 2) Call 'GFSDK_Aftermath_SetEventMarker', to inject an event
* marker directly into the command stream at that point.
*
* PERFORMANCE TIP:
*
* Do not use 'GFSDK_Aftermath_SetEventMarker' in high frequency code paths.
* Injecting event markers introduces considerable CPU overhead. For reduced CPU
* overhead, use 'GFSDK_Aftermath_SetEventMarker' with markerSize=0. This
* instructs Aftermath not to allocate and copy off memory internally, relying on
* the application to manage marker pointers itself.
*
*
* 3) Once TDR/hang occurs, call the 'GFSDK_Aftermath_GetData' API
* to fetch the event marker last processed by the GPU for each context.
* This API also supports fetching the current execution state for each
* the GPU.
*
*
* 4) Before the app shuts down, each Aftermath context handle must be cleaned
* up, this is done with the 'GFSDK_Aftermath_ReleaseContextHandle' call.
*
*
* HOW TO USE AFTERMATH for Vulkan
* -------------------------------
*
* For Vulkan use the VK_NV_device_diagnostics_config extension to initialize and
* configure the Aftermath feature set to use.
*
* Use the VK_NV_device_diagnostic_checkpoints extension to add event markers into
* the command stream.
*
*/
#ifndef GFSDK_Aftermath_H
#define GFSDK_Aftermath_H
#include "GFSDK_Aftermath_Defines.h"
#pragma pack(push, 8)
#ifdef __cplusplus
extern "C" {
#endif
// Here is defined a set of features that can be enabled/disable when using Aftermath
GFSDK_AFTERMATH_DECLARE_ENUM(FeatureFlags)
{
// The minimal flag only allows use of the GetDeviceStatus entry point.
GFSDK_Aftermath_FeatureFlags_Minimum = 0x00000000,
// With this flag set, the SetEventMarker and GetData entry points are available.
//
// Using event markers should be considered carefully as they can cause very high
// CPU overhead when used in high frequency code paths.
//
GFSDK_Aftermath_FeatureFlags_EnableMarkers = 0x00000001,
// With this flag set, resources are tracked, and information about
// possible page fault candidates can be accessed using GetPageFaultInformation.
GFSDK_Aftermath_FeatureFlags_EnableResourceTracking = 0x00000002,
// With this flag set, event markers are automatically set for all draw calls,
// compute dispatches and copy operations to capture the call stack for the
// corresponding API call as the event marker payload.
// Requires also GFSDK_Aftermath_FeatureFlags_EnableMarkers to be set.
//
// Using this option should be considered carefully. Enabling call stack capturing
// can cause considerable CPU overhead.
//
GFSDK_Aftermath_FeatureFlags_CallStackCapturing = 0x40000000,
// With this flag set, shader debug information is generated.
// Not supported for UWP applications.
GFSDK_Aftermath_FeatureFlags_GenerateShaderDebugInfo = 0x00000008,
// Use all Aftermath features
// Be careful when using this! Some features can cause considerable performance overhead,
// for example, GFSDK_Aftermath_FeatureFlags_EnableMarkers.
GFSDK_Aftermath_FeatureFlags_Maximum = GFSDK_Aftermath_FeatureFlags_Minimum |
GFSDK_Aftermath_FeatureFlags_EnableMarkers |
GFSDK_Aftermath_FeatureFlags_EnableResourceTracking |
GFSDK_Aftermath_FeatureFlags_CallStackCapturing |
GFSDK_Aftermath_FeatureFlags_GenerateShaderDebugInfo,
};
#if defined(__d3d11_h__) || defined(__d3d12_h__)
// Used with Aftermath entry points to reference an API object.
GFSDK_AFTERMATH_DECLARE_HANDLE(GFSDK_Aftermath_ContextHandle);
GFSDK_AFTERMATH_DECLARE_HANDLE(GFSDK_Aftermath_ResourceHandle);
// Used with, 'GFSDK_Aftermath_GetData'. Filled with information,
// about each requested context.
typedef struct GFSDK_Aftermath_ContextData
{
GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(void*, markerData);
uint32_t markerSize;
GFSDK_Aftermath_Context_Status status;
} GFSDK_Aftermath_ContextData;
// Minimal description of a graphics resource.
typedef struct GFSDK_Aftermath_ResourceDescriptor
{
// This is available in DX12 only and only if the application registers the
// resource pointers using GFSDK_Aftermath_DX12_RegisterResource().
#ifdef __d3d12_h__
GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(ID3D12Resource*, pAppResource);
#else
GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(void*, pAppResource);
#endif
uint64_t size;
uint32_t width;
uint32_t height;
uint32_t depth;
uint32_t mipLevels;
uint32_t format; // DXGI_FORMAT
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsBufferHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsStaticTextureHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsRtvDsvTextureHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bPlacedResource);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bWasDestroyed);
} GFSDK_Aftermath_ResourceDescriptor
;
// Used with GFSDK_Aftermath_GetPageFaultInformation
typedef struct GFSDK_Aftermath_PageFaultInformation
{
uint64_t faultingGpuVA;
GFSDK_Aftermath_ResourceDescriptor resourceDesc;
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bHasPageFaultOccured);
} GFSDK_Aftermath_PageFaultInformation;
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_DX11_Initialize
// GFSDK_Aftermath_DX12_Initialize
// ---------------------------------
//
// [pDx11Device]; DX11-Only
// the current dx11 device pointer.
//
// [pDx12Device]; DX12-Only
// the current dx12 device pointer.
//
// flags;
// set of features to enable when initializing Aftermath
//
// version;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking
// against library version.
//
//// DESCRIPTION;
// Library must be initialized before any other call is made.
// This should be done after device creation.
// Aftermath currently only supports one D3D device,
// the first one that is initialized.
//
/////////////////////////////////////////////////////////////////////////
#ifdef __d3d11_h__
GFSDK_Aftermath_API GFSDK_Aftermath_DX11_Initialize(GFSDK_Aftermath_Version version, uint32_t flags, ID3D11Device* const pDx11Device);
#endif
#ifdef __d3d12_h__
GFSDK_Aftermath_API GFSDK_Aftermath_DX12_Initialize(GFSDK_Aftermath_Version version, uint32_t flags, ID3D12Device* const pDx12Device);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_DX11_CreateContextHandle
// GFSDK_Aftermath_DX12_CreateContextHandle
// ---------------------------------
//
// (pDx11DeviceContext); DX11-Only
// Device context to use with Aftermath.
//
// (pDx12Unknown); DX12-Only
// Command list, Command Queue, or Device to use with Aftermath
// If a device, must be the same device given to GFSDK_Aftermath_DX12_Initialize()
//
// pOutContextHandle;
// The context handle for the specified context/command list/command queue/device
// to be used with future Aftermath calls.
//
//// DESCRIPTION;
// Before Aftermath event markers can be inserted,
// a context handle reference must first be fetched.
//
/////////////////////////////////////////////////////////////////////////
#ifdef __d3d11_h__
GFSDK_Aftermath_API GFSDK_Aftermath_DX11_CreateContextHandle(ID3D11DeviceContext* const pDx11DeviceContext, GFSDK_Aftermath_ContextHandle* pOutContextHandle);
#endif
#ifdef __d3d12_h__
GFSDK_Aftermath_API GFSDK_Aftermath_DX12_CreateContextHandle(IUnknown* const pDx12Unknown, GFSDK_Aftermath_ContextHandle* pOutContextHandle);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_API GFSDK_Aftermath_ReleaseContextHandle
// -------------------------------------
//
// contextHandle;
// Context to release
//
// DESCRIPTION;
// Cleans up any resources associated with an Aftermath context
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_ReleaseContextHandle(const GFSDK_Aftermath_ContextHandle contextHandle);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_SetEventMarker
// -------------------------------------
//
// contextHandle;
// Command list currently being populated.
//
// markerData;
// Pointer to data used for event marker.
// NOTE: If markerSize is also provided, an internal copy will be
// made of this data. In that case there is no need to keep it
// around after this call - stack alloc is safe.
//
// markerSize;
// Size of event marker data in bytes.
// NOTE: Passing a 0 for this parameter is valid, and will instruct
// Aftermath to only copy off the pointer supplied by markerData,
// rather than internally making a copy. This, however, precludes
// Aftermath from storing the marker data in GPU crash dumps.
// NOTE: Aftermath will internally truncate marker data to a maximum
// size of 1024 bytes. Use markerSize=0 and manually manage
// memory for markers if the application requires larger ones.
//
// DESCRIPTION;
// Drops a event into the command stream with a payload that can be
// linked back to the data given here, 'markerData'. It's
// safe to call from multiple threads simultaneously, normal D3D
// API threading restrictions apply.
//
// Using event markers should be considered carefully as they can cause considerable
// CPU overhead when used in high frequency code paths.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_SetEventMarker(const GFSDK_Aftermath_ContextHandle contextHandle, const void* markerData, const uint32_t markerSize);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetData
// ------------------------------
//
// numContexts;
// Number of contexts to fetch information for.
//
// pContextHandles;
// Array of contexts containing Aftermath event markers.
//
// pOutContextData;
// OUTPUT: context data for each context requested. Contains event
// last reached on the GPU, and status of context if
// applicable (DX12-Only).
// NOTE: must allocate enough space for 'numContexts' worth of structures.
// stack allocation is fine.
//
// DESCRIPTION;
// Once a TDR/crash/hang has occurred (or whenever you like), call
// this API to retrieve the event last processed by the GPU on the
// given context.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GetData(const uint32_t numContexts, const GFSDK_Aftermath_ContextHandle* pContextHandles, GFSDK_Aftermath_ContextData* pOutContextData);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetContextError()
// ------------------------------
//
// pContextData;
// Context data for which to determine error status.
//
// DESCRIPTION;
// Call this to determine the detailed failure reason for GFSDK_Aftermath_ContextData
// with 'status == GFSDK_Aftermath_Context_Status_Invalid'.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GetContextError(const GFSDK_Aftermath_ContextData* pContextData);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetDeviceStatus
// ---------------------------------
//
// pOutStatus;
// OUTPUT: Device status.
//
//// DESCRIPTION;
// Return the status of a D3D device. See GFSDK_Aftermath_Device_Status.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GetDeviceStatus(GFSDK_Aftermath_Device_Status* pOutStatus);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetPageFaultInformation
// ---------------------------------
//
// pOutPageFaultInformation;
// OUTPUT: Information about a page fault which may have occurred.
//
//// DESCRIPTION;
// Return any information available about a recent page fault which
// may have occurred, causing a device removed scenario.
// See GFSDK_Aftermath_PageFaultInformation.
//
// Requires WDDMv2 (Windows 10) or later
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GetPageFaultInformation(GFSDK_Aftermath_PageFaultInformation* pOutPageFaultInformation);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_DX12_RegisterResource
// ---------------------------------
//
// pResource;
// ID3D12Resource to register.
//
// pOutResourceHandle;
// OUTPUT: Aftermath resource handle for the resource that was registered.
//
//// DESCRIPTION;
// Register an ID3D12Resource with Aftermath. This allows Aftermath
// to map a GpuVA of a page fault to the corresponding ID3D12Resource.
//
// NOTE1: This function is only supported on Windows 10 RS4 and RS5.
// It will return GFSDK_Aftermath_Result_FAIL_D3dDllNotSupported, if the
// version of the D3D DLL is not supported.
// NOTE2: This function is not supported in UWP applications.
// NOTE3: This function is not compatible with graphics debuggers, such as
// Nsight Graphics or the Visual Studio Graphics Debugger. It may fail with
// GFSDK_Aftermath_Result_FAIL_D3dDllInterceptionNotSupported when called,
// if such a debugger is active.
//
// This is a BETA FEATURE and may not work with all versions of Windows.
//
/////////////////////////////////////////////////////////////////////////
#if defined(__d3d12_h__)
GFSDK_Aftermath_API GFSDK_Aftermath_DX12_RegisterResource(ID3D12Resource* const pResource, GFSDK_Aftermath_ResourceHandle* pOutResourceHandle);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_DX12_UnregisterResource
// ---------------------------------
//
// resourceHandle;
// Aftermath resource handle for a resource that was reagister earlier
// with GFSDK_Aftermath_DX12_RegisterResource().
//
//// DESCRIPTION;
// Unregisters a previously registered resource.
//
// This is a BETA FEATURE and may not work with all versions of Windows.
//
/////////////////////////////////////////////////////////////////////////
#if defined(__d3d12_h__)
GFSDK_Aftermath_API GFSDK_Aftermath_DX12_UnregisterResource(const GFSDK_Aftermath_ResourceHandle resourceHandle);
#endif
/////////////////////////////////////////////////////////////////////////
//
// NOTE: Function table provided - if dynamic loading is preferred.
//
/////////////////////////////////////////////////////////////////////////
#if defined(__d3d11_h__)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX11_Initialize)(GFSDK_Aftermath_Version version, uint32_t flags, ID3D11Device* const pDx11Device);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX11_CreateContextHandle)(ID3D11DeviceContext* const pDx11DeviceContext, GFSDK_Aftermath_ContextHandle* pOutContextHandle);
#endif
#if defined(__d3d12_h__)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX12_Initialize)(GFSDK_Aftermath_Version version, uint32_t flags, ID3D12Device* const pDx12Device);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX12_CreateContextHandle)(IUnknown* const pDx12CommandList, GFSDK_Aftermath_ContextHandle* pOutContextHandle);
#endif
#if defined(__d3d11_h__) || defined(__d3d12_h__)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ReleaseContextHandle)(const GFSDK_Aftermath_ContextHandle contextHandle);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_SetEventMarker)(const GFSDK_Aftermath_ContextHandle contextHandle, const void* markerData, const uint32_t markerSize);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetData)(const uint32_t numContexts, const GFSDK_Aftermath_ContextHandle* ppContextHandles, GFSDK_Aftermath_ContextData* pOutContextData);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetContextError)(const GFSDK_Aftermath_ContextData* pContextData);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetDeviceStatus)(GFSDK_Aftermath_Device_Status* pOutStatus);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetPageFaultInformation)(GFSDK_Aftermath_PageFaultInformation* pOutPageFaultInformation);
#endif
#if defined(__d3d12_h__)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX12_RegisterResource)(ID3D12Resource* const pResource, GFSDK_Aftermath_ResourceHandle* pOutResourceHandle);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DX12_UnregisterResource)(const GFSDK_Aftermath_ResourceHandle resourceHandle);
#endif
#endif // defined(__d3d11_h__) || defined(__d3d12_h__)
#if defined(VULKAN_H_)
// See VK_NV_device_diagnostics_config
// See VK_NV_device_diagnostic_checkpoints
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#pragma pack(pop)
#endif // GFSDK_Aftermath_H
external/aftermath/include/GFSDK_Aftermath_Defines.h
Vendored
-236
View File
@@ -1,236 +0,0 @@
/*
* Copyright (c) 2016-2021, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
/*
* █████ █████ ██████ ████ ████ ███████ ████ ██████ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██████ ████ ██ ████ █████ ██ ██ ██ ██████ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ ██ DEBUGGER
* ██ ██
* ████████████████████████████████████████████████████████ ██ █ ██ ████████████
*/
#ifndef GFSDK_Aftermath_Defines_H
#define GFSDK_Aftermath_Defines_H
#if defined(_MSC_VER)
#if defined(_M_X86)
#define GFSDK_AFTERMATH_CALL __cdecl
#else
#define GFSDK_AFTERMATH_CALL
#endif
#elif defined(__clang__) || defined(__GNUC__)
#if defined(__i386__)
#define GFSDK_AFTERMATH_CALL __attribute__((cdecl))
#else
#define GFSDK_AFTERMATH_CALL
#endif
#else
#error "Unsupported compiler"
#endif
#ifdef __cplusplus
#include <cstdint>
#else
#include <stdint.h>
#include <stdbool.h>
#endif
// Library stuff...
#define GFSDK_Aftermath_PFN typedef GFSDK_Aftermath_Result
#if defined(_MSC_VER)
#ifdef EXPORTS
#define GFSDK_Aftermath_DLLSPEC __declspec(dllexport)
#else
#define GFSDK_Aftermath_DLLSPEC
#endif
#elif defined(__clang__) || defined(__GNUC__)
#define GFSDK_Aftermath_DLLSPEC __attribute__((visibility("default")))
#endif
#ifdef __cplusplus
#define GFSDK_Aftermath_API extern "C" GFSDK_Aftermath_DLLSPEC GFSDK_Aftermath_Result GFSDK_AFTERMATH_CALL
#else
#define GFSDK_Aftermath_API GFSDK_Aftermath_DLLSPEC GFSDK_Aftermath_Result GFSDK_AFTERMATH_CALL
#endif
#pragma pack(push, 8)
// Helper macros for declare struct members and types with guaranteed properties
#define GFSDK_AFTERMATH_DECLARE_HANDLE(name) struct name##__ { int32_t ID; }; typedef struct name##__ *name
#ifdef __cplusplus
#define GFSDK_AFTERMATH_DECLARE_ENUM(name) enum GFSDK_Aftermath_##name : uint32_t
#else
#define GFSDK_AFTERMATH_DECLARE_ENUM(name) typedef uint32_t GFSDK_Aftermath_##name; enum GFSDK_Aftermath_##name
#endif
#define GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(type, name) union { type name; uint64_t ptr_align_##name; }
#define GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(name) union { bool name; uint32_t bool_align_##name; }
GFSDK_AFTERMATH_DECLARE_ENUM(Version)
{
GFSDK_Aftermath_Version_API = 0x000020b // Version 2.11
};
GFSDK_AFTERMATH_DECLARE_ENUM(Result)
{
GFSDK_Aftermath_Result_Success = 0x1,
GFSDK_Aftermath_Result_NotAvailable = 0x2,
GFSDK_Aftermath_Result_Fail = 0xBAD00000,
// The callee tries to use a library version
// which does not match the built binary.
GFSDK_Aftermath_Result_FAIL_VersionMismatch = GFSDK_Aftermath_Result_Fail | 1,
// The library hasn't been initialized, see;
// 'GFSDK_Aftermath_Initialize'.
GFSDK_Aftermath_Result_FAIL_NotInitialized = GFSDK_Aftermath_Result_Fail | 2,
// The callee tries to use the library with
// a non-supported GPU. Currently, only
// NVIDIA GPUs are supported.
GFSDK_Aftermath_Result_FAIL_InvalidAdapter = GFSDK_Aftermath_Result_Fail | 3,
// The callee passed an invalid parameter to the
// library, likely a null pointer or bad handle.
GFSDK_Aftermath_Result_FAIL_InvalidParameter = GFSDK_Aftermath_Result_Fail | 4,
// Something weird happened that caused the
// library to fail for some reason.
GFSDK_Aftermath_Result_FAIL_Unknown = GFSDK_Aftermath_Result_Fail | 5,
// Got a fail error code from the graphics API.
GFSDK_Aftermath_Result_FAIL_ApiError = GFSDK_Aftermath_Result_Fail | 6,
// Make sure that the NvAPI DLL is up to date.
GFSDK_Aftermath_Result_FAIL_NvApiIncompatible = GFSDK_Aftermath_Result_Fail | 7,
// It would appear as though a call has been
// made to fetch the Aftermath data for a
// context that hasn't been used with
// the EventMarker API yet.
GFSDK_Aftermath_Result_FAIL_GettingContextDataWithNewCommandList = GFSDK_Aftermath_Result_Fail | 8,
// Looks like the library has already been initialized.
GFSDK_Aftermath_Result_FAIL_AlreadyInitialized = GFSDK_Aftermath_Result_Fail | 9,
// Debug layer not compatible with Aftermath.
GFSDK_Aftermath_Result_FAIL_D3DDebugLayerNotCompatible = GFSDK_Aftermath_Result_Fail | 10,
// Aftermath failed to initialize in the driver.
GFSDK_Aftermath_Result_FAIL_DriverInitFailed = GFSDK_Aftermath_Result_Fail | 11,
// Aftermath v2.x requires driver version 387.xx and beyond
GFSDK_Aftermath_Result_FAIL_DriverVersionNotSupported = GFSDK_Aftermath_Result_Fail | 12,
// The system ran out of memory for allocations
GFSDK_Aftermath_Result_FAIL_OutOfMemory = GFSDK_Aftermath_Result_Fail | 13,
// No need to get data on bundles, as markers
// execute on the command list.
GFSDK_Aftermath_Result_FAIL_GetDataOnBundle = GFSDK_Aftermath_Result_Fail | 14,
// No need to get data on deferred contexts, as markers
// execute on the immediate context.
GFSDK_Aftermath_Result_FAIL_GetDataOnDeferredContext = GFSDK_Aftermath_Result_Fail | 15,
// This feature hasn't been enabled at initialization - see GFSDK_Aftermath_FeatureFlags.
GFSDK_Aftermath_Result_FAIL_FeatureNotEnabled = GFSDK_Aftermath_Result_Fail | 16,
// No resources have ever been registered.
GFSDK_Aftermath_Result_FAIL_NoResourcesRegistered = GFSDK_Aftermath_Result_Fail | 17,
// This resource has never been registered.
GFSDK_Aftermath_Result_FAIL_ThisResourceNeverRegistered = GFSDK_Aftermath_Result_Fail | 18,
// The functionality is not supported for UWP applications
GFSDK_Aftermath_Result_FAIL_NotSupportedInUWP = GFSDK_Aftermath_Result_Fail | 19,
// D3D DLL not compatible with Aftermath.
GFSDK_Aftermath_Result_FAIL_D3dDllNotSupported = GFSDK_Aftermath_Result_Fail | 20,
// D3D DLL interception is not compatible with Aftermath.
GFSDK_Aftermath_Result_FAIL_D3dDllInterceptionNotSupported = GFSDK_Aftermath_Result_Fail | 21,
// Aftermath is disabled on the system by the current user.
// On Windows, this is controlled by a Windows registry key:
// KeyPath : HKEY_CURRENT_USER\Software\NVIDIA Corporation\Nsight Aftermath
// KeyValue : ForceOff
// ValueType : REG_DWORD
// ValueData : Any value != 0 will force the functionality of the Aftermath
// SDK off on the system.
//
// On Linux, this is controlled by an environment variable:
// Name: NV_AFTERMATH_FORCE_OFF
// Value: Any value != '0' will force the functionality of the Aftermath
// SDK off.
//
GFSDK_Aftermath_Result_FAIL_Disabled = GFSDK_Aftermath_Result_Fail | 22,
};
#define GFSDK_Aftermath_SUCCEED(value) (((value) & 0xFFF00000) != GFSDK_Aftermath_Result_Fail)
GFSDK_AFTERMATH_DECLARE_ENUM(Context_Status)
{
// GPU:
// The GPU has not started processing this command list yet.
GFSDK_Aftermath_Context_Status_NotStarted = 0,
// This command list has begun execution on the GPU.
GFSDK_Aftermath_Context_Status_Executing,
// This command list has finished execution on the GPU.
GFSDK_Aftermath_Context_Status_Finished,
// This context has an invalid state, which could be
// caused by an error.
//
// NOTE: See, 'GFSDK_Aftermath_ContextData::getErrorCode()'
// for more information.
GFSDK_Aftermath_Context_Status_Invalid,
};
GFSDK_AFTERMATH_DECLARE_ENUM(Device_Status)
{
// The GPU is still active, and hasn't gone down.
GFSDK_Aftermath_Device_Status_Active = 0,
// A long running shader/operation has caused a
// GPU timeout. Reconfiguring the timeout length
// might help tease out the problem.
GFSDK_Aftermath_Device_Status_Timeout,
// Run out of memory to complete operations.
GFSDK_Aftermath_Device_Status_OutOfMemory,
// An invalid VA access has caused a fault.
GFSDK_Aftermath_Device_Status_PageFault,
// The GPU has stopped executing
GFSDK_Aftermath_Device_Status_Stopped,
// The device has been reset
GFSDK_Aftermath_Device_Status_Reset,
// Unknown problem - likely using an older driver
// incompatible with this Aftermath feature.
GFSDK_Aftermath_Device_Status_Unknown,
// An invalid rendering call has percolated through the driver
GFSDK_Aftermath_Device_Status_DmaFault,
};
#pragma pack(pop)
#endif // GFSDK_Aftermath_Defines_H
external/aftermath/include/GFSDK_Aftermath_GpuCrashDump.h
Vendored
-232
View File
@@ -1,232 +0,0 @@
/*
* Copyright (c) 2019-2021, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
/*
* █████ █████ ██████ ████ ████ ███████ ████ ██████ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██████ ████ ██ ████ █████ ██ ██ ██ ██████ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ ██ DEBUGGER
* ██ ██
* ████████████████████████████████████████████████████████ ██ █ ██ ████████████
*
*
* HOW TO USE AFTERMATH GPU CRASH DUMP COLLECTION:
* -----------------------------------------------
*
* 1) Call 'GFSDK_Aftermath_EnableGpuCrashDumps', to enable GPU crash dump collection.
* This must be done before any other library calls are made and before any D3D
* device is created by the application.
*
* With this call the application can register a callback function that is invoked
* with the GPU crash dump data once a TDR/hang occurs. In addition, it is also
* possible to provide optional callback functions for collecting shader debug
* information and for providing additional descriptive data from the application to
* include in the crash dump.
*
* Enabling GPU crash dumps will also override any settings from an also active
* Nsight Graphics GPU crash dump monitor for the calling process.
*
*
* 2) On DX11/DX12, call 'GFSDK_Aftermath_DXxx_Initialize', to initialize the library and
* to enable additional Aftermath features that will affect the data captured in the
* GPU crash dumps, such as Aftermath event markers; automatic call stack markers for
* all draw calls, compute dispatches, ray dispatches, or copy operations; resource
* tracking; or shader debug information. See GFSDK_Aftermath.h for more details.
*
* On Vulkan use the VK_NV_device_diagnostics_config extension to enable additional
* Aftermath features, such as automatic call stack markers for all draw calls, compute
* dispatches, ray dispatches, or copy operations; resource tracking; or shader debug
* information. See GFSDK_Aftermath.h for more details.
*
*
* 4) Before the application shuts down, call 'GFSDK_Aftermath_DisableGpuCrashDumps' to
* disable GPU crash dump collection.
*
* Disabling GPU crash dumps will also re-establish any settings from an also active
* Nsight Graphics GPU crash dump monitor for the calling process.
*
*
* OPTIONAL:
*
* o) (Optional) Instrument the application with event markers as described in
* GFSDK_Aftermath.h.
* o) (Optional, D3D12) Register D3D12 resource pointers with Aftermath as described in
* GFSDK_Aftermath.h.
* o) (Optional) To disable all GPU crash dump functionality at runtime:
* On Windows, set the registry key: 'HKEY_CURRENT_USER\Software\NVIDIA Corporation\Nsight Aftermath\ForceOff'.
* On Linux, set environment 'NV_AFTERMATH_FORCE_OFF'.
*
*
* PERFORMANCE TIPS:
*
* o) Enabling shader debug information creation will introduce shader compile time
* overhead as well as memory overhead for handling the debug information.
*
* o) User event markers cause considerable overhead and should be used very carefully.
* Using automatic callstack markers for draw calls, compute dispatches, ray dispatches,
* and copy operations may be a less costly alternative to injecting an event marker for
* every draw call. However, they also do not come for free and using them should be
* also considered carefully.
*
*/
#ifndef GFSDK_Aftermath_GpuCrashDump_H
#define GFSDK_Aftermath_GpuCrashDump_H
#include "GFSDK_Aftermath_Defines.h"
#pragma pack(push, 8)
#ifdef __cplusplus
extern "C" {
#endif
// Flags to configure for which graphisc APIs to enable GPU crash dumps
GFSDK_AFTERMATH_DECLARE_ENUM(GpuCrashDumpWatchedApiFlags)
{
// Default setting
GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_None = 0x0,
// Enable GPU crash dump tracking for the DX API
GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_DX = 0x1,
// Enable GPU crash dump tracking for the Vulkan API
GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_Vulkan = 0x2,
};
// Flags to configure GPU crash dump-specific Aftermath features
GFSDK_AFTERMATH_DECLARE_ENUM(GpuCrashDumpFeatureFlags)
{
// Default settings
GFSDK_Aftermath_GpuCrashDumpFeatureFlags_Default = 0x0,
// Defer shader debug information callbacks until an actual GPU crash
// dump is generated and also provide shader debug information
// for the shaders related to the crash dump only.
// Note: using this option will increase the memory footprint of the
// application.
GFSDK_Aftermath_GpuCrashDumpFeatureFlags_DeferDebugInfoCallbacks = 0x1,
};
// Key definitions for user-defined GPU crash dump description
GFSDK_AFTERMATH_DECLARE_ENUM(GpuCrashDumpDescriptionKey)
{
// Predefined key for application name
GFSDK_Aftermath_GpuCrashDumpDescriptionKey_ApplicationName = 0x00000001,
// Predefined key for application version
GFSDK_Aftermath_GpuCrashDumpDescriptionKey_ApplicationVersion = 0x00000002,
// Base key for creating user-defined key-value pairs.
// Any value >= GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined
// will create a user-defined key-value pair.
GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined = 0x00010000,
};
// Function for adding user-defined description key-value pairs.
// Key must be one of the predefined keys of GFSDK_Aftermath_GpuCrashDumpDescriptionKey
// or a user-defined key based on GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined.
// All keys greater than the last predefined key in GFSDK_Aftermath_GpuCrashDumpDescriptionKey
// and smaller than GFSDK_Aftermath_GpuCrashDumpDescriptionKey_UserDefined are
// considered illegal and ignored.
typedef void (GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription)(uint32_t key, const char* value);
// GPU crash dump callback definitions.
// NOTE: Except for the pUserData pointer, all pointer values passed to the
// callbacks are only valid for the duration of the call! An implementation
// must make copies of the data, if it intends to store it beyond that.
typedef void (GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDumpCb)(const void* pGpuCrashDump, const uint32_t gpuCrashDumpSize, void* pUserData);
typedef void (GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ShaderDebugInfoCb)(const void* pShaderDebugInfo, const uint32_t shaderDebugInfoSize, void* pUserData);
typedef void (GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDumpDescriptionCb)(PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription addValue, void* pUserData);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_EnableGpuCrashDumps
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// watchedApis;
// Controls which graphics APIs to watch for crashes. A combination (with OR) of
// GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags.
//
// flags;
// Controls GPU crash dump specific behavior. A combination (with OR) of
// GFSDK_Aftermath_GpuCrashDumpFeatureFlags.
//
// gpuCrashDumpCb;
// Callback function to be called when new GPU crash dump data is available.
// Callback is free-threaded, ensure the provided function is thread-safe.
//
// shaderDebugInfoCb;
// Callback function to be called when new shader debug information data is
// available.
// Callback is free-threaded, ensure the provided function is thread-safe.
// Optional, can be NULL.
// Note: if not using GFSDK_Aftermath_GpuCrashDumpFeatureFlags_DeferDebugInfoCallbacks
// shaderDebugInfoCb will be invoked for every shader compilation trigegred by the
// application, even if there will be never an invocation of gpuCrashDumpCb.
//
// descriptionCb;
// Callback function that allows the application to provide additional
// descriptive values to be include in crash dumps. This will be called
// before gpuCrashDumpCb.
// Callback is free-threaded, ensure the provided function is thread-safe.
// Optional, can be NULL.
//
// pUserData;
// User data made available in the callbacks.
//
//// DESCRIPTION;
// Device independent initialization call to enable Aftermath GPU crash dump
// creation. Overrides any settings from an also active GPU crash dump monitor
// for this process! This function must be called before any D3D device is
// created by the application.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_EnableGpuCrashDumps(
GFSDK_Aftermath_Version apiVersion,
uint32_t watchedApis,
uint32_t flags,
PFN_GFSDK_Aftermath_GpuCrashDumpCb gpuCrashDumpCb,
PFN_GFSDK_Aftermath_ShaderDebugInfoCb shaderDebugInfoCb,
PFN_GFSDK_Aftermath_GpuCrashDumpDescriptionCb descriptionCb,
void* pUserData);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_DisableGpuCrashDumps
// ---------------------------------
//
//// DESCRIPTION;
// Device independent call to disable Aftermath GPU crash dump creation.
// Re-enables settings from an also active GPU crash dump monitor for
// the current process!
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_DisableGpuCrashDumps();
/////////////////////////////////////////////////////////////////////////
//
// NOTE: Function table provided - if dynamic loading is preferred.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_EnableGpuCrashDumps)(GFSDK_Aftermath_Version apiVersion, uint32_t watchedApis, uint32_t flags, PFN_GFSDK_Aftermath_GpuCrashDumpCb gpuCrashDumpCb, PFN_GFSDK_Aftermath_ShaderDebugInfoCb shaderDebugInfoCb, PFN_GFSDK_Aftermath_GpuCrashDumpDescriptionCb descriptionCb, void* pUserData);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_DisableGpuCrashDumps)();
#ifdef __cplusplus
} // extern "C"
#endif
#pragma pack(pop)
#endif // GFSDK_Aftermath_GpuCrashDump_H
external/aftermath/include/GFSDK_Aftermath_GpuCrashDumpDecoding.h
Vendored
-982
View File
@@ -1,982 +0,0 @@
/*
* Copyright (c) 2019-2020, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
/*
* █████ █████ ██████ ████ ████ ███████ ████ ██████ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██████ ████ ██ ████ █████ ██ ██ ██ ██████ ██ ███████
* ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
* ██ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ ██ DEBUGGER
* ██ ██
* ████████████████████████████████████████████████████████ ██ █ ██ ████████████
*
*
* HOW TO DECODE AFTERMATH GPU CRASH DUMPS:
* ----------------------------------------
*
* 1) Call 'GFSDK_Aftermath_GpuCrashDump_CreateDecoder', to create a decoder object for
* a GPU crash dump.
*
*
* 2) Call one or more of the 'GFSDK_Aftermath_GpuCrashDump_Get*' functions with this
* decoder, to query information from the GPU crash dump.
*
* Some of the functions require caller allocated buffers to return the data. Those
* are accompanied with a corresponding 'GFSDK_Aftermath_GpuCrashDump_Get*Count()'
* function to query the element count the caller has to reserve for these buffers.
*
* If the requested data is not avilable in the crash dump the functions will return
* with GFSDK_Aftermath_Result_NotAvailable.
*
*
* 3) Call 'GFSDK_Aftermath_GpuCrashDump_DestroyDecoder', to destroy the decoder object
* and cleanup all related memory.
*
*/
#ifndef GFSDK_Aftermath_CrashDumpDecoding_H
#define GFSDK_Aftermath_CrashDumpDecoding_H
#include "GFSDK_Aftermath_Defines.h"
#pragma pack(push, 8)
#ifdef __cplusplus
extern "C" {
#endif
// Constants used in crash dump decoding functions
enum
{
GFSDK_Aftermath_MAX_STRING_LENGTH = 127,
};
// Unique identifier for shader debug information
typedef struct GFSDK_Aftermath_ShaderDebugInfoIdentifier
{
uint64_t id[2];
} GFSDK_Aftermath_ShaderDebugInfoIdentifier;
// Unique identifier for shader binaries
typedef struct GFSDK_Aftermath_ShaderHash
{
uint64_t hash;
} GFSDK_Aftermath_ShaderHash;
// Unique identifier for shader instructions
typedef struct GFSDK_Aftermath_ShaderInstructionsHash
{
uint64_t hash;
} GFSDK_Aftermath_ShaderInstructionsHash;
// Shader DebugName, i.e. a unique identifier for shader source debug information
typedef struct GFSDK_Aftermath_ShaderDebugName
{
char name[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
} GFSDK_Aftermath_ShaderDebugName;
// SPIR-V shader code
#if defined(VULKAN_H_)
typedef struct GFSDK_Aftermath_SpirvCode
{
GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(void*, pData);
uint32_t size;
} GFSDK_Aftermath_SpirvCode;
#endif
// Graphics API
GFSDK_AFTERMATH_DECLARE_ENUM(GraphicsApi)
{
GFSDK_Aftermath_GraphicsApi_Unknown = 0,
GFSDK_Aftermath_GraphicsApi_D3D_10_0 = 1,
GFSDK_Aftermath_GraphicsApi_D3D_10_1 = 2,
GFSDK_Aftermath_GraphicsApi_D3D_11_0 = 3,
GFSDK_Aftermath_GraphicsApi_D3D_11_1 = 4,
GFSDK_Aftermath_GraphicsApi_D3D_11_2 = 5,
GFSDK_Aftermath_GraphicsApi_D3D_12_0 = 6,
GFSDK_Aftermath_GraphicsApi_Vulkan = 7,
};
// GPU crash dump - base information
typedef struct GFSDK_Aftermath_GpuCrashDump_BaseInfo
{
char applicationName[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
char creationDate[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
uint32_t pid;
GFSDK_Aftermath_GraphicsApi graphicsApi;
} GFSDK_Aftermath_GpuCrashDump_BaseInfo;
// GPU crash dump - device information
typedef struct GFSDK_Aftermath_GpuCrashDump_DeviceInfo
{
GFSDK_Aftermath_Device_Status status;
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(adapterReset);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(channel3dReset);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(channelComputeReset);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(channelCopyReset);
} GFSDK_Aftermath_GpuCrashDump_DeviceInfo;
// GPU crash dump - system information
typedef struct GFSDK_Aftermath_GpuCrashDump_SystemInfo
{
char osVersion[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
struct DisplayDriverVersion
{
uint32_t major;
uint32_t minor;
} displayDriver;
} GFSDK_Aftermath_GpuCrashDump_SystemInfo;
// GPU crash dump - GPU information
typedef struct GFSDK_Aftermath_GpuCrashDump_GpuInfo
{
char adapterName[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
char generationName[GFSDK_Aftermath_MAX_STRING_LENGTH + 1];
uint64_t adapterLUID;
} GFSDK_Aftermath_GpuCrashDump_GpuInfo;
// GPU crash dump - page fault information
typedef struct GFSDK_Aftermath_GpuCrashDump_PageFaultInfo
{
uint64_t faultingGpuVA;
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bHasResourceInfo);
struct ResourceInfo {
uint64_t gpuVa;
uint64_t size;
uint32_t width;
uint32_t height;
uint32_t depth;
uint32_t mipLevels;
uint32_t format; // DXGI_Format for DX, VkFormat for Vulkan
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsBufferHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsStaticTextureHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bIsRenderTargetOrDepthStencilViewHeap);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bPlacedResource);
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(bWasDestroyed);
uint32_t createDestroyTickCount;
} resourceInfo;
} GFSDK_Aftermath_GpuCrashDump_PageFaultInfo;
// GPU crash dump - shader types
GFSDK_AFTERMATH_DECLARE_ENUM(ShaderType)
{
GFSDK_Aftermath_ShaderType_Unknown = 0,
GFSDK_Aftermath_ShaderType_Vertex,
GFSDK_Aftermath_ShaderType_Tessellation_Control,
GFSDK_Aftermath_ShaderType_Hull = GFSDK_Aftermath_ShaderType_Tessellation_Control,
GFSDK_Aftermath_ShaderType_Tessellation_Evaluation,
GFSDK_Aftermath_ShaderType_Domain = GFSDK_Aftermath_ShaderType_Tessellation_Evaluation,
GFSDK_Aftermath_ShaderType_Geometry,
GFSDK_Aftermath_ShaderType_Fragment,
GFSDK_Aftermath_ShaderType_Pixel = GFSDK_Aftermath_ShaderType_Fragment,
GFSDK_Aftermath_ShaderType_Compute,
GFSDK_Aftermath_ShaderType_RayTracing_RayGeneration,
GFSDK_Aftermath_ShaderType_RayTracing_Miss,
GFSDK_Aftermath_ShaderType_RayTracing_Intersection,
GFSDK_Aftermath_ShaderType_RayTracing_AnyHit,
GFSDK_Aftermath_ShaderType_RayTracing_ClosestHit,
GFSDK_Aftermath_ShaderType_RayTracing_Callable,
GFSDK_Aftermath_ShaderType_RayTracing_Internal,
GFSDK_Aftermath_ShaderType_Mesh,
GFSDK_Aftermath_ShaderType_Task,
};
// GPU crash dump - shader information
typedef struct GFSDK_Aftermath_GpuCrashDump_ShaderInfo
{
uint64_t shaderHash;
uint64_t shaderInstance;
GFSDK_AFTERMATH_DECLARE_BOOLEAN_MEMBER(isInternal);
GFSDK_Aftermath_ShaderType shaderType;
} GFSDK_Aftermath_GpuCrashDump_ShaderInfo;
// GPU crash dump - Event marker context type
GFSDK_AFTERMATH_DECLARE_ENUM(Context_Type)
{
GFSDK_Aftermath_Context_Type_Invalid = 0,
GFSDK_Aftermath_Context_Type_Immediate,
GFSDK_Aftermath_Context_Type_CommandList,
GFSDK_Aftermath_Context_Type_Bundle,
GFSDK_Aftermath_Context_Type_CommandQueue
};
// GPU crash dump - Event marker data ownership
GFSDK_AFTERMATH_DECLARE_ENUM(EventMarkerDataOwnership)
{
// Data is owned by the user application
GFSDK_Aftermath_EventMarkerDataOwnership_User = 0,
// Data is part of the crash dump and is owned by the decoder
GFSDK_Aftermath_EventMarkerDataOwnership_Decoder,
};
// GPU crash dump - Aftermath event marker information
// NOTE: If GFSDK_Aftermath_SetEventMarker was called with markerSize=0,
// markerDataOwnership will be set to GFSDK_Aftermath_EventMarkerDataOwnership_User
// and the markerData pointer will be only valid within the context of the process
// setting the marker and if the application properly manages the lifetime of the
// pointed to data. It is the responsibility of the caller to ensure that the pointer
// is valid before accessing the pointed to data.
typedef struct GFSDK_Aftermath_GpuCrashDump_EventMarkerInfo
{
uint64_t contextId;
GFSDK_Aftermath_Context_Status contextStatus;
GFSDK_Aftermath_Context_Type contextType;
GFSDK_AFTERMATH_DECLARE_POINTER_MEMBER(const void*, markerData);
GFSDK_Aftermath_EventMarkerDataOwnership markerDataOwnership;
uint32_t markerDataSize;
} GFSDK_Aftermath_GpuCrashDump_EventMarkerInfo;
// Flags that control the behavior of GFSDK_Aftermath_GpuCrashDump_GenerateJSON
GFSDK_AFTERMATH_DECLARE_ENUM(GpuCrashDumpDecoderFlags)
{
// Include basic information about the GPU crash dump.
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_BASE_INFO = 0x1,
// Include information about the device state
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_DEVICE_INFO = 0x2,
// Include information about the OS
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_OS_INFO = 0x4,
// Include information about the display driver
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_DISPLAY_DRIVER_INFO = 0x8,
// Include information about the GPU
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_GPU_INFO = 0x10,
// Include information about page faults (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_PAGE_FAULT_INFO = 0x20,
// Include information about shaders (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_INFO = 0x40,
// Include information about active warps (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_WARP_STATE_INFO = 0x80,
// Try to map shader addresses to source or intermediate assembly lines
// using additional information provided through shaderDebugInfoLookupCb,
// shaderLookupCb and shaderInstructionsLookupCb, if provided.
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO = 0x100,
// Include Aftermath event marker data (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_EVENT_MARKER_INFO = 0x200,
// Include automatic event marker call stack data (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_CALL_STACK_INFO = 0x400,
// Include user provided GPU crash dump description values (if available)
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_DESCRIPTION_INFO = 0x800,
// Include all available information
GFSDK_Aftermath_GpuCrashDumpDecoderFlags_ALL_INFO= 0xFFF,
};
GFSDK_AFTERMATH_DECLARE_ENUM(GpuCrashDumpFormatterFlags)
{
// No special formatting
GFSDK_Aftermath_GpuCrashDumpFormatterFlags_NONE = 0x0,
// Remove all unnecessary whitespace from formatted string
GFSDK_Aftermath_GpuCrashDumpFormatterFlags_CONDENSED_OUTPUT = 0x1,
// Use UTF8 encoding
GFSDK_Aftermath_GpuCrashDumpFormatterFlags_UTF8_OUTPUT = 0x2,
};
// Crash dump decoder handle
GFSDK_AFTERMATH_DECLARE_HANDLE(GFSDK_Aftermath_GpuCrashDump_Decoder);
// Function for providing shader debug information and shader binary to the crash dump decoder
typedef void(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_SetData)(const void* pData, uint32_t size);
// GPU crash dump decoder callback definitions
typedef void(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ShaderDebugInfoLookupCb)(const GFSDK_Aftermath_ShaderDebugInfoIdentifier* pIdentifier, PFN_GFSDK_Aftermath_SetData setShaderDebugInfo, void* pUserData);
typedef void(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ShaderLookupCb)(const GFSDK_Aftermath_ShaderHash* pShaderHash, PFN_GFSDK_Aftermath_SetData setShaderBinary, void* pUserData);
typedef void(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ShaderInstructionsLookupCb)(const GFSDK_Aftermath_ShaderInstructionsHash* pShaderInstructionsHash, PFN_GFSDK_Aftermath_SetData setShaderBinary, void* pUserData);
typedef void(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_ShaderSourceDebugInfoLookupCb)(const GFSDK_Aftermath_ShaderDebugName* pShaderDebugName, PFN_GFSDK_Aftermath_SetData setShaderBinary, void* pUserData);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_CreateDecoder
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pGpuCrashDump;
// Pointer to GPU crash dump data captured in a GFSDK_Aftermath_GpuCrashDumpCb
// callback.
//
// gpuCrashDumpSize;
// Size of GPU crash dump data in bytes.
//
// pDecoder;
// Pointer to a decoder object owned by the caller that is initialized.
//
//// DESCRIPTION;
// Create a decoder object that can be used to query information about the
// provided GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_CreateDecoder(
GFSDK_Aftermath_Version apiVersion,
const void* pGpuCrashDump,
const uint32_t gpuCrashDumpSize,
GFSDK_Aftermath_GpuCrashDump_Decoder* pDecoder);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_DestroyDecoder
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
//// DESCRIPTION;
// Free any data related to the passed in decoder object.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_DestroyDecoder(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetBaseInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pBaseInfo;
// Pointer to data structure owned by the caller that is filled in with
// information from the GPU crash dump.
//
//// DESCRIPTION;
// Query basic information from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetBaseInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
GFSDK_Aftermath_GpuCrashDump_BaseInfo* pBaseInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetDescriptionSize
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// key;
// What value to query from the description section.
//
// pValueSize;
// Populated with the size of the value in bytes (including 0-termination
// of the string).
//
//// DESCRIPTION;
// Query the size of a description value from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetDescriptionSize(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t key,
uint32_t* pValueSize);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetDescription
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// key;
// What value to query from the description section.
//
// valueBufferSize;
// Size in bytes of the caller allocated results buffer pValue.
//
// pValue;
// Caller allocated results buffer.
//
//// DESCRIPTION;
// Query description value from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetDescription(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t key,
const uint32_t valueBufferSize,
char* pValue);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetDeviceInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pDeviceInfo;
// Pointer to data structure owned by the caller that is filled in with
// information from the GPU crash dump.
//
//// DESCRIPTION;
// Query device state information from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetDeviceInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
GFSDK_Aftermath_GpuCrashDump_DeviceInfo* pDeviceInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetSystemInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pSystemInfo;
// Pointer to data structure owned by the caller that is filled in with
// information from the GPU crash dump.
//
//// DESCRIPTION;
// Query system information (OS, display driver) from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetSystemInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
GFSDK_Aftermath_GpuCrashDump_SystemInfo* pSystemInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetGpuInfoCount
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pGpuCount;
// Populated with the number of GPU entries in the GPU crash dump.
//
//// DESCRIPTION;
// Query number of GPU entries from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetGpuInfoCount(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
uint32_t* pGpuCount);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetGpuInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// gpuInfoBufferCount;
// Number of elements in caller allocated array passed in pGpuInfo.
//
// pGpuInfo;
// Pointer to caller allocated array of GFSDK_Aftermath_GpuCrashDump_GpuInfo
// that is filled in with information from the GPU crash dump.
//
//// DESCRIPTION;
// Query information about the GPUs from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetGpuInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t gpuInfoBufferCount,
GFSDK_Aftermath_GpuCrashDump_GpuInfo* pGpuInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetPageFaultInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pPageFaultInfo;
// Pointer to data structure owned by the caller that is filled in with
// information from the GPU crash dump.
//
//// DESCRIPTION;
// Query page fault information from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetPageFaultInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
GFSDK_Aftermath_GpuCrashDump_PageFaultInfo* pPageFaultInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfoCount
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pShaderCount;
// Populated with the number of active shaders in the GPU crash dump.
//
//// DESCRIPTION;
// Query the number of active shaders from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfoCount(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
uint32_t* pShaderCount);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// shaderInfoBufferCount;
// Number of elements in caller allocated array passed in pShaderInfo.
//
// pShaderInfo;
// Pointer to caller allocated array of GFSDK_Aftermath_GpuCrashDump_ShaderInfo
// that is filled in with information from the GPU crash dump.
//
//// DESCRIPTION;
// Query information about active shaders from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t shaderInfoBufferCount,
GFSDK_Aftermath_GpuCrashDump_ShaderInfo* pShaderInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfoCount
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// pMarkerCount;
// Populated with the number of event markers in the GPU crash dump.
//
//// DESCRIPTION;
// Query the number of event markers from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfoCount(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
uint32_t* pMarkerCount);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfo
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// markerInfoBufferCount;
// Number of elements in caller allocated array passed in pMarkerInfo.
//
// pMarkerInfo;
// Pointer to caller allocated array of GFSDK_Aftermath_GpuCrashDump_EventMarkerInfo
// that is filled in with information from the GPU crash dump.
//
//// DESCRIPTION;
// Query information about event markers from a GPU crash dump.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfo(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t markerInfoBufferCount,
GFSDK_Aftermath_GpuCrashDump_EventMarkerInfo* pMarkerInfo);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GenerateJSON
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// decoderFlags;
// Flags that define what information to include in the decoding. Bitwise OR of any
// of the flags defined in GFSDK_Aftermath_GpuCrashDumpDecoderFlags.
//
// formatFlags;
// Flags controlling the formatting. Bitwise OR of any of the flags defined in
// GFSDK_Aftermath_GpuCrashDumpFormatterFlags.
//
// shaderDebugInfoLookupCb;
// Callback used by the decoder to query shader debug information for mapping shader
// addresses to source or intermediate assembly line.
// Optional, can be NULL.
// Used when GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO is set in
// decoderFlags.
//
// shaderLookupCb;
// Callback used by the decoder to query shader information for mapping shader
// addresses to shader intermediate assembly (DXIL/SPIR-V) or source.
// Optional, can be NULL.
// Used when GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO is set in
// decoderFlags.
//
// shaderInstructionsLookupCb;
// Callback used by the decoder to query shader information for mapping shader
// addresses to shader intermediate assembly (DXIL/SPIR-V) or source.
// Optional, can be NULL.
// Used when GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO is set in
// decoderFlags.
//
// shaderSourceDebugInfoLookupCb;
// Callback used by the decoder to query high-level shader debug information for
// mapping shader addresses to shader source, if the shaders used by the application
// are stripped off debug information. This lookup is done by the shader's DebugName,
// a unique identifier of the source debug information.
//
// Optional, can be NULL.
// Used when GFSDK_Aftermath_GpuCrashDumpDecoderFlags_SHADER_MAPPING_INFO is set in
// decoderFlags.
//
// For DXIL shaders DebugName is generated by the dxc compiler and is defined here:
// https://github.com/microsoft/DirectXShaderCompiler/blob/master/docs/SourceLevelDebuggingHLSL.rst#using-debug-names.
//
// The following variants of generating source shader debug information for DXIL shaders
// are supported:
//
// 1) Compile and use a full shader blob
// Compile the shaders with the debug information. Use the full (i.e. not
// stripped) shader binary when running the application and make it accessible
// through shaderLookupCb and shaderInstructionsLookupCb. In this case there is
// no need to provide shaderSourceDebugInfoLookupCb.
//
// Compilation example:
// dxc -Zi [..] -Fo shader.bin shader.hlsl
//
// 2) Compile and strip
// Compile the shaders with debug information and then strip off the debug
// information. Use the stripped shader binary data when running the application.
// Make the stripped shader binary data accessible through shaderLookupCb and
// shaderInstructionsLookupCb. In addition, make the non-stripped shader binary
// data accessible through shaderSourceDebugInfoLookupCb.
//
// Compilation example:
// dxc -Zi [..] -Fo full_shader.bin shader.hlsl
// dxc -dumpbin -Qstrip_debug -Fo shader.bin full_shader.bin
//
// The shader's DebugName required for implementing the
// shaderSourceDebugInfoLookupCb may be extracted from the stripped or the
// non-stripped shader binary data with GFSDK_Aftermath_GetShaderDebugName().
//
// 3) Compile with separate debug information (and auto-generated debug data file name)
// Compile the shaders with debug information and instruct the compiler to store
// the debug meta data in a separate shader debug information file. The name of
// the file generated by the compiler will match the DebugName of the shader.
// Make the shader binary data accessible through shaderLookupCb and
// shaderInstructionsLookupCb. In addition, make the data from the compiler
// generated shader debug data file accessible through
// shaderSourceDebugInfoLookupCb.
//
// Compilation example:
// dxc -Zi [..] -Fo shader.bin -Fd debugInfo\ shader.hlsl
//
// The debug data file generated by the compiler does not contain any reference to
// the shader's DebugName. It is the responsibility of the user providing the
// shaderSourceDebugInfoLookupCb callback to implement a solution to lookup the
// debug data based on the name of the generated debug data file.
//
// 4) Compile with separate debug information (and user-defined debug data file name)
// Compile the shaders with debug information and instruct the compiler to store
// the debug meta data in a separate shader debug information file. The name of
// the file is freely choosen by the user. Make the shader binary data accessible
// through shaderLookupCb and shaderInstructionsLookupCb. In addition, make the
// data from the compiler generated shader debug data file accessible through
// shaderSourceDebugInfoLookupCb.
//
// Compilation example:
// dxc -Zi [..] -Fo shader.bin -Fd debugInfo\shader.dbg shader.hlsl
//
// The debug data file generated by the compiler does not contain any reference to
// the shader's DebugName. It is the responsibility of the user providing the
// shaderSourceDebugInfoLookupCb callback to implement a solution that performs
// the lookup of the debug data based on a mapping between the shader's DebugName
// the debug data file's name that was chosen for the compilation. The shader's
// DebugName may be extracted from the shader binary data with
// GFSDK_Aftermath_GetShaderDebugName().
//
// For SPIR-V shaders the Aftermath SDK provides support for the following variants of
// generating source shader debug information:
//
// 1) Compile and use a full shader blob
// Compile the shaders with the debug information. Use the full (i.e. not
// stripped) shader binary when running the application and make it accessible
// through shaderLookupCb. In this case there is no need to provide
// shaderInstructionsLookupCb or shaderSourceDebugInfoLookupCb.
//
// Compilation example using Vulkan SDK tool-chain:
// glslangValidator -V -g -o ./full/shader.spv shader.vert
//
// 2) Compile and strip
// Compile the shaders with debug information and then strip off the debug
// information. Use the stripped shader binary data when running the application.
// Make the stripped shader binary data accessible through shaderLookupCb.
// In addition, make the non-stripped shader binary data accessible through
// shaderSourceDebugInfoLookupCb.
//
// Compilation example using Vulkan SDK tool-chain:
// glslangValidator -V -g -o ./full/shader.spv shader.vert
// spirv-remap --map all --strip-all --input full/shader.spv --output ./stripped/
//
// Then pass the content of ./full/shader.spv and ./stripped/shader.spv to
// GFSDK_Aftermath_GetDebugNameSpirv() to generate the debug name to use with
// shaderSourceDebugInfoLookupCb.
//
// pUserData;
// User data made available in callbacks.
//
// pJsonSize;
// Populated with the size of the generated JSON data in bytes.
//
//// DESCRIPTION;
// Decode a crash dump to JSON format.
// The decoded JSON can be later queried by calling GFSDK_Aftermath_GpuCrashDump_GetJSON.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GenerateJSON(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
uint32_t decoderFlags,
uint32_t formatFlags,
PFN_GFSDK_Aftermath_ShaderDebugInfoLookupCb shaderDebugInfoLookupCb,
PFN_GFSDK_Aftermath_ShaderLookupCb shaderLookupCb,
PFN_GFSDK_Aftermath_ShaderInstructionsLookupCb shaderInstructionsLookupCb,
PFN_GFSDK_Aftermath_ShaderSourceDebugInfoLookupCb shaderSourceDebugInfoLookupCb,
void* pUserData,
uint32_t* pJsonSize);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GpuCrashDump_GetJSON
// ---------------------------------
//
// decoder;
// A valid decoder object.
//
// jsonBufferSize;
// The size of the caller allocated buffer for the JSON data in bytes.
//
// pJson;
// Caller allocated buffer populated with the JSON data (0-terminated string).
//
//// DESCRIPTION;
// Copy the JSON generated by the last call to GFSDK_Aftermath_GpuCrashDump_GenerateJSON
// into a caller provided buffer.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GpuCrashDump_GetJSON(
const GFSDK_Aftermath_GpuCrashDump_Decoder decoder,
const uint32_t jsonBufferSize,
char* pJson);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetShaderDebugInfoIdentifier
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pShaderDebugInfo;
// Pointer to shader debug information data captured in a GFSDK_Aftermath_ShaderDebugInfoCb callback.
//
// shaderDebugInfoSize;
// Size in bytes of the shader debug information data.
//
// pIdentifier;
// Pointer to GFSDK_Aftermath_ShaderDebugInfoIdentifier structure receiving the result
//
//// DESCRIPTION;
// Read the shader debug information identifier from shader debug information.
// The shader debug information identifier is required when implementing the
// PFN_GFSDK_Aftermath_ShaderDebugInfoLookupCb callback.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_API GFSDK_Aftermath_GetShaderDebugInfoIdentifier(
GFSDK_Aftermath_Version apiVersion,
const void* pShaderDebugInfo,
const uint32_t shaderDebugInfoSize,
GFSDK_Aftermath_ShaderDebugInfoIdentifier* pIdentifier);
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetShaderHash
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pShader;
// The binary shader blob for which to compute the identifier.
//
// pShaderHash;
// Pointer to GFSDK_Aftermath_ShaderHash structure receiving the computed shader hash.
// Optional, can be NULL.
//
// pShaderInstructionsHash;
// Pointer to GFSDK_Aftermath_ShaderInstructionsHash structure receiving the computed
// shader instructions hash.
// Optional, can be NULL.
//
//// DESCRIPTION;
// Computes shader hashes uniquely identifying the provided DXBC shader binary.
// This is, for example, required for comparison in the shader binary lookup by
// PFN_GFSDK_Aftermath_ShaderLookupCb or PFN_GFSDK_Aftermath_ShaderInstructionsLookupCb.
//
/////////////////////////////////////////////////////////////////////////
#if defined(__d3d12_h__)
GFSDK_Aftermath_API GFSDK_Aftermath_GetShaderHash(
GFSDK_Aftermath_Version apiVersion,
const D3D12_SHADER_BYTECODE* pShader,
GFSDK_Aftermath_ShaderHash* pShaderHash,
GFSDK_Aftermath_ShaderInstructionsHash* pShaderInstructionsHash);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetShaderHashSpirv
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pShader;
// The SPIR-V shader binary for which to compute the identifier.
//
// pShaderHash;
// Pointer to GFSDK_Aftermath_ShaderHash structure receiving the computed shader hash.
// Optional, can be NULL.
//
//// DESCRIPTION;
// Computes a shader hash uniquely identifying the provided SPIR-V shader binary.
// This is, for example, required for comparison in the shader binary lookup by
// PFN_GFSDK_Aftermath_ShaderLookupCb.
//
/////////////////////////////////////////////////////////////////////////
#if defined(VULKAN_H_)
GFSDK_Aftermath_API GFSDK_Aftermath_GetShaderHashSpirv(
GFSDK_Aftermath_Version apiVersion,
const GFSDK_Aftermath_SpirvCode *pShader,
GFSDK_Aftermath_ShaderHash* pShaderHash);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetShaderDebugName
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pShader;
// The binary shader data blob from which to extract the DebugName.
//
// pShaderDebugName;
// Pointer to GFSDK_Aftermath_ShaderDebugName structure receiving the DebugName.
//
//// DESCRIPTION;
// Extracts the shader's DebugName (if available) from the provided DXBC shader binary.
// This is, for example, required for comparison in the shader debug data lookup by
// PFN_GFSDK_Aftermath_ShaderSourceDebugInfoLookupCb. For more information about shader
// debug names please read:
// https://github.com/microsoft/DirectXShaderCompiler/blob/master/docs/SourceLevelDebuggingHLSL.rst#using-debug-names.
//
/////////////////////////////////////////////////////////////////////////
#if defined(__d3d12_h__)
GFSDK_Aftermath_API GFSDK_Aftermath_GetShaderDebugName(
GFSDK_Aftermath_Version apiVersion,
const D3D12_SHADER_BYTECODE* pShader,
GFSDK_Aftermath_ShaderDebugName* pShaderDebugName);
#endif
/////////////////////////////////////////////////////////////////////////
// GFSDK_Aftermath_GetShaderDebugNameSpirv
// ---------------------------------
//
// apiVersion;
// Must be set to GFSDK_Aftermath_Version_API. Used for checking against library
// version.
//
// pShader;
// The not-stripped SPIR-V binary shader data of the shader pair for which to
// generate the DebugName.
//
// pStrippedShader;
// The stripped SPIR-V binary shader data of the shader pair for which to
// generate the DebugName.
//
// pShaderDebugName;
// Pointer to GFSDK_Aftermath_ShaderDebugName structure receiving the DebugName.
//
//// DESCRIPTION;
// Generates a shader DebugName from the provided pair of SPIR-V shader binary
// data. This is, for example, required for comparison in the shader debug data
// lookup by PFN_GFSDK_Aftermath_ShaderSourceDebugInfoLookupCb. For more information
// about how to generate the pair of shader binaries, see the description of
// GFSDK_Aftermath_GpuCrashDump_GenerateJSON().
//
/////////////////////////////////////////////////////////////////////////
#if defined(VULKAN_H_)
GFSDK_Aftermath_API GFSDK_Aftermath_GetShaderDebugNameSpirv(
GFSDK_Aftermath_Version apiVersion,
const GFSDK_Aftermath_SpirvCode *pShader,
const GFSDK_Aftermath_SpirvCode *pStrippedShader,
GFSDK_Aftermath_ShaderDebugName* pShaderDebugName);
#endif
/////////////////////////////////////////////////////////////////////////
//
// NOTE: Function table provided - if dynamic loading is preferred.
//
/////////////////////////////////////////////////////////////////////////
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_CreateDecoder)(GFSDK_Aftermath_Version apiVersion, const void* pGpuCrashDump, const uint32_t gpuCrashDumpSize, GFSDK_Aftermath_GpuCrashDump_Decoder* pDecoder);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_DestroyDecoder)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetBaseInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, GFSDK_Aftermath_GpuCrashDump_BaseInfo* pBaseInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetDescriptionSize)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t key, uint32_t* pValueSize);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetDescription)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t key, const uint32_t valueBufferSize, char* pValue);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetDeviceInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, GFSDK_Aftermath_GpuCrashDump_DeviceInfo* pDeviceInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetSystemInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, GFSDK_Aftermath_GpuCrashDump_SystemInfo* pSystemInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetGpuInfoCount)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, uint32_t* pGpuCount);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetGpuInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t gpuInfoBufferCount, GFSDK_Aftermath_GpuCrashDump_GpuInfo* pGpuInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetPageFaultInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, GFSDK_Aftermath_GpuCrashDump_PageFaultInfo* pPageFaultInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfoCount)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, uint32_t* pShaderCount);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetActiveShadersInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t shaderInfoBufferCount, GFSDK_Aftermath_GpuCrashDump_ShaderInfo* pShaderInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfoCount)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t markerInfoBufferCount);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetEventMarkersInfo)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t markerInfoBufferCount, GFSDK_Aftermath_GpuCrashDump_EventMarkerInfo* pMarkerInfo);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GenerateJSON)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, uint32_t decoderFlags, uint32_t formatFlags, PFN_GFSDK_Aftermath_ShaderDebugInfoLookupCb shaderDebugInfoLookupCb, PFN_GFSDK_Aftermath_ShaderLookupCb shaderLookupCb, PFN_GFSDK_Aftermath_ShaderInstructionsLookupCb shaderInstructionsLookupCb, PFN_GFSDK_Aftermath_ShaderSourceDebugInfoLookupCb shaderSourceDebugInfoLookupCb, void* pUserData, uint32_t* pJsonSize);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GpuCrashDump_GetJSON)(const GFSDK_Aftermath_GpuCrashDump_Decoder decoder, const uint32_t jsonBufferSize, char* pJson);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetShaderDebugInfoIdentifier)(GFSDK_Aftermath_Version apiVersion, const void* pShaderDebugInfo, const uint32_t shaderDebugInfoSize, GFSDK_Aftermath_ShaderDebugInfoIdentifier* pIdentifier);
#if defined(__d3d12_h__)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetShaderHash)(GFSDK_Aftermath_Version apiVersion, const D3D12_SHADER_BYTECODE* pShader, GFSDK_Aftermath_ShaderHash* pShaderHash, GFSDK_Aftermath_ShaderInstructionsHash* pShaderInstructionsHash);
GFSDK_Aftermath_PFN(*GPFN_GFSDK_Aftermath_GetShaderDebugName)(GFSDK_Aftermath_Version apiVersion, const D3D12_SHADER_BYTECODE* pShader, GFSDK_Aftermath_ShaderDebugName* pShaderDebugName);
#endif
#if defined(VULKAN_H_)
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetShaderHashSpirv)(GFSDK_Aftermath_Version apiVersion, const GFSDK_Aftermath_SpirvCode *pShader, GFSDK_Aftermath_ShaderHash* pShaderHash);
GFSDK_Aftermath_PFN(GFSDK_AFTERMATH_CALL *PFN_GFSDK_Aftermath_GetShaderDebugNameSpirv)(GFSDK_Aftermath_Version apiVersion, const GFSDK_Aftermath_SpirvCode *pShader, const GFSDK_Aftermath_SpirvCode *pStrippedShader, GFSDK_Aftermath_ShaderDebugName* pShaderDebugName);
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#pragma pack(pop)
#endif // GFSDK_Aftermath_CrashDumpDecoding_H
external/aftermath/nsight-aftermath-usage-guidelines.txt
Vendored
-22
View File
@@ -1,22 +0,0 @@
Nsight Aftermath is primarily a development tool and is intended to be used
with minimal side effects to the user application. Despite this, there may be
overhead when it is enabled resulting in performance degradation. The
application should only fully enable Nsight Aftermath when in an application
controlled 'diagnostics mode', e.g. enabled after the user has experienced a
GPU crash and exhaustive data collection is required.
Your users should also be able to easily disable Nsight Aftermath in situations
where performance is critical, such as when benchmarking or during competitive
play.
To override the behavior of applications that do not follow the above guidelines
a user may force off all Aftermath functionality in the application:
on Windows, set a Windows registry key:
HKEY_CURRENT_USER\Software\NVIDIA Corporation\Nsight Aftermath\ForceOff=1
on Linux, set an environment variable:
export NV_AFTERMATH_FORCE_OFF=1
For questions regarding these guidelines or Nsight Aftermath in general, please
email NsightAftermath@nvidia.com
src/Engine/Graphics/Enums.h
+1 -1
View File
@@ -164,7 +164,7 @@ typedef uint32 KeyModifierFlags;
namespace Gfx namespace Gfx
{ {
static constexpr bool useAsyncCompute = true; static constexpr bool useAsyncCompute = true;
static constexpr bool waitIdleOnSubmit = true; static constexpr bool waitIdleOnSubmit = false;
static constexpr bool useMeshShading = true; static constexpr bool useMeshShading = true;
static constexpr uint32 numFramesBuffered = 3; static constexpr uint32 numFramesBuffered = 3;
src/Engine/Graphics/Initializer.h
+1 -1
View File
@@ -24,7 +24,7 @@ struct GraphicsInitializer
: applicationName("SeeleEngine") : applicationName("SeeleEngine")
, engineName("SeeleEngine") , engineName("SeeleEngine")
, windowLayoutFile(nullptr) , windowLayoutFile(nullptr)
, layers{"VK_LAYER_KHRONOS_validation"} , layers{"VK_LAYER_KHRONOS_validation", "VK_LAYER_LUNARG_monitor"}
, instanceExtensions{} , instanceExtensions{}
, deviceExtensions{"VK_KHR_swapchain"} , deviceExtensions{"VK_KHR_swapchain"}
, windowHandle(nullptr) , windowHandle(nullptr)
src/Engine/Graphics/Vulkan/Command.cpp
+15 -8
View File
@@ -7,7 +7,6 @@
#include "Pipeline.h" #include "Pipeline.h"
#include "Descriptor.h" #include "Descriptor.h"
#include "Window.h" #include "Window.h"
#include <vulkan/vulkan_core.h>
using namespace Seele; using namespace Seele;
using namespace Seele::Vulkan; using namespace Seele::Vulkan;
@@ -28,7 +27,9 @@ Command::Command(PGraphics graphics, VkCommandPool cmdPool, PCommandPool pool)
VK_CHECK(vkAllocateCommandBuffers(graphics->getDevice(), &allocInfo, &handle)) VK_CHECK(vkAllocateCommandBuffers(graphics->getDevice(), &allocInfo, &handle))
fence = new Fence(graphics); fence = new Fence(graphics);
signalSemaphore = new Semaphore(graphics);
state = State::Init; state = State::Init;
//std::cout << "Cmd " << handle << " semaphore " << signalSemaphore->getHandle() << std::endl;
} }
Command::~Command() Command::~Command()
@@ -98,6 +99,7 @@ void Command::executeCommands(const Array<Gfx::PRenderCommand>& commands)
for(auto& descriptor : command->boundDescriptors) for(auto& descriptor : command->boundDescriptors)
{ {
boundDescriptors.add(descriptor); boundDescriptors.add(descriptor);
//std::cout << "Cmd " << handle << " bound descriptor " << descriptor->getHandle() << std::endl;
} }
cmdBuffers[i] = command->getHandle(); cmdBuffers[i] = command->getHandle();
} }
@@ -119,6 +121,7 @@ void Command::executeCommands(const Array<Gfx::PComputeCommand>& commands)
for(auto& descriptor : command->boundDescriptors) for(auto& descriptor : command->boundDescriptors)
{ {
boundDescriptors.add(descriptor); boundDescriptors.add(descriptor);
//std::cout << "Cmd " << handle << " bound descriptor " << descriptor->getHandle() << std::endl;
} }
cmdBuffers[i] = command->getHandle(); cmdBuffers[i] = command->getHandle();
} }
@@ -129,6 +132,7 @@ void Command::waitForSemaphore(VkPipelineStageFlags flags, PSemaphore semaphore)
{ {
waitSemaphores.add(semaphore); waitSemaphores.add(semaphore);
waitFlags.add(flags); waitFlags.add(flags);
//std::cout << "Cmd " << handle << " wait for " << semaphore->getHandle() << std::endl;
} }
void Command::checkFence() void Command::checkFence()
@@ -136,6 +140,7 @@ void Command::checkFence()
assert(state == State::Submit || !fence->isSignaled()); assert(state == State::Submit || !fence->isSignaled());
if (fence->isSignaled()) if (fence->isSignaled())
{ {
//std::cout << "Cmd " << handle << " was signaled" << std::endl;
vkResetCommandBuffer(handle, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT); vkResetCommandBuffer(handle, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
fence->reset(); fence->reset();
for(auto& command : executingComputes) for(auto& command : executingComputes)
@@ -151,7 +156,7 @@ void Command::checkFence()
for(auto& descriptor : boundDescriptors) for(auto& descriptor : boundDescriptors)
{ {
descriptor->unbind(); descriptor->unbind();
//std::cout << "Unbinding descriptor " << descriptor.cast<DescriptorSet>()->getHandle() << " to cmd " << handle << std::endl; //std::cout << "Cmd " << handle << " unbind " << descriptor->getHandle() << std::endl;
} }
boundDescriptors.clear(); boundDescriptors.clear();
graphics->getDestructionManager()->notifyCmdComplete(this); graphics->getDestructionManager()->notifyCmdComplete(this);
@@ -286,7 +291,6 @@ void RenderCommand::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorS
assert(descriptorSet->writeDescriptors.size() == 0); assert(descriptorSet->writeDescriptors.size() == 0);
descriptorSet->bind(); descriptorSet->bind();
//std::cout << "Binding descriptor " << descriptorSet->getHandle() << " to cmd " << handle << std::endl;
boundDescriptors.add(descriptorSet.getHandle()); boundDescriptors.add(descriptorSet.getHandle());
sets[descriptorSet->getSetIndex()] = descriptorSet->getHandle(); sets[descriptorSet->getSetIndex()] = descriptorSet->getHandle();
} }
@@ -321,6 +325,7 @@ void RenderCommand::pushConstants(Gfx::PPipelineLayout layout, Gfx::SeShaderStag
void RenderCommand::draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance) void RenderCommand::draw(uint32 vertexCount, uint32 instanceCount, int32 firstVertex, uint32 firstInstance)
{ {
graphics->setCheckpointMarker(handle, "Fuck");
assert(threadId == std::this_thread::get_id()); assert(threadId == std::this_thread::get_id());
vkCmdDraw(handle, vertexCount, instanceCount, firstVertex, firstInstance); vkCmdDraw(handle, vertexCount, instanceCount, firstVertex, firstInstance);
} }
@@ -516,15 +521,15 @@ void CommandPool::submitCommands(PSemaphore signalSemaphore)
{ {
assert(command->state == Command::State::Begin); // Not in a renderpass assert(command->state == Command::State::Begin); // Not in a renderpass
command->end(); command->end();
Array<VkSemaphore> semaphores = { command->signalSemaphore->getHandle() };
if (signalSemaphore != nullptr) if (signalSemaphore != nullptr)
{ {
queue->submitCommandBuffer(command, signalSemaphore->getHandle()); semaphores.add(signalSemaphore->getHandle());
}
else
{
queue->submitCommandBuffer(command);
} }
queue->submitCommandBuffer(command, semaphores);
//std::cout << "Cmd " << command->getHandle() << " signalling " << command->signalSemaphore->getHandle() << std::endl;
PSemaphore waitSemaphore = command->signalSemaphore;
for (uint32 i = 0; i < allocatedBuffers.size(); ++i) for (uint32 i = 0; i < allocatedBuffers.size(); ++i)
{ {
PCommand cmdBuffer = allocatedBuffers[i]; PCommand cmdBuffer = allocatedBuffers[i];
@@ -533,6 +538,7 @@ void CommandPool::submitCommands(PSemaphore signalSemaphore)
{ {
command = cmdBuffer; command = cmdBuffer;
command->begin(); command->begin();
command->waitForSemaphore(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, waitSemaphore);
return; return;
} }
else else
@@ -543,4 +549,5 @@ void CommandPool::submitCommands(PSemaphore signalSemaphore)
allocatedBuffers.add(new Command(graphics, commandPool, this)); allocatedBuffers.add(new Command(graphics, commandPool, this));
command = allocatedBuffers.back(); command = allocatedBuffers.back();
command->begin(); command->begin();
command->waitForSemaphore(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, waitSemaphore);
} }
src/Engine/Graphics/Vulkan/Command.h
+1
View File
@@ -48,6 +48,7 @@ private:
PGraphics graphics; PGraphics graphics;
PCommandPool pool; PCommandPool pool;
OFence fence; OFence fence;
OSemaphore signalSemaphore;
State state; State state;
VkViewport currentViewport; VkViewport currentViewport;
VkRect2D currentScissor; VkRect2D currentScissor;
src/Engine/Graphics/Vulkan/Descriptor.h
+5 -5
View File
@@ -57,7 +57,7 @@ public:
: setHandle(VK_NULL_HANDLE) : setHandle(VK_NULL_HANDLE)
, graphics(graphics) , graphics(graphics)
, owner(owner) , owner(owner)
, currentlyBound(false) , bindCount(0)
, currentlyInUse(false) , currentlyInUse(false)
{ {
} }
@@ -72,7 +72,7 @@ public:
constexpr bool isCurrentlyBound() const constexpr bool isCurrentlyBound() const
{ {
return currentlyBound; return bindCount > 0;
} }
constexpr bool isCurrentlyInUse() const constexpr bool isCurrentlyInUse() const
{ {
@@ -80,11 +80,11 @@ public:
} }
constexpr void bind() constexpr void bind()
{ {
currentlyBound = true; bindCount++;
} }
constexpr void unbind() constexpr void unbind()
{ {
currentlyBound = false; bindCount--;
} }
constexpr void allocate() constexpr void allocate()
{ {
@@ -111,7 +111,7 @@ private:
VkDescriptorSet setHandle; VkDescriptorSet setHandle;
PGraphics graphics; PGraphics graphics;
PDescriptorPool owner; PDescriptorPool owner;
bool currentlyBound; uint32 bindCount;
bool currentlyInUse; bool currentlyInUse;
friend class DescriptorPool; friend class DescriptorPool;
friend class Command; friend class Command;
src/Engine/Graphics/Vulkan/Queue.cpp
+5 -8
View File
@@ -18,7 +18,7 @@ Queue::~Queue()
{ {
} }
void Queue::submitCommandBuffer(PCommand command, uint32 numSignalSemaphores, VkSemaphore *signalSemaphores) void Queue::submitCommandBuffer(PCommand command, const Array<VkSemaphore>& signalSemaphores)
{ {
std::unique_lock lock(queueLock); std::unique_lock lock(queueLock);
assert(command->state == Command::State::End); assert(command->state == Command::State::End);
@@ -28,12 +28,9 @@ void Queue::submitCommandBuffer(PCommand command, uint32 numSignalSemaphores, Vk
VkCommandBuffer cmdHandle = command->handle; VkCommandBuffer cmdHandle = command->handle;
Array<VkSemaphore> waitSemaphores; Array<VkSemaphore> waitSemaphores;
if (command->waitSemaphores.size() > 0) for (PSemaphore semaphore : command->waitSemaphores)
{ {
for (PSemaphore semaphore : command->waitSemaphores) waitSemaphores.add(semaphore->getHandle());
{
waitSemaphores.add(semaphore->getHandle());
}
} }
VkSubmitInfo submitInfo = { VkSubmitInfo submitInfo = {
@@ -44,8 +41,8 @@ void Queue::submitCommandBuffer(PCommand command, uint32 numSignalSemaphores, Vk
.pWaitDstStageMask = command->waitFlags.data(), .pWaitDstStageMask = command->waitFlags.data(),
.commandBufferCount = 1, .commandBufferCount = 1,
.pCommandBuffers = &cmdHandle, .pCommandBuffers = &cmdHandle,
.signalSemaphoreCount = static_cast<uint32>(numSignalSemaphores), .signalSemaphoreCount = static_cast<uint32>(signalSemaphores.size()),
.pSignalSemaphores = signalSemaphores, .pSignalSemaphores = signalSemaphores.data(),
}; };
VK_CHECK(vkQueueSubmit(queue, 1, &submitInfo, command->fence->getHandle())); VK_CHECK(vkQueueSubmit(queue, 1, &submitInfo, command->fence->getHandle()));
src/Engine/Graphics/Vulkan/Queue.h
+1 -5
View File
@@ -12,11 +12,7 @@ class Queue
public: public:
Queue(PGraphics graphics, Gfx::QueueType queueType, uint32 familyIndex, uint32 queueIndex); Queue(PGraphics graphics, Gfx::QueueType queueType, uint32 familyIndex, uint32 queueIndex);
virtual ~Queue(); virtual ~Queue();
void submitCommandBuffer(PCommand command, uint32 numSignalSemaphores = 0, VkSemaphore *signalSemaphore = nullptr); void submitCommandBuffer(PCommand command, const Array<VkSemaphore>& signalSemaphore);
void submitCommandBuffer(PCommand command, VkSemaphore signalSemaphore)
{
submitCommandBuffer(command, 1, &signalSemaphore);
}
constexpr uint32 getFamilyIndex() const constexpr uint32 getFamilyIndex() const
{ {
return familyIndex; return familyIndex;
src/Engine/Window/Window.cpp
-1
View File
@@ -33,7 +33,6 @@ void Window::render()
view->render(); view->render();
} }
gfxHandle->endFrame(); gfxHandle->endFrame();
std::cout << "Render" << std::endl;
} }
} }