26672524104

Committed 30 May 2026 02:53AM UTC coverage: 81.34% (+0.007%) from 81.333%

Build # 26672524104

Build Type

push

github

Committed by

web-flow

Commit Message

Support endf.Material in `from_endf` methods (#3932)

Coverage Stats

17987 of 26081 branches covered (68.97%)

Branch coverage included in aggregate %.

35 of 35 new or added lines in 11 files covered. (100.0%)

1 existing line in 1 file now uncovered.

59133 of 68731 relevant lines covered (86.04%)

46519448.66 hits per line

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

80.36

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

  //! 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 {	11,177!
27
28	public:
29	//==========================================================================
30	// Constructors
31
32	//! Default constructor.
33	SharedArray() = default;	8,017✔
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)	3,160✔
39	{
40	data_ = make_unique<T[]>(size);	3,160!
41	}	3,160!
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,723,471✔
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,140✔
56	{
57	data_ = make_unique<T[]>(capacity);	7,986!
58	capacity_ = capacity;	7,140✔
59	}	7,140✔
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)	599,149,489✔
72	{
73	// Atomically capture the index we want to write to
74	int64_t idx;
75	#pragma omp atomic capture seq_cst	544,585,930✔
76	idx = size_++;	599,149,489✔
77
78	// Check that we haven't written off the end of the array
79	if (idx >= capacity_) {	599,149,489!
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;	599,149,489✔
87
88	return idx;	599,149,489✔
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()	42,256✔
94	{
95	data_.reset();	42,256✔
96	size_ = 0;	42,256✔
97	capacity_ = 0;	42,256✔
98	}	42,256✔
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)	19,412,440✔
106	{
107	if (size_ == capacity_) {	19,412,440✔
108	int64_t new_capacity = capacity_ == 0 ? 8 : 2 * capacity_;	45,421✔
109	unique_ptr<T[]> new_data = make_unique<T[]>(new_capacity);	45,421✔
110	std::copy_n(data_.get(), size_, new_data.get());	45,421✔
111	data_ = std::move(new_data);	45,421✔
112	capacity_ = new_capacity;	45,421!
113	}	45,421✔
114	data_[size_++] = value;	19,412,440✔
115	}	19,412,440✔
116
117	//! Return the number of elements in the container
118	int64_t size() { return size_; }	168,900,555!
119	int64_t size() const { return size_; }
120
121	//! Resize the container to contain a specified number of elements. This is
122	//! useful in cases where the container is written to in a non-thread safe
123	//! manner, where the internal size of the array needs to be manually updated.
124	//
125	//! \param size The new size of the container
126	void resize(int64_t size) { size_ = size; }	3,925,361✔
127
128	//! Return whether the array is full
129	bool full() const { return size_ == capacity_; }	2,003,557,446✔
130
131	//! Return the number of elements that the container has currently allocated
132	//! space for.
133	int64_t capacity() { return capacity_; }	94,639✔
134
135	//! Return pointer to the underlying array serving as element storage.
136	T* data() { return data_.get(); }	191,307✔
137	const T* data() const { return data_.get(); }
138
139	//! Classic iterators
140	T* begin() { return data_.get(); }	1,214✔
141	const T* cbegin() const { return data_.get(); }
142	T* end() { return data_.get() + size_; }
143	const T* cend() const { return data_.get() + size_; }
144
145	private:
146	//==========================================================================
147	// Data members
148
149	unique_ptr<T[]> data_; //!< An RAII handle to the elements
150	int64_t size_ {0}; //!< The current number of elements
151	int64_t capacity_ {0}; //!< The total space allocated for elements
152	};
153
154	} // namespace openmc
155
156	#endif // OPENMC_SHARED_ARRAY_H

openmc-dev / openmc / 26672524104

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