Aumenta le dimensioni dello stack in Linux con setrlimit

Question

leggendo le informazioni su come aumentare le dimensioni dello stack per un'applicazione C++ compilata con gnu, al momento della compilazione, ho capito che può essere eseguito con setrlimit all'inizio del programma. Tuttavia non sono riuscito a trovare alcun esempio di successo su come usarlo e in quale parte del programma applicarlo per ottenere una dimensione dello stack 64M per un programma C++, qualcuno potrebbe aiutarmi?

Thanlks

Answer 1

Normalmente si dovrebbe impostare la dimensione dello stack nella fase iniziale, e, g, all'inizio del main(), prima di chiamare qualsiasi altra funzione. Tipicamente la logica sarebbe:

• chiamata getrlimit arrivare stack corrente
• se dimensione corrente < stack richiesto quindi
  • chiamata setrlimit aumentare stack di dimensioni richieste

In C che potrebbe essere codificato qualcosa del tipo:

#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

vedere se il massimo di esecuzione runtime è limitarla:

[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 

noti che la dimensione dello stack, per default, è limitato a 10 MiB. Quindi, per aumentare a 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

di andare oltre il limite duro in setrlimit (su OSX il suo solo 64 MB di default), creare un nuovo thread utilizzando pthreads con uno stack di vostra scelta. Ecco un frammento 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; 

    }