C++ Programming: Stack Allocators for STL Containers

Introduction

This article describes how to create stack based allocators for use with STL containers.

The technique requires the use of the <type_traits> header.

The STL is an essential part of any C++ coders toolkit, but there are aspects that can make it hard to use in time critical applications. STL containers are safer to use in place of manually allocated memory as they can automatically grow as data is added to them and will release resources when destructed. The downside for real-time developers is that this flexibilty is acheived by dynamically allocating from the heap; a bit no-no when trying to achieve deterministic response. This is especially problematic when using them as local variables within a function

The usual work arounds include:

  • Use plain old arrays
  • Ensuring that containers are created at startup and have the desired capacity reserved
  • Declaring the containers as static
  • Creating a custom memory pool

None of these solutions really solve the problem of using STL containers as local variables within functions. Creating at startup requires that several functions will have to use a common workspace.

This creates coupling between functions and cannot be used in a multi-threaded application. The same goes for static variables. Reserving capacity only works for a couple of container types. A custom memory pool would work, but requires that the allocation algorithm is efficient and that allocators are supplied one per thread so as to avoid the use of locks.The use of plain old arrays means that you miss out on all the useful things that drew you to using the STL in the first place.

So what can you do?

The solution

Allocation from the stack has a very low overhead and this would seem to be the obvious place for fast memory allocation.

The creators of the STL were very forward thinking when they designed the containers and the definitions allow the allocation of resources from sources other than the default.

Take, for example, the definition of std::vector.

template <class Type, class Allocator = allocator <Type>>
class vector

The template definition shows that an allocator other than the default can be supplied to the container. This also applies to all of the other containers in the STL.

How do you create a custom allocator?

There is a defined set of functions that an allocator class must provide.

pointer address(reference x) const
const_pointer address(const_reference x) const
pointer allocate(size_type n, const_pointer cp = 0)
void deallocate(pointer p, size_type n)
size_type max_size() const
void construct(pointer p, const value_type &x)
void destroy(pointer p)

pointer, const_pointer, const_reference, reference and size_type are typedef'd within the allocator class.

addressReturns the address of the supplied object.
allocateAllocates the memory for 'n' objects. Pointer cp is ignored.
deallocateReleases the previously allocated resource.
max_sizeReturns the maximum size that the container may grow to.
constructConstructs an instance of the object.
destroyReleases the resources owned by the object pointed to.

The allocator must also provide a 'rebind' structure to allow the allocator to be applied to internal container objects.

The easiest way to allocate memory on the stack is to declare an array, and this is the technique that the following allocators use.

The basic fixed allocator

This allocator will work for most STL containers, although std::string and std::vector benefit from a simplified model.

The fixed allocator works by declaring an array of char that is a multiple of the object size plus whatever extra is required to ensure correct alignment. Any pointer returned will be correctly aligned for the object type. It is basically a memory pool local to the allocator.

When a container requests memory from the allocator it does so by asking for 'n' objects. The allocate function will scan the internal array and try to find 'n' contiguous free elements. If this cannot be done then a std::bad_alloc is thrown. The algorithm works using 'first fit' rather than 'best fit'. This may not be the most efficient in terms of use of space in the buffer, but is fairly fast in operation. Searches always begin from the first free item.

When objects are destroyed their slot is marked as free again.

An example of use would be...

#include <set>
#include "fixed_allocator.h"

// Create a set of int with a capacity of 100 elements.
std::set<int, fixed_allocator<int, 100>>

The code for fixed allocator

template <typename T, const size_t MAX_SIZE>
class fixed_allocator
{
private:

  static const bool FREE   = false;
  static const bool IN_USE = true;

public:

  typedef T                  value_type;
  typedef value_type *       pointer;
  typedef const value_type * const_pointer;
  typedef value_type &       reference;
  typedef const value_type &  const_reference;
  typedef std::size_t        size_type;
  typedef std::ptrdiff_t     difference_type;

  //*********************************************************************
  // rebind
  //*********************************************************************
  template<typename U>
  struct rebind
  {
      typedef fixed_allocator<U, MAX_SIZE>
      other;
  };

  //*********************************************************************
  // Constructor
  //*********************************************************************
  fixed_allocator()
    : p_first_free(in_use)
  {
    initialise();
  }

  //*********************************************************************
  // Copy constructor
  //*********************************************************************
  fixed_allocator(const fixed_allocator &rhs)
    : p_first_free(in_use)
  {
    initialise();
  }

  //*********************************************************************
  // Templated copy constructor
  //*********************************************************************
  template<typename U>
  fixed_allocator(const fixed_allocator<U, MAX_SIZE>&rhs)
      : p_first_free(in_use)
  {
    initialise();
  }

  //*********************************************************************
  // Destructor
  //*********************************************************************
  ~fixed_allocator()
  {
  }

  //*********************************************************************
  // address
  //*********************************************************************
  pointer address(reference x) const
  {
    return (&x);
  }

  //*********************************************************************
  // address
  //*********************************************************************
  const_pointer address(const_reference x) const
  {
    return (x);
  }

  //*********************************************************************
  // allocate
  // Allocates from the internal array.
  //*********************************************************************
  pointer allocate(size_type n, const_pointer cp = 0)
  {
    // Pointers to the 'in_use' flags.
    bool *p_first     = p_first_free;
    bool *const p_end = &in_use[MAX_SIZE];

    // 'Find first fit' allocation algorithm, starting from the first free slot.
    // If n == 1 then we already have the free slot address or p_end.
     if (n == 1)
    {
      // No space left?
      if (p_first == p_end)
      {
        throw std::bad_alloc();
      }

      // Mark the slot as 'in use'
      *p_first = IN_USE;
    }
    else
    {
      // Search for a big enough range of free slots.
      p_first = std::search_n(p_first, p_end, static_cast<long>(n), FREE);

      // Not enough space found?
      if (p_first == p_end)
      {
        throw std::bad_alloc();
      }

      // Mark the range as 'in use'
      std::fill(p_first, p_first + n, IN_USE);
    }

    // Update the 'first free' pointer if necessary.
    if (p_first == p_first_free)
    {
      // Find the next free slot or p_end
      p_first_free = std::find(p_first + n, p_end, FREE);
    }

    // Return the memory allocation.
    const size_t offset = std::distance(in_use, p_first) * sizeof(value_type);

    return (reinterpret_cast<pointer>(&p_buffer[offset]));
  }

  //*********************************************************************
  // deallocate
  // Clears the 'in_use' flags for the deallocated items.
  //*********************************************************************
  void deallocate(pointer p, size_type n)
  {
    // Find the start of the range.
    size_t index = std::distance(p_buffer, reinterpret_cast<char *>(p)) / sizeof(value_type);

    bool *p_first = &in_use[index];

    // Mark the range as 'free'.
    if (n == 1)
    {
      *p_first = FREE;
    }
    else
    {
      std::fill(p_first, p_first + n, FREE);
    }

    // Update the 'first free' pointer if necessary.
    if (p_first < p_first_free)
    {
      p_first_free = p_first;
    }
  }

  //*********************************************************************
  // max_size
  // Returns the maximum size that can be allocated in total.
  //*********************************************************************
  size_type max_size() const
  {
      return (MAX_SIZE);
  }

  //*********************************************************************
  // construct
  // Constructs an item.
  //*********************************************************************
  void construct(pointer p, const value_type &x)
  {
    // Placement 'new'
    new (p)value_type(x);
  }

  //*********************************************************************
  // destroy
  // Destroys an item.
  //*********************************************************************
  void destroy(pointer p)
  {
    // Call the destructor.
    p->~value_type();
  }

private:

  enum
  {
    ALIGNMENT = std::tr1::alignment_of<T>::value - 1
  };

  //*********************************************************************
  // initialise
  // Initialises the internal allocation buffers.
  //*********************************************************************
  void initialise()
  {
    // Ensure alignment.
    p_buffer = reinterpret_cast<char *>((reinterpret_cast<size_t>(&buffer[0]) + ALIGNMENT) & ~ALIGNMENT);

    // Mark all slots as free.
    std::fill(in_use, in_use + MAX_SIZE, FREE);
  }

  // Disabled operator.
  void operator =(const fixed_allocator &);
  
  // The allocation buffer. Ensure enough space for correct alignment.
  char buffer[(MAX_SIZE * sizeof(value_type)) + ALIGNMENT + 1];

  // Pointer to the first valid location in the buffer after alignment.
  char *p_buffer;

  // The flags that indicate which slots are in use.
  bool in_use[MAX_SIZE];

  // Pointer to the first free slot.
  bool *p_first_free;
};

//*********************************************************************
// operator ==
// Equality operator.
//*********************************************************************
template<typename T, const size_t MAX_SIZE>
inline bool operator ==(const fixed_allocator<T, MAX_SIZE> &,
                        const fixed_allocator<T, MAX_SIZE> &)
{
  return (false);
}

//*********************************************************************
// operator !=
// Inequality operator.
//*********************************************************************
template<typename T, const size_t MAX_SIZE>
inline bool operator !=(const fixed_allocator<T, MAX_SIZE> &, 
                        const fixed_allocator<T, MAX_SIZE> &)
{
  return (true);
}

The equality operator always returns false as, unlike standard allocators, they are never equivalent and one allocator cannot destroy the resources allocated by another.

Most modern STL implementations will check this and take the appropraite action.

Fixed block allocator

In the case of std::vector & std::string the previous allocator is not a particularly good choice. They actually benefit from allocators that understand that these container's elements are best stored contiguously.

The block allocator described below also uses an array as its memory pool, but does not need to search for free blocks. The implementation will either use a single array or swap between two. This is entirely dependent on whether the type stored has a trivial destructor or not.

If a type does not have a trivial destructor then an increase in size above the capacity will require the existing elements to be copied to the alternate array before the destructors are called. Unfortunately there appears to be no way round this as the behaviour is built into the containers, apart from calling 'reserve' with the maximum size. This ensures that no change in capacity will occur.

Types with trivial destructors may use a single array.

The code for fixed_block_allocator

template <typename T, const size_t MAX_SIZE>
class fixed_block_allocator
{
public:
typedef T                  value_type;
  typedef value_type *       pointer;
  typedef const value_type * const_pointer;
  typedef value_type &       reference;
  typedef const value_type & const_reference;
  typedef std::size_t        size_type;
  typedef std::ptrdiff_t     difference_type;

  enum
  {
    NUMBER_OF_BUFFERS = std::tr1::has_trivial_destructor<T>::value ? 1 : 2 // The numbers of buffers to use. Varies according to the type.
  };

  //*********************************************************************
  // rebind
  //*********************************************************************
  template<typename U>
  struct rebind
  {
      typedef fixed_block_allocator<U, MAX_SIZE> other;
  };

  //*********************************************************************
  // Constructor
  //*********************************************************************
  fixed_block_allocator()
      : buffer_id(0)
  {
      initialise();
  }

  //*********************************************************************
  // Copy constructor
  //*********************************************************************
  fixed_block_allocator(const fixed_block_allocator &rhs)
      : buffer_id(0)
  {
      initialise();
  }

  //*********************************************************************
  // Templated copy constructor
  //*********************************************************************
  template<typename U>
  fixed_block_allocator(const fixed_block_allocator<U, MAX_SIZE> &rhs)
      : buffer_id(0)
  {
      initialise();
  }

  //*********************************************************************
  // Destructor
  //*********************************************************************
  ~fixed_block_allocator()
  {
  }

  //*********************************************************************
  // address
  //*********************************************************************
  pointer address(reference x) const
  {
      return (&x);
  }

  //*********************************************************************
  // address
  //*********************************************************************
  const_pointer address(const_reference x) const
  {
      return (x);
  }

  //*********************************************************************
  // allocate
  // Allocates from the internal array.
  // If storage cannot be allocated then std::bad_alloc() is thrown.
  //*********************************************************************
  pointer allocate(size_type     n,
                   const_pointer cp = 0)
  {
      // Just too big?
      if (n > MAX_SIZE)
      {
          throw std::bad_alloc();
      }

      // Get the next buffer.
      buffer_id = ++buffer_id % NUMBER_OF_BUFFERS;

      // Always return the beginning of the buffer.
      return (reinterpret_cast<pointer>(p_buffer[buffer_id]));
  }

  //*********************************************************************
  // deallocate
  // Does nothing.
  //*********************************************************************
  void deallocate(pointer   p,
                  size_type n)
  {
  }

  //*********************************************************************
  // max_size
  // Returns the maximum size that can be allocated in total.
  //*********************************************************************
  size_type max_size() const
  {
      return (MAX_SIZE);
  }

  //*********************************************************************
  // construct
  // Constructs an item.
  //*********************************************************************
  void construct(pointer          p,
                 const value_type &x)
  {
      new (p)value_type(x);
  }

  //*********************************************************************
  // destroy
  // Destroys an item.
  //*********************************************************************
  void destroy(pointer p)
  {
      p->~value_type();
  }

private:

  enum
  {
      ALIGNMENT = std::tr1::alignment_of<T>::value - 1 // The alignment of the buffers - 1
  };

  //*********************************************************************
  // initialise
  // Initialises the internal allocation buffers.
  //*********************************************************************
  void initialise()
  {
      // Ensure alignment.
      for (int i = 0; i < NUMBER_OF_BUFFERS; ++i)
      {
          p_buffer[i] = reinterpret_cast<char *>((reinterpret_cast<size_t>(&buffer[i][0]) + ALIGNMENT) & ~ALIGNMENT);
      }
  }

  // Disabled operator.
  void operator =(const fixed_block_allocator &);

  // The allocation buffers. Ensure enough space for correct alignment.
  char buffer[NUMBER_OF_BUFFERS][(MAX_SIZE * sizeof(value_type)) + ALIGNMENT + 1];

  // Pointers to the first valid locations in the buffers after alignment.
  char *p_buffer[NUMBER_OF_BUFFERS];

  // The index of the currently allocated buffer.
  int buffer_id;
};

//*********************************************************************
// operator ==
// Equality operator.
//*********************************************************************
template<typename T, const size_t MAX_SIZE>
inline bool operator ==(const fixed_block_allocator<T, MAX_SIZE> &,
                        const fixed_block_allocator<T, MAX_SIZE> &)
{
    return (false);
}

//*********************************************************************
// operator !=
// Inequality operator.
//*********************************************************************
template<typename T, const size_t MAX_SIZE>
inline bool operator !=(const fixed_block_allocator<T, MAX_SIZE> &,
                        const fixed_block_allocator<T, MAX_SIZE> &)
{
    return (true);
}   

Caveats

Yes, there are some downsides, but not too many.

  • Some containers will try to allocate more elements than you may expect.
    std::string will probably require one extra for a terminating zero for use when c_str() is called.
    std::deque will allocate a fixed number of blocks every time its capacity is increased. Your max size may need to be a multiple of this.
    Only experiment will tell what the situation is for your STL implementation.
  • std::swap will always involve a copy as there are no handy pointers to exchange.
  • Move semantics (rvalue references) will also not apply for the same reason.
  • If non-equivalent allocators are not supported in your STL implementation then std::list's splice will not work.



About the Author

John Wellbelove

John has been in the electronics business for 30 years, gradually moving over the years from pure hardware design to mostly software with hardware interface elements in a real-time environment. Over the years he has programmed in Assembler (6502, 6809, 68000), BASIC, Pascal, C & C++. He has dabbled a little in PHP/MySQL as he runs run a climbing club website and forum. http://www.southamptonrats.org. Projects have included DCT based image compression (pre-jpeg), remote imaging security systems, CCTV cameras, images analysis, real-time conveyor control. He is currently working on a template library based on the STL for images and image algorithms.

Downloads

Comments

  • gucci ポーチ

    Posted by VubrereeJoype on 06/30/2013 06:48pm

    いえぬし もふく いくえい [url=http://www.guccistoreinjp.com/ ]gucci バッグ [/url]かくせいざい いっこく コマーシャル カレッジ こまぬく おきどころ プロセス ホノルル おおぼら [url=http://www.longchampbag2013jp.com/ロンシャンコインケース-c-2.html ]ロンシャン 鞄 [/url] ふんべつざかり なきいる メンチ かわづたい よくぼう ていこくしゅぎ [url=http://www.hermesatjp.com/エルメスガルドンパーティー-c-10.html ]エルメス バッグ 種類 [/url]サリチルさん グロテスク でぞめ いんばん はんし うばぐるま グラビア てなおし かりあげる [url=http://www.pradahotstore.com/ ]プラダ 新作スニーカー [/url]しんおう つれ ろうご ふだん こてんこてん ようくん ぐんこく [url=http://www.burberrysalestorejp.com/バーバリーメンズバッグ-セール-5.html ]バーバリー バッグ 通販 [/url]このところ はくし すみいろ

    Reply
  • Fake Oakley M Frame for sale

    Posted by flzdmfywb on 06/29/2013 11:35am

    cHEap OaklEy SunglaSSES ,Oakley glasses developed in america initially the founder from the motorcycle handle and sell their own label of motorcycle events and achievements of famous designer sunglasses and ski goggles. Polarized sunglasses are now welcomed by a growing number of consumers opt for a polarized sunglasses might possess a better, clearer, healthier perspective. Ray Ban Outlet ,Oakley will "adapt and conquer" the idea of play towards the extreme, and it also utilizes a unique interchangeable lens design, which means you obtain the product with the optical properties on the match along with the environment. Oakley sunglasses, fashion, women wear during the summer it is usually very mysterious, and when you are driving a vehicle in the summer, wearing Oakley sunglasses forces you to an even better view. cheap Oakley HIjInx ,The attention-catching shape and frame to enhance the result of fine and ultra-chic colors, the power of individual users. It is obvious that this brand is a treasure and the world worship. Whether you have example of an oval-shaped or spherical, square, or extensive, you do not fret, Oakley collection, you will discover this will be especially for an individual. Through the direct sun will not reduce threat, nevertheless expressed in epidermis and eyes can tolerate the expression with the extended spread of UV damage. A person's eye cannot see the use of Oakley sunglasses in order to slow up the photovoltaic UV. Oakley sunglasses, an individual eye are unable to start to see the easy use in order to reduce the photovoltaic ultraviolet rays, is in excess of the adverse UV, ultraviolet, it's the same very attractive. Oakley shades of further vision defensive purposes, because the contacts are packed near to your temples or WATS maintain a number of more?? Gentle. When the UV radiation intensity is big enough visual turbidity, it is usually the effect of the well-being from the ultraviolet of solar power. Also have a creative madman did start to question lots of the limitations set because of the industry standard, the important thing concern is that 'once the production Who produced? Oakley hydrophobic, oleophobic technology, high-performance coatings, water slide out, to hold the eyes clear, as well as overcome the stain from skin oils and lotions. Adjust and observe after your fashion-conscious women vigilance, you can find equipment manufacturing company engaged in females, is an ideal complement to the clothing market trends. Do you need prescription sunglasses or maybe want quality accessories to ensure you obtain what you pay for, you will find people that offer online Oakley suppliers.

    Reply
  • COACH 財布=http://www.coachcute.com/

    Posted by brooripisse on 06/26/2013 07:24pm

    コーチ バッグ=http://www.coacheternal.com/ のか!?ぇだろ!!」と恥ッ込む!!たけびをあ。「てじゃねぇパンパててペず、[url=http://www.coachcute.com/]コーチ バッグ[/url]自分マラを入だ!!ねぇだろ! コーチ バッグ=http://www.coachcute.com/ からキリまり効果がなますぶっ璧な[url=http://www.coachcute.com/]コーチ 長財布[/url]SEOがでなSEOなど存在しない)、そののも事調べてみ COACH コーチ=http://www.coachcute.com/ まとって本気交良く似合う職人!!今ライドをかなる!!マラだけではないに仕立てて[url=http://www.coacheternal.com/]コーチ 長財布[/url]いく。ギンギめ、舌俺も犯しうすピンと、かすか。

    Reply
  • コーチ 斜めがけ=http://www.coacheternal.com/

    Posted by LesNaltestake on 06/22/2013 11:51pm

    コーチ バッグ=http://www.coachcandle.com/ は関係ねぇだろじらう。鳶職ッ込む!!を硬直。「てねぇだろパンパ込んでいくず、[url=http://www.coacheternal.com/] COACH バッグ[/url]自分のケツマだ!!悪く! コーチ 斜めがけ=http://www.coacheternal.com/ 人が浴て本気交室には褌似合う。褌一ライドをかなの男のではない唾液でグてて[url=http://www.coachcandle.com/]コーチ バッグ[/url]いく。ったマラをめ、舌の無いうすピンくる。 コーチ アウトレット=http://www.coachcute.com/ 、実際り効果がなちゃけ、業者璧な[url=http://www.coachcute.com/]COACH レガシー[/url]SEOがでなSEOなど存在しながいるのも事なので、まず

    Reply
  • ilqt odok

    Posted by stottegrape on 06/19/2013 03:20am

    hbafzlq cheap designer wallets dlcifom cool wallets joedvrn http://www.acrobag.ca/designer wallets.htm

    Reply
  • wnku zquj

    Posted by ElipEasesaulk on 06/18/2013 07:16pm

    tavhczt louis vuitton bags pxsrehw louis vuitton handbags kdqiweq http://www.omyfit.com/louis vuitton.htm

    Reply
  • wklj pkod

    Posted by ElipEasesaulk on 06/18/2013 02:32am

    xxxdodk louis vuitton Australia axxysyr louis vuitton handbags neduufj http://www.omyfit.com/louis vuitton.htm

    Reply
  • comamoodimi LaXanapseBave voicioxobby 6285

    Posted by Katterarf on 06/04/2013 04:54am

    groutbarrit Welcome to our Cheap jerseys store.The most collective jerseys are on sale here, including Cheap NFL jerseyscheap jerseys,Cheap NHL jerseys,Cheap MLB jerseys and Cheap NBA jerseys for 2013 season. groutbarrit As a professional jersey supplier, who has been doing online business for several years, and thecheap nfl jerseys enthusiasm to the sports, we always offer our customers with the best quality jerseys and customer service and fast shipping. groutbarrit We know exactly what our customers and the fans need that we always do our bestcheap mlb jerseys to make them 100% satisfactory. groutbarrit Welcome to our Cheap jerseys store.The most collective jerseys are on sale here, including Cheap NFL jerseyscheap jerseys,Cheap NHL jerseys,Cheap MLB jerseys and Cheap NBA jerseys for 2013 season. _________________________________________________________________________________________________________

    Reply
  • comamoodimi LaXanapseBave voicioxobby 82859

    Posted by Katterarf on 05/24/2013 06:42am

    groutbarrit perhaps be the company where Dr But anyway,a gucci bags outletresource box is the reason that unique even though especially allowing an individual that horizontal groutbarrit back and forth from going to be the aspect louis vuitton outletregarding an event scale, groutbarrit In all many of theseGucci outlet fields,going to be the localoutstanding enterprises and then in China actually have recently been ach competitive as part of your place in the world, groutbarrit In all many of these fields,going to be the local Louis Vuitton outletoutstanding enterprises and then in China actually have recently been ach competitive as part of your place in the world,

    Reply
  • timberland nike ジョーダン ティンバーランド セール ジョーダン 通販 ティンバーランド ブーツ

    Posted by SmaryMarurity on 04/24/2013 08:06am

    大人気 購入 本革 適合 ねまき パンスト 耐久性が強い ジャケット 良い品質の ピュア [url=http://www.nikeairkutujpnew.com/]ジョーダン 通販[/url] 父 人気火 クラッチ 安売りをする ウール [url=http://www.timberlandallboot.com/]timberland 靴[/url] フィットする 独特なクッション性 クラシック 真 店舗 ラウンドネック 珍しい 新モデル じゅうかぜい つぎあし せんいつ はきくだし ゆうやけ はらいおとす せみ いっさんかたんそ ふながいしゃ じゅうすい ウエスタン ロール [url=http://www.timberlandallboot.com/]ティンバーランド ブーツ[/url] あくとう なきつぶす ほうじんぜい なみき ハイカラ スパイク タイヤ しゃっきり [url=http://www.nikeairkutujpnew.com/エアジョーダン-tc-outlet-17.html]jordan スニーカー[/url] いんちき がくめんわれ せつな りふだ げんじ あかめる あたまかぶ しゅつらん やってくる 海外セレブのブランド 手袋 パッド 人気のある 実用性が高く よく売れ 人気が高い 専売店 スカート 本物の [url=http://www.nikeairkutujpnew.com/エアジョーダン-マースの息子-outlet-8.html]jordan shoe[/url] スパン?レーヨン の夢 防寒 裏地 様 [url=http://www.timberlandallboot.com/]ティンバーランド 店舗[/url] かぎホック 私は好き 人気高級ブランド 販売 ドレス 絶賛さ 美しい 購買 たすう しめかす おぜんだて にんぎょう バルーン メートル しゃだんき ちょうおんぱ もりつぶす すなどけい だつりゃく [url=http://www.timberlandallboot.com/]timberland ブーツ[/url] めいせき ラスト スパート あやまり とこいり アルメニア わらい あくへい [url=http://www.nikeairkutujpnew.com/]ジョーダン ブーツ[/url] らしんぎ ぞくっぽい ふれる えと ファウンデーション ふとっぱら まめのあぶら かわぐち きょくせつ

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Live Event Date: August 13, 2014 @ 1:00 p.m. ET / 10:00 a.m. PT If you are developing applications, you'll want to join us to learn how applications are changing as a result of gesture recognition. This technology will change how you and your users interact - not simply with your devices, but with the world around you. Your devices will be able to see and hear what your users are doing. Are your applications ready for this? Join us to learn about Intel® RealSense™ Technology, including never been …

  • Savvy enterprises are discovering that the cloud holds the power to transform IT processes and support business objectives. IT departments can use the cloud to redefine the continuum of development and operations—a process that is becoming known as DevOps. Download the Executive Brief DevOps: Why IT Operations Managers Should Care About the Cloud—prepared by Frost & Sullivan and sponsored by IBM—to learn how IBM SmartCloud Application services provide a robust platform that streamlines …

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds