work on package docs

jjallaire · jjallaire · commit a054c5715f3e · 2014-07-08T12:24:09.000-04:00
diff --git a/DESCRIPTION b/DESCRIPTION
@@ -2,11 +2,14 @@ Package: RcppParallel
 Type: Package
 Title: Parallel programming tools for Rcpp
 Version: 4.2.5
-Date: 2014-06-28
-Author: RStudio, Inc.; Intel, Inc.
+Date: 2014-07-08
+Author: RStudio, Inc.; Intel, Inc.; Marcus Geelnard
 Copyright: RStudio, Inc.
 Maintainer: JJ Allaire <jj@rstudio.com>
-Description: Parallel programming tools for Rcpp
+Description: High level functions for doing parallel programming with Rcpp.
+  For example, the parallelFor function can be used to convert the work of 
+  a standard serial "for" loop into a parallel one and the parallelReduce 
+  function can be used for accumulating aggregate or other values.
 SystemRequirements: GNU make
 License: GPL-2
 Collate: 
diff --git a/NEWS b/NEWS
@@ -1,4 +1,4 @@
-TBB 4.2.5
+RcppParallel 4.2.5
 ------------------------------------------------------------------------
 
 * Initial release
diff --git a/README.md b/README.md
@@ -0,0 +1,73 @@
+## RcppParallel Package
+
+High level functions for doing parallel programming with Rcpp. For example, the `parallelFor` function can be used to convert the work of a standard serial "for" loop into a parallel one and the `parallelReduce` function can be used for accumulating aggregate or other values.
+
+The high level interface enables safe and robust parallel programming without direct manipulation of operating system threads. The underlying implementation differs by platform: on Linux and Mac systems the [Intel TBB](https://www.threadingbuildingblocks.org/) (Threading Building Blocks) are used while on Windows systems the [TinyThread](http://tinythreadpp.bitsnbites.eu/) library is used.
+
+### Examples
+
+Here are links to three examples that illustrate using RcppParallel:
+
+[Parallel Matrix Transform](inst/examples/parallel-matrix-transform.cpp) --- Demonstrates using `parallelFor` to transform a matrix (take the square root of each element) in parallel. In this  example the parallel version performs about 2.5x faster than the serial version on a 4-core machine.
+
+[Parallel Vector Sum](inst/examples/parallel-vector-sum.cpp) --- Demonstrates using `parallelReduce` to take the sum of a vector in parallel. In this example the parallel version performs 4x faster than the serial version on a 4-core machine.
+
+[Parallel Inner Product](inst/examples/parallel-inner-product.cpp) --- Demonstrates using `parallelReduce` to compute the inner product of two vectors in parallel. In this example the parallel version performs 2.5x faster than the serial version on a 4-core machine.
+
+Note that the benchmark times above are for the TBB back-end (Posix systems only). Performance on Windows is about 30% slower.
+
+### Usage
+
+You can install the RcppParallel package from GitHub as follows:
+
+```s
+devtools::install_github("jjallaire/RcppParallel")
+```
+
+#### sourceCpp
+
+You can use the RcppParallel library from within a standalone C++ source file as follows:
+
+```cpp
+// [[Rcpp::depends(RcppParallel)]]
+#include <RcppParallel.h>
+```
+
+#### Packages
+
+If you want to use RcppParallel from within an R package you add the following to your DESCRIPTION file:
+
+```yaml
+Imports: RcppParallel
+LinkingTo: RcppParallel
+```
+
+And the following to your NAMESPACE file:
+
+```s
+import(RcppParallel)
+```
+
+### License
+
+The RcppParallel package is made available under the [GPLv2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.html).
+
+The TinyThread library is licensed under the [zlib/libpng](http://www.opensource.org/licenses/zlib-license.php) license as described [here](https://gitorious.org/tinythread/tinythreadpp/source/master:README.txt).
+
+The Intel TBB Library is licensed under the GPLv2 (as described at https://www.threadingbuildingblocks.org/Licensing):
+
+TBB and other open-source software available from this site is licensed under GPLv2 with the (libstdc++) runtime exception. Specifically, the TBB open-source license is the same license used by the GNU libstdc++ library in gcc 4.2.1 (and earlier). For a complete description of the license, please visit the official GNU website for [GPLv2](http://www.gnu.org/licenses/old-licenses/gpl-2.0.html) and for the [runtime exception](https://www.threadingbuildingblocks.org/licensing#runtime-exception). 
+
+**Runtime Exception**
+
+```
+As a special exception, you may use this file as part of a free software
+library without restriction.  Specifically, if other files instantiate
+templates or use macros or inline functions from this file, or you compile
+this file and link it with other files to produce an executable, this
+file does not by itself cause the resulting executable to be covered by
+the GNU General Public License.  This exception does not however
+invalidate any other reasons why the executable file might be covered by
+the GNU General Public License.
+```
+
diff --git a/man/RcppParallel-package.Rd b/man/RcppParallel-package.Rd
@@ -0,0 +1,16 @@
+\docType{package}
+\name{RcppParallel-package}
+\alias{RcppParallel}
+\alias{RcppParallel-package}
+\title{Parallel programming tools for Rcpp}
+\description{
+  High level functions for doing parallel programming with Rcpp.
+  For example, the parallelFor function can be used to convert the work of 
+  a standard serial "for" loop into a parallel one and the parallelReduce 
+  function can be used for accumulating aggregate or other values.
+}
+\author{
+  JJ Allaire \email{jj@rstudio.com}
+}
+\keyword{package}
+
diff --git a/man/setThreadOptions.Rd b/man/setThreadOptions.Rd
@@ -2,11 +2,11 @@
 \alias{setThreadOptions}
 \alias{defaultNumThreads}
 \title{
-Thread options for TBB
+Thread options for RcppParallel
 }
 \description{
 Set thread options (number of threads to use for task scheduling and stack
-size per-thread) for TBB.
+size per-thread) for RcppParallel.
 }
 \usage{
 setThreadOptions(numThreads = "auto", 
@@ -22,18 +22,19 @@ defaultNumThreads()
   \item{stackSize}{
       Stack size (in bytes) to use for worker threads. The 
       default used for "auto" is 2MB on 32-bit systems and
-      4MB on 64-bit systems.
+      4MB on 64-bit systems (note that this parameter has
+      no effect on Windows).
    }
 }
 \details{
-   The TBB library is automatically initialized with the default number
+   RcppParallel is automatically initialized with the default number
    of threads and thread stack size when it loads. You can call 
    \code{setThreadOptions} at any time to change the defaults.
 }
 
 \value{
    The \code{defaultNumThreads} returns the default number of threads
-   that are used by TBB if another value isn't specified using
+   that are used by RcppParallel if another value isn't specified using
    \code{setThreadOptions}.
 }
 
diff --git a/man/tbb-package.Rd b/man/tbb-package.Rd

Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,11 @@`
`2`	`2`	`\alias{setThreadOptions}`
`3`	`3`	`\alias{defaultNumThreads}`
`4`	`4`	`\title{`
`5`		`-Thread options for TBB`
	`5`	`+Thread options for RcppParallel`
`6`	`6`	`}`
`7`	`7`	`\description{`
`8`	`8`	`Set thread options (number of threads to use for task scheduling and stack`
`9`		`-size per-thread) for TBB.`
	`9`	`+size per-thread) for RcppParallel.`
`10`	`10`	`}`
`11`	`11`	`\usage{`
`12`	`12`	`setThreadOptions(numThreads = "auto",`
`@@ -22,18 +22,19 @@ defaultNumThreads()`
`22`	`22`	`\item{stackSize}{`
`23`	`23`	`Stack size (in bytes) to use for worker threads. The`
`24`	`24`	`default used for "auto" is 2MB on 32-bit systems and`
`25`		`- 4MB on 64-bit systems.`
	`25`	`+ 4MB on 64-bit systems (note that this parameter has`
	`26`	`+ no effect on Windows).`
`26`	`27`	`}`
`27`	`28`	`}`
`28`	`29`	`\details{`
`29`		`- The TBB library is automatically initialized with the default number`
	`30`	`+ RcppParallel is automatically initialized with the default number`
`30`	`31`	`of threads and thread stack size when it loads. You can call`
`31`	`32`	`\code{setThreadOptions} at any time to change the defaults.`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`\value{`
`35`	`36`	`The \code{defaultNumThreads} returns the default number of threads`
`36`		`- that are used by TBB if another value isn't specified using`
	`37`	`+ that are used by RcppParallel if another value isn't specified using`
`37`	`38`	`\code{setThreadOptions}.`
`38`	`39`	`}`
`39`	`40`