small fixes in documentation

Author: benvanwerkhoven

doc/source/cache_files.rst

@@ -4,14 +4,14 @@ Cache files
 ===========
 
 A very useful feature of Kernel Tuner is the ability to store benchmarking results in a cache file during tuning. You can enable cache files by 
-passing any filename to the ``cache=`` optional argument of ``tune_kernel()``.
+passing any filename to the ``cache=`` optional argument of ``tune_kernel``.
 
 The benchmark results of individual kernel configurations are appended to the cache file as Kernel Tuner is running. This also allows Kernel Tuner 
 to restart a ``tune_kernel()`` session from an existing cache file, should something have terminated the previous session before the run had 
 completed. This happens quite often in HPC environments when a job reservation runs out. 
 
 Cache files enable a number of other features, such as simulations and visualizations. Simulations are useful for benchmarking optimization 
-strategies. You can start a simulation by call tune_kernel with a cache file that contains the full search space and the ``simulation=True`` option.
+strategies. You can start a simulation by calling ``tune_kernel`` with a cache file that contains the full search space and the ``simulation=True`` option.
 
 Cache files can be used to create visualizations of the search space. This even works while Kernel Tuner is still running. As the new results are 
 coming, they are streamed to the visualization. Please see `Kernel Tuner Dashboard <https://github.com/KernelTuner/dashboard>`__.

doc/source/index.rst

@@ -98,4 +98,11 @@ If you use Kernel Tuner in research or research software, please cite the most r
       publisher={IEEE}
     }
 
-
+    @article{schoonhoven2022going,
+      author = {Schoonhoven, Richard and Veenboer, Bram, and van Werkhoven, Ben and Batenburg, K Joost},
+      title = {Going green: optimizing GPUs for energy efficiency through model-steered auto-tuning},
+      journal = {International Workshop on Performance Modeling, Benchmarking and Simulation
+         of High Performance Computer Systems (PMBS) at Supercomputing (SC22)},
+      year = {2022},
+      url = {https://arxiv.org/abs/2211.07260}
+    }

doc/source/quickstart.rst

@@ -3,7 +3,7 @@ Getting Started
 
 So you have installed Kernel Tuner! That's great! But now you'd like to get started tuning some GPU code.
 
-Let's say we have a simple CUDA kernel stored in a file called vector_add_kernel.cu:
+Let's say we have a simple CUDA kernel stored in a file called ``vector_add_kernel.cu``:
 
 .. code-block:: cuda
 
@@ -16,7 +16,7 @@ Let's say we have a simple CUDA kernel stored in a file called vector_add_kernel
     }
 
 
-This kernel simply performs a point-wise addition of vectors a and b and stores the result in c.
+This kernel simply performs a point-wise addition of vectors ``a`` and ``b`` and stores the result in ``c``.
 
 To tune this kernel with Kernel Tuner, we are going to create the input and output data in Python using Numpy arrays.
 
@@ -34,30 +34,30 @@ To tune this kernel with Kernel Tuner, we are going to create the input and outp
 To tell Kernel Tuner how it should call the kernel, we can create a list in Python that should correspond to 
 our CUDA kernel's argument list with the same order and types.
 
-.. code-block::python
+.. code-block:: python
 
     args = [c, a, b, n]
 
 So far, we have created the data structures needed by Kernel Tuner to call our kernel, but we have not yet specified what we 
 want Kernel Tuner to tune in our kernel. For that, we create a dictionary that we call tune_params, in which keys correspond 
 to tunable parameters in our kernel and the values are lists of values that these parameters may take.
 
-.. code-block::python
+.. code-block:: python
 
     tune_params = dict()
     tune_params["block_size_x"] = [32, 64, 128, 256, 512, 1024]
 
-In the code above, we have inserted a key into our dictionary called "block_size_x". This is a special name for a tunable
+In the code above, we have inserted a key into our dictionary, namely ``"block_size_x"``. This is a special name for a tunable
 parameter that is recognized by Kernel Tuner to denote the size of our thread block in the x-dimension. 
 For a full list of special parameter names, please see the :ref:`parameter-vocabulary`.
 
-Alright, we are all set to start calling Kernel Tuner's main function, which is called tune_kernel. 
+Alright, we are all set to start calling Kernel Tuner's main function, which is called ``tune_kernel``. 
 
-.. code-block::python
+.. code-block:: python
 
     results, env = kernel_tuner.tune_kernel("vector_add", "vector_add_kernel.cu", size, args, tune_params)
 
-In the above, tune_kernel takes five arguments:
+In the above, ``tune_kernel`` takes five arguments:
 
  * The kernel name passed as a string
  * The filename of the kernel, also as a string