Add some doc update that was missing in previous PR.

doc/library/sandbox/cuda/dnn.txt

@@ -66,6 +66,8 @@ get an error when CuDNN can not be sued with them, use this flag:
    * ``large`` : use a sometimes faster implementation with large memory usage
    * ``fft`` : use the Fast Fourrier Transform implementation of convolution
      (very high memory usage)
+   * ``fft_tiling`` : use the Fast Fourrier Transform implementation of convolution
+     with tiling (high memory usage, but less then fft)
    * ``guess_once`` : the first time a convolution is executed, the
      implementation to use is chosen according to CuDNN's heuristics and reused
      for every subsequent execution of the convolution.
@@ -79,9 +81,11 @@ get an error when CuDNN can not be sued with them, use this flag:
      implementation selected every time the shapes of the inputs and kernels
      don't match the shapes from the last execution.
 
-   The Theano flag ``dnn.conv.algo_bwd`` allows to specify the CuDNN
-   convolution implementation that Theano should use for gradient convolutions.
-   Possible values include :
+   The Theano flag ``dnn.conv.algo_bwd_filter`` and
+   ``dnn.conv.algo_bwd_data`` allows to specify the CuDNN The Theano
+   flag ``dnn.conv.algo_bwd_data`` allows to specify the CuDNN
+   convolution implementation that Theano should use for gradient
+   convolutions.  Possible values include :
 
    * ``none`` (default) : use the default non-deterministic convolution
      implementation
@@ -101,6 +105,13 @@ get an error when CuDNN can not be sued with them, use this flag:
      implementation selected every time the shapes of the inputs and kernels
      don't match the shapes from the last execution.
 
+   * (algo_bwd_data only) ``fft_tiling`` : use the Fast Fourrier
+     Transform implementation of convolution with tiling (high memory
+     usage, but less then fft)
+
+   * (algo_bwd_data only) ``small`` : use a convolution implementation
+     with small memory usage
+
    ``guess_*`` and ``time_*`` flag values take into account the amount of
    available memory when selecting an implementation. This means that slower
    implementations might be selected if not enough memory is available for the