Arcane  v3.16.0.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-2025 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-2025 */
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#define ARCANE_HAS_LONG_LONG
201
202/*---------------------------------------------------------------------------*/
203/*---------------------------------------------------------------------------*/
204
205const double cgrEPSILON_DELTA = 1.0e-2;
206const double cgrPI = 3.14159265358979323846;
207
208/*---------------------------------------------------------------------------*/
209/*---------------------------------------------------------------------------*/
210
211#define ARCANE_REAL(val) ARCCORE_REAL(val)
212
213#ifdef ARCCORE_REAL_NOT_BUILTIN
214# define ARCANE_REAL_NOT_BUILTIN
215#endif
216
217#ifdef ARCCORE_REAL_LONG
218# define ARCANE_REAL_LONG
219#endif
220
221#ifdef ARCCORE_REAL_IS_DOUBLE
222# define ARCANE_REAL_IS_DOUBLE
223#endif
224
232using LocalIdType = Int32;
233
241using UniqueIdType = Int64;
242
247
267
268/*---------------------------------------------------------------------------*/
269/*---------------------------------------------------------------------------*/
270
272extern "C++" ARCANE_UTILS_EXPORT void
273arcanePrintf(const char*,...);
274
275/*---------------------------------------------------------------------------*/
276/*---------------------------------------------------------------------------*/
277
288extern "C++" ARCANE_UTILS_EXPORT void
289arcaneDebugPause(const char* msg);
290
291/*---------------------------------------------------------------------------*/
292/*---------------------------------------------------------------------------*/
293
294extern "C++" ARCANE_UTILS_EXPORT void
295_internalArcaneMathError(long double arg_value,const char* func_name);
296
297extern "C++" ARCANE_UTILS_EXPORT void
298_internalArcaneMathError(long double arg_value1,long double arg_value2,const char* func_name);
299
300/*---------------------------------------------------------------------------*/
301/*---------------------------------------------------------------------------*/
310ARCCORE_HOST_DEVICE inline void
311arcaneMathError(long double arg_value,const char* func_name)
312{
313#ifndef ARCCORE_DEVICE_CODE
314 _internalArcaneMathError(arg_value,func_name);
315#else
316 ARCANE_UNUSED(arg_value);
317 ARCANE_UNUSED(func_name);
318#endif
319}
320
330ARCCORE_HOST_DEVICE inline void
331arcaneMathError(long double arg_value1,long double arg_value2,const char* func_name)
332{
333#ifndef ARCCORE_DEVICE_CODE
334 _internalArcaneMathError(arg_value1,arg_value2,func_name);
335#else
336 ARCANE_UNUSED(arg_value1);
337 ARCANE_UNUSED(arg_value2);
338 ARCANE_UNUSED(func_name);
339#endif
340}
341
342/*---------------------------------------------------------------------------*/
343/*---------------------------------------------------------------------------*/
354extern "C++" ARCANE_UTILS_EXPORT void
355arcaneNotYetImplemented(const char* file,const char* func,unsigned long line,const char* msg);
356
357/*---------------------------------------------------------------------------*/
358/*---------------------------------------------------------------------------*/
359
361extern "C++" ARCANE_UTILS_EXPORT void
362arcaneDeprecated(const char* file,const char* func,unsigned long line,const char* text);
363
364/*---------------------------------------------------------------------------*/
365/*---------------------------------------------------------------------------*/
366
376extern "C++" ARCANE_UTILS_EXPORT void
377arcaneNoReferenceError(const void* ptr);
378
388extern "C++" ARCANE_UTILS_EXPORT void
389arcaneNoReferenceErrorCallTerminate(const void* ptr);
390
397extern "C++" ARCANE_UTILS_EXPORT Integer
398arcaneCheckArraySize(unsigned long long size);
399
406extern "C++" ARCANE_UTILS_EXPORT Integer
407arcaneCheckArraySize(long long size);
408
415extern "C++" ARCANE_UTILS_EXPORT Integer
416arcaneCheckArraySize(unsigned long size);
417
424extern "C++" ARCANE_UTILS_EXPORT Integer
425arcaneCheckArraySize(long size);
426
433extern "C++" ARCANE_UTILS_EXPORT Integer
434arcaneCheckArraySize(unsigned int size);
435
442extern "C++" ARCANE_UTILS_EXPORT Integer
443arcaneCheckArraySize(int size);
444
449extern "C++" ARCANE_UTILS_EXPORT void
450arcaneCheckAlignment(const void* ptr,Integer alignment);
451
458extern "C++" ARCANE_UTILS_EXPORT
459bool arcaneIsCheck();
460
468extern "C++" ARCANE_UTILS_EXPORT
469void arcaneSetCheck(bool v);
470
474extern "C++" ARCANE_UTILS_EXPORT
475bool arcaneIsDebug();
476
480extern "C++" ARCANE_UTILS_EXPORT
481bool arcaneHasThread();
482
492extern "C++" ARCANE_UTILS_EXPORT
493void arcaneSetHasThread(bool v);
494
500extern "C++" ARCANE_UTILS_EXPORT
501Int64 arcaneCurrentThread();
502
503/*---------------------------------------------------------------------------*/
504/*---------------------------------------------------------------------------*/
505
506#ifdef ARCANE_DEBUG
507extern "C++" ARCANE_UTILS_EXPORT bool _checkDebug(size_t);
508#define ARCANE_DEBUGP(a,b) if (_checkDebug(a)) { arcanePrintf b; }
509#else
510#define ARCANE_DEBUGP(a,b)
511#endif
512
513/*---------------------------------------------------------------------------*/
514/*---------------------------------------------------------------------------*/
515
516#ifdef __GNUG__
517# define ARCANE_NOT_YET_IMPLEMENTED(a) \
518{ arcaneNotYetImplemented(__FILE__,__PRETTY_FUNCTION__,__LINE__,(a)); }
519#else
520# define ARCANE_NOT_YET_IMPLEMENTED(a) \
521{ arcaneNotYetImplemented(__FILE__,"(NoInfo)",__LINE__,(a)); }
522#endif
523
524#define ARCANE_DEPRECATED ARCCORE_DEPRECATED
525
526#define ARCANE_DEPRECATED_112 ARCANE_DEPRECATED
527#define ARCANE_DEPRECATED_114 ARCANE_DEPRECATED
528#define ARCANE_DEPRECATED_116 ARCANE_DEPRECATED
529#define ARCANE_DEPRECATED_118 ARCANE_DEPRECATED
530#define ARCANE_DEPRECATED_120 ARCANE_DEPRECATED
531#define ARCANE_DEPRECATED_122 ARCANE_DEPRECATED
532#define ARCANE_DEPRECATED_200 ARCANE_DEPRECATED
533#define ARCANE_DEPRECATED_220 ARCANE_DEPRECATED
534#define ARCANE_DEPRECATED_240 ARCANE_DEPRECATED
535#define ARCANE_DEPRECATED_260 ARCANE_DEPRECATED
536#define ARCANE_DEPRECATED_280 ARCANE_DEPRECATED
537#define ARCANE_DEPRECATED_2018 ARCANE_DEPRECATED
538#define ARCANE_DEPRECATED_2018_R(reason) [[deprecated(reason)]]
539
540#ifndef ARCCORE_DEPRECATED_2021
541#define ARCCORE_DEPRECATED_2021(reason) [[deprecated(reason)]]
542#endif
543
544#define ARCANE_DEPRECATED_REASON(reason) [[deprecated(reason)]]
545
546#ifdef ARCANE_NO_DEPRECATED_LONG_TERM
547#define ARCANE_DEPRECATED_LONG_TERM(reason)
548#else
556#define ARCANE_DEPRECATED_LONG_TERM(reason) [[deprecated(reason)]]
557#endif
558
559// Définir cette macro si on souhaite supprimer de la compilation les
560// méthodes et types obsolètes.
561#define ARCANE_NO_DEPRECATED
562
563// Si la macro est définie, ne notifie pas des méthodes obsolètes des anciennes
564// classes tableaux.
565#ifdef ARCANE_NO_NOTIFY_DEPRECATED_ARRAY
566#define ARCANE_DEPRECATED_ARRAY
567#else
568#define ARCANE_DEPRECATED_ARRAY ARCANE_DEPRECATED
569#endif
570
571/*---------------------------------------------------------------------------*/
572/*---------------------------------------------------------------------------*/
573
574// Les macros suivantes permettent de de créer un identifiant en suffixant
575// le numéro de ligne du fichier. Cela permet d'avoir un identifiant unique
576// pour un fichier et est utilisé par exemple pour générer des noms
577// de variable globale pour l'enregistrement des services.
578// La macro a utiliser est ARCANE_JOIN_WITH_LINE(name).
579#define ARCANE_JOIN_HELPER2(a,b) a ## b
580#define ARCANE_JOIN_HELPER(a,b) ARCANE_JOIN_HELPER2(a,b)
581#define ARCANE_JOIN_WITH_LINE(a) ARCANE_JOIN_HELPER(a,__LINE__)
582
583/*---------------------------------------------------------------------------*/
584/*---------------------------------------------------------------------------*/
585// La macro ARCANE_NORETURN utilise l'attribut [[noreturn]] du C++11 pour
586// indiquer qu'une fonction ne retourne pas.
587#define ARCANE_NORETURN ARCCORE_NORETURN
588
590#define ARCANE_CONSTEXPR ARCCORE_CONSTEXPR
591
592// Le C++11 définit un mot clé 'noexcept' pour indiquer qu'une méthode ne
593// renvoie pas d'exceptions. Malheureusement, comme le support du C++11
594// est fait de manière partielle par les compilateurs, cela ne marche pas
595// pour tous. En particulier, icc 13, 14 et 15 ne supportent pas cela, ni
596// Visual Studio 2013 et antérieurs.
597#define ARCANE_NOEXCEPT ARCCORE_NOEXCEPT
598#define ARCANE_NOEXCEPT_FALSE ARCCORE_NOEXCEPT_FALSE
599
600/*---------------------------------------------------------------------------*/
601/*---------------------------------------------------------------------------*/
602
603// Support pour l'alignement.
604// le C++11 utilise le mot clé alignas pour spécifier l'alignement.
605// Cela fonctionne avec GCC 4.9+ et Visual Studio 2015. Cela ne fonctionne
606// pas avec Visual Studio 2013. Donc pour Visual Studio on utilise dans tous
607// les cas __declspec qui fonctionne toujours. Sous Linux, __attribute__ fonctionne
608// aussi toujours donc on utilise cela. A noter que les structures Simd ont besoin
609// de l'attribut 'packed' qui n'existe que avec GCC et Intel. Il ne semble pas y avoir
610// d'équivalent avec MSVC.
611#ifdef _MSC_VER
613# define ARCANE_ALIGNAS(value) __declspec(align(value))
615# define ARCANE_ALIGNAS_PACKED(value) __declspec(align(value))
616#else
618# define ARCANE_ALIGNAS_PACKED(value) __attribute__ ((aligned (value),packed))
620# define ARCANE_ALIGNAS(value) __attribute__ ((aligned (value)))
621#endif
622
623/*---------------------------------------------------------------------------*/
624/*---------------------------------------------------------------------------*/
625
626#ifdef ARCANE_SWIG
627#ifdef ARCANE_DEPRECATED
628#undef ARCANE_DEPRECATED
629#endif
630#endif
631
632/*---------------------------------------------------------------------------*/
633/*---------------------------------------------------------------------------*/
634
635#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
636#ifndef ARCANE_DEBUG_ASSERT
637#define ARCANE_DEBUG_ASSERT
638#endif
639#endif
640
641/*---------------------------------------------------------------------------*/
642/*---------------------------------------------------------------------------*/
650extern "C++" ARCANE_UTILS_EXPORT void
651arcaneNullPointerError [[noreturn]] ();
652
653/*---------------------------------------------------------------------------*/
654/*---------------------------------------------------------------------------*/
666extern "C++" ARCANE_UTILS_EXPORT void
667arcaneThrowNullPointerError [[noreturn]] (const char* ptr_name,const char* text);
668
669/*---------------------------------------------------------------------------*/
670/*---------------------------------------------------------------------------*/
674static inline void
675arcaneCheckNull(const void* ptr)
676{
677 if (!ptr)
678 arcaneNullPointerError();
679}
680
681/*---------------------------------------------------------------------------*/
682/*---------------------------------------------------------------------------*/
691static const Integer SIMD_PADDING_SIZE = 8;
692
693/*---------------------------------------------------------------------------*/
694/*---------------------------------------------------------------------------*/
703extern "C++" ARCANE_UTILS_EXPORT Integer
704arcaneSizeWithPadding(Integer size);
705
706/*---------------------------------------------------------------------------*/
707/*---------------------------------------------------------------------------*/
708
709/*
710 * Macros utilisées pour le débug.
711 */
712#ifdef ARCANE_DEBUG_ASSERT
713extern "C++" ARCANE_UTILS_EXPORT void _doAssert(const char*,const char*,const char*,size_t);
714template<typename T> inline T*
715_checkPointer(T* t,const char* file,const char* func,size_t line)
716{
717 if (!t){
718 _doAssert("ARCANE_ASSERT",file,func,line);
719 arcanePrintf("Bad Pointer");
720 }
721 return t;
722}
723# ifdef __GNUG__
724# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,__PRETTY_FUNCTION__,__LINE__)
725# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,__PRETTY_FUNCTION__,__LINE__);
726# else
727# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,"(NoInfo)",__LINE__)
728# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,"(NoInfo"),__LINE__);
729# endif
730# define ARCANE_CHECK_PTR(a) \
731 {if (!(a)){Arcane::arcanePrintf("Null value");ARCANE_D_WHERE("ARCANE_ASSERT");}}
732
733# define ARCANE_ASSERT(a,b) \
734 {if (!(a)){ Arcane::arcanePrintf("Assertion '%s' fails:",#a); Arcane::arcanePrintf b; ARCANE_D_WHERE("ARCANE_ASSERT");}}
735# define ARCANE_WARNING(a) \
736 { Arcane::arcanePrintf a; ARCANE_D_WHERE("ARCANE_WARNING"); }
737#else
738# define ARCANE_CHECK_PTR(a)
739# define ARCANE_ASSERT(a,b)
740# define ARCANE_WARNING(a)
741# define ARCANE_DCHECK_POINTER(a) (a);
742#endif
743
744/*---------------------------------------------------------------------------*/
745/*---------------------------------------------------------------------------*/
753#define ARCANE_THROW(exception_class,...) \
754 throw exception_class (A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
755
756/*---------------------------------------------------------------------------*/
757/*---------------------------------------------------------------------------*/
764#define ARCANE_FATAL(...)\
765 throw Arcane::FatalErrorException(A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
766
767/*---------------------------------------------------------------------------*/
768/*---------------------------------------------------------------------------*/
775static inline void*
776arcaneThrowIfNull(void* ptr,const char* ptr_name,const char* text)
777{
778 if (!ptr)
779 arcaneThrowNullPointerError(ptr_name,text);
780 return ptr;
781}
782
783/*---------------------------------------------------------------------------*/
784/*---------------------------------------------------------------------------*/
791static inline const void*
792arcaneThrowIfNull(const void* ptr,const char* ptr_name,const char* text)
793{
794 if (!ptr)
795 arcaneThrowNullPointerError(ptr_name,text);
796 return ptr;
797}
798
799/*---------------------------------------------------------------------------*/
800/*---------------------------------------------------------------------------*/
807template<typename T> inline T*
808arcaneThrowIfNull(T* ptr,const char* ptr_name,const char* text)
809{
810 if (!ptr)
811 arcaneThrowNullPointerError(ptr_name,text);
812 return ptr;
813}
814
815/*---------------------------------------------------------------------------*/
816/*---------------------------------------------------------------------------*/
823#define ARCANE_CHECK_POINTER(ptr) \
824 arcaneThrowIfNull(ptr,#ptr,nullptr)
825
832#define ARCANE_CHECK_POINTER2(ptr,text)\
833 arcaneThrowIfNull(ptr,#ptr,text)
834
835/*---------------------------------------------------------------------------*/
836/*---------------------------------------------------------------------------*/
846extern "C++" ARCANE_UTILS_EXPORT void
847arcaneRangeError [[noreturn]] (Int64 i,Int64 max_size);
848
852static inline constexpr ARCCORE_HOST_DEVICE void
853arcaneCheckAt(Int64 i,Int64 max_size)
854{
855#ifndef ARCCORE_DEVICE_CODE
856 if (i<0 || i>=max_size)
857 arcaneRangeError(i,max_size);
858#else
859 ARCANE_UNUSED(i);
860 ARCANE_UNUSED(max_size);
861#endif
862}
863
864#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
865#define ARCANE_CHECK_AT(a,b) ::Arcane::arcaneCheckAt((a),(b))
866#else
867#define ARCANE_CHECK_AT(a,b)
868#endif
869
870/*---------------------------------------------------------------------------*/
871/*---------------------------------------------------------------------------*/
872
873} // End namespace Arcane
874
875/*---------------------------------------------------------------------------*/
876/*---------------------------------------------------------------------------*/
877
878#endif
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:182
Arcane::arcaneCurrentThread
Int64 arcaneCurrentThread()
Retourne l'identifiant du thread courant.
Definition Misc.cc:117
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:68
Arcane::arcaneHasThread
bool arcaneHasThread()
Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs.
Definition Misc.cc:99
Arcane::UniqueIdType
Int64 UniqueIdType
Type des entiers utilisés pour stocker les identifiants uniques (globaux) des entités.
Definition ArcaneGlobal.h:241
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::arcaneSetHasThread
void arcaneSetHasThread(bool v)
Active ou désactive le support des threads.
Definition Misc.cc:105
Arcane::arcaneNullPointerError
void arcaneNullPointerError()
Signalue l'utilisation d'un pointeur nul.
Definition ArcaneGlobal.cc:131
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::arcanePrintf
void arcanePrintf(const char *,...)
Encapsulation de la fonction C printf.
Definition Misc.cc:192
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::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:80
Arcane::arcaneSetCheck
void arcaneSetCheck(bool v)
Active ou désactive le mode vérification.
Definition Misc.cc:74
Arcane::arcaneNoReferenceError
void arcaneNoReferenceError(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:172
Arcane::_checkDebug
bool _checkDebug(unsigned int val)
Definition Misc.cc:252
Arcane::arcaneMathError
__host__ __device__ void arcaneMathError(long double arg_value, const char *func_name)
Signale un argument invalide d'une fonction mathématique.
Definition ArcaneGlobal.h:311
Arcane::_doAssert
void _doAssert(const char *text, const char *file, const char *func, size_t line)
Definition Misc.cc:235
Arcane::arcaneDebugPause
void arcaneDebugPause(const char *msg)
Passe en mode pause ou lance une erreur fatale.
Definition Misc.cc:137
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::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184
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