################################################################################
  Kodowanie Windows-1250, koniec wiersza CR+LF, test: Za gl ja
  FreeList - Bardzo szybki alokator pamici
  Copyleft (C) 2007 Adam Sawicki
  Licencja: GNU LGPL
  Kontakt: mailto:sawickiap@poczta.onet.pl , http://regedit.gamedev.pl/
################################################################################


Modu FreeList rozszerza przestrze nazw common o dwa szablony klas - FreeList
oraz DynamicFreeList. Obiekty tych klas to napisane we wasnym zakresie
alokatory przeznaczone do alokowania duych iloci zmiennych jednego wybranego
typu, ktre dziaaj znaczco szybciej ni standardowe operatory new i delete.

FreeList nadaj si dobrze wszdzie tam, gdzie czsto trzeba alokowa i zwalnia
rne drobiazgi (niekoniecznie mae rozmiarem, bo dziaaj szybciej zarwno dla
maych jak i duych elementw), na przykad struktury czsteczek czy wzy
drzewa BSP.

Zalety:
- Znaczco szybsza alokacja i zwalnianie obiektw.
- Poprawiona Spatial Locality of Reference - lepsze wykorzystanie cache.

Wady:
- Trzeba utworzy FreeList i korzysta z niej przy alokacji i zwalnianiu.
- Z powodu rezerwowania caych duych blokw pamici cz pamici si marnuje.


Rodzaje FreeList
================================================================================

S dwie klasy. Po utworzeniu ich obiektw dalsza obsuga wyglda ju tak samo.

1. Klasa FreeList
Rezerwuje jeden blok o podanej liczbie elementw i jest to maksymalna liczba
elementw, jakie mona z jej uyciem zaalokowa.
Konstruktor:
  FreeList(uint Capacity);

2. Klasa DynamicFreeList
Zarzdza ca kolekcj zarezerwowanych blokw o podanym rozmiarze (liczbie
elementw w jednym bloku), potrafi rezerwowa nowe, a take zwalnia te
kompletnie nieuywane (oczywicie z pewn histerez).
Konstruktor:
  DynamicFreeList(uint BlockCapacity);


Obsuga
================================================================================

#include "Base.hpp"
#include "FreeList.hpp"
using namespace common;

Utworzenie listy:
  FreeList<int> L(1024);
  DynamicFreeList<int> L(1024);

Alokacja domylnym konstruktorem:
(typy atomowe zostaj niezainicjalizowane)
  int *p = L.New();
Alokacja jawnie wywoanym domylnym konstruktorem:
(typy atomowe zostaj zainicjalizowane zerem)
  int *p = L.New_ctor();
Alokacja z wywoaniem konstruktora z parametrami:
(istniej wersje dla 1, 2, 3, 4, 5 parametrw)
  int *p = L.New(123);

Zwolnienie pamici:
(pami musi by przydzielona wczeniej z puli tej listy)
  L.Delete(p);

Sprawdzanie stanu i statystyki - metody:
- IsEmpty, IsFull
- GetUsedCount, GetFreeCount, GetCapacity, GetUsedSize itd...

Uwagi
--------------------------------------------------------------------------------

Przed ususniciem obiektu listy zwolnione musz by wszystkie zaalokowane z jej
uyciem elementy. Jest to sprawdzane za pomoc asercji.

Kada z wersji metod do alokacji New ma te wersj o nazwie TryNew, ktra w
przypadku bdu (brak miejsca w bloku pamici) nie rzuca wyjtku std::bad_alloc
jak tamte, tylko zwraca NULL.


Wydajno
================================================================================

Pomiar dla 10240 losowych alokacji lub zwolnie (90% szansa na alokacj, 10% na
zwolnienie, na kocu zwolnienie pozostaych zmiennych):

DEBUG:
Element typu int:
  FreeList : 68.0636 ms
  DynamicFreeList : 184.441 ms
  new i delete : 78.8142 ms
Element typu zajmujacego 1024 bajty:
  FreeList : 69.3896 ms
  DynamicFreeList : 203.506 ms
  new i delete : 93.2942 ms
RELEASE:
Element typu int:
  FreeList : 7.87224 ms
  DynamicFreeList : 11.4786 ms
  new i delete : 17.0348 ms
Element typu zajmujacego 1024 bajty:
  FreeList : 9.18059 ms
  DynamicFreeList : 18.0729 ms
  new i delete : 24.0537 ms

