Où puis-je apprendre à écrire du code C pour accélérer les fonctions R lentes? [fermé]

Hadley,

Vous pouvez certainement écrire du code C++ similaire au code C.

Je comprends ce que vous dites à propos de C++ étant plus compliqué que C. c'est si vous voulez tout maîtriser : objets, templates, STL, template meta programming, etc... la plupart des gens n'ont pas besoin de ces choses et peuvent simplement compter sur les autres. La mise en œuvre de Rcpp est très compliquée, mais juste parce que vous ne savez pas comment fonctionne Votre Réfrigérateur, cela ne signifie pas que vous ne pouvez pas ouvrir la porte et saisir le lait frais ...

De vos nombreuses contributions à R, Ce Qui me frappe, c'est que vous trouvez R un peu fastidieux (manipulation de données, graphiques, manipulatio de chaîne, etc...). Eh bien, préparez-vous à beaucoup plus de surprises avec L'API C interne de R. C'est très fastidieux.

De temps en temps, je lis les manuels R-exts ou R-ints. Cela aide. Mais la plupart du temps, quand je veux vraiment savoir quelque chose, je vais dans la source R, et aussi dans la source des paquets écrits par exemple Simon (il y a généralement beaucoup à apprendre là-bas).

Rcpp est conçu pour faire disparaître ces aspects fastidieux de L'API.

Vous pouvez juger par vous-même ce que vous trouvez plus compliqué, obscurci, etc... basée sur quelques exemples. Cette fonction crée un vecteur de caractères à l'aide de L'API C:

SEXP foobar(){
  SEXP ab;
  PROTECT(ab = allocVector(STRSXP, 2));
  SET_STRING_ELT( ab, 0, mkChar("foo") );
  SET_STRING_ELT( ab, 1, mkChar("bar") );
  UNPROTECT(1);
}

En utilisant Rcpp, vous pouvez écrire la même fonction que:

SEXP foobar(){
   return Rcpp::CharacterVector::create( "foo", "bar" ) ;
}

Ou:

SEXP foobar(){
   Rcpp::CharacterVector res(2) ;
   res[0] = "foo" ;
   res[1] = "bar" ;
   return res ;
}

Comme Dirk l'a dit, il y a d'autres exemples sur les différentes vignettes. Nous pointons aussi généralement les gens vers nos tests unitaires parce que chacun d'eux teste une partie très spécifique du code et est un peu explicite.

Je suis évidemment biaisé ici, mais je recommanderais de me familiariser avec Rcpp au lieu d'apprendre l'API C de R, puis de venir à la liste de diffusion si quelque chose n'est pas clair ou ne semble pas faisable avec Rcpp.

De toute façon, fin de l'argumentaire de vente.

Je suppose que tout dépend du type de code que vous voulez écrire éventuellement.

Romain

@hadley: malheureusement, je n'ai pas de ressources spécifiques en tête pour vous aider à démarrer sur C++. Je l'ai ramassé dans les livres de Scott Meyers (efficace c++, plus efficace c++, etc...) mais ce ne sont pas vraiment ce que l'on pourrait appeler l'introduction.

Nous utilisons presque exclusivement le.Interface d'appel pour appeler le code C++. La règle est assez facile :

• la fonction C++ doit renvoyer un objet R. Tous les objets R sont SEXP.
• la fonction C++ prend entre 0 et 65 R objets en entrée (encore SEXP)
• , il doit (pas vraiment, mais on peut l'enregistrer pour plus tard) être déclaré avec une liaison C, soit avec extern "C" ou RcppExport alias Rcpp définit.

Donc un .La fonction d'appel est déclarée comme ceci dans un fichier d'en-tête:

#include <Rcpp.h>

RcppExport SEXP foo( SEXP x1, SEXP x2 ) ;

Et mis en œuvre comme ceci dans un .fichier cpp :

SEXP foo( SEXP x1, SEXP x2 ){
   ...
}

Il n'y a pas beaucoup plus à savoir sur L'API R pour utiliser Rcpp.

La plupart des gens veulent seulement traiter avec numeric vecteurs dans Rcpp. Vous faites cela avec la classe NumericVector. Il existe plusieurs façons de créer un vecteur numérique :

À partir d'un objet existant que vous transmettez depuis R:

 SEXP foo( SEXP x_) {
    Rcpp::NumericVector x( x_ ) ;
    ...
 }

Avec des valeurs données en utilisant la fonction:: create static:

 Rcpp::NumericVector x = Rcpp::NumericVector::create( 1.0, 2.0, 3.0 ) ;
 Rcpp::NumericVector x = Rcpp::NumericVector::create( 
    _["a"] = 1.0, 
    _["b"] = 2.0, 
    _["c"] = 3
 ) ;

D'une taille donnée:

 Rcpp::NumericVector x( 10 ) ;      // filled with 0.0
 Rcpp::NumericVector x( 10, 2.0 ) ; // filled with 2.0

Ensuite, une fois que vous avez un vecteur, le plus utile est d'en extraire un élément. Ceci est fait avec l'opérateur [], avec une indexation basée sur 0, donc par exemple la somme des valeurs d'un vecteur numérique va quelque chose comme ceci:

SEXP sum( SEXP x_ ){
   Rcpp::NumericVector x(x_) ;
   double res = 0.0 ;
   for( int i=0; i<x.size(), i++){
      res += x[i] ;
   }
   return Rcpp::wrap( res ) ;
}

Mais avec Rcpp sugar nous pouvons le faire beaucoup plus bien maintenant:

using namespace Rcpp ;
SEXP sum( SEXP x_ ){
   NumericVector x(x_) ;
   double res = sum( x ) ;
   return wrap( res ) ;
}

Comme je l'ai déjà dit, tout dépend du type de code que vous voulez écrire. Regardez ce que les gens font dans les paquets qui s'appuient sur Rcpp, vérifiez les vignettes, les tests unitaires, revenez nous sur la liste de diffusion. Nous sommes toujours heureux d'aider.

@jbremnant: C'est vrai. Les classes Rcpp implémentent quelque chose de proche du modèle RAII. Lorsqu'un objet Rcpp est créé, le constructeur prend les mesures appropriées pour s'assurer que L'objet R sous-jacent (SEXP) est protégé du garbage collector. Le destructeur retire la protection. Ceci est expliqué dans la vignetteRcpp-intrduction . L'implémentation sous-jacente repose sur les fonctions R API R_PreserveObject et R_ReleaseObject

Il y a en effet pénalité de performance due à l'encapsulation c++. Nous essayons de garder cela au minimum avec inlining, etc... La pénalité est faible, et quand vous prenez en compte le gain en termes de temps qu'il faut pour écrire et maintenir le code, ce n'est pas pertinent.

Appeler des fonctions R à partir de la fonction de classe Rcpp est plus lent que d'appeler directement eval avec l'api C. C'est parce que nous prenons des précautions et enveloppons l'appel de fonction dans un bloc tryCatch afin de capturer les erreurs R et de les promouvoir en C++ exceptions afin qu'elles puissent être traitées en utilisant le try/catch standard en C++.

La plupart des gens veulent utiliser des vecteurs (spécialement NumericVector), et la pénalité est très faible avec cette classe. Le répertoire examples/ConvolveBenchmarks contient plusieurs variantes de la fonction convolution notoire de R-exts et la vignette a des résultats de référence. Il s'avère que Rcpp le rend plus rapide que le code de référence qui utilise L'API R.