Berechnung der Zeit zum Erstellen von n Threads

Question

Ich versuche, 1000 Threads zu erstellen, so dass ich wissen kann, wie viel Zeit es dauert, um sie zu erstellen. Ich benutze Pthreads. Aber ich bekomme segmentation fault: 11. Googling sagt mir, dass es der Fall der Verwendung von zu viel Speicher ist, aber ich bezweifle, dass es möglich ist Grund.

Irgendwelche Hinweise, was könnte der Grund sein?

Code:

int main(int argc , char *argv[]) 
{ 
    int *i;   // Matti's answer below: ... = (int*)malloc(sizeof(int)); 
    *i = 0; 
    while(*i < 100) 
    { 
    pthread_t thread_id; 
    puts("Connection accepted"); 
    if(pthread_create(&thread_id , NULL , connection_handler , (void*) &i) < 0) 
    { 
     error("could not create thread"); 
     return 1; 
    } 

    //pthread_detach(thread_id); 
    *i = *i + 1; 
    } 

    return 0; 
} 

void *connection_handler(void *i) 
{ 
    sleep(1); 
    return 0; 
} 

Answer 1

Ihr Problem wäre die Tatsache, dass Sie einen Zeiger sind dereferencing, die nie initialisiert wurde:

int *i; 
*i = 0; 

Was mit nur int i; falsch?

Answer 2

googeln es mir sagt, dass es könnte der Fall von zu viel Speicher mit

auf Ubuntu 15.10 und mit g ++ v5.2.1, die

default stack size per thread is 8M bytes 

Somit 1000 * 8M könnte so viel wie 8G Bytes sein.

Meine ältere Dell hat nur 4 GB Bytes, insgesamt, von dram. Ich denke, das könnte bedeuten, dass mehr als die Hälfte der Thread-Stacks in die Swap-Partition hinein- oder herausrollt.

Nicht sicher, ob Sie Zeit damit verbringen wollen, das zu messen oder sich darüber Gedanken zu machen.

---

By the way, fädelt Kontextwechsel sehr langsam sind, etwa 3 Größenordnungen langsamer als Funktion/Methode Anrufe ... setze sie mit Bedacht.

auf meinem älteren Dell - mit C++ _ 11 Gewinde und std :: Mutex:

 50 nano seconds per std::mutex lock and std::mutex::unlock 
~12,000 nano seconds per context switch enforced by std::mutex 

---

Was ich nicht oben im Code-Schnipsel zu sehen war ist :: pthread_exit(). Du könntest möglicherweise ein angemessenes Maß an create und exit machen ... vielleicht beabsichtigst du auch, jeden Thread zu beenden, bevor dir der Speicher ausgeht?

---

update - immer Thread-Stapelgröße Posix

void stackShow() // posix thread stack size 
{ 
    pthread_attr_t tattr; 
    int stat = pthread_attr_init (&tattr); 
    assert(0 == stat); 

    size_t size; 
    stat = pthread_attr_getstacksize(&tattr, &size); 
    assert(0 == stat); 

    std::cout << " ----------------------------------------------------\n" 
      << " getstacksize: (" << stat << ") size is " << size 
      << "\n\n"; 

    stat = pthread_attr_destroy(&tattr); 
    assert(0 == stat); 
}