update path of examples/nonblocking

Author: wkliao

docs/nc4_vs_pnetcdf.md

@@ -89,8 +89,8 @@
   `put/get` requests and each of them has a small amount.  PnetCDF tries to
   aggregate and coalesce multiple registered nonblocking requests into a large
   one, because I/O usually performs better when the request amounts are large
-  and contiguous. [nonblocking_write.py](../examples/nonblocking_write.py) is
-  an example that makes use of nonblocking APIs.
+  and contiguous. See an example program in
+  [nonblocking_write.py](../examples/nonblocking/nonblocking_write.py).
 * Table below shows the difference in python programming between using blocking
   and nonblocking APIs.
 

docs/source/tutorial/compare_netcdf4.rst

@@ -4,54 +4,54 @@ Comparing with netCDF4-python API
 =================================
 .. warning::
 
-   Under construction. 
+   Under construction.
 
-PnetCDF-python inherits many features from netCDF4-python, making the transition from the former to the latter a seamless process 
-for most netCDF4-python applications. However, there are some exceptions to this as listed below. On the other hand, PnetCDF-python supports 
-some new APIs not available in netCDF4-python.  
+PnetCDF-python inherits many features from netCDF4-python, making the transition from the former to the latter a seamless process
+for most netCDF4-python applications. However, there are some exceptions to this as listed below. On the other hand, PnetCDF-python supports
+some new APIs not available in netCDF4-python.
 
 Supported File Formats
 --------------------------
 
  NetCDF4-python supports NETCDF4 formats(HDF5) in addition to classic netCDF formats(NETCDF3_CLASSIC, NETCDF3_64BIT_OFFSET, NETCDF3_64BIT_DATA). However,
- PnetCDF-python library only supports netCDF classic file formats, which means all netCDF4-dependent features are **not** supported, including user-defined types, 
+ PnetCDF-python library only supports netCDF classic file formats, which means all netCDF4-dependent features are **not** supported, including user-defined types,
  compression, hirarchical structure, etc.
 
 Difference in Programming Model
 --------------------------------
 
  Data/Define Mode
-  NetCDF4-python library automatically switches between data and define mode for the user by calling ``redef`` and ``enddef`` internally within the define-mode 
-  operation functions, which is **not** implemented in Pnetcdf-python. A manual call to :meth:`File.redef` is compulsory to activate define mode before swtiching 
-  to define mode opearations, following the C library convention. Similarly, :meth:`File.enddef` is required before switching to data mode operations. This design is based on considerations of 
+  NetCDF4-python library automatically switches between data and define mode for the user by calling ``redef`` and ``enddef`` internally within the define-mode
+  operation functions, which is **not** implemented in Pnetcdf-python. A manual call to :meth:`File.redef` is compulsory to activate define mode before swtiching
+  to define mode opearations, following the C library convention. Similarly, :meth:`File.enddef` is required before switching to data mode operations. This design is based on considerations of
   the following aspects:
 
-  - Minimize overheads during consecutive define operations: Automatically wrapping all define functions with :meth:`File.redef` and :meth:`File.enddef` could introduce 
+  - Minimize overheads during consecutive define operations: Automatically wrapping all define functions with :meth:`File.redef` and :meth:`File.enddef` could introduce
     significant overhead between consecutive define operations. This approach results in unnecessary data/define mode switches, impacting performance.
-  - Avoid potential hanging when performing independent I/O: if :meth:`File.enddef` is automatically embeded in all data mode operation functions, the program will hang when 
+  - Avoid potential hanging when performing independent I/O: if :meth:`File.enddef` is automatically embeded in all data mode operation functions, the program will hang when
     partial processes are performing independent I/O(while others don't) because :meth:`File.enddef` is a collective call which requires all processes to participate.
 
  Independent/Collective I/O Mode
   There are two types of parallel I/O, independent I/O and collective I/O supported both in PnetCDF-python and netCDF4-python. NetCDF4-python toggles back and forth
-  between the two types at variable-level. However, PnetCDF-python manages this at file-level through :meth:`File.begin_indep` and :meth:`File.end_indep`. The default I/O mode 
+  between the two types at variable-level. However, PnetCDF-python manages this at file-level through :meth:`File.begin_indep` and :meth:`File.end_indep`. The default I/O mode
   is collective I/O in PnetCDF-python.
- 
+
 
 Alternative Reads and Writes Methods
 ------------------------------------------
 
  For reading from and writing to netCDF4 variables, PnetCDF-python provides alternative methods in addition to numpy-like indexer syntax. The :meth:`Variable.get_var` and
- :meth:`Variable.put_var` methods are faithfull python-implementations of the put/get_var families from the original PnetCDF-C library. By overloading the input arguments, 
- these methods can fulfill specific I/O needs to the target variable depending on the requirements of the applications: the entire variable, a single data value, an 
- (subsampled) array of values, a mapped array or a list of subarrays. These methods require an array argument as read/write buffer, which is a prerequisite non-blocking 
+ :meth:`Variable.put_var` methods are faithfull python-implementations of the put/get_var families from the original PnetCDF-C library. By overloading the input arguments,
+ these methods can fulfill specific I/O needs to the target variable depending on the requirements of the applications: the entire variable, a single data value, an
+ (subsampled) array of values, a mapped array or a list of subarrays. These methods require an array argument as read/write buffer, which is a prerequisite non-blocking
  I/O as introduced below.
 
  For the example program, see ``examples/get_vara.py``.
 
 Non-blocking I/O
 ------------------------------------------
- In additional to blocking read/writes, PnetCDF also offers the nonblocking API that enables users to initiate multiple requests without actually doing I/O and subsequently 
- flush them altogether. This approach is designed to enhance performance by merging small I/O requests and maximizing I/O efficiency. This features is faithfully 
- preserved in PnetCDF-python API. 
+ In additional to blocking read/writes, PnetCDF also offers the nonblocking API that enables users to initiate multiple requests without actually doing I/O and subsequently
+ flush them altogether. This approach is designed to enhance performance by merging small I/O requests and maximizing I/O efficiency. This features is faithfully
+ preserved in PnetCDF-python API.
 
- For the example program, see ``examples/non_blocking_write.py``.
+ For the example program, see ``examples/nonblocking/nonblocking_write.py``.