vtkSMPThreadLocal.h.in 5.17 KB
Newer Older
Sujin Philip's avatar
Sujin Philip committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkSMPThreadLocal.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
// .NAME vtkSMPThreadLocal - A thread local storage implementation using
// platform specific facilities.
// .SECTION Description
// A thread local object is one that maintains a copy of an object of the
// template type for each thread that processes data. vtkSMPThreadLocal
// creates storage for all threads but the actual objects are created
// the first time Local() is called. Note that some of the vtkSMPThreadLocal
// API is not thread safe. It can be safely used in a multi-threaded
// environment because Local() returns storage specific to a particular
// thread, which by default will be accessed sequentially. It is also
// thread-safe to iterate over vtkSMPThreadLocal as long as each thread
// creates its own iterator and does not change any of the thread local
// objects.
//
// A common design pattern in using a thread local storage object is to
// write/accumulate data to local object when executing in parallel and
// then having a sequential code block that iterates over the whole storage
// using the iterators to do the final accumulation.

#ifndef vtkSMPThreadLocal_h
#define vtkSMPThreadLocal_h

#include "vtkSMPThreadLocalImpl.h"
#include "vtkSMPToolsInternal.h"

template <typename T>
class vtkSMPThreadLocal
{
public:
  // Description:
  // Default constructor. Creates a default exemplar.
  vtkSMPThreadLocal() : Backend(vtk::detail::smp::GetNumberOfThreads())
  {
  }

  // Description:
  // Constructor that allows the specification of an exemplar object
  // which is used when constructing objects when Local() is first called.
  // Note that a copy of the exemplar is created using its copy constructor.
Sujin Philip's avatar
Sujin Philip committed
54
  explicit vtkSMPThreadLocal(const T& exemplar)
Sujin Philip's avatar
Sujin Philip committed
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
    : Backend(vtk::detail::smp::GetNumberOfThreads()), Exemplar(exemplar)
  {
  }

  ~vtkSMPThreadLocal()
  {
    detail::ThreadSpecificStorageIterator it;
    it.SetThreadSpecificStorage(Backend);
    for (it.SetToBegin(); !it.GetAtEnd(); it.Forward())
      {
      delete reinterpret_cast<T*>(it.GetStorage());
      }
  }

  // Description:
  // Returns an object of type T that is local to the current thread.
  // This needs to be called mainly within a threaded execution path.
  // It will create a new object (local to the tread so each thread
  // get their own when calling Local) which is a copy of exemplar as passed
  // to the constructor (or a default object if no exemplar was provided)
  // the first time it is called. After the first time, it will return
  // the same object.
  T& Local()
  {
    detail::StoragePointerType &ptr = this->Backend.GetStorage();
    T *local = reinterpret_cast<T*>(ptr);
    if (!ptr)
      {
       ptr = local = new T(this->Exemplar);
      }
    return *local;
  }

  // Description:
  // Return the number of thread local objects that have been initialized
  size_t size() const
  {
    return this->Backend.Size();
  }

  // Description:
  // Subset of the standard iterator API.
  // The most common design pattern is to use iterators in a sequential
  // code block and to use only the thread local objects in parallel
  // code blocks.
  // It is thread safe to iterate over the thread local containers
  // as long as each thread uses its own iterator and does not modify
  // objects in the container.
  class iterator
  {
  public:
    iterator& operator++()
    {
      this->Impl.Forward();
      return *this;
    }

    iterator operator++(int)
    {
      iterator copy = *this;
      this->Impl.Forward();
      return copy;
    }

    bool operator==(const iterator& other)
    {
      return this->Impl == other.Impl;
    }

    bool operator!=(const iterator& other)
    {
      return !(this->Impl == other.Impl);
    }

    T& operator*()
    {
      return *reinterpret_cast<T*>(this->Impl.GetStorage());
    }

    T* operator->()
    {
      return reinterpret_cast<T*>(this->Impl.GetStorage());
    }

  private:
    detail::ThreadSpecificStorageIterator Impl;

    friend class vtkSMPThreadLocal<T>;
  };

  // Description:
  // Returns a new iterator pointing to the beginning of
  // the local storage container. Thread safe.
  iterator begin()
  {
    iterator it;
    it.Impl.SetThreadSpecificStorage(Backend);
    it.Impl.SetToBegin();
    return it;
  }

  // Description:
  // Returns a new iterator pointing to past the end of
  // the local storage container. Thread safe.
  iterator end()
  {
    iterator it;
    it.Impl.SetThreadSpecificStorage(Backend);
    it.Impl.SetToEnd();
    return it;
  }

private:
  detail::ThreadSpecific Backend;
  T Exemplar;
Sujin Philip's avatar
Sujin Philip committed
170 171 172 173

  // disable copying
  vtkSMPThreadLocal(const vtkSMPThreadLocal&);
  void operator=(const vtkSMPThreadLocal&);
Sujin Philip's avatar
Sujin Philip committed
174 175 176 177
};

#endif
// VTK-HeaderTest-Exclude: vtkSMPThreadLocal.h