25282275446

Committed 03 May 2026 02:48PM UTC coverage: 81.376% (+0.002%) from 81.374%

Build # 25282275446

Build Type

Pull #3934

github

Committed by

web-flow

Commit Message

Merge c0d1ce4ce into 368ea069c

Pull Request Pull Request #3934: Fix virtual surface crossing

Coverage Stats

17711 of 25585 branches covered (69.22%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 1 file covered. (100.0%)

2 existing lines in 2 files now uncovered.

58550 of 68129 relevant lines covered (85.94%)

47674112.13 hits per line

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

83.61

/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 "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 zero size container with space to hold capacity number of
  //! elements.
  //
  //! \param capacity The number of elements for the container to allocate
  //! space for
  SharedArray(int64_t capacity) : capacity_(capacity)
  {
    data_ = make_unique<T[]>(capacity);
  }

  //==========================================================================
  // 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;
  }

  //! Return the number of elements in the container
  int64_t size() { 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 "openmc/memory.h"
8
9	namespace openmc {
10
11	//==============================================================================
12	// Class declarations
13	//==============================================================================
14
15	// This container is an array that is capable of being appended to in an
16	// thread safe manner by use of atomics. It only provides protection for the
17	// use cases currently present in OpenMC. Namely, it covers the scenario where
18	// multiple threads are appending to an array, but no threads are reading from
19	// or operating on it in any other way at the same time. Multiple threads can
20	// call the thread_safe_append() function concurrently and store data to the
21	// object at the index returned from thread_safe_append() safely, but no other
22	// operations are protected.
23	template<typename T>
24	class SharedArray {
25
26	public:
27	//==========================================================================
28	// Constructors
29
30	//! Default constructor.
31	SharedArray() = default;
32
33	//! Construct a zero size container with space to hold capacity number of
34	//! elements.
35	//
36	//! \param capacity The number of elements for the container to allocate
37	//! space for
38	SharedArray(int64_t capacity) : capacity_(capacity)
39	{
40	data_ = make_unique<T[]>(capacity);
41	}
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]; }	299,903,711!
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,465✔
56	{
57	data_ = make_unique<T[]>(capacity);	8,210!
58	capacity_ = capacity;	7,465✔
59	}	7,465✔
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)	606,956,150✔
72	{
73	// Atomically capture the index we want to write to
74	int64_t idx;
75	#pragma omp atomic capture seq_cst	538,768,564✔
76	idx = size_++;	606,956,150✔
77
78	// Check that we haven't written off the end of the array
79	if (idx >= capacity_) {	606,956,150!
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;	606,956,150✔
87
88	return idx;	606,956,150✔
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()	26,749✔
94	{
95	data_.reset();	26,749✔
96	size_ = 0;	26,749✔
97	capacity_ = 0;	26,749✔
98	}	26,749✔
99
100	//! Return the number of elements in the container
101	int64_t size() { return size_; }	153,984,281!
102
103	//! Resize the container to contain a specified number of elements. This is
104	//! useful in cases where the container is written to in a non-thread safe
105	//! manner, where the internal size of the array needs to be manually updated.
106	//
107	//! \param size The new size of the container
108	void resize(int64_t size) { size_ = size; }	2,925,369✔
109
110	//! Return whether the array is full
111	bool full() const { return size_ == capacity_; }	2,147,483,647✔
112
113	//! Return the number of elements that the container has currently allocated
114	//! space for.
115	int64_t capacity() { return capacity_; }	94,083✔
116
117	//! Return pointer to the underlying array serving as element storage.
118	T* data() { return data_.get(); }	101,768✔
119	const T* data() const { return data_.get(); }
120
121	//! Classic iterators
122	T* begin() { return data_.get(); }	1,336✔
123	const T* cbegin() const { return data_.get(); }
124	T* end() { return data_.get() + size_; }
125	const T* cend() const { return data_.get() + size_; }
126
127	private:
128	//==========================================================================
129	// Data members
130
131	unique_ptr<T[]> data_; //!< An RAII handle to the elements
132	int64_t size_ {0}; //!< The current number of elements
133	int64_t capacity_ {0}; //!< The total space allocated for elements
134	};
135
136	} // namespace openmc
137
138	#endif // OPENMC_SHARED_ARRAY_H

openmc-dev / openmc / 25282275446

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