SWDEV-447465 - Update HIP documents for the repos link change

Change-Id: Ib191c96b57458c7abc9c490329d582c28d4632a7

README.md

@@ -7,7 +7,7 @@ Key features include:
 * HIP is very thin and has little or no performance impact over coding directly in CUDA mode.
 * HIP allows coding in a single-source C++ programming language including features such as templates, C++11 lambdas, classes, namespaces, and more.
 * HIP allows developers to use the "best" development environment and tools on each target platform.
-* The [HIPIFY](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/amd-staging/README.md) tools automatically convert source from CUDA to HIP.
+* The [HIPIFY](https://github.com/ROCm/HIPIFY/blob/amd-staging/README.md) tools automatically convert source from CUDA to HIP.
 * Developers can specialize for the platform (CUDA or AMD) to tune for performance or handle tricky cases.
 
 New projects can be developed directly in the portable HIP C++ language and can run on either NVIDIA or AMD platforms.  Additionally, HIP provides porting tools which make it easy to port existing CUDA codes to the HIP layer, with no loss of performance as compared to the original CUDA application.  HIP is not intended to be a drop-in replacement for CUDA, and developers should expect to do some manual coding and performance tuning work to complete the port.
@@ -45,17 +45,17 @@ HIP releases are typically naming convention for each ROCM release to help diffe
 - [HIP Debugging ](docs/how_to_guides/debugging.md)
 - [HIP RTC](docs/user_guide/hip_rtc.md)
 - [HIP Terminology](docs/reference/terms.md) (including Rosetta Stone of GPU computing terms across CUDA/HIP/OpenCL)
-- [HIPIFY](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/amd-staging/README.md)
+- [HIPIFY](https://github.com/ROCm/HIPIFY/blob/amd-staging/README.md)
 - Supported CUDA APIs:
-  * [Runtime API](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUDA_Runtime_API_functions_supported_by_HIP.md)
-  * [Driver API](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUDA_Driver_API_functions_supported_by_HIP.md)
-  * [cuComplex API](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/cuComplex_API_supported_by_HIP.md)
-  * [Device API](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUDA_Device_API_supported_by_HIP.md)
-  * [cuBLAS](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUBLAS_API_supported_by_HIP.md)
-  * [cuRAND](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CURAND_API_supported_by_HIP.md)
-  * [cuDNN](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUDNN_API_supported_by_HIP.md)
-  * [cuFFT](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUFFT_API_supported_by_HIP.md)
-  * [cuSPARSE](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/doc/markdown/CUSPARSE_API_supported_by_HIP.md)
+  * [Runtime API](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUDA_Runtime_API_functions_supported_by_HIP.md)
+  * [Driver API](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUDA_Driver_API_functions_supported_by_HIP.md)
+  * [cuComplex API](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/cuComplex_API_supported_by_HIP.md)
+  * [Device API](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUDA_Device_API_supported_by_HIP.md)
+  * [cuBLAS](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUBLAS_API_supported_by_ROC.md)
+  * [cuRAND](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CURAND_API_supported_by_HIP.md)
+  * [cuDNN](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUDNN_API_supported_by_HIP.md)
+  * [cuFFT](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUFFT_API_supported_by_HIP.md)
+  * [cuSPARSE](https://github.com/ROCm/HIPIFY/blob/amd-staging/docs/tables/CUSPARSE_API_supported_by_HIP.md)
 - [Developer/CONTRIBUTING Info](docs/developer_guide/contributing.md)
 - [Release Notes](RELEASE.md)
 
@@ -115,15 +115,15 @@ HIP C++ code can be compiled with either,
   profiler and debugger.
 - On the AMD ROCm platform, HIP provides a header and runtime library built on top of HIP-Clang compiler.  The HIP runtime implements HIP streams, events, and memory APIs,
   and is a object library that is linked with the application.  The source code for all headers and the library implementation is available on GitHub.
-  HIP developers on ROCm can use AMD's ROCgdb (https://github.com/ROCm-Developer-Tools/ROCgdb) for debugging and profiling.
+  HIP developers on ROCm can use AMD's ROCgdb (https://github.com/ROCm/ROCgdb) for debugging and profiling.
 
 Thus HIP source code can be compiled to run on either platform.  Platform-specific features can be isolated to a specific platform using conditional compilation.  Thus HIP
 provides source portability to either platform.   HIP provides the _hipcc_ compiler driver which will call the appropriate toolchain depending on the desired platform.
 
 
 ## Examples and Getting Started:
 
-* A sample and [blog](https://github.com/ROCm-Developer-Tools/hip-tests/tree/develop/samples/0_Intro/square) that uses any of [HIPIFY](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/amd-staging/README.md) tools to convert a simple app from CUDA to HIP:
+* A sample and [blog](https://github.com/ROCm/hip-tests/tree/develop/samples/0_Intro/square) that uses any of [HIPIFY](https://github.com/ROCm/HIPIFY/blob/amd-staging/README.md) tools to convert a simple app from CUDA to HIP:
 
 
 ```shell
@@ -135,8 +135,8 @@ cd samples/01_Intro/square
 
 
 ## More Examples
-The GitHub repository [HIP-Examples](https://github.com/ROCm-Developer-Tools/HIP-Examples) contains a hipified version of benchmark suite.
-Besides, there are more samples in Github [HIP samples](https://github.com/ROCm-Developer-Tools/hip-tests/tree/develop/samples), showing how to program with different features, build and run.
+The GitHub repository [HIP-Examples](https://github.com/ROCm/HIP-Examples) contains a hipified version of benchmark suite.
+Besides, there are more samples in Github [HIP samples](https://github.com/ROCm/hip-tests/tree/develop/samples), showing how to program with different features, build and run.
 
 ## Tour of the HIP Directories
 * **include**:
@@ -151,6 +151,6 @@ Besides, there are more samples in Github [HIP samples](https://github.com/ROCm-
 * **docs**: Documentation - markdown and doxygen info.
 
 ## Reporting an issue
-Use the [GitHub issue tracker](https://github.com/ROCm-Developer-Tools/HIP/issues).
+Use the [GitHub issue tracker](https://github.com/ROCm/HIP/issues).
 If reporting a bug, include the output of "hipconfig --full" and samples/1_hipInfo/hipInfo (if possible).
 

RELEASE.md

@@ -1,6 +1,6 @@
 # Release notes
 
-We have attempted to document known bugs and limitations - in particular the [HIP Kernel Language](docs/markdown/hip_kernel_language.md) document uses the phrase "Under Development", and the [HIP Runtime API bug list](http://rocm-developer-tools.github.io/HIP/bug.html) lists known bugs. 
+We have attempted to document known bugs and limitations - in particular the [HIP Kernel Language](docs/markdown/hip_kernel_language.md) document uses the phrase "Under Development", and the [HIP Runtime API issue list](https://github.com/ROCm/HIP/issues) lists known bugs. 
 
 
 ===================================================================================================
@@ -155,7 +155,7 @@ Date: 2016.06.06
 - Add cross-linking support between G++ and HCC, in particular for interfaces that use
   standard C++ libraries (ie std::vectors, std::strings).  HIPCC now uses libstdc++ by default on the HCC
   compilation path.
-- More samples including gpu-burn, SHOC, nbody, rtm.  See [HIP-Examples](https://github.com/ROCm-Developer-Tools/HIP-Examples)
+- More samples including gpu-burn, SHOC, nbody, rtm.  See [HIP-Examples](https://github.com/ROCm/HIP-Examples)
 
 
 ===================================================================================================

docs/developer_guide/build.md

@@ -134,7 +134,7 @@ HIP catch tests, with the newly architectured Catch2, are officially separated f
 ##### Get HIP tests source code
 
 ```shell
-git clone -b "$ROCM_BRANCH" https://github.com/ROCm-Developer-Tools/hip-tests.git
+git clone -b "$ROCM_BRANCH" https://github.com/ROCm/hip-tests.git
 ```
 ##### Build HIP tests from source
 

docs/developer_guide/contributing.md

@@ -59,7 +59,7 @@ Selected multilib: .;@m64
 
 ## Unit Testing Environment
 
-Tests for HIP are hosted at [ROCm-Developer-Tools/hip-tests](https://github.com/ROCm-Developer-Tools/hip-tests).
+Tests for HIP are hosted at [ROCm/hip-tests](https://github.com/ROCm/hip-tests).
 
 To run `hip-tests` please go to the repo and follow the steps.
 
@@ -124,7 +124,7 @@ Differences or limitations of HIP APIs as compared to CUDA APIs should be clearl
 
 
 ### Presubmit Testing:
-Before checking in or submitting a pull request, run all hip-tests (see [ROCm-Developer-Tools/hip-tests](https://github.com/ROCm-Developer-Tools/hip-tests)).
+Before checking in or submitting a pull request, run all hip-tests (see [ROCm/hip-tests](https://github.com/ROCm/hip-tests)).
 
 
 ### Checkin messages

docs/how_to_guides/debugging.md

@@ -79,7 +79,7 @@ PASSED!
 ### Using ROCgdb
 HIP developers on ROCm can use AMD's ROCgdb for debugging and profiling.
 ROCgdb is the ROCm source-level debugger for Linux, based on GDB, the GNU source-level debugger, equivalent of cuda-gdb, can be used with debugger frontends, such as eclipse, vscode, or gdb-dashboard.
-For details, see (https://github.com/ROCm-Developer-Tools/ROCgdb).
+For details, see (https://github.com/ROCm/ROCgdb).
 
 Below is a sample how to use ROCgdb run and debug HIP application, rocgdb is installed with ROCM package in the folder /opt/rocm/bin.
 
@@ -91,7 +91,7 @@ Copyright (C) 2020 Free Software Foundation, Inc.
 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
 ...
 For bug reporting instructions, please see:
-<https://github.com/ROCm-Developer-Tools/ROCgdb/issues>.
+<https://github.com/ROCm/ROCgdb/issues>.
 Find the GDB manual and other documentation resources online at:
     <http://www.gnu.org/software/gdb/documentation/>.
 

docs/reference/deprecated_api_list.md

@@ -86,3 +86,5 @@ Should use roctracer/rocTX instead
 ### hipTexRefSetMipmapLevelClamp
 ### hipTexRefSetMipmappedArray
 ### hipBindTextureToMipmappedArray
+### hipTexRefGetBorderColor
+### hipTexRefGetArray

docs/reference/glossary.md

@@ -10,10 +10,13 @@ The default device can be set with hipSetDevice.
 
 - HIP-Clang - Heterogeneous AMDGPU Compiler, with its capability to compile HIP programs on AMD platform (https://github.com/RadeonOpenCompute/llvm-project).
 
-- ROCclr - a virtual device interface that compute runtimes interact with different backends such as ROCr on Linux or PAL on Windows.
-  The ROCclr (https://github.com/ROCm-Developer-Tools/ROCclr) is an abstraction layer allowing runtimes to work on both OSes without much effort.
+- clr - a repository for AMD Common Language Runtime, contains source codes for AMD's compute languages runtimes: HIP and OpenCL™.
+clr (https://github.com/ROCm/clr) contains the following three parts,
+hipamd: contains implementation of HIP language on AMD platform.
+rocclr: contains common runtime used in HIP and OpenCL™, which provides virtual device interfaces that compute runtimes interact with different backends such as ROCr on Linux or PAL on Windows.
+opencl: contains implementation of OpenCL™ on AMD platform.
 
-- hipify tools - tools to convert CUDA code to portable C++ code (https://github.com/ROCm-Developer-Tools/HIPIFY).
+- hipify tools - tools to convert CUDA code to portable C++ code (https://github.com/ROCm/HIPIFY).
 
 - hipconfig - tool to report various configuration properties of the target platform.
 

docs/user_guide/hip_porting_driver_api.md

@@ -40,7 +40,7 @@ The CUDA Runtime API unifies the Context API with the Device API. This simplifie
 HIP provides a context API to facilitate easy porting from existing Driver codes.
 In HIP, the Ctx functions largely provide an alternate syntax for changing the active device.
 
-Most new applications will prefer to use `hipSetDevice` or the stream APIs , therefore HIP has marked hipCtx APIs as **deprecated**. Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer [HIP deprecated APIs](https://github.com/ROCm-Developer-Tools/HIP/tree/master/docs/markdown/hip_deprecated_api_list.md).
+Most new applications will prefer to use `hipSetDevice` or the stream APIs , therefore HIP has marked hipCtx APIs as **deprecated**. Support for these APIs may not be available in future releases. For more details on deprecated APIs please refer [HIP deprecated APIs](https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md).
 
 ## HIP Module and Ctx APIs
 

docs/user_guide/hip_porting_guide.md

@@ -9,10 +9,10 @@ and provides practical suggestions on how to port CUDA code and work through com
 - Starting the port on a CUDA machine is often the easiest approach, since you can incrementally port pieces of the code to HIP while leaving the rest in CUDA. (Recall that on CUDA machines HIP is just a thin layer over CUDA, so the two code types can interoperate on nvcc platforms.) Also, the HIP port can be compared with the original CUDA code for function and performance.
 - Once the CUDA code is ported to HIP and is running on the CUDA machine, compile the HIP code using the HIP compiler on an AMD machine.
 - HIP ports can replace CUDA versions: HIP can deliver the same performance as a native CUDA implementation, with the benefit of portability to both Nvidia and AMD architectures as well as a path to future C++ standard support. You can handle platform-specific features through conditional compilation or by adding them to the open-source HIP infrastructure.
-- Use **[hipconvertinplace-perl.sh](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/bin/hipconvertinplace-perl.sh)** to hipify all code files in the CUDA source directory.
+- Use **[hipconvertinplace-perl.sh](https://github.com/ROCm/HIPIFY/blob/amd-staging/bin/hipconvertinplace-perl.sh)** to hipify all code files in the CUDA source directory.
 
 ### Scanning existing CUDA code to scope the porting effort
-The **[hipexamine-perl.sh](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/bin/hipexamine-perl.sh)** tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
+The **[hipexamine-perl.sh](https://github.com/ROCm/HIPIFY/blob/amd-staging/bin/hipexamine-perl.sh)** tool will scan a source directory to determine which files contain CUDA code and how much of that code can be automatically hipified.
 ```
 > cd examples/rodinia_3.0/cuda/kmeans
 > $HIP_DIR/bin/hipexamine-perl.sh.
@@ -66,7 +66,7 @@ For each input file FILE, this script will:
 This is useful for testing improvements to the hipify toolset.
 
 
-The [hipconvertinplace-perl.sh](https://github.com/ROCm-Developer-Tools/HIPIFY/blob/master/bin/hipconvertinplace-perl.sh) script will perform inplace conversion for all code files in the specified directory.
+The [hipconvertinplace-perl.sh](https://github.com/ROCm/HIPIFY/blob/amd-staging/bin/hipconvertinplace-perl.sh) script will perform inplace conversion for all code files in the specified directory.
 This can be quite handy when dealing with an existing CUDA code base since the script preserves the existing directory structure
 and filenames - and includes work.  After converting in-place, you can review the code to add additional parameters to
 directory names.
@@ -461,7 +461,7 @@ In this case, memory type translation for hipPointerGetAttributes needs to be ha
 
 So in any HIP applications which use HIP APIs involving memory types, developers should use #ifdef in order to assign the correct enum values depending on Nvidia or AMD platform.
 
-As an example, please see the code from the [link](https://github.com/ROCm-Developer-Tools/hip-tests/tree/develop/catch/unit/memory/hipMemcpyParam2D.cc).
+As an example, please see the code from the [link](https://github.com/ROCm/hip-tests/tree/develop/catch/unit/memory/hipMemcpyParam2D.cc).
 
 With the #ifdef condition, HIP APIs work as expected on both AMD and NVIDIA platforms.
 

docs/user_guide/programming_manual.md

@@ -127,8 +127,9 @@ HIP now supports runtime compilation (HIPRTC), the usage of which will provide t
 
 HIPRTC APIs accept HIP source files in character string format as input parameters and create handles of programs by compiling the HIP source files without spawning separate processes.
 
-For more details on HIPRTC APIs, refer to HIP-API.pdf in GitHub (https://docs.amd.com/category/api_documentation).
-For Linux developers, the link here(https://github.com/ROCm-Developer-Tools/hip-tests/blob/develop/samples/2_Cookbook/23_cmake_hiprtc/saxpy.cpp) shows an example how to program HIP application using runtime compilation mechanism, and detail HIPRTC programming guide is also available in Github (https://github.com/ROCm-Developer-Tools/HIP/blob/develop/docs/user_guide/hip_rtc.md).
+For more details on HIPRTC APIs, refer to [HIP Runtime API Reference](https://rocm.docs.amd.com/projects/HIP/en/latest/doxygen/html/index.html).
+
+For Linux developers, the link here (https://github.com/ROCm/hip-tests/blob/develop/samples/2_Cookbook/23_cmake_hiprtc/saxpy.cpp) shows an example how to program HIP application using runtime compilation mechanism, and detail HIPRTC programming guide is also available in Github (https://github.com/ROCm/HIP/blob/develop/docs/user_guide/hip_rtc.md).
 
 ## HIP Graph
 HIP graph is supported. For more details, refer to the HIP API Guide.
@@ -145,7 +146,7 @@ The per-thread default stream is a blocking stream and will synchronize with the
 The per-thread default stream can be enabled via adding a compilation option,
 "-fgpu-default-stream=per-thread".
 
-And users can explicitly use "hipStreamPerThread" as per-thread default stream handle as input in API commands. There are test codes as examples in the link (https://github.com/ROCm-Developer-Tools/hip-tests/tree/develop/catch/unit/streamperthread).
+And users can explicitly use "hipStreamPerThread" as per-thread default stream handle as input in API commands. There are test codes as examples in the link (https://github.com/ROCm/hip-tests/tree/develop/catch/unit/streamperthread).
 
 ## Use of Long Double Type
 
@@ -190,4 +191,4 @@ Here is an example to create and use static libraries:
     hipcc libHipDevice.a test.cpp -fgpu-rdc -o test.out
     ```
 
-For more information, please see [HIP samples](https://github.com/ROCm-Developer-Tools/hip-tests/tree/rocm-5.5.x/samples/2_Cookbook/15_static_library/host_functions) and [samples](https://github.com/ROCm-Developer-Tools/hip-tests/tree/rocm-5.5.x/samples/2_Cookbook/15_static_library/device_functions).
+For more information, please see [HIP samples](https://github.com/ROCm/hip-tests/tree/develop/samples/2_Cookbook/15_static_library/host_functions) and [samples](https://github.com/ROCm/hip-tests/tree/rocm-5.5.x/samples/2_Cookbook/15_static_library/device_functions).