Aumente el tamaño de la pila en Linux con setrlimit

Question

leyendo información acerca de cómo aumentar el tamaño de la pila para una aplicación de C++ compilada con gnu, en tiempo de compilación, entendí que se puede hacer con setrlimit al principio del programa. Sin embargo, no pude encontrar ningún ejemplo exitoso sobre cómo usarlo y en qué parte del programa aplicarlo para obtener un tamaño de pila de 64M para un programa de C++. ¿Alguien podría ayudarme?

Thanlks

Answer 1

Normalmente debería definir el tamaño de la pila desde el principio, e, g, al inicio del main(), antes de llamar a cualquier otra función. Normalmente, la lógica sería:

• llamada getrlimit conseguir tamaño de pila actual
• si el tamaño actual < tamaño de la pila requerida a continuación
  • llamada setrlimit para aumentar tamaño de la pila de tamaño requerido

En C que podría estar codificado algo como esto:

#include <sys/resource.h> 

int main (int argc, char **argv) 
{ 
    const rlim_t kStackSize = 64L * 1024L * 1024L; // min stack size = 64 Mb 
    struct rlimit rl; 
    int result; 

    result = getrlimit(RLIMIT_STACK, &rl); 
    if (result == 0) 
    { 
     if (rl.rlim_cur < kStackSize) 
     { 
      rl.rlim_cur = kStackSize; 
      result = setrlimit(RLIMIT_STACK, &rl); 
      if (result != 0) 
      { 
       fprintf(stderr, "setrlimit returned result = %d\n", result); 
      } 
     } 
    } 

    // ... 

    return 0; 
} 

Answer 2

ver si el tiempo de ejecución máximo de ejecución es limitante que:

[wally@zf conf]$ ulimit -all 
core file size   (blocks, -c) 0 
data seg size   (kbytes, -d) unlimited 
scheduling priority    (-e) 0 
file size    (blocks, -f) unlimited 
pending signals     (-i) 16114 
max locked memory  (kbytes, -l) 32 
max memory size   (kbytes, -m) unlimited 
open files      (-n) 1024 
pipe size   (512 bytes, -p) 8 
POSIX message queues  (bytes, -q) 819200 
real-time priority    (-r) 0 
stack size    (kbytes, -s) 10240 
cpu time    (seconds, -t) unlimited 
max user processes    (-u) 16114 
virtual memory   (kbytes, -v) unlimited 
file locks      (-x) unlimited 

Tenga en cuenta que el tamaño de pila, de forma predeterminada, se limita a 10 MiB. Así que para aumentar la cantidad hasta 64 MiB:

[wally@zf conf]$ ulimit -s 64M 
-bash: ulimit: 64M: invalid number 
[wally@zf conf]$ ulimit -s 65536 
[wally@zf conf]$ ulimit -all 
core file size   (blocks, -c) 0 
data seg size   (kbytes, -d) unlimited 
scheduling priority    (-e) 0 
file size    (blocks, -f) unlimited 
pending signals     (-i) 16114 
max locked memory  (kbytes, -l) 32 
max memory size   (kbytes, -m) unlimited 
open files      (-n) 1024 
pipe size   (512 bytes, -p) 8 
POSIX message queues  (bytes, -q) 819200 
real-time priority    (-r) 0 
stack size    (kbytes, -s) 65536 
cpu time    (seconds, -t) unlimited 
max user processes    (-u) 16114 
virtual memory   (kbytes, -v) unlimited 
file locks      (-x) unlimited 

Answer 3

ir más allá del límite duro en setrlimit (en OSX su único 64MB por defecto), cree un nuevo hilo utilizando pthreads con un tamaño de pila de su elección. He aquí un fragmento C:

// Call function f with a 256MB stack. 
    static int bigstack(void *(*f)(void *), void* userdata) { 

     pthread_t thread; 
     pthread_attr_t attr; 

     // allocate a 256MB region for the stack. 
     size_t stacksize = 256*1024*1024; 
     pthread_attr_init(&attr); 
     pthread_attr_setstacksize(&attr, stacksize); 

     int rc = pthread_create(&thread, &attr, f, userdata); 
     if (rc){ 
     printf("ERROR: return code from pthread_create() is %d\n", rc); 
     return 0; 
     } 
     pthread_join(thread, NULL); 
     return 1; 

    }