Intel(R) Threading Building Blocks Doxygen Documentation  version 4.2.3
Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
tbb::interface5::internal::split_ordered_list< T, Allocator > Class Template Reference

#include <_concurrent_unordered_impl.h>

Inheritance diagram for tbb::interface5::internal::split_ordered_list< T, Allocator >:
Collaboration diagram for tbb::interface5::internal::split_ordered_list< T, Allocator >:

Classes

struct  node
 

Public Types

typedef split_ordered_list< T, Allocator > self_type
 
typedef Allocator::template rebind< T >::other allocator_type
 
typedef node * nodeptr_t
 
typedef allocator_type::size_type size_type
 
typedef allocator_type::difference_type difference_type
 
typedef allocator_type::pointer pointer
 
typedef allocator_type::const_pointer const_pointer
 
typedef allocator_type::reference reference
 
typedef allocator_type::const_reference const_reference
 
typedef allocator_type::value_type value_type
 
typedef solist_iterator< self_type, const value_type > const_iterator
 
typedef solist_iterator< self_type, value_type > iterator
 
typedef flist_iterator< self_type, const value_type > raw_const_iterator
 
typedef flist_iterator< self_type, value_type > raw_iterator
 

Public Member Functions

nodeptr_t create_node (sokey_t order_key)
 
template<typename Arg >
nodeptr_t create_node (sokey_t order_key, __TBB_FORWARDING_REF(Arg) t, tbb::internal::true_type=tbb::internal::true_type())
 
template<typename Arg >
nodeptr_t create_node (sokey_t, __TBB_FORWARDING_REF(Arg), tbb::internal::false_type)
 
template<typename __TBB_PARAMETER_PACK Args>
nodeptr_t create_node_v (__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
 
 split_ordered_list (allocator_type a=allocator_type())
 
 ~split_ordered_list ()
 
allocator_type get_allocator () const
 
void clear ()
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
bool empty () const
 
size_type size () const
 
size_type max_size () const
 
void swap (self_type &other)
 
raw_iterator raw_begin ()
 
raw_const_iterator raw_begin () const
 
raw_iterator raw_end ()
 
raw_const_iterator raw_end () const
 
iterator get_iterator (raw_iterator it)
 
const_iterator get_iterator (raw_const_iterator it) const
 
raw_iterator get_iterator (raw_const_iterator it)
 
iterator first_real_iterator (raw_iterator it)
 
const_iterator first_real_iterator (raw_const_iterator it) const
 
void destroy_node (nodeptr_t pnode)
 
std::pair< iterator, bool > try_insert (raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
 
raw_iterator insert_dummy (raw_iterator it, sokey_t order_key)
 
void erase_node (raw_iterator previous, raw_const_iterator &where)
 
iterator erase_node (raw_iterator previous, const_iterator where)
 
void move_all (self_type &source)
 

Static Public Member Functions

static sokey_t get_order_key (const raw_const_iterator &it)
 
static sokey_t get_safe_order_key (const raw_const_iterator &it)
 
static iterator get_iterator (const_iterator it)
 
static nodeptr_t try_insert_atomic (nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
 

Private Member Functions

void check_range (raw_iterator first, raw_iterator last)
 
void check_range ()
 

Private Attributes

allocator_type::template rebind< node >::other my_node_allocator
 
size_type my_element_count
 
nodeptr_t my_head
 

Friends

template<typename Traits >
class concurrent_unordered_base
 

Detailed Description

template<typename T, typename Allocator>
class tbb::interface5::internal::split_ordered_list< T, Allocator >

Definition at line 55 of file _concurrent_unordered_impl.h.

Member Typedef Documentation

◆ allocator_type

template<typename T, typename Allocator>
typedef Allocator::template rebind<T>::other tbb::interface5::internal::split_ordered_list< T, Allocator >::allocator_type

Definition at line 188 of file _concurrent_unordered_impl.h.

◆ const_iterator

template<typename T, typename Allocator>
typedef solist_iterator<self_type, const value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::const_iterator

Definition at line 200 of file _concurrent_unordered_impl.h.

◆ const_pointer

template<typename T, typename Allocator>
typedef allocator_type::const_pointer tbb::interface5::internal::split_ordered_list< T, Allocator >::const_pointer

Definition at line 195 of file _concurrent_unordered_impl.h.

◆ const_reference

template<typename T, typename Allocator>
typedef allocator_type::const_reference tbb::interface5::internal::split_ordered_list< T, Allocator >::const_reference

Definition at line 197 of file _concurrent_unordered_impl.h.

◆ difference_type

template<typename T, typename Allocator>
typedef allocator_type::difference_type tbb::interface5::internal::split_ordered_list< T, Allocator >::difference_type

Definition at line 193 of file _concurrent_unordered_impl.h.

◆ iterator

template<typename T, typename Allocator>
typedef solist_iterator<self_type, value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::iterator

Definition at line 201 of file _concurrent_unordered_impl.h.

◆ nodeptr_t

template<typename T, typename Allocator>
typedef node* tbb::interface5::internal::split_ordered_list< T, Allocator >::nodeptr_t

Definition at line 189 of file _concurrent_unordered_impl.h.

◆ pointer

template<typename T, typename Allocator>
typedef allocator_type::pointer tbb::interface5::internal::split_ordered_list< T, Allocator >::pointer

Definition at line 194 of file _concurrent_unordered_impl.h.

◆ raw_const_iterator

template<typename T, typename Allocator>
typedef flist_iterator<self_type, const value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_const_iterator

Definition at line 202 of file _concurrent_unordered_impl.h.

◆ raw_iterator

template<typename T, typename Allocator>
typedef flist_iterator<self_type, value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_iterator

Definition at line 203 of file _concurrent_unordered_impl.h.

◆ reference

template<typename T, typename Allocator>
typedef allocator_type::reference tbb::interface5::internal::split_ordered_list< T, Allocator >::reference

Definition at line 196 of file _concurrent_unordered_impl.h.

◆ self_type

template<typename T, typename Allocator>
typedef split_ordered_list<T, Allocator> tbb::interface5::internal::split_ordered_list< T, Allocator >::self_type

Definition at line 187 of file _concurrent_unordered_impl.h.

◆ size_type

template<typename T, typename Allocator>
typedef allocator_type::size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::size_type

Definition at line 192 of file _concurrent_unordered_impl.h.

◆ value_type

template<typename T, typename Allocator>
typedef allocator_type::value_type tbb::interface5::internal::split_ordered_list< T, Allocator >::value_type

Definition at line 198 of file _concurrent_unordered_impl.h.

Constructor & Destructor Documentation

◆ split_ordered_list()

template<typename T, typename Allocator>
tbb::interface5::internal::split_ordered_list< T, Allocator >::split_ordered_list ( allocator_type  a = allocator_type())
inline

Definition at line 302 of file _concurrent_unordered_impl.h.

303  : my_node_allocator(a), my_element_count(0)
304  {
305  // Immediately allocate a dummy node with order key of 0. This node
306  // will always be the head of the list.
307  my_head = create_node(sokey_t(0));
308  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642

◆ ~split_ordered_list()

template<typename T, typename Allocator>
tbb::interface5::internal::split_ordered_list< T, Allocator >::~split_ordered_list ( )
inline

Definition at line 310 of file _concurrent_unordered_impl.h.

311  {
312  // Clear the list
313  clear();
314 
315  // Remove the head element which is not cleared by clear()
316  nodeptr_t pnode = my_head;
317  my_head = NULL;
318 
319  __TBB_ASSERT(pnode != NULL && pnode->my_next == NULL, "Invalid head list node");
320 
321  destroy_node(pnode);
322  }
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

Member Function Documentation

◆ begin() [1/2]

template<typename T, typename Allocator>
iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::begin ( )
inline

Definition at line 350 of file _concurrent_unordered_impl.h.

350  {
351  return first_real_iterator(raw_begin());
352  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::begin(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::cbegin().

Here is the caller graph for this function:

◆ begin() [2/2]

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::begin ( ) const
inline

Definition at line 355 of file _concurrent_unordered_impl.h.

355  {
356  return first_real_iterator(raw_begin());
357  }

◆ cbegin()

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::cbegin ( ) const
inline

Definition at line 367 of file _concurrent_unordered_impl.h.

367  {
368  return (((const self_type *)this)->begin());
369  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::cbegin().

Here is the caller graph for this function:

◆ cend()

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::cend ( ) const
inline

Definition at line 371 of file _concurrent_unordered_impl.h.

371  {
372  return (((const self_type *)this)->end());
373  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::cend().

Here is the caller graph for this function:

◆ check_range() [1/2]

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::check_range ( raw_iterator  first,
raw_iterator  last 
)
inlineprivate

Definition at line 621 of file _concurrent_unordered_impl.h.

622  {
623 #if TBB_USE_ASSERT
624  for (raw_iterator it = first; it != last; ++it)
625  {
626  raw_iterator next = it;
627  ++next;
628 
629  __TBB_ASSERT(next == raw_end() || get_order_key(next) >= get_order_key(it), "!!! List order inconsistency !!!");
630  }
631 #else
632  tbb::internal::suppress_unused_warning(first, last);
633 #endif
634  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:44
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:38
tbb::interface5::internal::split_ordered_list::get_order_key
static sokey_t get_order_key(const raw_const_iterator &it)
Definition: _concurrent_unordered_impl.h:423
tbb::interface5::internal::split_ordered_list::raw_iterator
flist_iterator< self_type, value_type > raw_iterator
Definition: _concurrent_unordered_impl.h:203
tbb::internal::suppress_unused_warning
void suppress_unused_warning(const T1 &)
Utility template function to prevent "unused" warnings by various compilers.
Definition: tbb_stddef.h:381

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base().

Here is the caller graph for this function:

◆ check_range() [2/2]

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::check_range ( )
inlineprivate

Definition at line 635 of file _concurrent_unordered_impl.h.

636  {
637 #if TBB_USE_ASSERT
638  check_range( raw_begin(), raw_end() );
639 #endif
640  }

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::check_range(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::try_insert().

Here is the caller graph for this function:

◆ clear()

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::clear ( )
inline

Definition at line 330 of file _concurrent_unordered_impl.h.

330  {
331  nodeptr_t pnext;
332  nodeptr_t pnode = my_head;
333 
334  __TBB_ASSERT(my_head != NULL, "Invalid head list node");
335  pnext = pnode->my_next;
336  pnode->my_next = NULL;
337  pnode = pnext;
338 
339  while (pnode != NULL)
340  {
341  pnext = pnode->my_next;
342  destroy_node(pnode);
343  pnode = pnext;
344  }
345 
346  my_element_count = 0;
347  }
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_copy(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::~split_ordered_list().

Here is the caller graph for this function:

◆ create_node() [1/3]

template<typename T, typename Allocator>
nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  order_key)
inline

Definition at line 254 of file _concurrent_unordered_impl.h.

254  {
255  nodeptr_t pnode = my_node_allocator.allocate(1);
256  pnode->init(order_key);
257  return (pnode);
258  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::split_ordered_list().

Here is the caller graph for this function:

◆ create_node() [2/3]

template<typename T, typename Allocator>
template<typename Arg >
nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  order_key,
__TBB_FORWARDING_REF(Arg)  t,
tbb::internal::true_type  = tbb::internal::true_type() 
)
inline

Definition at line 262 of file _concurrent_unordered_impl.h.

263  {
264  nodeptr_t pnode = my_node_allocator.allocate(1);
265 
266  //TODO: use RAII scoped guard instead of explicit catch
267  __TBB_TRY {
268  new(static_cast<void*>(&pnode->my_element)) T(tbb::internal::forward<Arg>(t));
269  pnode->init(order_key);
270  } __TBB_CATCH(...) {
271  my_node_allocator.deallocate(pnode, 1);
272  __TBB_RETHROW();
273  }
274 
275  return (pnode);
276  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642
__TBB_CATCH
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:288
__TBB_TRY
#define __TBB_TRY
Definition: tbb_stddef.h:287
__TBB_RETHROW
#define __TBB_RETHROW()
Definition: tbb_stddef.h:290

◆ create_node() [3/3]

template<typename T, typename Allocator>
template<typename Arg >
nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  ,
__TBB_FORWARDING_REF(Arg)  ,
tbb::internal::false_type   
)
inline

Definition at line 280 of file _concurrent_unordered_impl.h.

281  {
282  __TBB_ASSERT(false, "This compile-time helper should never get called");
283  return nodeptr_t();
284  }
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

◆ create_node_v()

template<typename T, typename Allocator>
template<typename __TBB_PARAMETER_PACK Args>
nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node_v ( __TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK  args)
inline

Definition at line 288 of file _concurrent_unordered_impl.h.

288  {
289  nodeptr_t pnode = my_node_allocator.allocate(1);
290 
291  //TODO: use RAII scoped guard instead of explicit catch
292  __TBB_TRY {
293  new(static_cast<void*>(&pnode->my_element)) T(__TBB_PACK_EXPANSION(tbb::internal::forward<Args>(args)));
294  } __TBB_CATCH(...) {
295  my_node_allocator.deallocate(pnode, 1);
296  __TBB_RETHROW();
297  }
298 
299  return (pnode);
300  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642
__TBB_CATCH
#define __TBB_CATCH(e)
Definition: tbb_stddef.h:288
__TBB_TRY
#define __TBB_TRY
Definition: tbb_stddef.h:287
__TBB_RETHROW
#define __TBB_RETHROW()
Definition: tbb_stddef.h:290
__TBB_PACK_EXPANSION
#define __TBB_PACK_EXPANSION(A)
Definition: tbb_stddef.h:517

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::emplace().

Here is the caller graph for this function:

◆ destroy_node()

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::destroy_node ( nodeptr_t  pnode)
inline

Definition at line 479 of file _concurrent_unordered_impl.h.

479  {
480  if (!pnode->is_dummy()) my_node_allocator.destroy(pnode);
481  my_node_allocator.deallocate(pnode, 1);
482  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::clear(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::erase_node(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::~split_ordered_list().

Here is the caller graph for this function:

◆ empty()

template<typename T, typename Allocator>
bool tbb::interface5::internal::split_ordered_list< T, Allocator >::empty ( ) const
inline

Definition at line 376 of file _concurrent_unordered_impl.h.

376  {
377  return (my_element_count == 0);
378  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::empty().

Here is the caller graph for this function:

◆ end() [1/2]

template<typename T, typename Allocator>
iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::end ( )
inline

Definition at line 359 of file _concurrent_unordered_impl.h.

359  {
360  return (iterator(0, this));
361  }
tbb::interface5::internal::split_ordered_list::iterator
solist_iterator< self_type, value_type > iterator
Definition: _concurrent_unordered_impl.h:201

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::cend(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::end(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::try_insert().

Here is the caller graph for this function:

◆ end() [2/2]

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::end ( ) const
inline

Definition at line 363 of file _concurrent_unordered_impl.h.

363  {
364  return (const_iterator(0, this));
365  }
tbb::interface5::internal::split_ordered_list::const_iterator
solist_iterator< self_type, const value_type > const_iterator
Definition: _concurrent_unordered_impl.h:200

◆ erase_node() [1/2]

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::erase_node ( raw_iterator  previous,
raw_const_iterator &  where 
)
inline

Definition at line 568 of file _concurrent_unordered_impl.h.

569  {
570  nodeptr_t pnode = (where++).get_node_ptr();
571  nodeptr_t prevnode = previous.get_node_ptr();
572  __TBB_ASSERT(prevnode->my_next == pnode, "Erase must take consecutive iterators");
573  prevnode->my_next = pnode->my_next;
574 
575  destroy_node(pnode);
576  }
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::erase_node(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all().

Here is the caller graph for this function:

◆ erase_node() [2/2]

template<typename T, typename Allocator>
iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::erase_node ( raw_iterator  previous,
const_iterator  where 
)
inline

Definition at line 579 of file _concurrent_unordered_impl.h.

580  {
581  raw_const_iterator it = where;
582  erase_node(previous, it);
583  my_element_count--;
584 
585  return get_iterator(first_real_iterator(it));
586  }
tbb::interface5::internal::split_ordered_list::raw_const_iterator
flist_iterator< self_type, const value_type > raw_const_iterator
Definition: _concurrent_unordered_impl.h:202
tbb::interface5::internal::split_ordered_list::erase_node
void erase_node(raw_iterator previous, raw_const_iterator &where)
Definition: _concurrent_unordered_impl.h:568

◆ first_real_iterator() [1/2]

template<typename T, typename Allocator>
iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::first_real_iterator ( raw_iterator  it)
inline

Definition at line 458 of file _concurrent_unordered_impl.h.

459  {
460  // Skip all dummy, internal only iterators
461  while (it != raw_end() && it.get_node_ptr()->is_dummy())
462  ++it;
463 
464  return iterator(it.get_node_ptr(), this);
465  }
tbb::interface5::internal::split_ordered_list::iterator
solist_iterator< self_type, value_type > iterator
Definition: _concurrent_unordered_impl.h:201

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::begin(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::erase_node(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_begin(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end().

Here is the caller graph for this function:

◆ first_real_iterator() [2/2]

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::first_real_iterator ( raw_const_iterator  it) const
inline

Definition at line 469 of file _concurrent_unordered_impl.h.

470  {
471  // Skip all dummy, internal only iterators
472  while (it != raw_end() && it.get_node_ptr()->is_dummy())
473  ++it;
474 
475  return const_iterator(it.get_node_ptr(), this);
476  }
tbb::interface5::internal::split_ordered_list::const_iterator
solist_iterator< self_type, const value_type > const_iterator
Definition: _concurrent_unordered_impl.h:200

◆ get_allocator()

template<typename T, typename Allocator>
allocator_type tbb::interface5::internal::split_ordered_list< T, Allocator >::get_allocator ( ) const
inline

Definition at line 326 of file _concurrent_unordered_impl.h.

326  {
327  return (my_node_allocator);
328  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::get_allocator().

Here is the caller graph for this function:

◆ get_iterator() [1/4]

template<typename T, typename Allocator>
iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_iterator  it)
inline

Definition at line 434 of file _concurrent_unordered_impl.h.

434  {
435  __TBB_ASSERT(it.get_node_ptr() == NULL || !it.get_node_ptr()->is_dummy(), "Invalid user node (dummy)");
436  return iterator(it.get_node_ptr(), this);
437  }
tbb::interface5::internal::split_ordered_list::iterator
solist_iterator< self_type, value_type > iterator
Definition: _concurrent_unordered_impl.h:201
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

Referenced by tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::begin(), tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::end(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::erase_node(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_equal_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_erase().

Here is the caller graph for this function:

◆ get_iterator() [2/4]

template<typename T, typename Allocator>
const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_const_iterator  it) const
inline

Definition at line 441 of file _concurrent_unordered_impl.h.

441  {
442  __TBB_ASSERT(it.get_node_ptr() == NULL || !it.get_node_ptr()->is_dummy(), "Invalid user node (dummy)");
443  return const_iterator(it.get_node_ptr(), this);
444  }
tbb::interface5::internal::split_ordered_list::const_iterator
solist_iterator< self_type, const value_type > const_iterator
Definition: _concurrent_unordered_impl.h:200
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169

◆ get_iterator() [3/4]

template<typename T, typename Allocator>
raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_const_iterator  it)
inline

Definition at line 447 of file _concurrent_unordered_impl.h.

447  {
448  return raw_iterator(it.get_node_ptr());
449  }
tbb::interface5::internal::split_ordered_list::raw_iterator
flist_iterator< self_type, value_type > raw_iterator
Definition: _concurrent_unordered_impl.h:203

◆ get_iterator() [4/4]

template<typename T, typename Allocator>
static iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( const_iterator  it)
inlinestatic

Definition at line 452 of file _concurrent_unordered_impl.h.

452  {
453  return iterator(it.my_node_ptr, it.my_list_ptr);
454  }
tbb::interface5::internal::split_ordered_list::iterator
solist_iterator< self_type, value_type > iterator
Definition: _concurrent_unordered_impl.h:201

◆ get_order_key()

template<typename T, typename Allocator>
static sokey_t tbb::interface5::internal::split_ordered_list< T, Allocator >::get_order_key ( const raw_const_iterator &  it)
inlinestatic

Definition at line 423 of file _concurrent_unordered_impl.h.

423  {
424  return it.get_node_ptr()->get_order_key();
425  }

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::check_range(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy().

Here is the caller graph for this function:

◆ get_safe_order_key()

template<typename T, typename Allocator>
static sokey_t tbb::interface5::internal::split_ordered_list< T, Allocator >::get_safe_order_key ( const raw_const_iterator &  it)
inlinestatic

Definition at line 427 of file _concurrent_unordered_impl.h.

427  {
428  if( !it.get_node_ptr() ) return ~sokey_t(0);
429  return it.get_node_ptr()->get_order_key();
430  }

◆ insert_dummy()

template<typename T, typename Allocator>
raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::insert_dummy ( raw_iterator  it,
sokey_t  order_key 
)
inline

Definition at line 510 of file _concurrent_unordered_impl.h.

511  {
512  raw_iterator last = raw_end();
513  raw_iterator where = it;
514 
515  __TBB_ASSERT(where != last, "Invalid head node");
516 
517  ++where;
518 
519  // Create a dummy element up front, even though it may be discarded (due to concurrent insertion)
520  nodeptr_t dummy_node = create_node(order_key);
521 
522  for (;;)
523  {
524  __TBB_ASSERT(it != last, "Invalid head list node");
525 
526  // If the head iterator is at the end of the list, or past the point where this dummy
527  // node needs to be inserted, then try to insert it.
528  if (where == last || get_order_key(where) > order_key)
529  {
530  __TBB_ASSERT(get_order_key(it) < order_key, "Invalid node order in the list");
531 
532  // Try to insert it in the right place
533  nodeptr_t inserted_node = try_insert_atomic(it.get_node_ptr(), dummy_node, where.get_node_ptr());
534 
535  if (inserted_node == dummy_node)
536  {
537  // Insertion succeeded, check the list for order violations
538  check_range(it, where);
539  return raw_iterator(dummy_node);
540  }
541  else
542  {
543  // Insertion failed: either dummy node was inserted by another thread, or
544  // a real element was inserted at exactly the same place as dummy node.
545  // Proceed with the search from the previous location where order key was
546  // known to be larger (note: this is legal only because there is no safe
547  // concurrent erase operation supported).
548  where = it;
549  ++where;
550  continue;
551  }
552  }
553  else if (get_order_key(where) == order_key)
554  {
555  // Another dummy node with the same value found, discard the new one.
556  destroy_node(dummy_node);
557  return where;
558  }
559 
560  // Move the iterator forward
561  it = where;
562  ++where;
563  }
564 
565  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:44
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::interface5::internal::split_ordered_list::get_order_key
static sokey_t get_order_key(const raw_const_iterator &it)
Definition: _concurrent_unordered_impl.h:423
tbb::interface5::internal::split_ordered_list::try_insert_atomic
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
Definition: _concurrent_unordered_impl.h:486
tbb::interface5::internal::split_ordered_list::raw_iterator
flist_iterator< self_type, value_type > raw_iterator
Definition: _concurrent_unordered_impl.h:203

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::init_bucket().

Here is the caller graph for this function:

◆ max_size()

template<typename T, typename Allocator>
size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::max_size ( ) const
inline

Definition at line 386 of file _concurrent_unordered_impl.h.

386  {
387  return my_node_allocator.max_size();
388  }
tbb::interface5::internal::split_ordered_list::my_node_allocator
allocator_type::template rebind< node >::other my_node_allocator
Definition: _concurrent_unordered_impl.h:642

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::max_size().

Here is the caller graph for this function:

◆ move_all()

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::move_all ( self_type &  source)
inline

Definition at line 589 of file _concurrent_unordered_impl.h.

590  {
591  raw_const_iterator first = source.raw_begin();
592  raw_const_iterator last = source.raw_end();
593 
594  if (first == last)
595  return;
596 
597  nodeptr_t previous_node = my_head;
598  raw_const_iterator begin_iterator = first++;
599 
600  // Move all elements one by one, including dummy ones
601  for (raw_const_iterator it = first; it != last;)
602  {
603  nodeptr_t pnode = it.get_node_ptr();
604 
605  nodeptr_t dummy_node = pnode->is_dummy() ? create_node(pnode->get_order_key()) : create_node(pnode->get_order_key(), pnode->my_element);
606  previous_node = try_insert_atomic(previous_node, dummy_node, NULL);
607  __TBB_ASSERT(previous_node != NULL, "Insertion must succeed");
608  raw_const_iterator where = it++;
609  source.erase_node(get_iterator(begin_iterator), where);
610  }
611  check_range();
612  }
tbb::internal::last
auto last(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:44
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:169
tbb::internal::first
auto first(Container &c) -> decltype(begin(c))
Definition: _range_iterator.h:38
tbb::interface5::internal::split_ordered_list::raw_const_iterator
flist_iterator< self_type, const value_type > raw_const_iterator
Definition: _concurrent_unordered_impl.h:202
tbb::interface5::internal::split_ordered_list::try_insert_atomic
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
Definition: _concurrent_unordered_impl.h:486

◆ raw_begin() [1/2]

template<typename T, typename Allocator>
raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_begin ( )
inline

Definition at line 406 of file _concurrent_unordered_impl.h.

406  {
407  return raw_iterator(my_head);
408  }
tbb::interface5::internal::split_ordered_list::raw_iterator
flist_iterator< self_type, value_type > raw_iterator
Definition: _concurrent_unordered_impl.h:203

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::begin(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::check_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_init(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all().

Here is the caller graph for this function:

◆ raw_begin() [2/2]

template<typename T, typename Allocator>
raw_const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_begin ( ) const
inline

Definition at line 411 of file _concurrent_unordered_impl.h.

411  {
412  return raw_const_iterator(my_head);
413  }
tbb::interface5::internal::split_ordered_list::raw_const_iterator
flist_iterator< self_type, const value_type > raw_const_iterator
Definition: _concurrent_unordered_impl.h:202

◆ raw_end() [1/2]

template<typename T, typename Allocator>
raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_end ( )
inline

Definition at line 415 of file _concurrent_unordered_impl.h.

415  {
416  return raw_iterator(0);
417  }
tbb::interface5::internal::split_ordered_list::raw_iterator
flist_iterator< self_type, value_type > raw_iterator
Definition: _concurrent_unordered_impl.h:203

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::check_range(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::first_real_iterator(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_equal_range(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_erase(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_find(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_bucket_size(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::unsafe_end().

Here is the caller graph for this function:

◆ raw_end() [2/2]

template<typename T, typename Allocator>
raw_const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_end ( ) const
inline

Definition at line 419 of file _concurrent_unordered_impl.h.

419  {
420  return raw_const_iterator(0);
421  }
tbb::interface5::internal::split_ordered_list::raw_const_iterator
flist_iterator< self_type, const value_type > raw_const_iterator
Definition: _concurrent_unordered_impl.h:202

◆ size()

template<typename T, typename Allocator>
size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::size ( ) const
inline

Definition at line 381 of file _concurrent_unordered_impl.h.

381  {
382  return my_element_count;
383  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::size().

Here is the caller graph for this function:

◆ swap()

template<typename T, typename Allocator>
void tbb::interface5::internal::split_ordered_list< T, Allocator >::swap ( self_type &  other)
inline

Definition at line 391 of file _concurrent_unordered_impl.h.

392  {
393  if (this == &other)
394  {
395  // Nothing to do
396  return;
397  }
398 
399  std::swap(my_element_count, other.my_element_count);
400  std::swap(my_head, other.my_head);
401  }
tbb::internal::swap
void swap(atomic< T > &lhs, atomic< T > &rhs)
Definition: atomic.h:539

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::swap().

Here is the caller graph for this function:

◆ try_insert()

template<typename T, typename Allocator>
std::pair<iterator, bool> tbb::interface5::internal::split_ordered_list< T, Allocator >::try_insert ( raw_iterator  it,
raw_iterator  next,
nodeptr_t  pnode,
size_type *  new_count 
)
inline

Definition at line 492 of file _concurrent_unordered_impl.h.

493  {
494  nodeptr_t inserted_node = try_insert_atomic(it.get_node_ptr(), pnode, next.get_node_ptr());
495 
496  if (inserted_node == pnode)
497  {
498  // If the insert succeeded, check that the order is correct and increment the element count
499  check_range(it, next);
500  *new_count = tbb::internal::as_atomic(my_element_count).fetch_and_increment();
501  return std::pair<iterator, bool>(iterator(pnode, this), true);
502  }
503  else
504  {
505  return std::pair<iterator, bool>(end(), false);
506  }
507  }
tbb::internal::as_atomic
atomic< T > & as_atomic(T &t)
Definition: atomic.h:547
tbb::interface5::internal::split_ordered_list::iterator
solist_iterator< self_type, value_type > iterator
Definition: _concurrent_unordered_impl.h:201
tbb::interface5::internal::split_ordered_list::try_insert_atomic
static nodeptr_t try_insert_atomic(nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)
Definition: _concurrent_unordered_impl.h:486

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::internal_insert().

Here is the caller graph for this function:

◆ try_insert_atomic()

template<typename T, typename Allocator>
static nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::try_insert_atomic ( nodeptr_t  previous,
nodeptr_t  new_node,
nodeptr_t  current_node 
)
inlinestatic

Definition at line 486 of file _concurrent_unordered_impl.h.

486  {
487  new_node->my_next = current_node;
488  return previous->atomic_set_next(new_node, current_node);
489  }

Referenced by tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::insert_dummy(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::try_insert().

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ concurrent_unordered_base

template<typename T, typename Allocator>
template<typename Traits >
friend class concurrent_unordered_base
friend

Definition at line 618 of file _concurrent_unordered_impl.h.

Member Data Documentation

◆ my_element_count

template<typename T, typename Allocator>
size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::my_element_count
private

Definition at line 643 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::empty(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::erase_node(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::size(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::swap(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::try_insert().

◆ my_head

template<typename T, typename Allocator>
nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::my_head
private

Definition at line 644 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::clear(), tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::concurrent_unordered_base(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::raw_begin(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::split_ordered_list(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::swap(), and tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::~split_ordered_list().

◆ my_node_allocator

template<typename T, typename Allocator>
allocator_type::template rebind<node>::other tbb::interface5::internal::split_ordered_list< T, Allocator >::my_node_allocator
private

Definition at line 642 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::create_node(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::create_node_v(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::destroy_node(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::get_allocator(), tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::max_size(), and tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, Hasher, Key_equality >, Allocator, false > >::operator=().

The documentation for this class was generated from the following file:

Copyright © 2005-2018 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.