Вопрос почему-то опять вызвал интерес. Вот взял и попробовал. Всегда приятно узнавать что-то новое.
Краткий отчет:
Оказалось, что в убунте, если soft limit не установлен, то вместо ожидаемого ENOMEM мы получаем SIGKILL от ядра.
На 64-бит виртуалке с гигом ОЗУ и 2.5 гигами свопа при malloc(1000) этот процесс продолжается всего-то 1.5 минуты !!! (Так что будем считать, что я просто пошутил, утверждая, "что так долго не живут").
После установки лимита на виртуальную память (800 мегов), malloc все-таки стал возвращать 0 и я проверил вопрос о фрагментации.
Действительно, освободив 80 мегов realloc-ом "по месту" (уменьшая каждый блок на 100 байт), не смог выделить 1000 байт malloc-ом, а по 50 байт удалось получить, как не сложно догадаться, только половину из освобожденной ранее памяти.
(Если тестовая программка кому-то интересна, то напишите, завтра вставлю в дополнение ответа.)
(наверное, лучше поздно, чем никогда -))
/* https://drive.google.com/file/d/0BzY1LBmZNGbwbUYtNS01VWVXUG8/view?usp=sharing
show memory fragmentation
use ulimit -a for look limits
ulimit -S -v NNNNN for see malloc returns 0 and try realloc show
or
ulimit -S -v unlimited for SIGKILL if no more memory
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <string.h>
#include <signal.h>
#include <errno.h>
#include <setjmp.h>
#include <sys/sysinfo.h>
#include <unistd.h>
#include <sys/wait.h>
#include <time.h>
struct memblk {
struct memblk *next;
size_t mbsize;
char d[];
};
struct data {
void *addr;
size_t nb;
};
#define M1 (1024 * 1024)
#ifndef SWAP_BOUND
#define SWAP_BOUND 10
/* когда мы выберем весь freeram и freeswap (величины при запуске программы)
кроме SWAP_BOUND доли swap (например 50 это 1/50-я),
мы начинаем слать данные о выделяемой памяти по пайпу для печати
окончательного результата
(поскольку тут уже в любой момент можем получить SIGKILL от ядра)
*/
#endif
sigjmp_buf jmp;
int signo = 0;
void
catch (int sig)
{
signo = sig;
siglongjmp(jmp, sig);
}
/*
время в миллисекундах
*/
static long long
mtime()
{
struct timeval t;
gettimeofday(&t, NULL);
long long mt = (long long)t.tv_sec * 1000 + t.tv_usec / 1000;
return mt;
}
int
main (int ac, char av[])
{
size_t mbsize = av[1] ? atoi(av[1]) : 1000,
n1000 = 0, s1000 = 0;
struct memblk l1000 = 0,
*p;
struct sysinfo info;
sysinfo(&info);
printf("total(free)ram: %ld (%ld) total(free)swap: %ld (%ld) (in %d units)\n",
info.totalram, info.freeram, info.totalswap, info.freeswap,
info.mem_unit);
int chan[2];
pipe(chan);
struct data tr = {0};
long long start = mtime();
pid_t child;
if (child = fork()) {
close(chan[1]);
int s, crit = 0;
while (read(chan[0], &tr, sizeof(tr)) == sizeof(tr))
crit++;
pid_t p = wait(&s);
if (crit)
printf("Fin %d critical blocks\n"
"total %ld blocks %ld bytes (%f MB) %lld msec\n",
crit,
(long)tr.nb, (long)(tr.nb * mbsize),
((double)(tr.nb * mbsize)) / M1, mtime() - start);
else
printf("no final critical data %lld msec\n", mtime() - start);
if (p == child)
if (WIFEXITED(s))
exit(WEXITSTATUS(s));
else
raise(WTERMSIG(s));
return puts("unexepcted exit");
}
int sig;
for (sig = 1; sig < 64; sig++)
if (signal(sig, catch) == SIG_ERR)
printf ("err signo %d\n", sig);
if (sig = sigsetjmp(jmp, 0)) {
printf ("catch sig %d (signo %d)\n",
sig, signo);
exit(0);
}
int done = 0;
while (p = (typeof(p))malloc(mbsize)) {
p->mbsize = mbsize;
p->next = l1000;
l1000 = p;
n1000++;
s1000 += mbsize;
if (n1000 % M1 == 0)
printf ("%ld blocks %ld bytes (%f MB) %lld msec\n",
(long)n1000, (long)s1000, ((double)s1000) / M1, mtime() - start);
else if (n1000 * mbsize > info.freeram * info.mem_unit + info.freeswap * info.mem_unit - info.freeswap * info.mem_unit / SWAP_BOUND) {
tr.nb = n1000;
tr.addr = p;
write(chan[1], &tr, sizeof(tr));
if (!done)
done = 1, printf("begin crit: %ld\n", (long)tr.nb);
}
}
printf ("End %ld blocks %ld bytes (%f MB) %lld msec\n",
(long)n1000, (long)s1000, ((double)s1000) / M1, mtime() - start);
close(chan[0]);
close(chan[1]);
if (p = malloc(5))
puts ("malloc(5) yes");
printf ("malloc(50) %s\n", malloc(50) ? "yes" : "no");
typeof (p) prev = 0, t;
size_t save = 0, d = mbsize / 10;
start = mtime();
for (p = l1000; p; p = p->next) {
if (t = realloc(p, p->mbsize - d)) {
t->mbsize -= d;
if (t != p) {
puts ("new addr");
if (prev)
prev->next = t;
else
l1000 = t;
}
prev = p = t;
save += d;
} else {
puts ("can't realloc");
exit(1);
}
}
printf ("realloc d: %ld sum: %ld (%lld msec)\n",
(long)d, (long)save, mtime() - start);
printf ("malloc(1000) again: %s\n", malloc(mbsize) ? "yes" : "no");
save = 0;
while (malloc(50))
save += 50;
printf ("malloc(50) = %ld\n", (long)save);
return 0;
}
Почему в 64-bit практически невероятно?
Например потому, что на создание такой ситуации уйдет слишком много времени.
Про винду не знаю, а в линуксе память под большие объекты каждый раз запрашивается у ядра в виде целого числа страниц. Реально ядро может выделять и несмежные физические страницы, которые отображаются в непрерывный диапазон виртуальной памяти. При освобождении они возвращаются и дефрагментации не происходит.
Ожидаемой Вами дефрагментации с кусками меньшими 4К добиться, наверное, можно, но такое время программы не живут.
– avp Jan 07 '13 at 21:24@avp живут, живут. Гигабайты свопа -- величина не бесконечная. :)
– alexlz Jan 08 '13 at 03:11Если коротко, то проблема во времени, затрачиваемом на пэйджинг в такой ситуации с нехваткой памяти.
– avp Aug 13 '13 at 16:26