Arcane  v3.14.10.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ArcaneGlobal.h
Aller à la documentation de ce fichier.
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ArcaneGlobal.h (C) 2000-2024 */
9/* */
10/* Déclarations générales de Arcane. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_UTILS_ARCANEGLOBAL_H
13#define ARCANE_UTILS_ARCANEGLOBAL_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arccore/base/ArccoreGlobal.h"
18
19// Infos globales sur les options de compilation comme
20// les threads, le mode debug, ...
21#include "arcane_core_config.h"
22
23#ifdef ARCCORE_OS_LINUX
24# define ARCANE_OS_LINUX
25# include <cstddef>
26#endif
27
28#ifdef ARCCORE_OS_WIN32
29# define ARCANE_OS_WIN32
30#endif
31
32#define ARCANE_EXPORT ARCCORE_EXPORT
33#define ARCANE_IMPORT ARCCORE_IMPORT
34#define ARCANE_TEMPLATE_EXPORT ARCCORE_TEMPLATE_EXPORT
35#define ARCANE_RESTRICT ARCCORE_RESTRICT
36
37#define ARCANE_STD std
38
39//Tag var as a voluntary unused variable.
40//Works with any compiler but might be improved by using attribute.
41#define ARCANE_UNUSED(var) ARCCORE_UNUSED(var)
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46#if defined(ARCANE_HAS_CUDA) && defined(__CUDACC__)
51#define ARCANE_COMPILING_CUDA
52#endif
53#if defined(ARCANE_HAS_HIP) && defined(__HIP__)
58#define ARCANE_COMPILING_HIP
59#endif
60
61#if defined(ARCANE_HAS_SYCL)
62# if defined(SYCL_LANGUAGE_VERSION) || defined(__ADAPTIVECPP__)
67# define ARCANE_COMPILING_SYCL
68# endif
69#endif
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73// TODO: supprimer l'inclusion de <iosfwd> et les using.
74// Pour l'instant (2022), on supprime ces inclusions uniquement pour Arcane.
75
76#ifndef ARCANE_NO_USING_FOR_STREAM
77#include <iosfwd>
78using std::istream;
79using std::ostream;
80using std::ios;
81using std::ifstream;
82using std::ofstream;
83using std::ostringstream;
84using std::istringstream;
85#endif
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89
90#ifdef DOXYGEN_DOC
91typedef ARCANE_TYPE_INT16 Int16;
92typedef ARCANE_TYPE_INT32 Int32;
93typedef ARCANE_TYPE_INT64 Int64;
94#endif
95
96#define ARCANE_BEGIN_NAMESPACE namespace Arcane {
97#define ARCANE_END_NAMESPACE }
98#define NUMERICS_BEGIN_NAMESPACE namespace Numerics {
99#define NUMERICS_END_NAMESPACE }
100
101/*---------------------------------------------------------------------------*/
102/*---------------------------------------------------------------------------*/
103
104#ifdef ARCANE_COMPONENT_FULL
105#define ARCANE_COMPONENT_arcane_utils
106#define ARCANE_COMPONENT_arcane
107#define ARCANE_COMPONENT_arcane_mesh
108#define ARCANE_COMPONENT_arcane_std
109#define ARCANE_COMPONENT_arcane_impl
110#define ARCANE_COMPONENT_arcane_script
111#endif
112
113#if defined(ARCANE_COMPONENT_arcane) || defined(ARCANE_COMPONENT_arcane_core)
114#define ARCANE_CORE_EXPORT ARCANE_EXPORT
115#define ARCANE_EXPR_EXPORT ARCANE_EXPORT
116#define ARCANE_DATATYPE_EXPORT ARCANE_EXPORT
117#define ARCANE_CORE_EXTERN_TPL
118#else
119#define ARCANE_CORE_EXPORT ARCANE_IMPORT
120#define ARCANE_EXPR_EXPORT ARCANE_IMPORT
121#define ARCANE_DATATYPE_EXPORT ARCANE_IMPORT
122#define ARCANE_CORE_EXTERN_TPL extern
123#endif
124
125#ifdef ARCANE_COMPONENT_arcane_utils
126#define ARCANE_UTILS_EXPORT ARCANE_EXPORT
127#define ARCANE_UTILS_EXTERN_TPL
128#else
129#define ARCANE_UTILS_EXPORT ARCANE_IMPORT
130#define ARCANE_UTILS_EXTERN_TPL extern
131#endif
132
133#ifdef ARCANE_COMPONENT_arcane_impl
134#define ARCANE_IMPL_EXPORT ARCANE_EXPORT
135#else
136#define ARCANE_IMPL_EXPORT ARCANE_IMPORT
137#endif
138
139#ifdef ARCANE_COMPONENT_arcane_mesh
140#define ARCANE_MESH_EXPORT ARCANE_EXPORT
141#else
142#define ARCANE_MESH_EXPORT ARCANE_IMPORT
143#endif
144
145#ifdef ARCANE_COMPONENT_arcane_std
146#define ARCANE_STD_EXPORT ARCANE_EXPORT
147#else
148#define ARCANE_STD_EXPORT ARCANE_IMPORT
149#endif
150
151#ifdef ARCANE_COMPONENT_arcane_script
152#define ARCANE_SCRIPT_EXPORT ARCANE_EXPORT
153#else
154#define ARCANE_SCRIPT_EXPORT ARCANE_IMPORT
155#endif
156
157#ifdef ARCANE_COMPONENT_arcane_solvers
158#define ARCANE_SOLVERS_EXPORT ARCANE_EXPORT
159#else
160#define ARCANE_SOLVERS_EXPORT ARCANE_IMPORT
161#endif
162
163#ifdef ARCANE_COMPONENT_arcane_geometry
164#define ARCANE_GEOMETRY_EXPORT ARCANE_EXPORT
165#else
166#define ARCANE_GEOMETRY_EXPORT ARCANE_IMPORT
167#endif
168
169#ifdef ARCANE_COMPONENT_arcane_thread
170#define ARCANE_THREAD_EXPORT ARCANE_EXPORT
171#else
172#define ARCANE_THREAD_EXPORT ARCANE_IMPORT
173#endif
174
175#ifdef ARCANE_COMPONENT_arcane_mpi
176#define ARCANE_MPI_EXPORT ARCANE_EXPORT
177#else
178#define ARCANE_MPI_EXPORT ARCANE_IMPORT
179#endif
180
181#ifdef ARCANE_COMPONENT_arcane_hyoda
182#define ARCANE_HYODA_EXPORT ARCANE_EXPORT
183#else
184#define ARCANE_HYODA_EXPORT ARCANE_IMPORT
185#endif
186
187#ifdef ARCANE_REAL_USE_APFLOAT
188#include <apfloat.h>
189#endif
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194namespace Arcane
195{
196
197/*---------------------------------------------------------------------------*/
198/*---------------------------------------------------------------------------*/
199/*
200 * Définition des types Arcane Int16, Int32 et Int64.
201 *
202 * Ces types sont définis lors de la configuration dans le fichier
203 * 'arcane_core_config.h'.
204 */
205
206using Arccore::Int16;
207using Arccore::Int32;
208using Arccore::Int64;
209using Arccore::UInt32;
210using Arccore::UInt64;
211
212#define ARCANE_HAS_LONG_LONG
213
214/*---------------------------------------------------------------------------*/
215/*---------------------------------------------------------------------------*/
216
217const double cgrEPSILON_DELTA = 1.0e-2;
218const double cgrPI = 3.14159265358979323846;
219
220/*---------------------------------------------------------------------------*/
221/*---------------------------------------------------------------------------*/
222
223#define ARCANE_REAL(val) ARCCORE_REAL(val)
224
225#ifdef ARCCORE_REAL_NOT_BUILTIN
226# define ARCANE_REAL_NOT_BUILTIN
227#endif
228
229#ifdef ARCCORE_REAL_LONG
230# define ARCANE_REAL_LONG
231#endif
232
233#ifdef ARCCORE_REAL_IS_DOUBLE
234# define ARCANE_REAL_IS_DOUBLE
235#endif
236
237using Arccore::Real;
238using Arccore::Pointer;
239using Arccore::APReal;
240using Arccore::Short;
241using Arccore::Integer;
242
250using LocalIdType = Int32;
251
259using UniqueIdType = Int64;
260
262using BFloat16 = Arccore::BFloat16;
263
265using Float16 = Arccore::Float16;
266
268using Float32 = float;
269
271using Int8 = Arccore::Int8;
272
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
303extern "C++" ARCANE_UTILS_EXPORT void
304arcanePrintf(const char*,...);
305
306/*---------------------------------------------------------------------------*/
307/*---------------------------------------------------------------------------*/
308
319extern "C++" ARCANE_UTILS_EXPORT void
320arcaneDebugPause(const char* msg);
321
322/*---------------------------------------------------------------------------*/
323/*---------------------------------------------------------------------------*/
324
325extern "C++" ARCANE_UTILS_EXPORT void
326_internalArcaneMathError(long double arg_value,const char* func_name);
327
328extern "C++" ARCANE_UTILS_EXPORT void
329_internalArcaneMathError(long double arg_value1,long double arg_value2,const char* func_name);
330
331/*---------------------------------------------------------------------------*/
332/*---------------------------------------------------------------------------*/
341ARCCORE_HOST_DEVICE inline void
342arcaneMathError(long double arg_value,const char* func_name)
343{
344#ifndef ARCCORE_DEVICE_CODE
345 _internalArcaneMathError(arg_value,func_name);
346#else
347 ARCANE_UNUSED(arg_value);
348 ARCANE_UNUSED(func_name);
349#endif
350}
351
361ARCCORE_HOST_DEVICE inline void
362arcaneMathError(long double arg_value1,long double arg_value2,const char* func_name)
363{
364#ifndef ARCCORE_DEVICE_CODE
365 _internalArcaneMathError(arg_value1,arg_value2,func_name);
366#else
367 ARCANE_UNUSED(arg_value1);
368 ARCANE_UNUSED(arg_value2);
369 ARCANE_UNUSED(func_name);
370#endif
371}
372
373/*---------------------------------------------------------------------------*/
374/*---------------------------------------------------------------------------*/
385extern "C++" ARCANE_UTILS_EXPORT void
386arcaneNotYetImplemented(const char* file,const char* func,unsigned long line,const char* msg);
387
388/*---------------------------------------------------------------------------*/
389/*---------------------------------------------------------------------------*/
390
392extern "C++" ARCANE_UTILS_EXPORT void
393arcaneDeprecated(const char* file,const char* func,unsigned long line,const char* text);
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397
407extern "C++" ARCANE_UTILS_EXPORT void
408arcaneNoReferenceError(const void* ptr);
409
419extern "C++" ARCANE_UTILS_EXPORT void
420arcaneNoReferenceErrorCallTerminate(const void* ptr);
421
428extern "C++" ARCANE_UTILS_EXPORT Integer
429arcaneCheckArraySize(unsigned long long size);
430
437extern "C++" ARCANE_UTILS_EXPORT Integer
438arcaneCheckArraySize(long long size);
439
446extern "C++" ARCANE_UTILS_EXPORT Integer
447arcaneCheckArraySize(unsigned long size);
448
455extern "C++" ARCANE_UTILS_EXPORT Integer
456arcaneCheckArraySize(long size);
457
464extern "C++" ARCANE_UTILS_EXPORT Integer
465arcaneCheckArraySize(unsigned int size);
466
473extern "C++" ARCANE_UTILS_EXPORT Integer
474arcaneCheckArraySize(int size);
475
480extern "C++" ARCANE_UTILS_EXPORT void
481arcaneCheckAlignment(const void* ptr,Integer alignment);
482
489extern "C++" ARCANE_UTILS_EXPORT
490bool arcaneIsCheck();
491
499extern "C++" ARCANE_UTILS_EXPORT
500void arcaneSetCheck(bool v);
501
505extern "C++" ARCANE_UTILS_EXPORT
506bool arcaneIsDebug();
507
511extern "C++" ARCANE_UTILS_EXPORT
512bool arcaneHasThread();
513
523extern "C++" ARCANE_UTILS_EXPORT
524void arcaneSetHasThread(bool v);
525
531extern "C++" ARCANE_UTILS_EXPORT
532Int64 arcaneCurrentThread();
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
541struct TrueType {};
546struct FalseType {};
547
548/*---------------------------------------------------------------------------*/
549/*---------------------------------------------------------------------------*/
550
551#ifdef ARCANE_DEBUG
552extern "C++" ARCANE_UTILS_EXPORT bool _checkDebug(size_t);
553#define ARCANE_DEBUGP(a,b) if (_checkDebug(a)) { arcanePrintf b; }
554#else
555#define ARCANE_DEBUGP(a,b)
556#endif
557
558/*---------------------------------------------------------------------------*/
559/*---------------------------------------------------------------------------*/
560
561#ifdef __GNUG__
562# define ARCANE_NOT_YET_IMPLEMENTED(a) \
563{ arcaneNotYetImplemented(__FILE__,__PRETTY_FUNCTION__,__LINE__,(a)); }
564#else
565# define ARCANE_NOT_YET_IMPLEMENTED(a) \
566{ arcaneNotYetImplemented(__FILE__,"(NoInfo)",__LINE__,(a)); }
567#endif
568
569#define ARCANE_DEPRECATED ARCCORE_DEPRECATED
570
571#define ARCANE_DEPRECATED_112 ARCANE_DEPRECATED
572#define ARCANE_DEPRECATED_114 ARCANE_DEPRECATED
573#define ARCANE_DEPRECATED_116 ARCANE_DEPRECATED
574#define ARCANE_DEPRECATED_118 ARCANE_DEPRECATED
575#define ARCANE_DEPRECATED_120 ARCANE_DEPRECATED
576#define ARCANE_DEPRECATED_122 ARCANE_DEPRECATED
577#define ARCANE_DEPRECATED_200 ARCANE_DEPRECATED
578#define ARCANE_DEPRECATED_220 ARCANE_DEPRECATED
579#define ARCANE_DEPRECATED_240 ARCANE_DEPRECATED
580#define ARCANE_DEPRECATED_260 ARCANE_DEPRECATED
581#define ARCANE_DEPRECATED_280 ARCANE_DEPRECATED
582#define ARCANE_DEPRECATED_2018 ARCANE_DEPRECATED
583#define ARCANE_DEPRECATED_2018_R(reason) [[deprecated(reason)]]
584
585#ifndef ARCCORE_DEPRECATED_2021
586#define ARCCORE_DEPRECATED_2021(reason) [[deprecated(reason)]]
587#endif
588
589#define ARCANE_DEPRECATED_REASON(reason) [[deprecated(reason)]]
590
591#ifdef ARCANE_NO_DEPRECATED_LONG_TERM
592#define ARCANE_DEPRECATED_LONG_TERM(reason)
593#else
601#define ARCANE_DEPRECATED_LONG_TERM(reason) [[deprecated(reason)]]
602#endif
603
604// Définir cette macro si on souhaite supprimer de la compilation les
605// méthodes et types obsolètes.
606#define ARCANE_NO_DEPRECATED
607
608// Si la macro est définie, ne notifie pas des méthodes obsolètes des anciennes
609// classes tableaux.
610#ifdef ARCANE_NO_NOTIFY_DEPRECATED_ARRAY
611#define ARCANE_DEPRECATED_ARRAY
612#else
613#define ARCANE_DEPRECATED_ARRAY ARCANE_DEPRECATED
614#endif
615
616/*---------------------------------------------------------------------------*/
617/*---------------------------------------------------------------------------*/
618
619// Les macros suivantes permettent de de créer un identifiant en suffixant
620// le numéro de ligne du fichier. Cela permet d'avoir un identifiant unique
621// pour un fichier et est utilisé par exemple pour générer des noms
622// de variable globale pour l'enregistrement des services.
623// La macro a utiliser est ARCANE_JOIN_WITH_LINE(name).
624#define ARCANE_JOIN_HELPER2(a,b) a ## b
625#define ARCANE_JOIN_HELPER(a,b) ARCANE_JOIN_HELPER2(a,b)
626#define ARCANE_JOIN_WITH_LINE(a) ARCANE_JOIN_HELPER(a,__LINE__)
627
628/*---------------------------------------------------------------------------*/
629/*---------------------------------------------------------------------------*/
630// La macro ARCANE_NORETURN utilise l'attribut [[noreturn]] du C++11 pour
631// indiquer qu'une fonction ne retourne pas.
632#define ARCANE_NORETURN ARCCORE_NORETURN
633
635#define ARCANE_CONSTEXPR ARCCORE_CONSTEXPR
636
637// Le C++11 définit un mot clé 'noexcept' pour indiquer qu'une méthode ne
638// renvoie pas d'exceptions. Malheureusement, comme le support du C++11
639// est fait de manière partielle par les compilateurs, cela ne marche pas
640// pour tous. En particulier, icc 13, 14 et 15 ne supportent pas cela, ni
641// Visual Studio 2013 et antérieurs.
642#define ARCANE_NOEXCEPT ARCCORE_NOEXCEPT
643#define ARCANE_NOEXCEPT_FALSE ARCCORE_NOEXCEPT_FALSE
644
645/*---------------------------------------------------------------------------*/
646/*---------------------------------------------------------------------------*/
647
648// Support pour l'alignement.
649// le C++11 utilise le mot clé alignas pour spécifier l'alignement.
650// Cela fonctionne avec GCC 4.9+ et Visual Studio 2015. Cela ne fonctionne
651// pas avec Visual Studio 2013. Donc pour Visual Studio on utilise dans tous
652// les cas __declspec qui fonctionne toujours. Sous Linux, __attribute__ fonctionne
653// aussi toujours donc on utilise cela. A noter que les structures Simd ont besoin
654// de l'attribut 'packed' qui n'existe que avec GCC et Intel. Il ne semble pas y avoir
655// d'équivalent avec MSVC.
656#ifdef _MSC_VER
658# define ARCANE_ALIGNAS(value) __declspec(align(value))
660# define ARCANE_ALIGNAS_PACKED(value) __declspec(align(value))
661#else
663# define ARCANE_ALIGNAS_PACKED(value) __attribute__ ((aligned (value),packed))
665# define ARCANE_ALIGNAS(value) __attribute__ ((aligned (value)))
666#endif
667
668/*---------------------------------------------------------------------------*/
669/*---------------------------------------------------------------------------*/
670
671#ifdef ARCANE_SWIG
672#ifdef ARCANE_DEPRECATED
673#undef ARCANE_DEPRECATED
674#endif
675#endif
676
677/*---------------------------------------------------------------------------*/
678/*---------------------------------------------------------------------------*/
679
680#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
681#ifndef ARCANE_DEBUG_ASSERT
682#define ARCANE_DEBUG_ASSERT
683#endif
684#endif
685
686/*---------------------------------------------------------------------------*/
687/*---------------------------------------------------------------------------*/
695extern "C++" ARCANE_UTILS_EXPORT void
696arcaneNullPointerError [[noreturn]] ();
697
698/*---------------------------------------------------------------------------*/
699/*---------------------------------------------------------------------------*/
711extern "C++" ARCANE_UTILS_EXPORT void
712arcaneThrowNullPointerError [[noreturn]] (const char* ptr_name,const char* text);
713
714/*---------------------------------------------------------------------------*/
715/*---------------------------------------------------------------------------*/
719static inline void
720arcaneCheckNull(const void* ptr)
721{
722 if (!ptr)
723 arcaneNullPointerError();
724}
725
726/*---------------------------------------------------------------------------*/
727/*---------------------------------------------------------------------------*/
736static const Integer SIMD_PADDING_SIZE = 8;
737
738/*---------------------------------------------------------------------------*/
739/*---------------------------------------------------------------------------*/
748extern "C++" ARCANE_UTILS_EXPORT Integer
749arcaneSizeWithPadding(Integer size);
750
751/*---------------------------------------------------------------------------*/
752/*---------------------------------------------------------------------------*/
753
754/*
755 * Macros utilisées pour le débug.
756 */
757#ifdef ARCANE_DEBUG_ASSERT
758extern "C++" ARCANE_UTILS_EXPORT void _doAssert(const char*,const char*,const char*,size_t);
759template<typename T> inline T*
760_checkPointer(T* t,const char* file,const char* func,size_t line)
761{
762 if (!t){
763 _doAssert("ARCANE_ASSERT",file,func,line);
764 arcanePrintf("Bad Pointer");
765 }
766 return t;
767}
768# ifdef __GNUG__
769# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,__PRETTY_FUNCTION__,__LINE__)
770# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,__PRETTY_FUNCTION__,__LINE__);
771# else
772# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,"(NoInfo)",__LINE__)
773# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,"(NoInfo"),__LINE__);
774# endif
775# define ARCANE_CHECK_PTR(a) \
776 {if (!(a)){Arcane::arcanePrintf("Null value");ARCANE_D_WHERE("ARCANE_ASSERT");}}
777
778# define ARCANE_ASSERT(a,b) \
779 {if (!(a)){ Arcane::arcanePrintf("Assertion '%s' fails:",#a); Arcane::arcanePrintf b; ARCANE_D_WHERE("ARCANE_ASSERT");}}
780# define ARCANE_WARNING(a) \
781 { Arcane::arcanePrintf a; ARCANE_D_WHERE("ARCANE_WARNING"); }
782#else
783# define ARCANE_CHECK_PTR(a)
784# define ARCANE_ASSERT(a,b)
785# define ARCANE_WARNING(a)
786# define ARCANE_DCHECK_POINTER(a) (a);
787#endif
788
789/*---------------------------------------------------------------------------*/
790/*---------------------------------------------------------------------------*/
798#define ARCANE_THROW(exception_class,...) \
799 throw exception_class (A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
800
801/*---------------------------------------------------------------------------*/
802/*---------------------------------------------------------------------------*/
809#define ARCANE_FATAL(...)\
810 throw Arcane::FatalErrorException(A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
811
812/*---------------------------------------------------------------------------*/
813/*---------------------------------------------------------------------------*/
820static inline void*
821arcaneThrowIfNull(void* ptr,const char* ptr_name,const char* text)
822{
823 if (!ptr)
824 arcaneThrowNullPointerError(ptr_name,text);
825 return ptr;
826}
827
828/*---------------------------------------------------------------------------*/
829/*---------------------------------------------------------------------------*/
836static inline const void*
837arcaneThrowIfNull(const void* ptr,const char* ptr_name,const char* text)
838{
839 if (!ptr)
840 arcaneThrowNullPointerError(ptr_name,text);
841 return ptr;
842}
843
844/*---------------------------------------------------------------------------*/
845/*---------------------------------------------------------------------------*/
852template<typename T> inline T*
853arcaneThrowIfNull(T* ptr,const char* ptr_name,const char* text)
854{
855 if (!ptr)
856 arcaneThrowNullPointerError(ptr_name,text);
857 return ptr;
858}
859
860/*---------------------------------------------------------------------------*/
861/*---------------------------------------------------------------------------*/
868#define ARCANE_CHECK_POINTER(ptr) \
869 arcaneThrowIfNull(ptr,#ptr,nullptr)
870
877#define ARCANE_CHECK_POINTER2(ptr,text)\
878 arcaneThrowIfNull(ptr,#ptr,text)
879
880/*---------------------------------------------------------------------------*/
881/*---------------------------------------------------------------------------*/
891extern "C++" ARCANE_UTILS_EXPORT void
892arcaneRangeError [[noreturn]] (Int64 i,Int64 max_size);
893
897static inline constexpr ARCCORE_HOST_DEVICE void
898arcaneCheckAt(Int64 i,Int64 max_size)
899{
900#ifndef ARCCORE_DEVICE_CODE
901 if (i<0 || i>=max_size)
902 arcaneRangeError(i,max_size);
903#else
904 ARCANE_UNUSED(i);
905 ARCANE_UNUSED(max_size);
906#endif
907}
908
909#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
910#define ARCANE_CHECK_AT(a,b) ::Arcane::arcaneCheckAt((a),(b))
911#else
912#define ARCANE_CHECK_AT(a,b)
913#endif
914
915/*---------------------------------------------------------------------------*/
916/*---------------------------------------------------------------------------*/
917
918} // End namespace Arcane
919
920/*---------------------------------------------------------------------------*/
921/*---------------------------------------------------------------------------*/
922
923namespace Arccore
924{
925class ITraceMng;
926class StringView;
927}
928
929namespace Arcane
930{
931using Arccore::StringView;
932using Arccore::String;
933using Arccore::StringBuilder;
934using Arccore::StringFormatterArg;
935using Arccore::ITraceMng;
936}
937
938/*---------------------------------------------------------------------------*/
939/*---------------------------------------------------------------------------*/
940
941#endif
Arcane::LimaWrapper
Lecteur des fichiers de maillage via la bibliothèque LIMA.
Definition Lima.cc:120
Arccore::APReal
Emulation de réel en précision arbitraire.
Definition ArccoreGlobal.h:227
Arccore::Float16
Type flottant demi-précision.
Definition arccore/src/base/arccore/base/Float16.h:33
Arccore::ITraceMng
Interface du gestionnaire de traces.
Definition arccore/src/trace/arccore/trace/ITraceMng.h:156
Arccore::StringBuilder
Constructeur de chaîne de caractère unicode.
Definition arccore/src/base/arccore/base/StringBuilder.h:47
Arccore::StringFormatterArg
Classe utilisée pour formatter une chaîne de caractères.
Definition arccore/src/base/arccore/base/String.h:590
Arccore::StringView
Vue sur une chaîne de caractères UTF-8.
Definition StringView.h:47
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AcceleratorGlobal.h:36
Arcane::arcaneNoReferenceErrorCallTerminate
void arcaneNoReferenceErrorCallTerminate(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:265
Arcane::arcaneCurrentThread
Int64 arcaneCurrentThread()
Retourne l'identifiant du thread courant.
Definition Misc.cc:200
Arcane::arcaneCheckArraySize
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
Definition ArcaneGlobal.cc:152
Arcane::arcaneIsCheck
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:151
Arcane::arcaneHasThread
bool arcaneHasThread()
Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs.
Definition Misc.cc:182
Arcane::arcaneSetHasThread
void arcaneSetHasThread(bool v)
Active ou désactive le support des threads.
Definition Misc.cc:188
Arcane::arcaneNullPointerError
void arcaneNullPointerError()
Signalue l'utilisation d'un pointeur nul.
Definition ArcaneGlobal.cc:131
Arcane::arcanePrintf
void arcanePrintf(const char *,...)
Encapsulation de la fonction C printf.
Definition Misc.cc:275
Arcane::arcaneNotYetImplemented
void arcaneNotYetImplemented(const char *file, const char *func, unsigned long line, const char *text)
Signale une fonction non implémentée.
Definition ArcaneGlobal.cc:117
Arcane::Int8
Arccore::Int8 Int8
Type représentant un entier sur 8 bits.
Definition ArcaneGlobal.h:271
Arcane::arcaneSizeWithPadding
Integer arcaneSizeWithPadding(Integer size)
Retourne la taille avec padding pour une taille size.
Definition ArcaneGlobal.cc:223
Arcane::arcaneDeprecated
void arcaneDeprecated(const char *file, const char *func, unsigned long line, const char *text)
Signale l'utilisation d'une fonction obsolète.
Arcane::arcaneIsDebug
bool arcaneIsDebug()
Vrai si la macro ARCANE_DEBUG est définie.
Definition Misc.cc:163
Arcane::arcaneMathError
ARCCORE_HOST_DEVICE void arcaneMathError(long double arg_value, const char *func_name)
Signale un argument invalide d'une fonction mathématique.
Definition ArcaneGlobal.h:342
Arcane::arcaneSetCheck
void arcaneSetCheck(bool v)
Active ou désactive le mode vérification.
Definition Misc.cc:157
Arcane::arcaneNoReferenceError
void arcaneNoReferenceError(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:255
Arcane::_checkDebug
bool _checkDebug(unsigned int val)
Definition Misc.cc:335
Arcane::LocalIdType
Int32 LocalIdType
Type des entiers utilisés pour stocker les identifiants locaux des entités.
Definition ArcaneGlobal.h:250
Arcane::_doAssert
void _doAssert(const char *text, const char *file, const char *func, size_t line)
Definition Misc.cc:318
Arcane::arcaneDebugPause
void arcaneDebugPause(const char *msg)
Passe en mode pause ou lance une erreur fatale.
Definition Misc.cc:220
Arcane::UniqueIdType
Int64 UniqueIdType
Type des entiers utilisés pour stocker les identifiants uniques (globaux) des entités.
Definition ArcaneGlobal.h:259
Arcane::arcaneCheckAlignment
void arcaneCheckAlignment(const void *ptr, Integer alignment)
Vérifie que ptr est aligné sur alignment octets. Si ce n'est pas le cas, Sinon, lance une exception d...
Definition ArcaneGlobal.cc:209
Arcane::arcaneThrowNullPointerError
void arcaneThrowNullPointerError(const char *ptr_name, const char *text)
Signalee l'utilisation d'un pointeur nul en envoyant une exception.
Definition ArcaneGlobal.cc:143
Arccore
Espace de nom de Arccore.
Definition ArcaneTypes.h:24
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arccore::UInt32
std::uint32_t UInt32
Type entier non signé sur 32 bits.
Definition ArccoreGlobal.h:188
Arccore::Pointer
void * Pointer
Type représentant un pointeur.
Definition ArccoreGlobal.h:199
Arccore::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arccore::UInt64
std::uint64_t UInt64
Type entier non signé sur 64 bits.
Definition ArccoreGlobal.h:190
Arccore::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184
Arccore::Int8
std::int8_t Int8
Type entier signé sur 8 bits.
Definition ArccoreGlobal.h:180
Arccore::Int16
std::int16_t Int16
Type entier signé sur 16 bits.
Definition ArccoreGlobal.h:182
Arcane::FalseType
Structure équivalente à la valeur booléenne vrai.
Definition ArcaneGlobal.h:546
Arcane::TrueType
Structure équivalente à la valeur booléenne vrai.
Definition ArcaneGlobal.h:541