30170305632

Committed 25 Jul 2026 06:46PM UTC coverage: 81.374% (-0.04%) from 81.414%

Build # 30170305632

Build Type

Pull #4027

github

Committed by

web-flow

Commit Message

Merge cd50e3e3e into ce78bdcb9

Pull Request Pull Request #4027: allow overlay material

Coverage Stats

18433 of 26706 branches covered (69.02%)

Branch coverage included in aggregate %.

93 of 128 new or added lines in 8 files covered. (72.66%)

3 existing lines in 3 files now uncovered.

60064 of 69759 relevant lines covered (86.1%)

49217883.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.54

/include/openmc/shared_array.h

#ifndef OPENMC_SHARED_ARRAY_H
#define OPENMC_SHARED_ARRAY_H

//! \file shared_array.h
//! \brief Shared array data structure

#include <algorithm> // for copy_n

#include "openmc/memory.h"

namespace openmc {

//==============================================================================
// Class declarations
//==============================================================================

// This container is an array that is capable of being appended to in an
// thread safe manner by use of atomics. It only provides protection for the
// use cases currently present in OpenMC. Namely, it covers the scenario where
// multiple threads are appending to an array, but no threads are reading from
// or operating on it in any other way at the same time. Multiple threads can
// call the thread_safe_append() function concurrently and store data to the
// object at the index returned from thread_safe_append() safely, but no other
// operations are protected.
template<typename T>
class SharedArray {

public:
  //==========================================================================
  // Constructors

  //! Default constructor.
  SharedArray() = default;

  //! Construct a container with `size` elements and capacity equal to `size`.
  //
  //! \param size The number of elements to allocate and initialize
  SharedArray(int64_t size) : size_(size), capacity_(size)
  {
    data_ = make_unique<T[]>(size);
  }

  //==========================================================================
  // Methods and Accessors

  //! Return a reference to the element at specified location i. No bounds
  //! checking is performed.
  T& operator[](int64_t i) { return data_[i]; }
  const T& operator[](int64_t i) const { return data_[i]; }

  //! Allocate space in the container for the specified number of elements.
  //! reserve() does not change the size of the container.
  //
  //! \param capacity The number of elements to allocate in the container
  void reserve(int64_t capacity)
  {
    data_ = make_unique<T[]>(capacity);
    capacity_ = capacity;
  }

  //! Increase the size of the container by one and append value to the
  //! array. Returns an index to the element of the array written to. Also
  //! tests to enforce that the append operation does not read off the end
  //! of the array. In the event that this does happen, set the size to be
  //! equal to the capacity and return -1.
  //
  //! \value The value of the element to append
  //! \return The index in the array written to. In the event that this
  //! index would be greater than what was allocated for the container,
  //! return -1.
  int64_t thread_safe_append(const T& value)
  {
    // Atomically capture the index we want to write to
    int64_t idx;
#pragma omp atomic capture seq_cst
    idx = size_++;

    // Check that we haven't written off the end of the array
    if (idx >= capacity_) {
#pragma omp atomic write seq_cst
      size_ = capacity_;
      return -1;
    }

    // Copy element value to the array
    data_[idx] = value;

    return idx;
  }

  //! Free any space that was allocated for the container. Set the
  //! container's size and capacity to 0.
  void clear()
  {
    data_.reset();
    size_ = 0;
    capacity_ = 0;
  }

  //! Push back an element to the array, with capacity and reallocation behavior
  //! as if this were a vector. This does not perform any thread safety checks.
  //! If the size exceeds the capacity, then the capacity will double just as
  //! with a vector. Data will be reallocated and moved to a new pointer and
  //! copied in before the new item is appended. Old data will be freed.
  void thread_unsafe_append(const T& value)
  {
    if (size_ == capacity_) {
      int64_t new_capacity = capacity_ == 0 ? 8 : 2 * capacity_;
      unique_ptr<T[]> new_data = make_unique<T[]>(new_capacity);
      std::copy_n(data_.get(), size_, new_data.get());
      data_ = std::move(new_data);
      capacity_ = new_capacity;
    }
    data_[size_++] = value;
  }

  //! Increase the size of the container by count elements without assigning
  //! values to the new elements. Existing elements are preserved if the
  //! container needs to grow. This does not perform any thread safety checks.
  //
  //! \param count The number of elements to append
  //! \return The starting index of the appended range
  int64_t extend_uninitialized(int64_t count)
  {
    int64_t offset = size_;
    int64_t new_size = size_ + count;
    if (new_size > capacity_) {
      int64_t new_capacity = capacity_ == 0 ? 8 : capacity_;
      while (new_capacity < new_size) {
        new_capacity *= 2;
      }
      unique_ptr<T[]> new_data = make_unique<T[]>(new_capacity);
      if (size_ > 0) {
        std::copy_n(data_.get(), size_, new_data.get());
      }
      data_ = std::move(new_data);
      capacity_ = new_capacity;
    }
    size_ = new_size;
    return offset;
  }

  //! Return the number of elements in the container
  int64_t size() { return size_; }
  int64_t size() const { return size_; }

  //! Resize the container to contain a specified number of elements. This is
  //! useful in cases where the container is written to in a non-thread safe
  //! manner, where the internal size of the array needs to be manually updated.
  //
  //! \param size The new size of the container
  void resize(int64_t size) { size_ = size; }

  //! Return whether the array is full
  bool full() const { return size_ == capacity_; }

  //! Return the number of elements that the container has currently allocated
  //! space for.
  int64_t capacity() { return capacity_; }

  //! Return pointer to the underlying array serving as element storage.
  T* data() { return data_.get(); }
  const T* data() const { return data_.get(); }

  //! Classic iterators
  T* begin() { return data_.get(); }
  const T* cbegin() const { return data_.get(); }
  T* end() { return data_.get() + size_; }
  const T* cend() const { return data_.get() + size_; }

private:
  //==========================================================================
  // Data members

  unique_ptr<T[]> data_; //!< An RAII handle to the elements
  int64_t size_ {0};     //!< The current number of elements
  int64_t capacity_ {0}; //!< The total space allocated for elements
};

} // namespace openmc

#endif // OPENMC_SHARED_ARRAY_H

1	#ifndef OPENMC_SHARED_ARRAY_H
2	#define OPENMC_SHARED_ARRAY_H
3
4	//! \file shared_array.h
5	//! \brief Shared array data structure
6
7	#include <algorithm> // for copy_n
8
9	#include "openmc/memory.h"
10
11	namespace openmc {
12
13	//==============================================================================
14	// Class declarations
15	//==============================================================================
16
17	// This container is an array that is capable of being appended to in an
18	// thread safe manner by use of atomics. It only provides protection for the
19	// use cases currently present in OpenMC. Namely, it covers the scenario where
20	// multiple threads are appending to an array, but no threads are reading from
21	// or operating on it in any other way at the same time. Multiple threads can
22	// call the thread_safe_append() function concurrently and store data to the
23	// object at the index returned from thread_safe_append() safely, but no other
24	// operations are protected.
25	template<typename T>
26	class SharedArray {	76,569!
27
28	public:
29	//==========================================================================
30	// Constructors
31
32	//! Default constructor.
33	SharedArray() = default;	71,097✔
34
35	//! Construct a container with `size` elements and capacity equal to `size`.
36	//
37	//! \param size The number of elements to allocate and initialize
38	SharedArray(int64_t size) : size_(size), capacity_(size)	5,472✔
39	{
40	data_ = make_unique<T[]>(size);	5,472!
41	}	5,472!
42
43	//==========================================================================
44	// Methods and Accessors
45
46	//! Return a reference to the element at specified location i. No bounds
47	//! checking is performed.
48	T& operator[](int64_t i) { return data_[i]; }	345,004,881✔
49	const T& operator[](int64_t i) const { return data_[i]; }
50
51	//! Allocate space in the container for the specified number of elements.
52	//! reserve() does not change the size of the container.
53	//
54	//! \param capacity The number of elements to allocate in the container
55	void reserve(int64_t capacity)	7,855✔
56	{
57	data_ = make_unique<T[]>(capacity);	8,865!
58	capacity_ = capacity;	7,855✔
59	}	7,855✔
60
61	//! Increase the size of the container by one and append value to the
62	//! array. Returns an index to the element of the array written to. Also
63	//! tests to enforce that the append operation does not read off the end
64	//! of the array. In the event that this does happen, set the size to be
65	//! equal to the capacity and return -1.
66	//
67	//! \value The value of the element to append
68	//! \return The index in the array written to. In the event that this
69	//! index would be greater than what was allocated for the container,
70	//! return -1.
71	int64_t thread_safe_append(const T& value)	623,244,178✔
72	{
73	// Atomically capture the index we want to write to
74	int64_t idx;
75	#pragma omp atomic capture seq_cst	555,023,273✔
76	idx = size_++;	623,244,178✔
77
78	// Check that we haven't written off the end of the array
79	if (idx >= capacity_) {	623,244,178!
80	#pragma omp atomic write seq_cst
81	size_ = capacity_;
UNCOV 82	return -1;	×
83	}
84
85	// Copy element value to the array
86	data_[idx] = value;	623,244,178✔
87
88	return idx;	623,244,178✔
89	}
90
91	//! Free any space that was allocated for the container. Set the
92	//! container's size and capacity to 0.
93	void clear()	53,275✔
94	{
95	data_.reset();	53,275✔
96	size_ = 0;	53,275✔
97	capacity_ = 0;	53,275✔
98	}	53,275✔
99
100	//! Push back an element to the array, with capacity and reallocation behavior
101	//! as if this were a vector. This does not perform any thread safety checks.
102	//! If the size exceeds the capacity, then the capacity will double just as
103	//! with a vector. Data will be reallocated and moved to a new pointer and
104	//! copied in before the new item is appended. Old data will be freed.
105	void thread_unsafe_append(const T& value)
106	{
107	if (size_ == capacity_) {
108	int64_t new_capacity = capacity_ == 0 ? 8 : 2 * capacity_;
109	unique_ptr<T[]> new_data = make_unique<T[]>(new_capacity);
110	std::copy_n(data_.get(), size_, new_data.get());
111	data_ = std::move(new_data);
112	capacity_ = new_capacity;
113	}
114	data_[size_++] = value;
115	}
116
117	//! Increase the size of the container by count elements without assigning
118	//! values to the new elements. Existing elements are preserved if the
119	//! container needs to grow. This does not perform any thread safety checks.
120	//
121	//! \param count The number of elements to append
122	//! \return The starting index of the appended range
123	int64_t extend_uninitialized(int64_t count)	38,908✔
124	{
125	int64_t offset = size_;	38,908✔
126	int64_t new_size = size_ + count;	38,908✔
127	if (new_size > capacity_) {	38,908✔
128	int64_t new_capacity = capacity_ == 0 ? 8 : capacity_;	9,049✔
129	while (new_capacity < new_size) {	23,506✔
130	new_capacity *= 2;	14,457✔
131	}
132	unique_ptr<T[]> new_data = make_unique<T[]>(new_capacity);	9,049✔
133	if (size_ > 0) {	9,049!
134	std::copy_n(data_.get(), size_, new_data.get());	×
135	}
136	data_ = std::move(new_data);	9,049✔
137	capacity_ = new_capacity;	9,049!
138	}	9,049✔
139	size_ = new_size;	38,908✔
140	return offset;	38,908✔
141	}
142
143	//! Return the number of elements in the container
144	int64_t size() { return size_; }	170,195,921!
145	int64_t size() const { return size_; }
146
147	//! Resize the container to contain a specified number of elements. This is
148	//! useful in cases where the container is written to in a non-thread safe
149	//! manner, where the internal size of the array needs to be manually updated.
150	//
151	//! \param size The new size of the container
152	void resize(int64_t size) { size_ = size; }	4,145,437✔
153
154	//! Return whether the array is full
155	bool full() const { return size_ == capacity_; }	2,147,483,647✔
156
157	//! Return the number of elements that the container has currently allocated
158	//! space for.
159	int64_t capacity() { return capacity_; }	95,228✔
160
161	//! Return pointer to the underlying array serving as element storage.
162	T* data() { return data_.get(); }	201,831✔
163	const T* data() const { return data_.get(); }
164
165	//! Classic iterators
166	T* begin() { return data_.get(); }	1,369✔
167	const T* cbegin() const { return data_.get(); }
168	T* end() { return data_.get() + size_; }
169	const T* cend() const { return data_.get() + size_; }
170
171	private:
172	//==========================================================================
173	// Data members
174
175	unique_ptr<T[]> data_; //!< An RAII handle to the elements
176	int64_t size_ {0}; //!< The current number of elements
177	int64_t capacity_ {0}; //!< The total space allocated for elements
178	};
179
180	} // namespace openmc
181
182	#endif // OPENMC_SHARED_ARRAY_H

openmc-dev / openmc / 30170305632

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous