web-dev-qa-db-fra.com

Erreur: l'utilisation de la pile C est trop proche de la limite

J'essaie d'exécuter du code récursif assez profond dans R et il continue de me donner cette erreur:

Erreur: l'utilisation de la pile C est trop proche de la limite 

Ma sortie de CStack_info() est:

Cstack_info()
    size    current  direction eval_depth 
67108864       8120          1          2

J'ai beaucoup de mémoire sur ma machine, j'essaye juste de comprendre comment augmenter le CStack pour R.

EDIT: Quelqu'un a demandé un exemple reproductible. Voici un exemple de code de base qui cause le problème. En exécutant f (1,1) plusieurs fois, vous obtiendrez l'erreur. Notez que j'ai déjà défini --max-ppsize = 500000 et les options (expressions = 500000), donc si vous ne les définissez pas, vous risquez d'obtenir une erreur concernant l'une de ces deux choses. Comme vous pouvez le constater, la récursivité peut aller assez loin ici et je ne sais pas comment la faire fonctionner de manière cohérente. Merci.

f <- function(root=1,lambda=1) {
    x <- c(0,1);
    prob <- c(1/(lambda+1),lambda/(lambda+1));
        repeat {
      if(root == 0) {
        break;
      }
      else {
        child <- sample(x,2,replace=TRUE,prob);
        if(child[1] == 0 && child[2] == 0) {
          break;
        }
        if(child[1] == 1) {
          child[1] <- f(root=child[1],lambda);
        }
        if(child[2] == 1 && child[1] == 0) {
          child[2] <- f(root=child[2],lambda);
        }
      }
      if(child[1] == 0 && child[2] == 0) {
        break;
      }
      if(child[1] == 1 || child[2] == 1) {
        root <- sample(x,1,replace=TRUE,prob);
      }
        }
    return(root)
}
r
55
user2045093

La taille de la pile est un paramètre du système d'exploitation, ajustable par processus (voir setrlimit(2) ). Autant que je sache, vous ne pouvez pas l'ajuster à l'intérieur de R, mais vous pouvez l'ajuster à partir du shell avant de démarrer R, avec la commande ulimit. Cela fonctionne comme ceci:

$ ulimit -s # print default
8192
$ R --slave -e 'Cstack_info()["size"]'
   size 
8388608

8388608 = 1024 * 8192; R affiche la même valeur que ulimit -s, mais en octets au lieu de kilo-octets.

$ ulimit -s 16384 # enlarge stack limit to 16 megs
$ R --slave -e 'Cstack_info()["size"]'
    size 
16777216
46
zwol

Je soupçonne que, quelle que soit la limite de pile, vous obtiendrez des récursions trop profondes. Par exemple, avec lambda = Inf, f(1) conduit à une récursion immédiate, indéfiniment. La profondeur de la récursion semble être une marche aléatoire, avec une certaine probabilité d'aller plus en profondeur, 1 - r de terminer la récursion actuelle. Au moment où vous atteignez la limite de pile, vous avez effectué un grand nombre de pas «plus profonds». Cela implique que r> 1/2 et la très grande majorité du temps, vous continuerez simplement à récidiver.

De plus, il semble presque possible de trouver une solution analytique ou au moins numérique, même face à une récursion infinie. On peut définir p comme la probabilité que f(1) == 1, écrire des expressions implicites pour les états "enfant" après une seule itération, et les assimiler à p et résoudre. p peut alors être utilisé comme une chance de succès lors d’un tirage unique à partir d’une distribution binomiale.

16
Martin Morgan

Cela m'est arrivé pour une raison complètement différente. J'ai accidentellement créé une chaîne très longue en combinant deux colonnes:

output_table_subset = mutate(big_data_frame,
     combined_table = paste0(first_part, second_part, col = "_"))

au lieu de 

output_table_subset = mutate(big_data_frame,
     combined_table = paste0(first_part, second_part, sep = "_"))

Cela m’a pris à jamais de le comprendre car je ne pensais pas que la pâte était à l’origine du problème. 

6
Alex Joseph

J'ai rencontré le même problème de réception de l'erreur "L'usage de la pile C est trop proche de la limite" (bien que pour une autre application que celle indiquée par l'utilisateur2045093 ci-dessus). J'ai essayé la proposition de Zwol mais ça n'a pas marché.

À ma propre surprise, je pouvais résoudre le problème en installant la dernière version de R pour OS X (actuellement: version 3.2.3) ainsi que la dernière version de R Studio pour OS X (actuellement: 0.99.840), car je travaille avec R Studio.

J'espère que cela vous aidera également.

2
DAW

Un problème ici peut être que vous appelez f à l'intérieur de lui-même 

plop <- function(a = 2){
  pouet <- sample(a)
  plop(pouet)
}
plop()
Erreur : évaluations trop profondément imbriquées : récursion infinie / options(expressions=) ?
Erreur pendant l'emballage (wrapup) : évaluations trop profondément imbriquées : récursion infinie / options(expressions=) ?
1
Colin FAY

Pour la gouverne de tous, je suis soudainement confronté à cela avec R 3.6.1 sur Windows 7 (64 bits). Ce n'était pas un problème auparavant, et maintenant, les limites de pile semblent apparaître partout, lorsque j'essaie de "sauvegarder (.)" Des données ou même de faire un "save.image (.)". C'est comme si la sérialisation balaie ces piles.

J'envisage sérieusement de revenir à 3.6.0. N'est pas arrivé là-bas.

1
Jan Galkowski

Cette erreur n'est pas due à memory c'est à récursion . Une fonction s’appelle elle-même. Pour illustrer ce propos, voici un exemple minimal de 2 fonctions qui s’appellent:

change_to_factor <- function(x){
  x <- change_to_character(x)
  as.factor(x)
} 

change_to_character <- function(x){
  x <- change_to_factor(x)
  as.character(x)
}

change_to_character("1")

Erreur: l'utilisation de la pile C 7971600 est trop proche de la limite

Les fonctions continueront à s’appeler de manière récursive et ne seront théoriquement jamais complètes. Seules des vérifications au sein de votre système empêchent que cela se produise de manière définitive et consomment toutes les ressources de calcul de votre machine. Vous devez modifier les fonctions pour vous assurer qu'elles ne s'appellent pas elles-mêmes (ni l'une l'autre) de manière récursive.

0
Tom Kelly

Une autre façon de causer le même problème:

library(debug)
mtrace(lapply)

L'appel récursif n'est pas aussi évident ici.

0
Quigi

Comme l'a écrit Martin Morgan ... Le problème est que vous rentrez trop profondément dans la récursivité. Si la récursion ne converge pas du tout, vous devez la rompre vous-même. J'espère que ce code fonctionnera, car il n'est pas testé. Cependant, au moins, le point devrait être clair ici.

f <- function(root=1,lambda=1,depth=1) {
 if(depth > 256){
  return(NA)
 }
 x <- c(0,1);
 prob <- c(1/(lambda+1),lambda/(lambda+1));
 repeat {
  if(root == 0) {
    break;
  } else {
   child <- sample(x,2,replace=TRUE,prob);
   if(child[1] == 0 && child[2] == 0) {
     break;
   }
   if(child[1] == 1) {
     child[1] <- f(root=child[1],lambda,depth+1);
   }
   if(child[2] == 1 && child[1] == 0) {
     child[2] <- f(root=child[2],lambda,depth+1);
   }
  }
  if(child[1] == NA | child[2] == NA){
   return NA;
  }
  if(child[1] == 0 && child[2] == 0) {
    break;
  }
  if(child[1] == 1 || child[2] == 1) {
    root <- sample(x,1,replace=TRUE,prob);
  }
 }
 return(root)
}
0
Kamil S Jaron

Si vous utilisez plot_ly, vérifiez les colonnes que vous passez. Il semble que pour les colonnes POSIXdt/ct, vous devez utiliser as.character () avant de passer à plotly ou vous obtenez cette exception!

0
user2330270