"Yeni yerleşim" için ne gibi kullanımlar vardır?

Burada hiç kimse C ++ 'ın "yeni yerleşim" kullandı mı? Eğer öyleyse, ne için? Bana sadece bellek eşlemeli donanımda yararlı olacak gibi geliyor.

Yeni yerleşim, bellekte önceden ayrılmış bir nesne oluşturmanıza olanak tanır.

Bir nesnenin birden çok örneğini oluşturmanız gerektiğinde bunu en iyileştirme için yapmak isteyebilirsiniz ve yeni bir örneğe her ihtiyaç duyduğunuzda belleği yeniden ayırmamak daha hızlıdır. Bunun yerine, hepsini aynı anda kullanmak istemeseniz bile, birden fazla nesneyi tutabilen bir yığın bellek için tek bir ayırma gerçekleştirmek daha verimli olabilir.

DevX iyi bir örnek veriyor :

Standart C ++, önceden ayrılmış bir arabellek üzerinde bir nesne oluşturan yeni yerleşim işlecini de destekler. Bu, bir bellek havuzu, bir çöp toplayıcı oluştururken veya yalnızca performans ve istisna güvenliği çok önemli olduğunda yararlıdır (bellek zaten tahsis edildiğinden ve önceden ayrılmış bir arabellek üzerine bir nesne oluşturmak daha az zaman alır) :

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

Ayrıca, kritik kodun belirli bir bölümünde (örneğin, kalp pili tarafından yürütülen kodda) hiçbir ayırma hatası olmadığından emin olmak isteyebilirsiniz. Bu durumda belleği daha önce ayırmak, ardından kritik bölümdeki yeni yerleşimi kullanmak istersiniz.

Yerleşimde anlaşma yeni

Bellek arabelleğini kullanan her nesneyi yeniden konumlandırmamalısınız. Bunun yerine [] yalnızca orijinal arabelleği silmelisiniz. Daha sonra sınıflarınızın yıkıcılarını manuel olarak çağırmanız gerekir. Bu konuda iyi bir öneri için lütfen Stroustrup'un SSS konusuna bakın: "Yerleşim silme" var mı?

Özel bellek havuzları ile kullanıyoruz. Sadece bir taslak:

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, ...);

Artık nesneleri tek bir bellek arenasında kümeleyebilir, çok hızlı ancak ayırma yapmayan bir ayırıcı seçebilir, bellek eşlemesini kullanabilir ve havuzu seçip onu bir nesnenin yerleşimine argüman olarak ileterek uygulamak istediğiniz diğer semantikleri kullanabilirsiniz. yeni operatör.

Tahsisi başlatma işleminden ayırmak istiyorsanız kullanışlıdır. STL, konteyner öğeleri oluşturmak için yeni yerleşimi kullanır.

Gerçek zamanlı programlamada kullandım. Sistem başladıktan sonra genellikle herhangi bir dinamik ayırma (veya yeniden konumlandırma) yapmak istemiyoruz, çünkü bunun ne kadar süreceğini garanti etmiyoruz .

Ne yapabilirim bellek büyük bir yığın (sınıf ne gerektirebilir olursa olsun herhangi bir miktarda tutacak kadar büyük) önceden. Sonra, çalışma zamanında şeyleri nasıl yapılacağını anladıktan sonra, yeni yerleştirme, nesneleri istediğim yerde oluşturmak için kullanılabilir. İçinde kullandığımı bildiğim bir durum heterojen dairesel bir tampon oluşturmaya yardımcı olmaktı .

Kesinlikle kalbin zayıflığı için değil, ama bu yüzden sözdizimini biraz gnarly yapıyorlar.

Ben alloca () ile yığın tahsis nesneleri oluşturmak için kullandım.

utanmaz fişi: Ben bu konuda blogged burada .

Başkan Geek: BINGO! Tamamen anladınız - tam olarak bunun için mükemmel. Birçok gömülü ortamda, harici kısıtlamalar ve / veya genel kullanım senaryosu, programcıyı bir nesnenin tahsisini başlatma işleminden ayırmaya zorlar. Birlikte toplanan C ++, bu "örnekleme" olarak adlandırır; ancak dinamik veya otomatik ayırma OLMADAN yapıcı eyleminin açıkça başlatılması gerektiğinde, yeni yerleşim bunu yapmanın yoludur. Ayrıca, bir donanım bileşeninin (bellek eşlemeli G / Ç) adresine sabitlenmiş genel bir C ++ nesnesini veya herhangi bir nedenle sabit bir adreste bulunması gereken statik bir nesneyi bulmak için mükemmel bir yoldur.

Ben bir Variant sınıfı oluşturmak için kullandım (yani bir dizi farklı türden biri olabilir tek bir değeri temsil edebilir bir nesne).

Variant sınıfı tarafından desteklenen tüm değer türlerinin POD türleri (ör. İnt, float, double, bool) olması durumunda, etiketli bir C stili birleşimi yeterlidir, ancak bazı değer türlerinin C ++ nesneleri olmasını istiyorsanız ( örneğin std :: string), P birliği olmayan veri türleri birliğin parçası olarak bildirilmeyebileceğinden, C birleşimi özelliği çalışmaz.

Bu yüzden bunun yerine yeterince büyük bir bayt dizisi ayırıyorum (örneğin sizeof (the_largest_data_type_I_support)) ve Variant bu tür bir değeri tutmak için ayarlandığında o alanda uygun C ++ nesnesini başlatmak için yeni yerleşimi kullanıyorum. (Ve tabii ki farklı bir POD olmayan veri türünden uzaklaşırken yerleşim önceden silinir)

Serileştirme sırasında yeni yerleştirme de çok yararlıdır (boost :: serialization ile birlikte). C ++ 10 yıl içinde bu sadece yeni yerleştirilmesi gereken ikinci durumda (üçüncü görüşmeler dahil :)).

Global veya statik olarak tahsis edilmiş yapıları yeniden başlatmak istediğinizde de yararlıdır.

Eski C yolu memset() tüm öğeleri 0 olarak ayarlamak . Bunu, vtables ve özel nesne yapıcıları nedeniyle C ++ ile yapamazsınız.

Bu yüzden bazen aşağıdakileri kullanıyorum

 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.
 }

Aslında, eklenen öğe sayısı için minimum düzeyde gerekenden daha fazla bellek ayıran her türlü veri yapısının uygulanması gerekir (yani, bir kerede bir düğümü ayıran bağlantılı bir yapı dışında herhangi bir şey).

Al konteynerler gibi unordered_map, vectorya da deque. Bunların hepsi, her bir ekleme için yığın tahsisi gerektirmemek için şimdiye kadar eklediğiniz öğeler için minimum düzeyde gerekenden daha fazla bellek ayırır. vectorEn basit örnek olarak kullanalım .

Yaptığınızda:

vector<Foo> vec;

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

... aslında bin Foo yapmaz. Onlar için sadece bellek ayırır / ayırır. Eğer vectoryeni burada yerleşim kullanın vermedi, varsayılan-inşa olurdu Foosbiryere yanı sıra bile bile ilk etapta eklenen asla elemanları kendi yıkıcı çağırmak zorunda.

Tahsis! = İnşaat, Serbest! = Yıkım

Genel olarak yukarıdaki gibi birçok veri yapısını uygulamak için konuşursak, bellek ayırmayı ve öğeleri oluşturmayı bölünmez bir şey olarak ele alamazsınız ve aynı zamanda belleği serbest bırakmayı ve öğeleri yok etmeyi bölünmez bir şey olarak ele alamazsınız.

Gereksiz yere sol ve sağ gereksiz kurucuları ve yıkıcıları çağırmak için bu fikirler arasında bir ayrım olmalıdır ve bu nedenle standart kütüphane std::allocator(hafızayı ayırdığında / serbest bıraktığında öğeleri oluşturmaz veya imha etmez *) fikrini yeni yerleşimi kullanarak öğeleri el ile yapılandıran ve yıkıcıların açık çağrılarını kullanarak öğeleri el ile yok eden, onu kullanan kaplar.

• Tasarımından nefret ediyorum, std::allocatorama bu sıralamamaktan kaçınacağım farklı bir konu. :-D

Her neyse, çok fazla kullanma eğilimindeyim, çünkü mevcut olanlar açısından inşa edilemeyen bir dizi genel amaçlı standart uyumlu C ++ kapları yazdım. Bunların arasında, birkaç yıl önce yaygın durumlarda yığın tahsislerinden kaçınmak için oluşturduğum küçük bir vektör uygulaması ve bellek verimli bir üçlü (bir seferde bir düğüm ayırmaz) bulunur. Her iki durumda da onları mevcut kapları kullanarak gerçekten uygulayamadım ve bu nedenle placement newgereksiz sol ve sağdaki şeylere yapıcıları ve yıkıcıları gereksiz yere çağırmaktan kaçınmak zorunda kaldım .

Doğal olarak, ücretsiz bir liste gibi, nesneleri ayrı ayrı tahsis etmek için özel ayırıcılar ile çalışırsanız, genellikle placement newbu şekilde de kullanmak istersiniz (istisna güvenliği veya RAII ile uğraşmayan temel örnek):

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

Bir çekirdek oluşturuyorsanız yararlıdır - diskten veya sayfalı tablodan okuduğunuz çekirdek kodunu nereye yerleştirirsiniz? Nereye atlayacağınızı bilmelisiniz.

Ya da, çok fazla tahsis edilmiş odanız olduğunda ve birkaç yapıyı birbirinizin arkasına yerleştirmek gibi çok nadir durumlarda. Offsetof () operatörüne gerek kalmadan bu şekilde paketlenebilirler. Yine de bunun için başka numaralar da var.

Ayrıca bazı STL uygulamalarının yerleşimi yeni kullandığını düşünüyorum, std :: vector gibi. Bu şekilde 2 ^ n eleman için yer ayırırlar ve her zaman yeniden yer ayırmaları gerekmez.

Bunun herhangi bir cevapla vurgulanmadığını düşünüyorum, ancak yeni yerleşim için bir başka iyi örnek ve kullanım , bellek parçalanmasını (bellek havuzlarını kullanarak) azaltmaktır. Bu, gömülü ve yüksek kullanılabilirlikli sistemlerde özellikle yararlıdır. Bu son durumda özellikle önemlidir, çünkü 24/365 gün çalışması gereken bir sistem için parçalanma olmaması çok önemlidir. Bu sorunun bellek sızıntısıyla ilgisi yoktur.

Çok iyi bir malloc uygulaması (veya benzer bir bellek yönetim fonksiyonu) kullanıldığında bile, parçalanma ile uzun süre uğraşmak çok zordur. Bir noktada, bellek ayırma / bırakma çağrılarını akıllıca yönetmezseniz, yeniden kullanımı zor olan çok sayıda küçük boşlukla karşılaşabilirsiniz (yeni rezervasyonlara atayın). Dolayısıyla, bu durumda kullanılan çözümlerden biri, uygulama nesneleri için belleği önceden ayırmak için bir bellek havuzu kullanmaktır. Sonrasında bazı nesneler için belleğe her ihtiyacınız olduğunda , önceden ayrılmış bellekte yeni bir nesne oluşturmak için yeni yerleşimi kullanırsınız.

Bu şekilde, uygulamanız başladıktan sonra gereken tüm belleğe zaten sahip olursunuz. Tüm yeni bellek ayırma / bırakma ayrılmış havuzlara gider (her farklı nesne sınıfı için bir tane olmak üzere birkaç havuzunuz olabilir). Boşluk olmayacağından ve sisteminiz parçalanmadan muzdarip olmadan uzun süre (yıl) çalışabileceğinden bu durumda bellek parçalanması olmaz.

Bunu uygulamada özellikle VxWorks RTOS için gördüm, çünkü varsayılan bellek ayırma sistemi parçalanmadan çok acı çekiyor. Bu nedenle, projede standart yeni / malloc yöntemi ile bellek tahsisi temel olarak yasaklanmıştır. Tüm bellek rezervasyonları özel bir bellek havuzuna gitmelidir.

Bu tarafından kullanılan std::vector<>çünkü std::vector<>tipik sayısından daha fazla bellek ayırır objectsiçinde vector<>.

Bellek eşlemeli dosyalar ile nesneleri depolamak için kullandım.
Bu özel örnek, çok sayıda büyük görüntüyü (belleğe sığmayacak kadar çok) işleyen bir görüntü veritabanıdır.

Ben bir "dinamik tip" işaretçi ("Başlık Altında" bölümünde) için hafif bir performans kesmek olarak kullanılan gördüm :

Ama burada küçük türler için hızlı performans elde etmek için kullandığım hileci: eğer tutulan değer bir boşluğun * içine sığabiliyorsa, aslında yeni bir nesne tahsis etmeye zahmet etmiyorum, yeni yerleşimi kullanarak işaretçinin kendisine zorlarım .

Şebekeden alınan mesajları içeren belleğe dayalı nesneler oluşturmak için kullandım.

Genellikle, yeni yerleştirme, 'normal yeni'nin dağıtım maliyetinden kurtulmak için kullanılır.

Kullandığım başka bir senaryo , belge başına tekil bir uygulama yapmak için hala inşa edilecek bir nesneye işaretçiye erişmek istediğim bir yer .

Paylaşılan belleği kullanırken, diğer kullanımlar arasında kullanışlı olabilir ... Örneğin: http://www.boost.org/doc/libs/1_51_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.conditions. conditions_anonymous_example

Üzerinde koştuğum tek yer bitişik bir tampon ayıran ve sonra gerektiği gibi nesnelerle dolduran kaplarda. Belirtildiği gibi, std :: vector bunu yapabilir ve MFC CArray ve / veya CList'in bazı sürümlerini yaptım (çünkü ilk kez bu yerde koştum). Arabellek aşırı ayırma yöntemi çok kullanışlı bir optimizasyon ve yeni yerleştirme, bu senaryoda nesneleri oluşturmanın hemen hemen tek yoludur. Bazen doğrudan kodunuzun dışında ayrılmış bellek bloklarında nesneler oluşturmak için de kullanılır.

Sık sık gelmese de benzer bir kapasitede kullandım. Yine de C ++ araç kutusu için yararlı bir araçtır.

Komut dosyası motorları, yerel arayüzleri komut dosyalarından ayırmak için yerel arayüzde kullanabilir. Örnekler için Angelscript'e (www.angelcode.com/angelscript) bakın.

Boyutlarını yanlarında taşımak isteyen diziler için http://xll.codeplex.com adresindeki xll projesinde fp.h dosyasına bakın .

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

İşte C ++ yerinde oluşturucu için katil kullanım: bir önbellek satırına hizalama ve 2 sınırın diğer güçleri. İşte 5 veya daha az tek döngü talimatları ile 2 sınırın herhangi bir gücüne ultra hızlı işaretçi hizalama algoritmam :

/* 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 ();

Şimdi bu sadece yüzüne bir gülümseme koymuyor (:-). I ♥♥♥ C ++ 1x