Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
New Features

This page contains the new features of each version of Arcane v3.X.X.

The successive new features brought by versions of Arcane prior to version 3 are listed here: Changelog Arcane v2.X.X

Arcane Version 4.1+ (March 2026)

New Features/Improvements

Accelerator API

Changes

  • Removes the template parameter MinValue in SpanImpl. This parameter was not used (PR #2255)
  • Makes certain methods of Item and derived classes constexpr (PR #2261, PR #2264)
  • Uses the STL thread implementation by default for IThreadImplementation instead of the TBB implementation PR #2379
  • Removes support for compilation without enabling threads (PR #2380)
  • Uses HIP instead of ROCM for the CMake variable ARCCORE_ACCELERATOR_MODE. The old name is still available for compatibility (PR #2457).

Corrections

Internal

Compilation and Continuous Integration (CI)

  • Removes support for old versions of TBB (before OneTBB 2021) : PR #2267
  • Adds support for "self-hosted" runners (PR #2279)
  • Removes the CMake option ARCANE_ADD_RPATH_TO_LIBS (PR #2304)
  • Replaces the CMake option ARCCORE_USE_MPI with ARCCORE_ENABLE_MPI (PR #2305)
  • Replaces the CMake option ARCCORE_WANT_TESTS with ARCCORE_ENABLE_TESTS (PR #2471)
  • Adds CMake properties INSTALL_RPATH_USE_LINK_PATH and BUILD_RPATH_USE_ORIGIN for Arccore libraries (PR #2331)
  • Updates IFPEN workflows (PR #2422, PR #2432, PR #2433)
  • Updates the codecov workflow (PR #2431)
  • Prevents merging in a Pull Request without performing a "rebase" (PR #2436, PR #2437)
  • Adds workflow for ROCM 7.2 (PR #2448)
  • Cleans up the compilation system for alien/ArcaneInterface (PR #2487, PR #2490)
  • By default, disables the display of deprecated methods during compilation (PR #2488)

Arccore

  • Adds new common component containing the collections and classes needed for the accelerator API (PR #2268)
  • In ITraceMng, uses std::mutex instead of Mutex (PR #2253)
  • Optimizes the construction/destruction of the SmallArray class (PR #2242)
  • Removes the retention of the number of elements of an SpanImpl when using a static dimension (PR #2241)
  • Moves JSON handling classes from arcane_utils to arccore_common (PR #2391)

Alien

Arcane Version 4.0.0 (October 15, 2025)

Version 4.0.0 is identical to version 3.16.12 and only removes C++17 support.

Arcane Version 3.16.12 (October 14, 2025)

Note
This version is the last to support the C++17 standard. Later versions (4+) require C++20 support.

New Features/Improvements

Accelerator API

Changes

Corrections

Internal

Compilation and Continuous Integration (CI)

  • Improves compatibility with Doxygen version 1.10.0 (PR #2001, PR #2003, PR #2014)
  • Adds a necessary workflow to apply 'Merge Requests' (PR #2004)
  • Removes workflows using ubuntu-20.04 because this operating system is no longer available on GitHub (PR #2023)
  • Corrects compilation error with oneTBB 2022 (PR #2050)
  • Adds support for .Net 9 (PR #2059)
  • Adds CMake option ARCANE_ENABLE_ALEPH to disable Aleph (PR #2075)
  • Adds IFPEN workflows using C++20 (PR #2027)
  • Removes the workflow using windows-2019 because it is no longer supported by github (PR #2117)
  • Adds the possibility to compile only Arccore from framework (PR #2125)
  • Adds preliminary support for compiling with Guix (PR #2128)
  • Adds Win32 workflow in debug mode (PR #2135)
  • Updates the compile-all-vcpkg workflow with vcpkg version 2025.06 (PR #2140)
  • Increases the number of tests in the Win32 workflow (PR #2162)
  • Adds workflow for MacOS 15 and MacOS 26 (PR #2166, PR #2167, PR #2188, PR #2192, PR #2208)
  • Adds Arcane installation in the compile-all-vcpkg workflow (PR #2182)
  • Switches to version 5 of actions/checkout (PR #2186)
  • Adds option --parallel 4 for ctest in IFPEN 2021 workflows (PR #2189, PR #2201)
  • Updates docker images to add CUDA 13 and CLANG 21 (PR #2190, PR #2191)
  • Removes vtu tests in the ARM64 workflow for CircleCI because the system VTK version contains a bug when reading XML (PR #2195)

Arccore

  • Moves certain classes from message_passing_mpi to the private API of Arccore (PR #1992)
  • Removes the MpiSerializeMessageList class which has not been used for a long time (PR #2000)

Alien

Arcane Version 3.15.3 (February 4, 2025)

New Features/Improvements

Accelerator API

Changes

Fixes

  • Fixes compilation with ROCM version 5 (PR #1852)
  • Fixes the number of the first uniqueId() generated after a restart when the mesh is empty, setting it to 0 instead of 1. This allows for the same numbering whether or not a restart occurs in this specific case (PR #1924)
  • Fixes memory leak for RunCommand created by RunQueue with a priority other than the default priority (PR #1927)
  • Fixes incorrect return values in GenericFilterer and GenericPartitioner when input arrays have a zero size (PR #1929)
  • Fixes missing call to MPI_Group_free when creating an IParallelMng from an IParallelMng (PR #1933)
  • Correctly recalculates synchronization information after the creation of an AMR patch (PR #1946)
  • Fixes memory leak in Aleph when creating Hypre, PETSc, or Epetra matrices (PR #1947)
  • Fixes array overflow if multi-threading is used with a single thread (PR #1954)
  • Fixes memory leaks in certain operations on the DOM (PR #1965)

Internal

Build and Continuous Integration (CI)

  • Removes the possibility of installing Arccore separately from Arcane. This ensures that Arccore and Arcane will always be consistent (PR #1865).
  • Simplifies component dependency management to speed up compilation (PR #1874).
  • Updates the compile-all-vcpkg workflow with version 2024.12 (PR #1894).
  • Adds compile-all-vcpkg workflow with ubuntu 24.04 (PR #1896)
  • Uses .Net 8 for certain compile-all-vcpkg workflows and adds C# wrapper tests (PR #1897)
  • Adds workflow for ROCM version 6.3.1 and 5.7.1 (PR #1899)
  • Uses .mli2 instead of .mli for Lima mesh files (PR #1904)
  • Updates CI images (PR #1905, PR #1915)
  • Adds workflow with -fsanitize=address (PR #1940, PR #1955)

Arccore

Alien

  • Removes use of boost::remove_reference and replaces it with std::remove_reference (PR #1844)
  • Fixes compilation when PETSc is compiled with MUMPS support (PR #1917)

Arcane Version 3.14.15 (December 11, 2024)

New Features/Improvements

Accelerator API

Changes

Fixes

Internal

  • Adds environment variable ARCANE_CUDA_MEMORY_HINT_ON_DEVICE to automatically call cudaMemAdvise() on unified memory to force it to use a specific allocator (PR #1833)
  • Calls Array::resizeNoInit() instead of Array::resize() when resizing material variables. Initialization is done later, which prevents double initialization (PR #1832)
  • Renames Adjency to Adjacency in certain classes and methods (PR #1823)
  • Adds command line option -A,UseAccelerator=1 to specify that accelerator execution is desired. The backend used will be automatically chosen based on the compilation configuration (PR #1815)
  • Adds typedef AlephInt which is used to specify the indices of rows and columns of matrices and vectors. Currently, this type is int, but when 64-bit support is active, it will be long int or long long int (PR #1770)
  • Frees serialization buffers as soon as possible during load balancing (PR #1744, PR #1756)
  • Adds an experimental service allowing mesh subdivision during initialization (PR #1606, PR #1728)
  • Makes the classes ItemBase and MutableItemBase public PR #1740
  • Adds an internal finalization method for the accelerator API. This allows statistics to be displayed and associated resources to be freed (PR #1727)
  • Adds tests for using multiple criteria with multi-mesh partitioning (PR #1719, PR #1772)
  • In BitonicSort, does not allocate arrays for ranks and indices if they are not used (PR #1680)
  • Uses a new hashing implementation for ItemInternalMap. This implementation is active by default, but the old one can be used by setting the option ARCANE_USE_HASHTABLEMAP2_FOR_ITEMINTERNALMAP to OFF during configuration (PR #1611, PR #1617, PR #1622, PR #1624, PR #1625, PR #1628, PR #1629, PR #1631, PR #1677, PR #1745)
  • Cleanup and refactoring of partitioning with ParMetis to use IParallelMng instead of calling MPI directly (PR #1662, PR #1665, PR #1667, PR #1671)
  • Adds support for creating a sub-communicator in the style of MPI_Comm_Split (PR #1669, PR #1672)
  • Cleanup and refactoring of classes managing the numbering of uniqueId() for edges (PR #1658)
  • Uses a pointer to mesh::DynamicMeshKindInfos instead of an instance in mesh::ItemFamily (PR #1646)
  • Adds to ICaseMeshService the possibility of performing operations after partitioning (PR #1637)
  • Adds internal API for IIncrementalItemConnectivity (PR #1615, PR #1618, PR #1626)
  • Adds a build type entry point for the unit test service (PR #1613)
  • Adds the possibility in IIncrementalItemConnectivity to notify of the addition of multiple entities at once (PR #1610)
  • Adds a method to retrieve the call stack via LLVM or GDB. This allows, in particular, obtaining line numbers in the call stack (PR #1572, PR #1597, PR #1616) TODO INDICATE METHOD
  • Adds experimental support for KDI (PR #1594, PR #1595, PR #1599)
  • Various optimizations in the VtkHdfV2PostProcessor service (PR #1575, PR #1600)
  • [EXPERIMENTAL] Adds a new version of face uniqueId() calculation based on the uniqueId() of the nodes that compose it. This only works in sequential mode for now (PR #1550)
  • Adds function to generate a uniqueId() from a list of uniqueId() (PR #1549)
  • Optimizes the calculation of the version 3 of ghost cells (PR #1547)

Build and Continuous Integration (CI)

  • Uses a dotnet wrapper for compilation. This wrapper ensures that the user's HOME is not modified, which could cause locking issues when multiple instances of dotnet run simultaneously (PR #1789, PR #1791, PR #1792, PR #1830)
  • Adds the possibility of adding libraries during the linking of arccore_message_passing_mpi. This ensures that certain libraries are properly added to the link and is notably used for MPI 'GPU-Aware' support with CRAY MPICH (PR #1786)
  • Adds 'ubuntu 22.04' workflow for IFPEN dockers (PR #1781)
  • Adds CMake variable ARCCON_NO_TBB_CONFIG to force not to use the CMake configuration file for TBB (PR #1779)
  • Adds protection/restart tests for coarsening (PR #1707)
  • Fixes compilation error when PETSc is not compiled with MUMPS (PR #1694)
  • Adds VTK reader test with properties (PR #1656, PR #1659)
  • Adds support for a connectivity checksum in mesh tests (PR #1654)
  • Writes test output files to the test directory to allow them to be run in parallel (PR #1541, PR #1653)
  • Updates IFPEN images 2021 (PR #1542, PR #1579, PR #1587, PR #1588, PR #1592, PR #1593, PR #1598)
  • Removes internal versions of hostfxr.h and coreclr_delegates.h. These files are now in the dotnet SDK (PR #1591)
  • Fixes FlexLM detection and configuration (PR #1602, PR #1630)
  • Removes test output directories after execution to reduce storage footprint (PR #1581)
  • Runs CI tests in parallel for multiple workflows (PR #1553)
  • Refactors the CI action system and images to make it more flexible (PR #1545)

Arccore

Axlstar

  • Replaces std::move() with std::forward() in the generation of certain methods (PR #1773)
  • Generates the methods to retrieve the functions associated with dataset options via the specified interface (PR #1601)
  • Removes the date from generated files so they are not modified if regenerated identically (PR #1797

Alien

Arcane Version 3.13.08 (July 19, 2024)

New Features/Improvements

Accelerator API

Changes

  • Removes the component managing vector expressions on variables as it has not been used for a long time (PR #1537)
  • Uses clock_gettime() instead of clock() to measure CPU time used (PR #1532)
  • By default, uses the parallel version of the MSH reader. It is always possible to use the sequential version by setting the environment variable ARCANE_USE_PARALLEL_MSH_READER to 0 ( PR #1528).
  • Removes support for C# compilation with mono. dotnet (version 6 or higher) must now be used (PR #1470).
  • Renames ArrayIndex to MDIndex (PR #1397).
  • Adds the possibility of retrieving an ComponentCell from an ComponentItemVectorView (PR #1478)

Fixes

  • Fixes various bugs in mesh graph management (PR #1536, PR #1535)
  • Fixes potential concurrency issues in multi-threaded mode (PR #1467, PR #1534, PR #1533, PR #1529)
  • Adds support for 1D meshes in the VtkHdfV2 format (PR #1519)
  • Re-enables signal sending in a signal handler. This had been implicitly disabled when using sigaction instead of sigset to position signals (PR #1518)
  • Fixes reading groups in the MSH format when there are multiple groups per physical entity (PR #1507, PR #1509).
  • Adds verification tests in the use of partial variables (PR #1485)
  • Explicitly indicates the underlying type for eDataType (PR #1418)
  • Fixes memory reuse issue for reductions introduced during the creation of version 2 of reductions (PR #1439).
  • Fixes potential incorrect calculation of the number of entities to serialize, which could result in an array overflow (PR #1423).
  • Does not keep behavioral change properties in MeshMaterialModifier to avoid inconsistencies (PR #1453).

Internal

Continuous Integration (CI)

  • Adds Python tests in certain workflows (PR #1448, PR #1526).
  • Updates Ubuntu images (PR #1417, PR #1442, PR #1503).
  • Activates ccache for the codecov workflow (PR #1464).
  • Switches to vcpkg version 2024.04 for the compile-all-vcpkg workflow (PR #1450).
  • Uses a specific CMake variable to enable test coverage (PR #1444, PR #1445).
  • Updates CI to no longer use obsolete GitHub actions (PR #1416).
  • Updates CI for IFPEN dockers (PR #1402, PR #1409)
  • Adds the possibility of using accelerator tests via googletest (PR #1401, PR #1403).
  • Explicitly uses the sequential message exchange service for sequential tests (PR #1430).

Arccore

Axlstar

  • Improvement of documentation generated from AXL files (PR #1452)

Alien

Arcane Version 3.12.18 (May 02, 2024)

Note
With this version, it is necessary to enable C++20 to use the accelerator API. To do this, you must set the CMake variable ARCCORE_CXX_STANDARD=20 during configuration. You must then have at least GCC 11, Clang 16, or Visual Studio 2022, as well as CMake version 3.26.

New Features/Improvements

Accelerator API

Changes

Fixes

  • Fixes memory leak with asynchronous commands when RunQueue::barrier() is not called. This should normally not happen because barrier() must always be called after an asynchronous command. Now, if commands are active when the \arcanacc{RunQueue} is destroyed, an implicit barrier is performed (PR #995)
  • Fixes incorrect return type of MatItemVariableScalarOutViewT::operator[]() which did not allow modifying the value (PR #981).
  • Fixes incorrect property consideration when creating material variables in certain cases (PR #1012).
  • Fixes incorrect value for the Z dimension for 3D de-refinement (PR #1074)
  • Fixes renumbering of new entities in Cartesian meshes after 2D de-refinement (PR #1055).
  • Fixes various issues in the management of the AllCellToAllEnvCellAccessor class (PR #1071, PR #1133, PR #1188)
  • Ensures that the associated global variable is properly allocated when constructing a material variable (PR #1056)
  • Fixes incorrect return value of ItemInternal.Cell() in the C# wrapper (PR #1131)
  • Fixes version 2 serialization when using MPI_ANY_SOURCE (PR #1116)
  • Fixes missing synchronization update when de-refining but not refining afterward (PR #1266)
  • Fixes various compilation issues (PR #1044, PR #1047, PR #1280, PR #1309)
  • Fixes potential incorrect SIMD padding update in the update of ItemGroup (PR #1165)
  • Uses the CMake variable CMAKE_CUDA_HOST_COMPILER to specify the host compiler associated with CUDA instead of enforcing the NVIDIA compiler option -ccbin (PR #1386)
  • Fixes compilation with ROCM 6.0 (PR #1170)
  • Fixes compilation with Swig 4.2 (PR #1098)
  • Fixes compilation with LibXml2 versions 2.12.0 and later (PR #1019).

Internal

Continuous Integration (CI)

  • Updates the U22_G12_C15_CU122 image (PR #1031)
  • Removes the use of targets using CUDA 11.8 ( PR #1078)
  • Updates the vcpkg workflow to version 2023-12-12 (PR #1076)
  • Uses C++20 for the compile-all-vcpkg workflow (PR #1048)
  • By default, sets CMAKE_BUILD_TYPE to Release if this variable is not specified during configuration (PR #1149)
  • Adds the macro ARCANE_HAS_ACCELERATOR if Arcane is compiled with accelerator support (PR #1123)
  • Adds support for using 'googletest' with MPI cases (PR #1092)
  • Removes the use of Clang13 in CI (PR #1083)
  • Modifies the IFPEN workflow to compile all framework components directly (PR #1214, PR #1281)
  • Deactivates ongoing tests if a modification is published in the 'pull-request' branch (PR #1250)
  • Adds workflow for IFPEN 2021 with RHEL versions 7, 8, and 9 (PR #1255)
  • Updates certain obsolete actions (PR #1218,PR #1222)
  • Uses C++20 for certain workflows (PR #1189)

Arccore

Axlstar

Alien

Arcane Version 3.11.15 (November 23, 2023)

New Features/Improvements

Accelerator API

  • In Reducer, uses HostPinned memory instead of standard host memory to retain the reduced value. This allows for faster memory copying between GPUs (PR #782)
  • Adds missing ARCCORE_HOST_DEVICE macros for array size checking methods (PR #785).
  • Adds method RunQueue::platformStream() to retrieve a pointer to the associated native instance (cudaStream or hipStream, for example) (PR #796).
  • Adds accelerator support for version 6 and version 8 of material synchronizations (PR #855).
  • Adds support to retrieve the number of environment in a mesh (PR #860)
  • Adds views on the environment variable (PR #904).
  • Adds support for inclusive and exclusive Scan algorithms via the Scanner class (PR #921, PR #923).
  • Adds accelerator access to certain methods of AllEnvCell and EnvCell (PR #925).
  • Adds support for array filtering (PR #954, PR #955).
  • Adds asynchronous copy method for NumArray and variables on the mesh (PR #961, PR #962)
  • Adds asynchronous fill method NumArrayBase::fill() (PR #963, PR #964).

Changes

Corrections

  • In the MSH format, corrects incorrect reading of node groups when there is only one element in that group (PR #784).
  • Corrects compilation of ArrayExtentsValue for dimension 2 with Clang and NVCC compilers (PR #786).
  • Corrects compilation of C# examples if the environment is not available. Also sets the environment variable LD_LIBRARY_PATH if necessary (PR #811).
  • Corrects the optimization mode eModificationFlags::OptimizeMultiMaterialPerEnvironment to behave the same as other value update optimization modes when transitioning from a partial cell to a pure cell. The expected behavior is to take the partial material value and the partial environment value. To maintain backward compatibility, this mode is not active by default. The method IMeshMaterialMng::setUseMaterialValueWhenRemovingPartialValue() allows it to be activated (PR #844, PR #957).
  • Corrects a bug in DoF synchronization under certain conditions (PR #920).
  • Corrects memory leak in the accelerator management of AllEnvCell (PR #931).
  • Corrects incorrect accounting of additional meshes for complex options with multiple occurrences (PR #941).

Internal

Continuous Integration (CI) and Compilation

  • Adds example compilation in CI (PR #809).
  • Updates docker images in CI (PR #818)
  • For Arccore, compiles with the Z7 option under Windows and adds debug symbols. The Z7 option allows the use of the ccache tool (PR #821)
  • Uses 'GitHub actions' to simplify CI. This allows for composable high-level actions rather than duplicating code in every workflow (PR #849).
  • Uses a docker image for CI with 'Circle-CI' and adds an execution for ARM64 platforms (PR #887).
  • Adds CMake variable ARCANEFRAMEWORK_BUILD_COMPONENTS allowing specification of components to compile. This variable is a list that can contain Arcane and Alien. By default, both components are compiled (PR #877)
  • Deletes artifacts after retrieval to save disk space (PR #915).
  • Removes default activation of the CMake variable ARCANE_ADD_RPATH_TO_LIBS. This variable is obsolete and will be removed later (PR #919).
  • Removes the test output directory in CI to save disk space (PR #924).

Arccore

Axlstar

  • Improves support for old versions of Doxygen (PR #823).

Arcane Version 3.10.11 (June 30, 2023)

Starting with version 3.10, internal connectivity management modifications are planned to reduce memory consumption for Cartesian or structured meshes. The page Entity Connectivity Optimizations describes the planned evolutions and potential modifications required in Arcane user codes.

Deprecated Elements

New Features/Improvements

  • Creation of a SmallArray class to manage small-sized arrays with stack-allocated memory (PR #615, PR #732).
  • Adds the possibility in the Aleph PETSc implementation to pass arguments that will be used to initialize PETSc via the call to PetscInitialize() (PR #621).
  • Adds a post-processing writer in VTK HDF V2 format. This format allows multiple post-processing runs to be placed in the same HDF5 file (PR #637, PR #638, PR #639).
  • Improves memory management of connectivities during mesh creation. Arrays are pre-allocated to avoid successive copies when adding entities one by one (PR #689, PR #763).
  • Adds method MDSpan::slice() to return a view on a sub-part of the initial view (PR #690).
  • Possibility to dynamically calculate the output directory name in SimpleTableWriterHelper (PR #607).
  • Adds SHA3 hash calculation functions (PR #695, PR #697, PR #705).
  • Adds ItemGenericInfoListView class to make generic entity information accessible on the accelerator (such as Item::owner(), Item::uniqueId(), ...) (PR #727).
  • Optimizes ItemGroup::applyOperation() to avoid going through sub-groups and to directly use the base group if all entities are of the same type. This mechanism is not active by default. The environment variable ARCANE_APPLYOPERATION_VERSION must be set to 2 to use it (PR #728).
  • Adds operators -=, *= and /= for views (via DataSetter) {PR #733).
  • Adds Vector3 class to generalize Real3 for other types (PR #750).
  • Adds events for IMesh to be notified of calls to IMesh::prepareForDump() PR #771.

Accelerator API

  • Support for memory copies with indexing on the accelerator (PR #617, PR #625, PR #658, PR #773)
  • Partial integration of CUPTI (CUDA Profiling Tools Interface) allowing automatic retrieval of profiling information on NVIDIA cards. For example, this allows retrieving information on memory transfers between the CPU and the GPU (PR #627, PR #632, PR #642).
  • CUDA support for tracing managed memory allocations/deallocations and for allocating multiple page-sized blocks (PR #641, PR #672, PR #685, PR #693).
  • Support for synchronizations with MPI's 'Accelerator Aware' mode. This allows synchronizations without memory copying between the CPU and the accelerator. This mechanism is also available in shared memory message exchange mode and hybrid mode (PR #631, PR #644, PR #645, PR #646, PR #654, PR #661, PR #680, PR #681, PR #765).
  • Accelerator support to determine if a given memory address is accessible on the accelerator, on the CPU, or both. Also adds two macros ARCANE_CHECK_ACCESSIBLE_POINTER() and ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS() to verify that a memory region is to be used in a RunQueue (PR #660).
  • Accelerator support to specify information about variable memory allocation (IVariable::setAllocationInfo()). This allows, for example, indicating whether a variable will be accessed on the accelerator or on the CPU (PR #684).
  • Adds method MeshUtils::markMeshConnectivitiesAsMostlyReadOnly() to indicate that the variables managing connectivity will not be frequently modified. This allows optimizing memory management between the accelerator and CPU to avoid copies. By default, entity groups (ItemGroup) use this attribute (PR #691, PR #714).
  • Makes information stored in AllEnvCell accessible on the accelerator (PR #742).
  • Adds views based on Span to the accelerator API. This allows having views on containers other than those of Arcane (for example std::vector) as soon as the data is contiguous in memory (PR #770).
  • Allows copying NumArray from different memory regions (PR #651).
  • Support for the new interface IMemoryAllocator3 in accelerator allocators (PR #671, PR #674).

Changes

  • Allows copying an instance of Runner using reference semantics (PR #623).
  • On the accelerator, a specific kernel is used by default across the entire grid for reductions. Previously, a kernel was used that mixed atomic operations and calculation on blocks (PR #640).
  • Uses accelerator memory for reduction operations. Previously, managed memory was used (PR #643, PR #683).
  • Changes the node numbering of hexagonal cells for HoneyCombMeshGenerator (PR #657).
  • Groups the functions of mesh_utils and meshvisitor into the MeshUtils namespace (PR #725).
  • Moves internal Arcane methods from IMesh and IItemFamily into an internal interface (PR #726, PR #738, PR #752, PR #768).
  • In bit-by-bit comparisons, differences are not considered if both values being compared are NaN.
  • Adds display of time spent in MPI initialization and accelerator runtime (PR #760).
  • Automatically calls ICartesianMesh::computeDirections() after a call to IMesh::prepareForDump(). This ensures that Cartesian information is consistent after potential compaction (PR #772).

Corrections

  • Correctly handles the destruction of StandaloneSubDomain singleton instances. Previously, the instance was destroyed in global destructors after main() finished, which could cause problems in some cases (PR #619).
  • Corrects errors in the copy constructor of NumArray (PR #717).
  • In FloatingPointExceptionSentry, the exception handling flag is set unconditionally. Previously, it was tested whether exceptions were active, and if not, nothing was done. Since this detection mechanism is not always reliable, it is removed (PR #720).
  • Saves the mesh modification timestamp (IMesh::timestamp()) and the need-compact attribute in protections to ensure the same behavior with or without restoration. Notably, need-compact was always set to true during restoration, causing compaction to always occur at least once after restoration. Since the entities were compacted, this did not change the results, but it could cause reallocations that invalidated calculated structures such as Cartesian mesh information (PR #739, PR #756)
  • Corrects the use of MeshReaderMng::setUseMeshUnit() which was not taken into account when the data set language is French (PR #754).
  • Removes unnecessary reallocation in AbstractArray when the new capacity is identical to the old one (commit cac7fae3c471f6).

Internal

  • Starting support for dynamically creating services containing data set options (PR #613).
  • Removes use of ISubDomain in certain parts (PR #620).
  • Adds function to retrieve command line arguments (PR #624).
  • Removes coverity warnings (PR #626, PR #692).
  • Makes certain methods of Materials::IMeshComponent const (PR #630).
  • Various improvements to accelerator management (PR #647).
  • Corrects compilation with PAPI 7.0 and PETSc 3.19 (PR #648).
  • Adds a field of type Int32 in different classes managing connectivities to handle an offset on the localId(). Currently, this is not used and the offset is always 0 (PR #649, PR #712, PR #723, PR #736, PR #737, PR #744)
  • Support for using a specific parallel driver to run tests (PR #663).
  • Replaces the use of ENUMERATE_* to access connectivities with for-range (PR #666, PR #759).
  • Adds a specific interface to create Cartesian meshes. This will eventually allow specialized methods for these meshes to be provided so that generation is faster and directly uses the correct numbering (PR #694, PR #749, PR #751).
  • Adds typedefs in MDSpan to retrieve the type of the element and the Layout (PR #699).
  • Adds support for using common hashes in BasicReaderWriter, which can be used for bit-by-bit comparisons and generalizes the mechanism for accessing this hash base (PR #698, PR #700, PR #701).
  • Adds adapter for the Redis database {PR #702).
  • Internal refactoring of the synchronization mechanism to make it independent of the data type (PR #704, PR #708, PR #709, PR #711)
  • Uses a single buffer for multiple variable synchronization instead of going through serialization (PR #710).
  • Adds MeshKind class to manage properties on the mesh structure (Cartesian, unstructured, AMR, ...) (PR #718).
  • Adds a specific macro for obsolete methods, which will not be immediately removed, in order to disable compilation warnings for these methods. This allows user code to suppress compilation warnings for these methods if the macro ARCANE_NO_DEPRECATED_LONG_TERM is defined during compilation (PR #722).
  • Adds the possibility to display the CPU affinity of all ranks (PR #729).
  • For VTK HDF formats, adds information on the Item::uniqueId() of nodes and cells (PR #741).
  • Improves continuous integration to avoid running tests if only certain files are modified (for example, only .md) and adds date and license verification (PR #743, PR #745).
  • Makes the methods of ItemInternalConnectivityList internal to Arcane and simplifies class management by grouping connectivity information into a substructure (PR #640).
  • Moves the ItemGroupImplPrivate class into its own file (PR #730).
  • Makes the function Arcane::arcaneCheckAt() constexpr (PR #746).

Arccore (2.5.0)

  • Propagates the source allocator in the constructor and copy constructor of UniqueArray and UniqueArray2 (PR #635, PR #656).
  • Uses Span instead of ConstArrayView for certain arguments to allow views whose size exceeds 2Go (PR #635).
  • Avoids the construction of default elements that will subsequently be overwritten in AbstractArray::_resizeAndCopyView(). This also allows this method to be used with data types that do not have a default constructor (PR #635).
  • No longer performs minimal allocation even if an allocator other than the default allocator is used. Previously, at least 4 elements were always allocated (PR #635).
  • Corrects unnecessary double allocation in Array::operator=() if the two arrays do not have the same allocator (PR #655).
  • Allows displaying the exception message in the Exception constructor. This is useful for debugging exceptions outside of try{ ... } catch or exceptions that throw other exceptions (PR #659).
  • Adds IMemoryAllocator3 interface which enriches IMemoryAllocator to pass more information to the allocator. This allows, for example, adding the allocated size or the array name (PR #662, PR #673, PR #677, PR #713, PR #719).
  • Adds Int8 and BFloat16 types to Arccore::eBasicDataType (PR #669)
  • Adds various conversion functions between Span and std::array. Also adds the subPart and subPartInterval methods common to ArrayView, ConstArrayView and Span (PR #670).
  • Removes coverity warnings (PR #675).
  • Support for naming Array arrays. This is used in IMemoryAllocator3 to display allocation information (PR #676, PR #682).
  • Moves operators such as '==', '!=', '<<' and '<' into the corresponding classes as a friend function (PR #703).
  • Deprecates the methods ArrayView::range(), Span::range() and AbstractArray::range(). These methods generate temporary objects, which can cause problems when used in for-range loops. You can directly use the begin() or end() methods instead (PR #757).

Axlstar (2.2.0)

  • Adds, for experimentation, the possibility of specifying multiple types (caseoption, subdomain, ...) for services (PR #715).

Arcane Version 3.9.5 (April 4, 2023)

New Features/Improvements

Changes

Fixes

  • Fixes data set group retrieval in the case of multiple meshes. It always took the default mesh to search for groups even if the option was associated with another mesh (PR #604).
  • Fixes incorrect search bar dimension in the documentation in certain cases (PR #597).
  • Fixes incorrect usage of the initial partitioner when multiple meshes are present in the data set. The partitioner only defined variables on the first mesh, which introduced inconsistencies (PR #592).
  • Fixes incorrect detection of Cartesian connectivities in the Y direction in 3D (PR #590).
  • Fixes parallel blocking in the VTK reader if there are only connectivities in the mesh (PR #589).
  • Fixes incorrect mesh type when using sub-meshes ranging from a 2D mesh to a 1D mesh (PR #587).
  • Fixes possible ambiguity when constructing classes derived from Arcane::Item (PR #579).

Internal

Arccore (version 2.2.0)

Arcane Version 3.8.15 (February 22, 2023)

New Features/Improvements

Changes

  • Always uses a class instead of an integer to specify dimensions (extents) in the Arcane::NumArray and Arcane::MDSpan classes. This allows getting closer to the implementation planned in the C++23 standard and having static (compile-time known) dimensions (PR #419, PR #425, PR #428).
  • Removes timers that use CPU time instead of elapsed time. The Arcane::Timer::TimerVirtual type still exists but now behaves like the Arcane::Timer::TimerReal type (PR #421).
  • Removes the template parameter with the array rank in the Arcane::DefaultLayout, Arcane::RightLayout, and Arcane::LefLayout classes (PR #436).
  • Deprecates methods in Arcane::ModuleBuildInfo that use Arcane::IMesh. Methods that use Arcane::MeshHandle must be used instead. (PR #460).
  • Changes the return type of Arcane::IMeshBase::handle() so that it does not return a reference but a value (PR #489).
  • Uses specific base classes by service type when generating axl files (PR #472).
  • Uses a new class Arcane::ItemConnectedListView (instead of Arcane::ItemVectorView) to manage connectivities on entities. Methods such as Arcane::Cell::nodes() now return an object of this type. The purpose of this new class is to be able to propose a data structure specific to connectivities and another specific to entity lists (such as Arcane::ItemGroup groups). Conversion operators have been added to ensure compatibility with existing source code (PR #534,PR #535, PR #537, PR #539)
  • New VTK HDF format dump service. This format is only supported by Paraview versions 5.11+. The current implementation is experimental (PR #510, PR #525, PR #527, PR #528 PR #554, PR #546).
  • Moves header files of the arcane_core component, which were in the root of arcane, to a subdirectory arcane/core. To remain compatible with existing header files referencing these new files, they are generated during installation.
  • Adds an arcane_hdf5 component containing utility classes (such as Arcane::Hdf5::HFile, ...). The corresponding header files are now in the arcane/hdf5 directory (PR #505).
  • Cleanup of HDF5 managing classes: deprecates the copy constructor of classes in Hdf5Utils.h and removes support for HDF5 versions older than 1.10 (PR #526).
  • Allows the creation of null instances of Arcane::ItemGroup before the initialization of Arcane. This allows, for example, having global Arcane::ItemGroup variables or derived classes (PR #544).
  • Modifies the behavior of the ENUMERATE_COMPONENTITEM macro to use a type instead of a character string in the enumerator name. This allows it to be used with a template parameter (PR #540).

Fixes

Internal

Arccore

Axlstar

  • Add support for using a specific mesh in service instance (PR #451)
  • Remove support to build with mono (PR #465).
  • Remove support for 'DualNode' and 'Link' items (PR #524).
  • Various improvements in documentation (PR #530).
  • Add preliminary support for multi-dimension variables (PR #520).
  • Fix: Add support of Doxygen commands in AXL descriptions (PR #538)
  • Fix: error with complex options containing more than 30 suboptions (PR #533)

Arcane Version 3.7.23 (November 17, 2022)

New Features/Improvements:

Changes:

Fixes:

  • Fixes bug when reading information with the BasicReaderwriter service when compression is active (PR #299)
  • Fixes bug introduced in version 3.6 that changed the output directory name for bit-by-bit comparisons with the ArcaneCeaVerifier service (PR #300).
  • Fixes incorrect recalculation of the maximum number of entities connected to an entity in the case of particles (PR #301)

Internal:

Arccon:

Uses version 1.5.0:

  • Add CMake functions to unify handling of packages arccon Arccon componentbuildBuild configuration (PR #342).

Arccore:

Uses version 2.0.12.0:

  • Remove some coverity warnings (PR #400)
  • Use a reference counter for IMessagePassingMng (PR #400)
  • Fix method asBytes() with non-const types (PR #400)
  • Add a method in AbstractArray to resize without initializing (PR #400)
  • Make class ThreadPrivateStorage deprecated (PR #400)

Arcane Version 3.6.13 (July 06, 2022)

New Features/Improvements:

Changes:

  • The classes managing materials are split into two components. One part is now in the arcane_core component. This change is normally transparent to Arcane users and requires no modification of the sources (PR #264,PR #270,PR #274)
  • References are compacted after calling Arcane::IItemFamily::compactItems(). This prevents the array containing internal entity information from unnecessarily growing. Since this change can introduce a difference in the order of certain operations, it is possible to disable it by setting the environment variable ARCANE_USE_LEGACY_COMPACT_ITEMS to the value 1 (PR #225).
  • The types managing the localId() associated with entities (Arcane::NodeLocalId, Arcane::CellLocalId, ...) are now typedefs of a template class Arcane::ItemLocalIdT.
  • The different overloads in the variable access operators (operator[]) are removed. You must now use an 'Arcane::ItemLocalIdT' as the indexer. Conversion operators to this type have been added to keep the source code compatible.
  • Variables that were still allocated when calling Arcane::IVariableMng::removeAllVariables() are automatically unregistered. This prevents crashes when references to variables still existed after this call. This can notably happen with C# extensions because the associated services and modules are managed by a 'Garbage Collector' (PR #200).
  • The use of Arcane::Timer::TimerVirtual is deprecated. Timers that use this property behave as if they had the Arcane::Timer::TimerReal attribute.

Corrections:

Internal:

Axlstar version 2.0.3.0 update:

Arccore version 2.0.11.0 update:

  • Adds function mpDelete() to destroy IMessagePassingMng instances (PR #258)
  • Optimizations in class String(PR #256,PR #247)
    • Add move constructor String(String&&) and move copy operator operator=(String&&)
    • Make String destructor inline
    • Make method String::utf16() deprecated (replaced by StringUtils::asUtf16BE())
    • Methods String::bytes() and String::format no longer throws exceptions
    • Add a namespace StringUtils to contain utilitarian functions.
  • Add support for multisubscript operator[] from C++23 (PR #241)
  • Add operator() to access values of ArrayView, ArrayView2, ArrayView3, ArrayView4, Span, Span2 and const versions of these views (PR #223).
  • Add SmallSpan2 implementation for 2D arrays whose size_type is an Int32 (PR #223).
  • Add SpanImpl::findFirst() method (PR #211)
  • Fix build on Ubuntu 22.04

Arcane Version 3.5.7 (April 7, 2022)

New Features/Improvements:

  • Adds class Arcane::SimdReal3x3 and Arcane::SimdReal2x2, which are the vector equivalents of Arcane::Real3x3 and Arcane::Real2x2
  • Support for version 4.2 of VTK format mesh files
  • Adds a new synchronization implementation that uses the MPI_Sendrecv call.
  • Adds the possibility of using collective messages (MPI_AllToAllv) instead of point-to-point messages when exchanging entities following a load balance. This mechanism is temporarily accessible by specifying the environment variable ARCANE_MESH_EXCHANGE_USE_COLLECTIVE (PR #138,PR #154).
  • In bit-by-bit comparison, adds the possibility of only performing the comparison at the end of execution instead of doing it at every time step. This is done by specifying the environment variable STDENV_VERIF_ONLY_AT_EXIT.
  • Adds a 3D honeycomb mesh generator (PR #149).
  • Adds support for specifying the element layout in the Arcane::NumArray class. Two layouts are currently implemented: LeftLayout and RightLayout (PR #151)
  • Adds method Arcane::Accelerator::RunQueue::copyMemory() to perform asynchronous memory copies (PR #152).
  • Improves ROCM/HIP support. AMD GPU support is now functionally equivalent to NVIDIA GPU support via Cuda (PR #158, PR #159).
  • Adds support for pinned memory (Host Pinned Memory) for CUDA and ROCM (PR #147).
  • Adds class 'Arcane::Accelerator::RunQueueEvent' to support events on 'Arcane::Accelerator::RunQueue' and thus allow synchronization between different queues (PR #161).

Changes:

  • Removes the more used macros ARCANE_PROXY and ARCANE_TRACE (PR #145)

Corrections:

  • Fixes incorrect detection of OneTBB version 2021.5 following the removal of the 'tbb_thread.h' file (PR #146)
  • Fixes certain missing Cartesian information when there is only one cell layer in Y or Z (PR #162).
  • Fixes missing implementation of 'Arccore::Span<T>::operator==' when the type T is not constant (PR #163).
  • Removes some overly numerous listing messages.

Internal:

Arcane Version 3.4.5 (February 10, 2022)

New Features/Improvements:

  • In the accelerator API, Arcane::NumArray now supports directly allocating memory on the accelerator. Previously, only unified memory was available. The enumeration Arcane::eMemoryRessource and the type Arcane::IMemoryRessourceMng allow this to be managed (PR #111, PR #113).
  • Minor improvements to documentation (PR #117):
    • Added relative paths for header files.
    • Added classes and types from Arccore
  • Adds a new method for calculating the uniqueId() of faces in the Cartesian case. This new method allows for a Cartesian numbering of faces that is consistent with those of nodes and cells. To use it, you must specify the option <face-numbering-version>4</face-numbering-version> in the data set within the mesh generator tag (PR #104).
  • Adds an option in the Arcane post-processor to suppress dump output at the end of the calculation.
  • Adds implementation of Arcane::IParallelMng::gather() and Arcane::IParallelMng::gatherVariable() for shared memory mode and hybrid mode
  • Adds the list of environment in which the material is present to Arcane::Materials::MeshMaterialInfo
  • Supports compilation with the NVIDIA HPC SDK.
  • Supports (partially) deallocating the mesh (Arcane::IPrimaryMesh::deallocate()), which allows it to be reallocated later.
  • Adds a 2D honeycomb mesh generator.

Changes:

  • Adds the 'Arcane::' namespace to the CMake targets provided by Arcane. For example, the 'arcane_core' target becomes 'Arcane::arcane_core'. Old names remain valid (PR #120).
  • Deprecates the conversion of Arcane::ItemEnumerator to Arcane::ItemEnumeratorT. This prevents accidentally indexing a mesh variable with an enumerator of the wrong type (for example, indexing a variable in cells with a node enumerator).

Corrections:

  • Fixes the 'operator=' for the 'Arcane::CellDirectionMng' class (PR #109)
  • Fixes unnecessary Int64 to Int32 conversion in the construction of Cartesian meshes, which prevented exceeding 2^31 cells (PR #98)
  • Fixes incorrect calculation of time spent in synchronizations. Only the time of the last wait was used instead of the cumulative time (commit cf2cade961)
  • Fixes name collision for the 'MessagePassingService' option on the command line (commit 15670db4)

Internal:

  • Cleanup of the Accelerator API

Arccore version 2.0.8.1 update:

  • Improve doxygen documentation for types and classes in message_passing component.
  • Add functions in message_passing component to handle non blocking collectives (PR #116, PR #118)
  • Add some '#defines' to compile with hipSYCL.
  • Update '_clang-format' file for version 13 of LLVM/Clang.

Arcane Version 3.3.0 (December 16, 2021)

New Features/Improvements:

Changes:

Corrections:

Internal:

  • Cleanup of synchronization message management
  • Begins accelerator support for ROCM/HIP (AMD) version
  • Support for glibc version 2.34, which no longer contains memory management 'hooks' (this mechanism has been obsolete for years).
  • Adds the possibility of compiling with the C++20 standard.

Arccore version 2.0.6.0 update:

  • Update Array views (PR #76)
  • Separate metadata from data in 'Arccore::AbstractArray' (PR #72)
  • Deprecate Arccore::Array::clone(), Arccore::Array2::clone() and make Arccore::Array2 constructors protected (PR #71)
  • Add support for compilation with AMD ROCM HIP (e5d008b1b79b59)
  • Add method Arccore::ITraceMng::fatalMessage() to throw an Arccore::FatalErrorException in a method marked [[noreturn]]
  • Add support to compile with C++20 with ARCCORE_CXX_STANDARD optional CMake variable (665292fce)
  • [INTERNAL] Add support to change return type of IMpiProfiling methods. These methods should return int instead of void
  • [INTERNAL] Add methods in MpiAdapter to send and receive messages without gathering statistics
  • [INTERNAL] Add methods in MpiAdapter to disable checking of requests. These checks are disabled by default if CMake variable ARCCORE_BUILD_MODE is Release

Arcane Version 3.2.0 (November 15, 2021)

New Features/Improvements:

Changes:

  • CMake version 3.18 on Unix machines and CMake 3.21 on Windows.
  • Deprecates the singleton() method in Arcane::ItemTypeMng. Instances of this class are attached to the mesh and can be retrieved via Arcane::IMesh::itemTypeMng().
  • Moves the classes managing the Cartesian mesh to the arcane/cartesianmesh directory. Old paths in arcane/cea remain valid.
  • By default, uses version 3 (instead of 2) of the ghost cell creation service. This version is more efficient when using a large number of subdomains because it uses collective communications.
  • Removes memory preallocation for old connectivities.
  • Makes the constructors of Arcane::ItemSharedInfo private to Arcane
  • Raises a fatal exception if task support is requested but no implementation is available. Previously, there was only a warning message.

Corrections:

  • Fixes crash (SEGV) when using tasks and subtasks sequentially.

Arcane Version 3.1.2 (October 21, 2021)

New Features/Improvements:

Changes:

  • The mesh reader for the GMSH format is now in the arcane_std library instead of arcane_ios. Therefore, there is no longer a need to perform linking with the latter to be able to read meshes of this format.
  • Removal of old entity types Link and DualNode and associated enumerations and classes
  • Removal of certain classes associated with old connectivities
  • Removes support for the RedHat 6 operating system.

Corrections:

  • Fixes crash when updating materials if the global variable associated with a material is deallocated (Arcane::IVariable::isUsed()==false)
  • Fixes floating point exception (FPE) with versions 2.9.9+ of libxml2. This library explicitly performs division by 0 during initialization.

Arcane Version 3.0.5 (September 30, 2021)

New Features/Improvements:

Changes:

Corrections:

Arcane Version 3.0.3 (Not released)

New Features/Improvements:

  • Support for parallel AMR by patch
  • Adds an Arcane::SimpleSVGMeshExporter class to export a set of meshes in SVG format
  • Support for patch AMR in the Arcane::DirNode class for neighboring cells by direction.
  • During group synchronization, ensures that all subdomains have the same groups and that synchronization occurs in the same order.

Changes:

Corrections:

  • In patch AMR, ensures that neighboring entities by direction are always in the same patch level.
  • Fixes some missing dependencies during compilation that could cause compilation errors in certain cases.
  • Fixes compilation errors in examples outside the source directory.

Arcane Version 3.0.1 (May 27, 2021)

This version is the first 'open source' version of Arcane.

New Features/Improvements:

  • New version of the Arcane::BasicReaderWriter read/write service to generate fewer files and support compression. This service can be used for both backups/restorations and bit-by-bit comparison of variables. The C# variable comparison utility has been updated to support this new version.
  • Support for 'msh' format mesh files version 4.1. This version allows specifying groups of faces or cells in the mesh file.
  • Internally, uses a single executable for all C# utilities.

Changes:

  • Adds the possibility during Arcane compilation to specify required packages and not search for default packages.