8.7 Приклад - розподільник пам'яті

У Розділі 5 ми представили дуже обмежений, орієнтований на стек розподільник пам'яті. Версія, яку ми зараз напишемо не має обмежень. Виклики malloc і free можуть відбуватися в будь-якій послідовності; malloc звертається до операційної системи, щоб отримати більше пам'яті, коли в цьому виникає необхідність. Ці функції демонструють деякі міркування при написанні машинонезалежного коду у відносно машинонезалежний спосіб, а також ілюструють реальне застосування структур, сполук і typedef.

Замість того, щоб призначити вкомпільований, сталого розміру масив, malloc звертатиметься із запитом щодо пам'яті до операційної системи по мірі необхідності. Оскільки інші дії в програмі можуть також вимагати місця без виклику розподільника, пам'ять яку відводить malloc може виявитись несуміжною. Тому вільне місце зберігається як список вільних блоків. Кожний блок включає інформацію про власний розмір, покажчик на наступний блок і, власне, вільне місце. Блоки зберігаються в послідовності зростання адрес пам'яті, і покажчик останнього блока (з найбільшою адресою) вказує на перший.

.---. .-----------------. .-------------. .----. .---.

| | | | | | | | | |

----+---+-|-+-v-|-+-------+-----+-v-|-+---+-----+-v-|-+--v-|-+-v-+---

::::|in | | | in | in | |:::| in | | | |:::

::::|use| | | use | use | |:::| use | | | |:::

----+---+---+-----+-------+-----+-----+---+-----+-----+------+-|-+---

^ |

| |

`----------------------------------------------------'

+-----+

| | вільна пам'ять, яка належить malloc

+-----+

+-----+

| in | задіяна пам'ять, яка належить malloc

| use |

+-----+

+-----+

|:::::| пам'ять, яка не належить malloc

+-----+

Під час запиту перевіряється вільний список доти, доки не буде знайдено досить великого блока. Цей алгоритм називається «алгоритмом першого збігу», на відміну від «алгоритму найкращого збігу», який шукає найменший блок, що задовільнить запит. Якщо розмір блока збігається з запитаним, його буде вилучено зі списку і повернено користувачеві. Якщо блок завеликий, його буде поділено і належна кількість повернено користувачеві, тоді як залишок зостанеться у вільному списку. Якщо не знайдено досить великого блока, операційна система надасть великий відрізок пам'яті, який буде приєднано до вільного списку.

Звільненя також спричиняє до пошуку списку вільної пам'яті, щоб знайти відповідне місце, щоб вставити звільнений блок. Якщо звільнений блок суміжний з вільним блоком з будь-якого боку, ці два буде об'єднано в один більший блок, щоб запобігти фрагментації пам'яті. Визначити суміжність легко, оскільки вільний список зберігається в послідовності зростання адрес.

Одна проблема, якої ми не торкнулися в Розділі 5, це впевненість, що пам'ять повернена mallocналежно вирівняно для об'єктів, які там зберігатимуться. Незважаючи на те, що різні машини відрізняються, для кожної існує найбільший обмежувальний тип: якщо цей тип можна зберегти за певною адресою, то решту типів можна також. На деяких машинах найбільшим обмежувальним типом є double, на інших достатньо int або long.

Вільний блок містить покажчик на наступний вільний блок у низці, запис розміру блока і потім, власне, вільне місце; керівна інформація напочатку називається «заголовком». Для спрощення вирівнювання, всі блоки є кратними розміру заголовка, і самий заголовок вирівнено відповідно. Цього досягнуто за допомогою сполуки, яка містить відповідну структуру заголовка і приклад найбільшого обмежувального типу вирівнювання, який ми довільно зробили long:

typedef long Align; /* для вирівнювання до межі long */

union header { /* заголовок блока */

struct {

union header *ptr; /* наступний блок, якщо є у списку вільних */

unsigned size; /* розмір цього блока */

} s;

Align x; /* примусити вирівнювання блоків */

};

typedef union header Header;

Поле Align ніколи не використовується, воно просто змушує, щоб кожний заголовок було вирівнено у межах найгіршого випадку.

У випадку malloc, запитаний розмір у символах округлюється вверх до відповідного числа одиниць заголовкового розміру; блок, який буде відведено міститиме одну або більше одиницю для самого заголовка, і це значення буде внесено в поле size заголовка. Покажчик, поверненийmalloc вказує на вільне місце пам'яті, а не на заголовок. Користувач може робити все, що йому заманеться із наданим вільним місцем, але, якщо щось записати поза межі призначеної пам'яті, найімовірніше, що список буде зіпсовано.

.-------> вказує на наступний вільний блок

+--|--+------+------------------------------+

| | size | |

+-----+------+------------------------------+

^

| адреса повернена користувачеві

`-------------------------------

Блок, який повертає malloc

Поле size обов'язкове, оскільки блоки, контрольовані malloc, не обов'язково повинні бути нрперервними, тож немає ніякої можливості обчислити розмір за допомогою покажчикової арифметики.

Для початку використовується змінна base. Якщо freep має значення NULL, як і повинно бути при першому виклику malloc, тоді буде утворено деградований список вільної пам'яті, що міститиме один блок розміром нуль і вказуватиме самий на себе. В будь-якому разі, після цього відбудеться пошук по списку вільної пам'яті. Пошук вільного блока відповідного розміру розпочнеться з місця (freep), де було знайдено останній блок; така стратегія допомагає зберегти список однорідним. Якщо знайдено завеликий блок, користувачеві буде повернено кінцеву (хвостову) частину, таким чином заголовок оригінальної повинен лиш змінити свій розмір. В усякому випадку, користувачу повертається покажчик, що вказує на вільне місце всредині блока, що бере свій початок з наступною одиницею після заголовка.

static Header base; /* очищаємо список дле початку */

static Header *freep = NULL; /* започатковуємо список вільної

пам'яті */

/* malloc: розподільник пам'яті загального призначення */

void *malloc(unsigned nbytes)

{

Header *p, *prevp;

Header *moreroce(unsigned);

unsigned nunits;

nunits = (nbytes + sizeof(Header) - 1) / sizeof(header) + 1;

if ((prevp = freep) == NULL) { /* ще немає вільного списку */

base.s.ptr = freeptr = prevptr = &base;

base.s.size = 0;

}

for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr) {

if (p->s.size >= nunits) { /* достатньо великий */

if (p->s.size == nunits) /* точно */

prevp->s.ptr = p->s.ptr;

else { /* виділити хвостову частину */

p->s.size -= nunits;

p += p->s.size;

p->s.size = nunits;

}

freep = prevp;

return (void *) (p + 1);

}

if (p == freep) /* звернений на себе вільний список */

if ((p = morecore(nunits)) == NULL)

return NULL; /* нічого не залишилось */

}

}

Функція morecore добуває пам'ять від операційної системи. Подробиці щодо того як саме вона це здійснює можуть відрізнятися на різних системах. Це тому, що запит операційної системи щодо пам'яті, це доволі громіздка операція, ми не хочемо цього робити з кожним викликомmalloc, тож morecore вимагає щонайменше NALLOC одиниць; цей більший блок буде розбито по мірі необхідності. Після встановлення поля size, morecore привносить додаткову пам'ять в поле зору, викликаючи free.

Системний виклик Юнікса sbrk(n) повертає покажчик на на n байтів більшу кількість пам'яті.sbrk повертає -1, якщо не залишилося місця, навіть якщо NULL було би кращим значенням. -1потрібно звести в char *, щоб його можна було порівняти з поверненим значенням. Знову ж таки, зведення роблять функцію відносно невразливою до деталей представлення покажчиків на різноманітних машинах. Проте існує одне припущення, що покажчики на різні блоки, поверненіsbrk, можна змістовно порівнювати. Це не гарантовано стандартом, який який дозволяє порівняння покажчиків тільки в межах того самого масиву. Таким чином, ця версія mallocпортабельна тільки серед машин, де загальне порівнювання покажчиків має сенс.

#define NALLOC 1024 /* мінімальна кількість одиниць, яку

слід запитати */

/* morecore: звертається до системи по додаткову пам'ять */

static Header *morecore(unsigned nu)

{

char *cp, *sbrk(int);

Header *up;

if (nu < NALLOC)

nu = NALLOC;

cp = sbrk(nu * sizeof(Header));

if (cp == (char *) -1) /* зовсім не залишилось місця */

return NULL;

up = (Header *) cp;

up->s.size = nu;

free((void *) (up + 1));

return freep;

}

free сама по собі йде останньою. Вона сканує список вільної пам'яті, починаючи з freep, шукаючи місце, де можна вставити вільний блок. Це або між двома вже наявними блоками, або в кінці списку. В будь-якому разі, якщо звільнений блок прилягає до сусіднього, ці два блоки об'єднано в один. Єдина проблема в тому, щоб покажчики вказували на правильне місце і розміри були дійсними.

/* free: додає блок ap до списку вільної пам'яті */

void free(void *ap)

{

Header *bp, *p;

bp = (Header *) ap - 1; /* покажчик на заголовок блока */

for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)

if (p >= p->s.ptr && (bp > p || bp < p->s.ptr))

break; /* звільнений блок напочатку чи вкінці */

if (bp + bp->size == p->s.ptr) { /* об'єднати до верхнього nbr */

bp->s.size += p->s.ptr->s.size;

bp->s.ptr = p->s.ptr->s.ptr;

} else

bp->s.ptr = p->s.ptr;

if (p + p->size == bp) { /* об'єднати до нижнього nbr */

p->s.size += bp->s.size;

p->s.ptr = bp->s.ptr;

} else

p->s.ptr = bp;

freep = p;

}

Незважаючи на те, що операція розподілу пам'яті за визначенням машинозалежна, вищенаведений код демонструє як залежність від машини може бути контрольвана та обмежена дуже маленькою частиною програми. Використання typedef та union (сполук) допомагає з вирівнюванням (за умови, що sbrk забезпечить належним покажчиком). Зведення влаштовують, щоб перетворення покажчиків були явними, і навіть справляються з погано розробленим інтерфейсом. Хоча деталі, оговорені тут, стосуються розподілу пам'яті, загальний підхід може застосовуватись так само для інших ситуацій.

Вправа 8-6. Функція стандартної бібліотеки calloc(n, size) повертає покажчик на n об'єктів розміром size, з пам'ятю ініційованою до нуля. Напишіть calloc, викликаючи malloc, або модифікуючи його.

Вправа 8-7. malloc приймає запити розміру без перевірки їхньої вірогідності; free вірить в те, що блок, який вона звільняє містить чинне поле size. Вдоскональте ці функції, щоб вони докладали більше зусиль до перевірки на помилки.

Вправа 8-8. Напишіть функцію bfree(p,n), яка би звільняла довільний блок p на n символів, передаючи їх спискові вільної пам'яті, який підтримує malloc і free. За допомогою bfreeкористувач могтиме коли-завгодно додати статичний чи зовнішній масив до списку вільної пам'яті.

* * *

Додаток А: Довідковий посібник

А.1 Введення

У цьому посібнику описується мова C як зазначено чернеткою, поданою ANSI 31-го жовтня 1988-го року, для схвалення як «Американського стандарту інформаційних систем — мова програмування C, X3.159-1989». Цей посібник являється інтерпретацією висунутого стандарту, а не самим стандартом, хоч було відведено багато уваги, щоб зробити його надійним керівництвом до мови.

Здебільшого, цей документ слідує основним рисам стандарту, який в свою чергу слідує викладу першого видання цієї книжки, хоча їхня організація трохи відрізняється. За винятком зміни назв декількох похідних і відмови від формалізації визначень лексичних зворотів або препроцесора, подана тут граматика мови еквівалентна стандартові.

У цьому посібнику, коментарі розміщено з відступом і надруковано меншим шрифтом, як от це. Часто, ці коментарі підкреслюють як Стандартна C ANSI відрізняється від мови, визначеній у першому виданні цієї книжки, або від змін, привнесеними подальшими компіляторами.

А.2 Лексичні умовності

Програма складається з однієї або більше об'єктів перекладу, збережених у файлах. Вони перекладаються в декілька етапів, описаних в частині А.12. Перший етап — це низькорівневі лексичні перетворення, слідуючи директивам у рядках, що починаються зі знака #, які здійснюють визначення макросів та їхнє розкриття. Коли попередня обробка, описана в частині А.12, завершилась, програма розбивається на ряд лексем.

А.2.1 Лексеми

Існує шість класів лексем: ідентифікатори, ключові слова, константи, ланцюжкові літерали, оператори та інші розділювачі. Пробіли, горизонтальна та вертикальна табуляція, знаки нового рядка, знаки подання сторінки та коментарі, як описано нижче, (за загальним визначенням — «знаки пропуску») ігноруються за винятком коли це окремі лексеми. Знаки пропуску необхідні для відділення, у протилежному випадку суміжних, ідентифікаторів, ключових слів і констант.

Якщо поток вводу поділено на лексеми до певного знака, то наступною лексемою буде найдовший ланцюжок, що може скласти лексему.

А.2.2 Коментарі

Символи /* розпочинають коментар, який завершують */. Коментарі не гніздуються, вони не повинні з'являтися посередині ланцюжка символьного літералу.

А.2.3 Ідентифікатори

Ідентифікатор - це послідовність з літер і цифр. Першим символом повинна стояти літера; твердий пробіл _ вважається літерою. Літери верхнього та нижнього регістру вважаються різними. Ідентифікатори можуть бути будь-якої довжини, а для внутрішніх ідентифікаторів, принаймні перші 31 знаки являються значимими; у деякий реалізаціях, це число може бути більшим. Внутрішні ідентифікатори можуть складатися з назв макросів препроцесора, і будь-яких імен, що не пов'язані зовнішньо (Розділ А.11.2). На ідентифікатори із зовнішніми зв'язками накладається більше обмежень: деякі реалізації можуть розглядати тільки перші шість наків, як значимі, і можуть ігнорувати регістрові відмінності літер.

А.2.4 Ключові слова

Наступні ідентифікатори зарезервовано для використання, як ключові слова, і не вживаються інакше:

auto double int struct

break else long switch

case enum register typedef

char extern return union

const float short unsigned

continue for signed void

default goto sizeof volatile

do if static while

Деякі реалізації також мають зарезервованими слова fortran та asm.

Ключові слова const, signed та volatile являються новими, привнесеними стандартом ANSI; enum та void являються новими після першого видання книжки, але є загальновживаними; entry, колись зарезервоване, але не використане, більше не вважається зарезервованим.

А.2.5 Константи

Існує декілька типів констант. Кожна належить до якогось типу даних; Розділ А.4.2 розгляне базові типи:

константа: цілочисельна-константа символьна-константа дробова-константа константа-енумератор

А.2.5.1 Цілочисельні константи

Цілочисельна константа, що складається з ряду цифр, вважається вісімковою, якщо починається з 0 (цифра нуль), і десятковою у протилежному випадку. Вісімкові константи не можуть містити цифри 8 та 9. Ряд цифр з попереднім 0x або 0X (нулем та ікс) вважається шістнадцятковим числом, і може включати літери від a або A до f або F, що позначають значення від 10 до 15.

Цілочисельній константі може передувати суфікс u або U, щоб вказати, що вона беззнакова (unsigned). Так само, суфікс l або L вказує на те, що вона довга (long).

Тип чилочисельної константи залежить від її форми, значення та суфікса. (Дивіться Розділ А.4 стосовно обговорення типів.) Якщо суфікса в неї немає і вона є деясятковою, тоді тип її складатиме найпеший цих типів, здатний її представити: int, long int, unsigned long int. Якщо суфікса в неї немає, вона — вісімкова або шістнадцяткова, тип її відповідатиме найпершому можливому з наступних: int, unsigned int, long int, unsigned long int. Якщо вона має суфікс u або U, тоді — unsigned int, unsigned long int. Якщо вона має суфікс l або L, тоді — long int, unsigned long int. Якщо цілочисельна константа має суфікс UL, тоді її тип становитиме unsigned long.

Детальний опис типів цілих тут значно переважає наведений у першому виданні, в якому великі цілочисельні константи просто ставали long. Суфікс U — новий.

А.2.5.2 Символьні константи

Символьна константа — це послідовність з одного або більше символів, включених в одинарні лапки, як от 'x'. Значення символьної сонстанти з одним символом відповідає числовому значенню символу в машинному наборі символів під час виконання програми. Значення багатосимвольної константи залежить від реалізації.

Символьні константи не містять символу ' або знаків нового рядка; для представлення їх, а також деяких інших символів, можна скористатися з наступних екранованих послідовностей:

знак нового рядка	NL(LF)	\n	зворотня похила риска	\	\\
горизонтальна табуляція	HT	\t	знак запитання	?	\?
вертикальна табуляція	VT	\v	одинарна лапка	'	\'
реверс	BS	\b	подвійна лапка	"	\"
повернення каретки	CR	\r	вісімкове число	ooo	\ooo
зміна сторінки	FF	\f	шістнадцяткове число	hh	\xhh
звуковий сигнал	BEL	\a

Екранована послідовність \ooo скадається зі зворотньої похилої, за якою слідують 1, 2 або три вісімкові цифри, які вказують числове значення бажаного символу. Поширеним прикладом такої конструкції служить \0 (без додаткових цифр), який вказує на нульовий символ (NUL). Екранована послідовність \xhh складається зі зворотньої похилої та літери x, за якими слідують шістнадцяткові цифри, які вказують числове значення бажаного символу. Обмеження кількості шістнадцяткових цифр не існує, але поводження — невизначене, якщо отримане в наслідок значення символу перевищує значення найбільшого.

--170--