Jakie są zastosowania „nowego miejsca docelowego”?

Czy ktoś tutaj kiedykolwiek używał „nowego miejsca docelowego” w C ++? Jeśli tak, to po co? Wydaje mi się, że przydałby się tylko na sprzęcie odwzorowanym w pamięci.

Umieszczenie nowego pozwala skonstruować obiekt w pamięci, który jest już przydzielony.

Możesz to zrobić w celu optymalizacji, gdy musisz zbudować wiele instancji obiektu, a szybsze jest nie przydzielanie pamięci za każdym razem, gdy potrzebujesz nowej instancji. Zamiast tego bardziej wydajne może być wykonanie pojedynczej alokacji dla części pamięci, która może pomieścić wiele obiektów, nawet jeśli nie chcesz korzystać z nich jednocześnie.

DevX daje dobry przykład :

Standardowy C ++ obsługuje także umieszczanie nowego operatora, który konstruuje obiekt na wstępnie przydzielonym buforze. Jest to przydatne podczas budowania puli pamięci, modułu wyrzucania elementów bezużytecznych lub po prostu, gdy najważniejsze są bezpieczeństwo wydajności i wyjątków (nie ma niebezpieczeństwa niepowodzenia alokacji, ponieważ pamięć została już przydzielona, ​​a budowa obiektu na wstępnie przydzielonym buforze zajmuje mniej czasu) :

char *buf  = new char[sizeof(string)]; // pre-allocated buffer
string *p = new (buf) string("hi");    // placement new
string *q = new string("hi");          // ordinary heap allocation

Możesz także mieć pewność, że nie wystąpi błąd alokacji w określonej części kodu krytycznego (na przykład w kodzie wykonywanym przez rozrusznik serca). W takim przypadku należy wcześniej przydzielić pamięć, a następnie użyć umieszczenia nowego w sekcji krytycznej.

Dezalokacja w miejscu docelowym nowość

Nie należy cofać przydziału każdego obiektu używającego bufora pamięci. Zamiast tego powinieneś usunąć [] tylko oryginalny bufor. Będziesz musiał ręcznie wywołać destruktory swoich klas. Dobra sugestia na ten temat znajduje się w FAQ Stroustrup na temat: Czy istnieje „usunięcie miejsca docelowego” ?

Używamy go z niestandardowymi pulami pamięci. Tylko szkic:

class Pool {
public:
    Pool() { /* implementation details irrelevant */ };
    virtual ~Pool() { /* ditto */ };

    virtual void *allocate(size_t);
    virtual void deallocate(void *);

    static Pool::misc_pool() { return misc_pool_p; /* global MiscPool for general use */ }
};

class ClusterPool : public Pool { /* ... */ };
class FastPool : public Pool { /* ... */ };
class MapPool : public Pool { /* ... */ };
class MiscPool : public Pool { /* ... */ };

// elsewhere...

void *pnew_new(size_t size)
{
   return Pool::misc_pool()->allocate(size);
}

void *pnew_new(size_t size, Pool *pool_p)
{
   if (!pool_p) {
      return Pool::misc_pool()->allocate(size);
   }
   else {
      return pool_p->allocate(size);
   }
}

void pnew_delete(void *p)
{
   Pool *hp = Pool::find_pool(p);
   // note: if p == 0, then Pool::find_pool(p) will return 0.
   if (hp) {
      hp->deallocate(p);
   }
}

// elsewhere...

class Obj {
public:
   // misc ctors, dtors, etc.

   // just a sampling of new/del operators
   void *operator new(size_t s)             { return pnew_new(s); }
   void *operator new(size_t s, Pool *hp)   { return pnew_new(s, hp); }
   void operator delete(void *dp)           { pnew_delete(dp); }
   void operator delete(void *dp, Pool*)    { pnew_delete(dp); }

   void *operator new[](size_t s)           { return pnew_new(s); }
   void *operator new[](size_t s, Pool* hp) { return pnew_new(s, hp); }
   void operator delete[](void *dp)         { pnew_delete(dp); }
   void operator delete[](void *dp, Pool*)  { pnew_delete(dp); }
};

// elsewhere...

ClusterPool *cp = new ClusterPool(arg1, arg2, ...);

Obj *new_obj = new (cp) Obj(arg_a, arg_b, ...);

Teraz możesz grupować obiekty razem w jednej arenie pamięci, wybierać alokator, który jest bardzo szybki, ale nie dokonuje dealokacji, używa mapowania pamięci i innych semantycznych, które chcesz narzucić, wybierając pulę i przekazując ją jako argument do umiejscowienia obiektu nowy operator.

Jest to przydatne, jeśli chcesz oddzielić alokację od inicjalizacji. STL używa nowego umieszczania do tworzenia elementów kontenera.

Użyłem go w programowaniu w czasie rzeczywistym. Zazwyczaj nie chcemy przeprowadzać żadnego dynamicznego przydzielania (lub zwalniania) po uruchomieniu systemu, ponieważ nie ma gwarancji, jak długo to zajmie.

To, co mogę zrobić, to wstępnie przydzielić dużą część pamięci (wystarczająco dużą, aby pomieścić dowolną ilość tego, czego może wymagać klasa). Następnie, kiedy wymyślę w czasie wykonywania, jak konstruować te rzeczy, nowe umieszczanie może być użyte do konstruowania obiektów dokładnie tam, gdzie chcę. Wiem, że użyłem go w jednej sytuacji, aby pomóc stworzyć heterogeniczny okrągły bufor .

Z pewnością nie jest to dla osób o słabym sercu, ale właśnie dlatego sprawiają, że składnia jest dla tego dość osobliwa.

Użyłem go do konstruowania obiektów przydzielonych na stosie za pomocą metody przydzielania ().

bezwstydna wtyczka: blogowałem o tym tutaj .

Head Geek: BINGO! Masz to całkowicie - właśnie do tego jest idealny. W wielu środowiskach osadzonych ograniczenia zewnętrzne i / lub ogólny scenariusz użycia zmusza programistę do oddzielenia alokacji obiektu od jego inicjalizacji. Zgrupowane razem, C ++ nazywa to „wystąpieniem”; ale ilekroć działanie konstruktora musi być jawnie wywoływane BEZ alokacji dynamicznej lub automatycznej, sposobem na to jest umieszczenie nowego. Jest to również doskonały sposób na zlokalizowanie globalnego obiektu C ++, który jest przypięty do adresu komponentu sprzętowego (we / wy mapowane w pamięci) lub dowolnego obiektu statycznego, który z jakiegokolwiek powodu musi znajdować się pod stałym adresem.

Użyłem go do stworzenia klasy Variant (tj. Obiektu, który może reprezentować pojedynczą wartość, która może być jedną z wielu różnych typów).

Jeśli wszystkie typy wartości obsługiwane przez klasę Variant są typami POD (np. Int, float, double, bool), wówczas wystarczające jest połączenie oznaczone w stylu C, ale jeśli chcesz, aby niektóre typy wartości były obiektami C ++ ( np. std :: string), funkcja unii C nie zadziała, ponieważ typy danych inne niż POD mogą nie zostać zadeklarowane jako część unii.

Zamiast tego przydzielam tablicę bajtów, która jest wystarczająco duża (np. Sizeof (the_largest_data_type_I_support)) i używam umieszczania new, aby zainicjować odpowiedni obiekt C ++ w tym obszarze, gdy Variant jest ustawiony na przechowywanie wartości tego typu. (I miejsce docelowe usuwa się wcześniej przy zmianie innego typu danych niż POD), oczywiście)

Nowe umieszczanie jest również bardzo przydatne podczas szeregowania (powiedzmy przy pomocy boost :: seriization). W ciągu 10 lat c ++ to dopiero drugi przypadek, dla którego potrzebowałem nowego miejsca (trzeci, jeśli uwzględnisz wywiady :)).

Jest to również przydatne, gdy chcesz ponownie zainicjować struktury globalne lub statycznie przydzielone.

Stary sposób memset()języka C służył do ustawiania wszystkich elementów na 0. Nie można tego zrobić w C ++ z powodu vtables i niestandardowych konstruktorów obiektów.

Czasami używam następujących

 static Mystruct m;

 for(...)  {
     // re-initialize the structure. Note the use of placement new
     // and the extra parenthesis after Mystruct to force initialization.
     new (&m) Mystruct();

     // do-some work that modifies m's content.
 }

W rzeczywistości jest to rodzaj implementacji jakiejkolwiek struktury danych, która przydziela więcej pamięci niż jest minimalnie wymagana dla liczby wstawianych elementów (tj. Wszystko inne niż struktura połączona, która przydziela jeden węzeł na raz).

Przystawki pojemniki podoba unordered_map, vectoralbo deque. Wszystkie one alokują więcej pamięci, niż jest to wymagane minimalnie dla elementów, które dotychczas wstawiłeś, aby uniknąć konieczności alokacji sterty dla każdego pojedynczego wstawienia. Użyjmy vectorjako najprostszego przykładu.

Kiedy to zrobisz:

vector<Foo> vec;

// Allocate memory for a thousand Foos:
vec.reserve(1000);

... to nie konstruuje tysiąc Foos. Po prostu alokuje / rezerwuje dla nich pamięć. Gdyby vectornie używał nowego umieszczania tutaj, byłoby to domyślne budowanie w Fooscałym miejscu, a także zmuszanie do wywoływania ich destrukterów nawet dla elementów, których nigdy nawet nie wstawiłeś.

Alokacja! = Budowa, uwolnienie! = Zniszczenie

Mówiąc ogólnie, aby zaimplementować wiele struktur danych takich jak powyżej, nie można traktować przydzielania pamięci i konstruowania elementów jako jednej niepodzielnej rzeczy, podobnie jak nie można traktować zwalniania pamięci i niszczenia elementów jako jednej niepodzielnej rzeczy.

Pomiędzy tymi pomysłami musi istnieć rozdział, aby uniknąć niepotrzebnego wywoływania konstruktorów i destruktorów niepotrzebnie w lewo i w prawo, i dlatego standardowa biblioteka oddziela ideę std::allocator (która nie konstruuje ani nie niszczy elementów, gdy alokuje / zwalnia pamięć *) z dala od kontenery, które go używają, które ręcznie konstruują elementy za pomocą umieszczania nowych i ręcznie niszczą elementy za pomocą jawnych wywołań destruktorów.

• Nienawidzę projektu std::allocator ale to inny temat, o którym będę się nie drażnić. :-RE

Tak czy inaczej, często go używam, ponieważ napisałem wiele ogólnie dostępnych kontenerów C ++ zgodnych ze standardami, których nie można zbudować w stosunku do istniejących. Wśród nich jest mała implementacja wektorowa, którą zbudowałem kilkadziesiąt lat temu, aby uniknąć alokacji sterty w typowych przypadkach, oraz trie wydajne pod względem pamięci (nie alokuje jednego węzła na raz). W obu przypadkach nie mogłem tak naprawdę zaimplementować ich przy użyciu istniejących kontenerów, więc musiałem użyć, placement newaby uniknąć zbędnego wywoływania konstruktorów i destruktorów na rzeczach niepotrzebnych z lewej i prawej strony.

Oczywiście, jeśli kiedykolwiek pracujesz z niestandardowymi alokatorami, aby alokować obiekty indywidualnie, jak na przykład bezpłatna lista, to na ogół powinieneś również użyć placement newtakiego, jak ten (podstawowy przykład, który nie przeszkadza w bezpieczeństwie wyjątków lub RAII):

Foo* foo = new(free_list.allocate()) Foo(...);
...
foo->~Foo();
free_list.free(foo);

Przydaje się, jeśli budujesz jądro - gdzie umieścisz kod jądra, który czytasz z dysku lub z pagetable? Musisz wiedzieć, gdzie skoczyć.

Lub w innych, bardzo rzadkich okolicznościach, na przykład gdy masz dużo przydzielonego pokoju i chcesz umieścić kilka struktur za sobą. Można je w ten sposób spakować bez potrzeby użycia operatora offsetof (). Istnieją jednak inne sztuczki.

Wierzę również, że niektóre implementacje STL wykorzystują nowe umieszczanie, takie jak std :: vector. W ten sposób przydzielają miejsce na 2 elementy i nie muszą zawsze zmieniać położenia.

Myślę, że nie została to podkreślona żadna odpowiedź, ale kolejny dobry przykład i zastosowanie nowego miejsca docelowego jest zmniejszenie fragmentacji pamięci (poprzez użycie pul pamięci). Jest to szczególnie przydatne w systemach wbudowanych io wysokiej dostępności. W tym ostatnim przypadku jest to szczególnie ważne, ponieważ dla systemu, który musi działać 24/365 dni, bardzo ważne jest, aby nie było fragmentacji. Ten problem nie ma nic wspólnego z wyciekiem pamięci.

Nawet jeśli używana jest bardzo dobra implementacja malloc (lub podobna funkcja zarządzania pamięcią), bardzo trudno jest poradzić sobie z fragmentacją przez długi czas. W pewnym momencie, jeśli nie będziesz sprytnie zarządzać wywołaniami rezerwacji / zwalniania pamięci, możesz skończyć z wieloma małymi lukami, które są trudne do ponownego wykorzystania (przypisz nowe rezerwacje). Tak więc jednym z rozwiązań zastosowanych w tym przypadku jest użycie puli pamięci do przydzielenia pamięci podręcznej dla obiektów aplikacji. Za każdym razem, gdy potrzebujesz pamięci dla jakiegoś obiektu, po prostu używasz nowego położenia, aby utworzyć nowy obiekt w już zarezerwowanej pamięci.

W ten sposób po uruchomieniu aplikacji masz już zarezerwowaną całą potrzebną pamięć. Wszystkie nowe rezerwacje / wydania pamięci trafiają do przydzielonych pul (możesz mieć kilka pul, po jednej dla każdej innej klasy obiektu). W tym przypadku nie dochodzi do fragmentacji pamięci, ponieważ nie będzie braków, a system może działać bardzo długo (lata) bez cierpienia z powodu fragmentacji.

Widziałem to w praktyce specjalnie dla VxWorks RTOS, ponieważ jego domyślny system alokacji pamięci bardzo cierpi z powodu fragmentacji. Tak więc alokacja pamięci za pomocą standardowej metody new / malloc była zasadniczo zabroniona w projekcie. Wszystkie rezerwacje pamięci powinny być kierowane do dedykowanej puli pamięci.

Jest używany przez, std::vector<>ponieważ std::vector<>zwykle przydziela więcej pamięci niż objectsw vector<>.

Użyłem go do przechowywania obiektów z plikami mapowanymi w pamięci.
Konkretnym przykładem była baza danych obrazów, która przetwarzała bardzo dużą liczbę dużych obrazów (więcej niż mogło zmieścić się w pamięci).

Widziałem to jako niewielki hack wydajnościowy dla wskaźnika „typu dynamicznego” (w sekcji „Pod maską”):

Ale oto podstępna sztuczka, której użyłem, aby uzyskać szybką wydajność dla małych typów: jeśli utrzymywana wartość może zmieścić się w pustce *, tak naprawdę nie zawracam sobie głowy przydzielaniem nowego obiektu, zmuszam go do samego wskaźnika za pomocą umieszczania nowego .

Użyłem go do tworzenia obiektów opartych na pamięci zawierającej wiadomości otrzymane z sieci.

Ogólnie rzecz biorąc, nowe miejsce docelowe służy do pozbycia się kosztów alokacji „normalnego nowego”.

Innym scenariuszem, w którym go użyłem, jest miejsce, w którym chciałem mieć dostęp do wskaźnika do obiektu, który jeszcze nie został zbudowany, aby wdrożyć singleton na dokument.

Może być przydatny podczas korzystania z pamięci współdzielonej, między innymi ... Na przykład: http://www.boost.org/doc/libs/1_51_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.conditions. warunki_anonimowy_przykład

Jedyne miejsce, na które natknąłem się na to, to pojemniki, które przydzielają ciągły bufor, a następnie wypełniają go odpowiednio do potrzeb obiektami. Jak wspomniano, std :: vector może to zrobić i wiem, że niektóre wersje MFC CArray i / lub CList to zrobiły (ponieważ to tam po raz pierwszy go uruchomiłem). Metoda nadmiernej alokacji buforów jest bardzo przydatną optymalizacją, a nowe umieszczanie jest prawie jedynym sposobem konstruowania obiektów w tym scenariuszu. Czasami jest również używany do konstruowania obiektów w blokach pamięci przydzielonych poza bezpośrednim kodem.

Użyłem go w podobnej pojemności, chociaż nie pojawia się często. Jest to jednak przydatne narzędzie do zestawu narzędzi C ++.

Silniki skryptów mogą używać go w interfejsie natywnym do przydzielania obiektów natywnych ze skryptów. Przykłady: patrz Angelscript (www.angelcode.com/angelscript).

Zobacz plik fp.h w projekcie xll na stronie http://xll.codeplex.com Rozwiązuje problem „nieuzasadnionej chumminess z kompilatorem” dla tablic, które lubią nosić ze sobą swoje wymiary.

typedef struct _FP
{
    unsigned short int rows;
    unsigned short int columns;
    double array[1];        /* Actually, array[rows][columns] */
} FP;

Oto użycie zabójcy dla konstruktora lokalnego C ++: wyrównanie do linii pamięci podręcznej, a także innych potęg 2 granic. Oto mój ultraszybki algorytm wyrównywania wskaźnika do dowolnej potęgi 2 granic z 5 lub mniej instrukcjami pojedynczego cyklu :

/* Quickly aligns the given pointer to a power of two boundary IN BYTES.
@return An aligned pointer of typename T.
@brief Algorithm is a 2's compliment trick that works by masking off
the desired number in 2's compliment and adding them to the
pointer.
@param pointer The pointer to align.
@param boundary_byte_count The boundary byte count that must be an even
power of 2.
@warning Function does not check if the boundary is a power of 2! */
template <typename T = char>
inline T* AlignUp(void* pointer, uintptr_t boundary_byte_count) {
  uintptr_t value = reinterpret_cast<uintptr_t>(pointer);
  value += (((~value) + 1) & (boundary_byte_count - 1));
  return reinterpret_cast<T*>(value);
}

struct Foo { Foo () {} };
char buffer[sizeof (Foo) + 64];
Foo* foo = new (AlignUp<Foo> (buffer, 64)) Foo ();

Czy to nie tylko wywołuje uśmiech na twojej twarzy (:-). I ♥♥♥ C ++ 1x