Arcane  v4.1.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#ifdef ARCCORE_OS_MACOS
33# define ARCANE_OS_MACOS
34#endif
35
36#define ARCANE_EXPORT ARCCORE_EXPORT
37#define ARCANE_IMPORT ARCCORE_IMPORT
38#define ARCANE_TEMPLATE_EXPORT ARCCORE_TEMPLATE_EXPORT
39#define ARCANE_RESTRICT ARCCORE_RESTRICT
40
41#define ARCANE_STD std
42
43//Tag var as a voluntary unused variable.
44//Works with any compiler but might be improved by using attribute.
45#define ARCANE_UNUSED(var) ARCCORE_UNUSED(var)
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49
50#if defined(ARCANE_HAS_CUDA) && defined(__CUDACC__)
55#define ARCANE_COMPILING_CUDA
56#endif
57#if defined(ARCANE_HAS_HIP) && defined(__HIP__)
62#define ARCANE_COMPILING_HIP
63#endif
64
65#if defined(ARCANE_HAS_SYCL)
66# if defined(SYCL_LANGUAGE_VERSION) || defined(__ADAPTIVECPP__)
71# define ARCANE_COMPILING_SYCL
72# endif
73#endif
74
75#if defined(ARCANE_COMPILING_CUDA) || defined(ARCANE_COMPILING_HIP)
76#define ARCANE_COMPILING_CUDA_OR_HIP
77#endif
78
79/*---------------------------------------------------------------------------*/
80/*---------------------------------------------------------------------------*/
81// TODO: supprimer l'inclusion de <iosfwd> et les using.
82// Pour l'instant (2022), on supprime ces inclusions uniquement pour Arcane.
83
84#ifndef ARCANE_NO_USING_FOR_STREAM
85#include <iosfwd>
86using std::istream;
87using std::ostream;
88using std::ios;
89using std::ifstream;
90using std::ofstream;
91using std::ostringstream;
92using std::istringstream;
93#endif
94
95/*---------------------------------------------------------------------------*/
96/*---------------------------------------------------------------------------*/
97
98#ifdef DOXYGEN_DOC
99typedef ARCANE_TYPE_INT16 Int16;
100typedef ARCANE_TYPE_INT32 Int32;
101typedef ARCANE_TYPE_INT64 Int64;
102#endif
103
104#define ARCANE_BEGIN_NAMESPACE namespace Arcane {
105#define ARCANE_END_NAMESPACE }
106#define NUMERICS_BEGIN_NAMESPACE namespace Numerics {
107#define NUMERICS_END_NAMESPACE }
108
109/*---------------------------------------------------------------------------*/
110/*---------------------------------------------------------------------------*/
111
112#ifdef ARCANE_COMPONENT_FULL
113#define ARCANE_COMPONENT_arcane_utils
114#define ARCANE_COMPONENT_arcane
115#define ARCANE_COMPONENT_arcane_mesh
116#define ARCANE_COMPONENT_arcane_std
117#define ARCANE_COMPONENT_arcane_impl
118#define ARCANE_COMPONENT_arcane_script
119#endif
120
121#if defined(ARCANE_COMPONENT_arcane) || defined(ARCANE_COMPONENT_arcane_core)
122#define ARCANE_CORE_EXPORT ARCANE_EXPORT
123#define ARCANE_EXPR_EXPORT ARCANE_EXPORT
124#define ARCANE_DATATYPE_EXPORT ARCANE_EXPORT
125#define ARCANE_CORE_EXTERN_TPL
126#else
127#define ARCANE_CORE_EXPORT ARCANE_IMPORT
128#define ARCANE_EXPR_EXPORT ARCANE_IMPORT
129#define ARCANE_DATATYPE_EXPORT ARCANE_IMPORT
130#define ARCANE_CORE_EXTERN_TPL extern
131#endif
132
133#ifdef ARCANE_COMPONENT_arcane_utils
134#define ARCANE_UTILS_EXPORT ARCANE_EXPORT
135#define ARCANE_UTILS_EXTERN_TPL
136#else
137#define ARCANE_UTILS_EXPORT ARCANE_IMPORT
138#define ARCANE_UTILS_EXTERN_TPL extern
139#endif
140
141#ifdef ARCANE_COMPONENT_arcane_impl
142#define ARCANE_IMPL_EXPORT ARCANE_EXPORT
143#else
144#define ARCANE_IMPL_EXPORT ARCANE_IMPORT
145#endif
146
147#ifdef ARCANE_COMPONENT_arcane_mesh
148#define ARCANE_MESH_EXPORT ARCANE_EXPORT
149#else
150#define ARCANE_MESH_EXPORT ARCANE_IMPORT
151#endif
152
153#ifdef ARCANE_COMPONENT_arcane_std
154#define ARCANE_STD_EXPORT ARCANE_EXPORT
155#else
156#define ARCANE_STD_EXPORT ARCANE_IMPORT
157#endif
158
159#ifdef ARCANE_COMPONENT_arcane_script
160#define ARCANE_SCRIPT_EXPORT ARCANE_EXPORT
161#else
162#define ARCANE_SCRIPT_EXPORT ARCANE_IMPORT
163#endif
164
165#ifdef ARCANE_COMPONENT_arcane_solvers
166#define ARCANE_SOLVERS_EXPORT ARCANE_EXPORT
167#else
168#define ARCANE_SOLVERS_EXPORT ARCANE_IMPORT
169#endif
170
171#ifdef ARCANE_COMPONENT_arcane_geometry
172#define ARCANE_GEOMETRY_EXPORT ARCANE_EXPORT
173#else
174#define ARCANE_GEOMETRY_EXPORT ARCANE_IMPORT
175#endif
176
177#ifdef ARCANE_COMPONENT_arcane_thread
178#define ARCANE_THREAD_EXPORT ARCANE_EXPORT
179#else
180#define ARCANE_THREAD_EXPORT ARCANE_IMPORT
181#endif
182
183#ifdef ARCANE_COMPONENT_arcane_mpi
184#define ARCANE_MPI_EXPORT ARCANE_EXPORT
185#else
186#define ARCANE_MPI_EXPORT ARCANE_IMPORT
187#endif
188
189#ifdef ARCANE_COMPONENT_arcane_hyoda
190#define ARCANE_HYODA_EXPORT ARCANE_EXPORT
191#else
192#define ARCANE_HYODA_EXPORT ARCANE_IMPORT
193#endif
194
195#ifdef ARCANE_REAL_USE_APFLOAT
196#include <apfloat.h>
197#endif
198
199/*---------------------------------------------------------------------------*/
200/*---------------------------------------------------------------------------*/
201
202namespace Arcane
203{
204
205/*---------------------------------------------------------------------------*/
206/*---------------------------------------------------------------------------*/
207
208#define ARCANE_HAS_LONG_LONG
209
210/*---------------------------------------------------------------------------*/
211/*---------------------------------------------------------------------------*/
212
213const double cgrEPSILON_DELTA = 1.0e-2;
214const double cgrPI = 3.14159265358979323846;
215
216/*---------------------------------------------------------------------------*/
217/*---------------------------------------------------------------------------*/
218
219#define ARCANE_REAL(val) ARCCORE_REAL(val)
220
221#ifdef ARCCORE_REAL_NOT_BUILTIN
222# define ARCANE_REAL_NOT_BUILTIN
223#endif
224
225#ifdef ARCCORE_REAL_LONG
226# define ARCANE_REAL_LONG
227#endif
228
229#ifdef ARCCORE_REAL_IS_DOUBLE
230# define ARCANE_REAL_IS_DOUBLE
231#endif
232
240using LocalIdType = Int32;
241
249using UniqueIdType = Int64;
250
255
275
276/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
280extern "C++" ARCANE_UTILS_EXPORT void
281arcanePrintf(const char*,...);
282
283/*---------------------------------------------------------------------------*/
284/*---------------------------------------------------------------------------*/
285
296extern "C++" ARCANE_UTILS_EXPORT void
297arcaneDebugPause(const char* msg);
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302extern "C++" ARCANE_UTILS_EXPORT void
303_internalArcaneMathError(long double arg_value,const char* func_name);
304
305extern "C++" ARCANE_UTILS_EXPORT void
306_internalArcaneMathError(long double arg_value1,long double arg_value2,const char* func_name);
307
308/*---------------------------------------------------------------------------*/
309/*---------------------------------------------------------------------------*/
318ARCCORE_HOST_DEVICE inline void
319arcaneMathError(long double arg_value,const char* func_name)
320{
321#ifndef ARCCORE_DEVICE_CODE
322 _internalArcaneMathError(arg_value,func_name);
323#else
324 ARCANE_UNUSED(arg_value);
325 ARCANE_UNUSED(func_name);
326#endif
327}
328
338ARCCORE_HOST_DEVICE inline void
339arcaneMathError(long double arg_value1,long double arg_value2,const char* func_name)
340{
341#ifndef ARCCORE_DEVICE_CODE
342 _internalArcaneMathError(arg_value1,arg_value2,func_name);
343#else
344 ARCANE_UNUSED(arg_value1);
345 ARCANE_UNUSED(arg_value2);
346 ARCANE_UNUSED(func_name);
347#endif
348}
349
350/*---------------------------------------------------------------------------*/
351/*---------------------------------------------------------------------------*/
362extern "C++" ARCANE_UTILS_EXPORT void
363arcaneNotYetImplemented(const char* file,const char* func,unsigned long line,const char* msg);
364
365/*---------------------------------------------------------------------------*/
366/*---------------------------------------------------------------------------*/
367
369extern "C++" ARCANE_UTILS_EXPORT void
370arcaneDeprecated(const char* file,const char* func,unsigned long line,const char* text);
371
372/*---------------------------------------------------------------------------*/
373/*---------------------------------------------------------------------------*/
374
384extern "C++" ARCANE_UTILS_EXPORT void
385arcaneNoReferenceError(const void* ptr);
386
396extern "C++" ARCANE_UTILS_EXPORT void
397arcaneNoReferenceErrorCallTerminate(const void* ptr);
398
405extern "C++" ARCANE_UTILS_EXPORT Integer
406arcaneCheckArraySize(unsigned long long size);
407
414extern "C++" ARCANE_UTILS_EXPORT Integer
415arcaneCheckArraySize(long long size);
416
423extern "C++" ARCANE_UTILS_EXPORT Integer
424arcaneCheckArraySize(unsigned long size);
425
432extern "C++" ARCANE_UTILS_EXPORT Integer
433arcaneCheckArraySize(long size);
434
441extern "C++" ARCANE_UTILS_EXPORT Integer
442arcaneCheckArraySize(unsigned int size);
443
450extern "C++" ARCANE_UTILS_EXPORT Integer
451arcaneCheckArraySize(int size);
452
457extern "C++" ARCANE_UTILS_EXPORT void
458arcaneCheckAlignment(const void* ptr,Integer alignment);
459
466extern "C++" ARCANE_UTILS_EXPORT
467bool arcaneIsCheck();
468
476extern "C++" ARCANE_UTILS_EXPORT
477void arcaneSetCheck(bool v);
478
482extern "C++" ARCANE_UTILS_EXPORT
483bool arcaneIsDebug();
484
488extern "C++" ARCANE_UTILS_EXPORT
489bool arcaneHasThread();
490
500extern "C++" ARCANE_UTILS_EXPORT
501void arcaneSetHasThread(bool v);
502
508extern "C++" ARCANE_UTILS_EXPORT
509Int64 arcaneCurrentThread();
510
511/*---------------------------------------------------------------------------*/
512/*---------------------------------------------------------------------------*/
513
514#ifdef ARCANE_DEBUG
515extern "C++" ARCANE_UTILS_EXPORT bool _checkDebug(size_t);
516#define ARCANE_DEBUGP(a,b) if (_checkDebug(a)) { arcanePrintf b; }
517#else
518#define ARCANE_DEBUGP(a,b)
519#endif
520
521/*---------------------------------------------------------------------------*/
522/*---------------------------------------------------------------------------*/
523
524#ifdef __GNUG__
525# define ARCANE_NOT_YET_IMPLEMENTED(a) \
526{ arcaneNotYetImplemented(__FILE__,__PRETTY_FUNCTION__,__LINE__,(a)); }
527#else
528# define ARCANE_NOT_YET_IMPLEMENTED(a) \
529{ arcaneNotYetImplemented(__FILE__,"(NoInfo)",__LINE__,(a)); }
530#endif
531
532#define ARCANE_DEPRECATED ARCCORE_DEPRECATED
533
534#define ARCANE_DEPRECATED_112 ARCANE_DEPRECATED
535#define ARCANE_DEPRECATED_114 ARCANE_DEPRECATED
536#define ARCANE_DEPRECATED_116 ARCANE_DEPRECATED
537#define ARCANE_DEPRECATED_118 ARCANE_DEPRECATED
538#define ARCANE_DEPRECATED_120 ARCANE_DEPRECATED
539#define ARCANE_DEPRECATED_122 ARCANE_DEPRECATED
540#define ARCANE_DEPRECATED_200 ARCANE_DEPRECATED
541#define ARCANE_DEPRECATED_220 ARCANE_DEPRECATED
542#define ARCANE_DEPRECATED_240 ARCANE_DEPRECATED
543#define ARCANE_DEPRECATED_260 ARCANE_DEPRECATED
544#define ARCANE_DEPRECATED_280 ARCANE_DEPRECATED
545#define ARCANE_DEPRECATED_2018 ARCANE_DEPRECATED
546#define ARCANE_DEPRECATED_2018_R(reason) [[deprecated(reason)]]
547
548#ifndef ARCCORE_DEPRECATED_2021
549#define ARCCORE_DEPRECATED_2021(reason) [[deprecated(reason)]]
550#endif
551
552#define ARCANE_DEPRECATED_REASON(reason) [[deprecated(reason)]]
553
554#ifdef ARCANE_NO_DEPRECATED_LONG_TERM
555#define ARCANE_DEPRECATED_LONG_TERM(reason)
556#else
564#define ARCANE_DEPRECATED_LONG_TERM(reason) [[deprecated(reason)]]
565#endif
566
567// Définir cette macro si on souhaite supprimer de la compilation les
568// méthodes et types obsolètes.
569#define ARCANE_NO_DEPRECATED
570
571// Si la macro est définie, ne notifie pas des méthodes obsolètes des anciennes
572// classes tableaux.
573#ifdef ARCANE_NO_NOTIFY_DEPRECATED_ARRAY
574#define ARCANE_DEPRECATED_ARRAY
575#else
576#define ARCANE_DEPRECATED_ARRAY ARCANE_DEPRECATED
577#endif
578
579/*---------------------------------------------------------------------------*/
580/*---------------------------------------------------------------------------*/
581
582// Les macros suivantes permettent de de créer un identifiant en suffixant
583// le numéro de ligne du fichier. Cela permet d'avoir un identifiant unique
584// pour un fichier et est utilisé par exemple pour générer des noms
585// de variable globale pour l'enregistrement des services.
586// La macro a utiliser est ARCANE_JOIN_WITH_LINE(name).
587#define ARCANE_JOIN_HELPER2(a,b) a ## b
588#define ARCANE_JOIN_HELPER(a,b) ARCANE_JOIN_HELPER2(a,b)
589#define ARCANE_JOIN_WITH_LINE(a) ARCANE_JOIN_HELPER(a,__LINE__)
590
591/*---------------------------------------------------------------------------*/
592/*---------------------------------------------------------------------------*/
593// La macro ARCANE_NORETURN utilise l'attribut [[noreturn]] du C++11 pour
594// indiquer qu'une fonction ne retourne pas.
595#define ARCANE_NORETURN ARCCORE_NORETURN
596
598#define ARCANE_CONSTEXPR ARCCORE_CONSTEXPR
599
600// Le C++11 définit un mot clé 'noexcept' pour indiquer qu'une méthode ne
601// renvoie pas d'exceptions. Malheureusement, comme le support du C++11
602// est fait de manière partielle par les compilateurs, cela ne marche pas
603// pour tous. En particulier, icc 13, 14 et 15 ne supportent pas cela, ni
604// Visual Studio 2013 et antérieurs.
605#define ARCANE_NOEXCEPT ARCCORE_NOEXCEPT
606#define ARCANE_NOEXCEPT_FALSE ARCCORE_NOEXCEPT_FALSE
607
608/*---------------------------------------------------------------------------*/
609/*---------------------------------------------------------------------------*/
610
611// Support pour l'alignement.
612// le C++11 utilise le mot clé alignas pour spécifier l'alignement.
613// Cela fonctionne avec GCC 4.9+ et Visual Studio 2015. Cela ne fonctionne
614// pas avec Visual Studio 2013. Donc pour Visual Studio on utilise dans tous
615// les cas __declspec qui fonctionne toujours. Sous Linux, __attribute__ fonctionne
616// aussi toujours donc on utilise cela. A noter que les structures Simd ont besoin
617// de l'attribut 'packed' qui n'existe que avec GCC et Intel. Il ne semble pas y avoir
618// d'équivalent avec MSVC.
619#ifdef _MSC_VER
621# define ARCANE_ALIGNAS(value) __declspec(align(value))
623# define ARCANE_ALIGNAS_PACKED(value) __declspec(align(value))
624#else
626# define ARCANE_ALIGNAS_PACKED(value) __attribute__ ((aligned (value),packed))
628# define ARCANE_ALIGNAS(value) __attribute__ ((aligned (value)))
629#endif
630
631/*---------------------------------------------------------------------------*/
632/*---------------------------------------------------------------------------*/
633
634#ifdef ARCANE_SWIG
635#ifdef ARCANE_DEPRECATED
636#undef ARCANE_DEPRECATED
637#endif
638#endif
639
640/*---------------------------------------------------------------------------*/
641/*---------------------------------------------------------------------------*/
642
643#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
644#ifndef ARCANE_DEBUG_ASSERT
645#define ARCANE_DEBUG_ASSERT
646#endif
647#endif
648
649/*---------------------------------------------------------------------------*/
650/*---------------------------------------------------------------------------*/
658extern "C++" ARCANE_UTILS_EXPORT void
659arcaneNullPointerError [[noreturn]] ();
660
661/*---------------------------------------------------------------------------*/
662/*---------------------------------------------------------------------------*/
674extern "C++" ARCANE_UTILS_EXPORT void
675arcaneThrowNullPointerError [[noreturn]] (const char* ptr_name,const char* text);
676
677/*---------------------------------------------------------------------------*/
678/*---------------------------------------------------------------------------*/
682static inline void
683arcaneCheckNull(const void* ptr)
684{
685 if (!ptr)
686 arcaneNullPointerError();
687}
688
689/*---------------------------------------------------------------------------*/
690/*---------------------------------------------------------------------------*/
699static const Integer SIMD_PADDING_SIZE = 8;
700
701/*---------------------------------------------------------------------------*/
702/*---------------------------------------------------------------------------*/
711extern "C++" ARCANE_UTILS_EXPORT Integer
712arcaneSizeWithPadding(Integer size);
713
714/*---------------------------------------------------------------------------*/
715/*---------------------------------------------------------------------------*/
716
717/*
718 * Macros utilisées pour le débug.
719 */
720#ifdef ARCANE_DEBUG_ASSERT
721extern "C++" ARCANE_UTILS_EXPORT void _doAssert(const char*,const char*,const char*,size_t);
722template<typename T> inline T*
723_checkPointer(T* t,const char* file,const char* func,size_t line)
724{
725 if (!t){
726 _doAssert("ARCANE_ASSERT",file,func,line);
727 arcanePrintf("Bad Pointer");
728 }
729 return t;
730}
731# ifdef __GNUG__
732# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,__PRETTY_FUNCTION__,__LINE__)
733# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,__PRETTY_FUNCTION__,__LINE__);
734# else
735# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,"(NoInfo)",__LINE__)
736# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,"(NoInfo"),__LINE__);
737# endif
738# define ARCANE_CHECK_PTR(a) \
739 {if (!(a)){Arcane::arcanePrintf("Null value");ARCANE_D_WHERE("ARCANE_ASSERT");}}
740
741# define ARCANE_ASSERT(a,b) \
742 {if (!(a)){ Arcane::arcanePrintf("Assertion '%s' fails:",#a); Arcane::arcanePrintf b; ARCANE_D_WHERE("ARCANE_ASSERT");}}
743# define ARCANE_WARNING(a) \
744 { Arcane::arcanePrintf a; ARCANE_D_WHERE("ARCANE_WARNING"); }
745#else
746# define ARCANE_CHECK_PTR(a)
747# define ARCANE_ASSERT(a,b)
748# define ARCANE_WARNING(a)
749# define ARCANE_DCHECK_POINTER(a) (a);
750#endif
751
752/*---------------------------------------------------------------------------*/
753/*---------------------------------------------------------------------------*/
761#define ARCANE_THROW(exception_class,...) \
762 ARCCORE_THROW(exception_class,__VA_ARGS__)
763
773#define ARCANE_THROW_IF(const, exception_class, ...) \
774 ARCCORE_THROW_IF(const, exception_class, __VA_ARGS__)
775
776/*---------------------------------------------------------------------------*/
777/*---------------------------------------------------------------------------*/
784#define ARCANE_FATAL(...) \
785 ARCCORE_FATAL(__VA_ARGS__)
786
795#define ARCANE_FATAL_IF(const, ...) \
796 ARCCORE_FATAL_IF(const, __VA_ARGS__)
797
798/*---------------------------------------------------------------------------*/
799/*---------------------------------------------------------------------------*/
806static inline void*
807arcaneThrowIfNull(void* ptr,const char* ptr_name,const char* text)
808{
809 if (!ptr)
810 arcaneThrowNullPointerError(ptr_name,text);
811 return ptr;
812}
813
814/*---------------------------------------------------------------------------*/
815/*---------------------------------------------------------------------------*/
822static inline const void*
823arcaneThrowIfNull(const void* ptr,const char* ptr_name,const char* text)
824{
825 if (!ptr)
826 arcaneThrowNullPointerError(ptr_name,text);
827 return ptr;
828}
829
830/*---------------------------------------------------------------------------*/
831/*---------------------------------------------------------------------------*/
838template<typename T> inline T*
839arcaneThrowIfNull(T* ptr,const char* ptr_name,const char* text)
840{
841 if (!ptr)
842 arcaneThrowNullPointerError(ptr_name,text);
843 return ptr;
844}
845
846/*---------------------------------------------------------------------------*/
847/*---------------------------------------------------------------------------*/
854#define ARCANE_CHECK_POINTER(ptr) \
855 arcaneThrowIfNull(ptr,#ptr,nullptr)
856
863#define ARCANE_CHECK_POINTER2(ptr,text)\
864 arcaneThrowIfNull(ptr,#ptr,text)
865
866/*---------------------------------------------------------------------------*/
867/*---------------------------------------------------------------------------*/
877extern "C++" ARCANE_UTILS_EXPORT void
878arcaneRangeError [[noreturn]] (Int64 i,Int64 max_size);
879
883static inline constexpr ARCCORE_HOST_DEVICE void
884arcaneCheckAt(Int64 i,Int64 max_size)
885{
886#ifndef ARCCORE_DEVICE_CODE
887 if (i<0 || i>=max_size)
888 arcaneRangeError(i,max_size);
889#else
890 ARCANE_UNUSED(i);
891 ARCANE_UNUSED(max_size);
892#endif
893}
894
895#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
896#define ARCANE_CHECK_AT(a,b) ::Arcane::arcaneCheckAt((a),(b))
897#else
898#define ARCANE_CHECK_AT(a,b)
899#endif
900
901/*---------------------------------------------------------------------------*/
902/*---------------------------------------------------------------------------*/
903
904} // End namespace Arcane
905
906/*---------------------------------------------------------------------------*/
907/*---------------------------------------------------------------------------*/
908
909#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:249
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:214
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:319
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:200
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