rocprofv3 doc updates (#982)

* updating rocprofv3

* using rocprofv3

* review updates

* naming standardization

* Update source/docs/how-to/using-rocprofv3.rst

Co-authored-by: Leo Paoletti <164940351+lpaoletti@users.noreply.github.com>

* review comments

* adding API references

* kernel filtering

* Remove Sphinx warn as error

To bypass false warning for linking between rst and md

* remove unused (duplicate) refs in _toc.yml.in

---------

Co-authored-by: Gopesh Bhardwaj <gopesh.bhardwaj@amd.com>
Co-authored-by: Leo Paoletti <164940351+lpaoletti@users.noreply.github.com>
Co-authored-by: Sam Wu <22262939+samjwu@users.noreply.github.com>
Co-authored-by: Peter Jun Park <peter.park@amd.com>

source/docs/api-reference/intercept_table.md

@@ -0,0 +1,96 @@
+# Runtime intercept tables
+
+Although most tools will want to leverage the callback or buffer tracing services for tracing the HIP, HSA, and ROCTx
+APIs, rocprofiler-sdk does provide access to the raw API dispatch tables. Each of the aforementioned APIs are
+designed similar to the following sample.
+
+## Dispatch Table Overview
+
+### Forward Declaration of public C API function
+
+```cpp
+extern "C"
+{
+// forward declaration of public C API function
+int
+foo(int) __attribute__((visibility("default")));
+}
+```
+
+### Internal Implementation of API function
+
+```cpp
+namespace impl
+{
+int
+foo(int val)
+{
+    // real implementation
+    return (2 * val);
+}
+}
+```
+
+### Dispatch Table Implementation
+
+```cpp
+namespace impl
+{
+struct dispatch_table
+{
+    int (*foo_fn)(int) = nullptr;
+};
+
+// invoked once: populates the dispatch_table with function pointers to implementation
+dispatch_table*&
+construct_dispatch_table()
+{
+    static dispatch_table* tbl = new dispatch_table{};
+    tbl->foo_fn                = impl::foo;
+
+    // in between above and below, rocprofiler-sdk gets passed the pointer
+    // to the dispatch table and has the opportunity to wrap the function
+    // pointers for interception
+
+    return tbl;
+}
+
+// constructs dispatch table and stores it in static variable
+dispatch_table*
+get_dispatch_table()
+{
+    static dispatch_table*& tbl = construct_dispatch_table();
+    return tbl;
+}
+}  // namespace impl
+```
+
+### Implementaiton of public C API function
+
+```cpp
+extern "C"
+{
+// implementation of public C API function
+int
+foo(int val)
+{
+    return impl::get_dispatch_table()->foo_fn(val);
+}
+}
+```
+
+### Dispatch Table Chaining
+
+rocprofiler-sdk is given an opportunity within `impl::construct_dispatch_table()` to
+save the original value(s) of the function pointers such as `foo_fn` and install
+it's own function pointers in its place -- this results in the public C API function `foo`
+calling into the rocprofiler-sdk function pointer, which then in turn, calls the original
+function pointer to `impl::foo` (this is called "chaining"). Once rocprofiler-sdk
+has made any necessary modifications to the dispatch table, tools which indicated
+they also want access to the raw dispatch table via `rocprofiler_at_intercept_table_registration`
+will be passed the pointer to the dispatch table.
+
+## Sample
+
+For a demo of dispatch table chaining, please see the `samples/intercept_table` example in the
+[rocprofiler-sdk GitHub repository](https://github.com/ROCm/rocproifler-sdk).