Verfügbare Speicher nach Adresse von malloc zurück

Question

ich diese So schrieb (Eigentlich versuchen zu sehen, ob realloc war O (n) -ish oder nicht):

int main() { 
time_t t1,t2; 
char* x=malloc(sizeof(char)); 
char* y=x; 
printf("%p %p\n",(void*)x,(void*)y); 
double tot_time=0.0; 
double time_r=0.0; 
size_t s=2; 
for(;;s++) { 
    t1=clock(); 
    x=realloc(x,s*sizeof(char)); 
    t2=clock(); 
    if(x!=y) break; 
    time_r=difftime(t2,t1)/CLOCKS_PER_SEC; 
    //printf("%p %p %zu %f secs\n",(void*)x,(void*)y,s,time_r); 
    tot_time+=time_r; 
} 

printf("%zu elements %f secs\n",s,tot_time); 
return 0;} 

, die mit einer ständig Inkrementieren Größe reallocs (von 1 byte) der von malloc am Anfang zurückgegebene Speicher, bis eine andere Adresse zurückgegeben wird. Wenn so etwas passiert, wird es Ihnen sagen, wie viel Speicher nach der von malloc zurückgegebenen Anfangsadresse zugewiesen werden konnte.

Meine Frage ist: Auf einer Maschine mit Linux (in meinem Fall Ubuntu 14.04 64bits) gibt es eine Möglichkeit, vor der Hand zu wissen, wie viel kann der Speicher, auf den x zeigt, expandieren?

Answer 1

Das ist wirklich schwierig. Sehen Sie sich den folgenden Code an. Insbesondere benutze ich malloc_userable_size, um anzuzeigen, was tatsächlich beim letzten Aufruf von realloc zugewiesen wurde.

Dies gilt Faktor auch nicht in irgendwelchen Auswirkungen, dass eine Anwendung könnte also einige Anwendungen haben Blöcke in bestimmten Bereichen mehr als andere zuteilen und die Umsetzung von realloc auf je dies einen großen Einfluss auf die Leistung haben kann.

Realloc kopiert in den meisten Fällen keine Daten, dh es wird nicht gezwungen, mindestens O (n) zu sein, es wird normalerweise ein Zeiger eingestellt. Wenn es Daten kopieren muss, ist es bestenfalls O (n), aber das wird von der Anwendung bestimmt.

#include <assert.h> 
#include <malloc.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <time.h> 

int main(void) { 
    time_t t1; 
    time_t t2; 
    double tot_time = 0.0; 
    double time_r = 0.0; 
    size_t s  = 2; 

    char *x = malloc(sizeof(char)); 
    char *y = x; 

    printf("%p %p\n",(void*)x,(void*)y); 

    for(;;s++) { 
    t1 = clock(); 
    printf("s=%zu usable=%zu\n", s, malloc_usable_size(x)); 
    x = realloc(x, s * sizeof(char)); 
    assert(x != NULL); 
    t2 = clock(); 
    if(x != y) { 
     break; 
    } 
    time_r = difftime(t2, t1)/CLOCKS_PER_SEC; 
    //printf("%p %p %zu %f secs\n",(void*)x,(void*)y,s,time_r); 
    tot_time += time_r; 
    } 
    printf("%zu elements %f secs\n", s, tot_time); 
    return 0; 
} 

Answer 2

malloc_usable_size() Gibt die Anzahl der nutzbaren Bytes, die dem Zeiger zugeordnet werden können