Final changes

Author: aepanchi

CONTRIBUTING.md

@@ -18,12 +18,12 @@ of `dpctl`
     - [Python Code Style](#python-code-style)
     - [Setting Up a Pre-commit](#setting-up-a-pre-commit)
     - [C/C++ File Headers](#cc-file-headers)
-    - [Python* File Headers](#python-file-headers)
+    - [Python File Headers](#python-file-headers)
   - [Security](#security)
     - [Bandit](#bandit)
   - [Code Coverage](#code-coverage)
   - [Error Reporting and Logging](#error-reporting-and-logging)
-    - [Optional use of the Google* logging library (glog*)](#optional-use-of-the-google-logging-library-glog)
+    - [Optional use of the Google logging library (glog)](#optional-use-of-the-google-logging-library-glog)
 
 
 # Mechanical Source Issues
@@ -53,7 +53,7 @@ clang-format -style=file -i         \
      libsyclinterface/helper/source/*.cpp
 ```
 
-> **:** It is easier to use `pre-commit` and the `clang-format` hook.
+> **NOTE:** It is recommended to use `pre-commit` that invokes `clang-format` among other linters as configured.
 
 ### Python Code Style
 
@@ -116,7 +116,7 @@ The standard header looks like this:
 > **NOTE:**
 >- The `-*- C++ -*-` string on the first line tells Emacs* that
   it is a C++ file. The string is only needed for `*.h` headers and
-  should be omitted for `*.cpp` files. Without the string, Emacs* assumes the
+  should be omitted for `*.cpp` files. Without the string, Emacs assumes the
   file is a C header.
 >- The copyright year must be updated every calendar year.
 >- Each comment line should be a max of 80 chars.
@@ -128,9 +128,9 @@ The standard header looks like this:
 ---
 
 
-### Python* File Headers
+### Python File Headers
 
-Every Python* and Cython* file should only include the following license header:
+Every Python and Cython file should only include the following license header:
 
 ```
 #                      Data Parallel Control (dpctl)
@@ -156,8 +156,8 @@ The copyright year should be updated every calendar year.
 
 ### Bandit
 
-We use [Bandit*](https://github.com/PyCQA/bandit) to find common security issues
-in the Python* code.
+We use [Bandit](https://github.com/PyCQA/bandit) to find common security issues
+in the Python code.
 
 To install, run:
 ```bash
@@ -182,15 +182,14 @@ To check the code coverage for your code, follow these steps:
 
 1. Install dependencies for C/C++ source.
 
-    For C/C++ source, we require `lcov`, `llvm-cov`, and `llvm-profdata`. `llvm-cov` and `llvm-profdata` 
-    should be version 11.0 or higher. If you
+    For C/C++ source,  `lcov`, `llvm-cov` (>=11.0), and `llvm-profdata` (>=11.0) are required. If you
     have multiple `llvm-cov` tools installed, set the `LLVM_TOOLS_HOME`
     environment variable to make sure the correct one is used to generate
     coverage.
 
-2. Install dependencies for Python* sources.
+2. Install dependencies for Python sources.
 
-    To generate the coverage data for dpctl Python* sources,
+    To generate the coverage data for dpctl Python sources,
     install `coverage`:
 
     ```bash
@@ -208,10 +207,10 @@ To check the code coverage for your code, follow these steps:
     reason, the coverage script builds the package in `develop` mode of
     `setup.py`.
 
-    The coverage results for the C and Python* sources are printed to the
-    terminal during the build (`libsyclinterface`) and pytest execution (Python*).
+    The coverage results for the C and Python sources are printed to the
+    terminal during the build (`libsyclinterface`) and pytest execution (Python).
     The detailed coverage reports for the `libsyclinterface` library are saved to the
-    `dpctl-c-api-coverage` directory. The Python* coverage reports are saved to
+    `dpctl-c-api-coverage` directory. The Python coverage reports are saved to
     the `htmlcov` directory.
 
     The coverage data for every PR is also available online at
@@ -241,24 +240,24 @@ export DPCTL_VERBOSITY=warning
 
 Messages of a given severity are shown not only in the console for that severity but also for the higher severity. For example, the severity level `warning` outputs severity errors for `error` and `warning` to the console.
 
-### Optional use of the Google* logging library (glog*)
+### Optional use of the Google logging library (glog)
 
-The dpctl error handler for libsyclinterface can be optionally configured to use [glog*](https://github.com/google/glog). 
+The dpctl error handler for libsyclinterface can be optionally configured to use [glog](https://github.com/google/glog). 
 
-To use glog*, complete the following steps:
+To use glog, complete the following steps:
 
-1. Install glog* package of the latest version
+1. Install glog package of the latest version
 
 ```bash
 conda install glog
 ```
-2. Build dpctl with the glog* support
+2. Build dpctl with the glog support
 
 ```bash
 python scripts/build_locally.py --oneapi --glog
 ```
 
-3. Use the `dpctl._diagnostics.syclinterface_diagnostics(verbosity="warning", log_dir=None)` context manager to switch library diagnostics on for a block of a Python* code.
+1. Use the `dpctl._diagnostics.syclinterface_diagnostics(verbosity="warning", log_dir=None)` context manager to switch library diagnostics on for a block of a Python code.
 Use `DPCTLService_InitLogger` and `DPCTLService_ShutdownLogger` library C functions during library development to initialize Google's logging library and de-initialize accordingly:
 
 ```python
@@ -278,4 +277,4 @@ Where:
  - `*log_dir` - a directory path for writing log files. Specifying `NULL` results in logging to ``std::cerr``.
 
 > **_NOTE:_**
-> If `InitGoogleLogging` is not called before the first use of the glog*, the library self-initializes to the `logtostderr` mode, and log files are not generated.
+> If `InitGoogleLogging` is not called before the first use of the glog, the library self-initializes to the `logtostderr` mode, and log files are not generated.

README.md

@@ -9,44 +9,44 @@
 
 # Data Parallel Control
 
-Data Parallel Control or `dpctl` is a Python* library that allows users
+Data Parallel Control or `dpctl` is a Python library that allows users
 to *control* the execution placement of a [compute
 kernel](https://en.wikipedia.org/wiki/Compute_kernel) on an
-[XPU*](https://www.intel.com/content/www/us/en/newsroom/news/xpu-vision-oneapi-server-gpu.html).
+[XPU](https://www.intel.com/content/www/us/en/newsroom/news/xpu-vision-oneapi-server-gpu.html).
 
 The compute kernel can be a code:
-* written by the user, e.g., using `numba-dppy`
+* written by the user, e.g., using [`numba-dpex`](https://github.com/IntelPython/numba-dpex)
 * that is part of a library, such as oneMKL  
 
-The `dpctl` library is built upon the [SYCL*
+The `dpctl` library is built upon the [SYCL
 standard](https://www.khronos.org/sycl/). It also implements Python
 bindings for a subset of the standard [runtime
 classes](https://www.khronos.org/registry/SYCL/specs/sycl-2020/html/sycl-2020.html#_sycl_runtime_classes) that allow users to:
 * query platforms
 * discover and represent devices and sub-devices
 * construct contexts and queues 
 
-`dpctl` features classes for [SYCL* Unified Shared Memory
+`dpctl` features classes for [SYCL Unified Shared Memory
 (USM)](https://link.springer.com/chapter/10.1007/978-1-4842-5574-2_6)
 management and implements a tensor [array
 API](https://data-apis.org/array-api/latest/).
 
 The library helps authors of Python native extensions written
-in C, Cython*, or pybind11* to access `dpctl` objects representing SYCL*
+in C, Cython, or pybind11 to access `dpctl` objects representing SYCL
 devices, queues, memory, and tensors.
 
-`Dpctl` is the core part of a larger family of [data-parallel Python*
+`Dpctl` is the core part of a larger family of [data-parallel Python
 libraries and tools](https://www.intel.com/content/www/us/en/developer/tools/oneapi/distribution-for-python.html)
 to program on XPUs. 
 
 
 
 # Installing
 
-You can install the library with [conda*](https://anaconda.org/intel/dpctl) and
-[pip*](https://pypi.org/project/dpctl/). It is also available in the [Intel(R)
+You can install the library with [conda](https://anaconda.org/intel/dpctl) and
+[pip](https://pypi.org/project/dpctl/). It is also available in the [Intel(R)
 Distribution for
-Python*](https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/distribution-for-python.html)
+Python](https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/distribution-for-python.html)
 (IDP).
 
 ## Inte(R) oneAPI
@@ -57,13 +57,13 @@ To get the library from the latest oneAPI release, follow the
 instructions from Intel(R) [oneAPI installation
 guide](https://www.intel.com/content/www/us/en/developer/articles/guide/installation-guide-for-oneapi-toolkits.html).
 
-> **NOTE:** You need to install the Intel(R) oneAPI Base Toolkit to get
+> **NOTE:** You need to install the Intel(R) oneAPI Basekit to get
 >IDP and `dpctl`.
 
 
 ## Conda
 
-To install `dpctl` from the Intel(R) channel on Annaconda*
+To install `dpctl` from the Intel(R) channel on Annaconda
 cloud, use the following command:
 
 ```bash
@@ -72,7 +72,7 @@ conda install dpctl -c intel
 
 ## PyPi
 
-To install `dpctl` from PyPi*, run the following command:
+To install `dpctl` from PyPi, run the following command:
 
 ```bash
 pip3 install dpctl
@@ -82,7 +82,7 @@ Installing the bleeding edge
 ------------------------
 
 To try out the current master, install it from our
-development channel on Anaconda* cloud:
+development channel on Anaconda cloud:
 
 ```bash
 conda install dpctl -c dppy\label\dev
@@ -106,8 +106,8 @@ for script in `ls examples/python/`;
 done
 ```
 
-##  Cython* extensions
-See examples of building Cython* extensions with DPC++ compiler that interoperates
+##  Cython extensions
+See examples of building Cython extensions with DPC++ compiler that interoperates
 with `dpctl` in the [cython folder](examples\cython).
 
 To build these examples, run:

docs/README.md

@@ -10,7 +10,7 @@ consolidated documentation is generated using the provided build scripts.
 Prerequisite
 ============
 
-The following tools are needed in order to build the documentation for dpctl
+The following tools are needed in order to build the documentation for dpctl:
 
 - `Sphinx`
 - `Doxygen`
@@ -22,18 +22,18 @@ output and add them to a consolidate `Sphinx` generated site. It is preferred
 that the latest `Doxyrest` binary is installed from
 https://github.com/vovkos/doxyrest/tags.
 
-`Lua` is required if using `Doxyrest`. Please follow your OS specific
-instructions to install `liblua`. *E.g.*, on Ubuntu 20.04:
+`Lua` is required if using `Doxyrest`. Follow your OS specific
+instructions to install `liblua`. For example, on Ubuntu 20.04:
 
 ```
 sudo apt-get install liblua5.2-dev
 ```
 
-Generating the docs
-===================
+Generating The Documentation 
+============================
 
 The helper script ``scripts/gen_docs.py`` is the preferred way to generate the
-documentation. The generated documentation html pages will be installed to the
+documentation. The generated documentation HTML pages are installed to the
 ``CMAKE_INSTALL_PREFIX/docs`` directory.
 
 ----------------------------

docs/docfiles/intro.rst

@@ -2,16 +2,16 @@ Welcome to the Data-parallel Control (dpctl) Documentation!
 ===========================================================
 
 The data-parallel control (dpctl) library provides C and Python bindings for
-:sycl_spec_2020:`SYCL 2020 <>`. The SYCL* 2020 features supported by dpctl are
+:sycl_spec_2020:`SYCL 2020 <>`. The SYCL 2020 features supported by dpctl are
 limited to those included by Intel(R) DPCPP compiler and specifically cover the
-SYCL* runtime classes described in :sycl_runtime_classes:`Section 4.6 <>`
-of the SYCL* 2020 specification. 
+SYCL runtime classes described in :sycl_runtime_classes:`Section 4.6 <>`
+of the SYCL 2020 specification. 
 
 Apart from the bindings for these runtime
-classes, dpctl includes bindings for SYCL* USM memory allocators and
-deallocators. Dpctl Python* API provides classes that implement
+classes, dpctl includes bindings for SYCL USM memory allocators and
+deallocators. Dpctl Python API provides classes that implement
 `Python buffer protocol <https://docs.python.org/3/c-api/buffer.html>`_
-using SYCL* USM memory. It makes it possible to create Python objects that are
+using SYCL USM memory. It makes it possible to create Python objects that are
 backed by SYCL USM memory.
 
 Dpctl also supports the DPCPP :oneapi_filter_selection:`oneapi::filter_selector <>` extension and has