Arcane  v3.16.6.0
Documentation utilisateur
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__)
51/*!
52 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
53 * de CUDA et qu'on utilise le compilateur CUDA.
54 */
55#define ARCANE_COMPILING_CUDA
56#endif
57#if defined(ARCANE_HAS_HIP) && defined(__HIP__)
58/*!
59 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
60 * de HIP et qu'on utilise le compilateur HIP.
61 */
62#define ARCANE_COMPILING_HIP
63#endif
64
65#if defined(ARCANE_HAS_SYCL)
66# if defined(SYCL_LANGUAGE_VERSION) || defined(__ADAPTIVECPP__)
67/*!
68 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
69 * de SYCL et qu'on utilise le compilateur SYCL.
70 */
71# define ARCANE_COMPILING_SYCL
72# endif
73#endif
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
77// TODO: supprimer l'inclusion de <iosfwd> et les using.
78// Pour l'instant (2022), on supprime ces inclusions uniquement pour Arcane.
79
80#ifndef ARCANE_NO_USING_FOR_STREAM
81#include <iosfwd>
82using std::istream;
83using std::ostream;
84using std::ios;
85using std::ifstream;
86using std::ofstream;
87using std::ostringstream;
88using std::istringstream;
89#endif
90
91/*---------------------------------------------------------------------------*/
92/*---------------------------------------------------------------------------*/
93
94#ifdef DOXYGEN_DOC
95typedef ARCANE_TYPE_INT16 Int16;
96typedef ARCANE_TYPE_INT32 Int32;
97typedef ARCANE_TYPE_INT64 Int64;
98#endif
99
100#define ARCANE_BEGIN_NAMESPACE namespace Arcane {
101#define ARCANE_END_NAMESPACE }
102#define NUMERICS_BEGIN_NAMESPACE namespace Numerics {
103#define NUMERICS_END_NAMESPACE }
104
105/*---------------------------------------------------------------------------*/
106/*---------------------------------------------------------------------------*/
107
108#ifdef ARCANE_COMPONENT_FULL
109#define ARCANE_COMPONENT_arcane_utils
110#define ARCANE_COMPONENT_arcane
111#define ARCANE_COMPONENT_arcane_mesh
112#define ARCANE_COMPONENT_arcane_std
113#define ARCANE_COMPONENT_arcane_impl
114#define ARCANE_COMPONENT_arcane_script
115#endif
116
117#if defined(ARCANE_COMPONENT_arcane) || defined(ARCANE_COMPONENT_arcane_core)
118#define ARCANE_CORE_EXPORT ARCANE_EXPORT
119#define ARCANE_EXPR_EXPORT ARCANE_EXPORT
120#define ARCANE_DATATYPE_EXPORT ARCANE_EXPORT
121#define ARCANE_CORE_EXTERN_TPL
122#else
123#define ARCANE_CORE_EXPORT ARCANE_IMPORT
124#define ARCANE_EXPR_EXPORT ARCANE_IMPORT
125#define ARCANE_DATATYPE_EXPORT ARCANE_IMPORT
126#define ARCANE_CORE_EXTERN_TPL extern
127#endif
128
129#ifdef ARCANE_COMPONENT_arcane_utils
130#define ARCANE_UTILS_EXPORT ARCANE_EXPORT
131#define ARCANE_UTILS_EXTERN_TPL
132#else
133#define ARCANE_UTILS_EXPORT ARCANE_IMPORT
134#define ARCANE_UTILS_EXTERN_TPL extern
135#endif
136
137#ifdef ARCANE_COMPONENT_arcane_impl
138#define ARCANE_IMPL_EXPORT ARCANE_EXPORT
139#else
140#define ARCANE_IMPL_EXPORT ARCANE_IMPORT
141#endif
142
143#ifdef ARCANE_COMPONENT_arcane_mesh
144#define ARCANE_MESH_EXPORT ARCANE_EXPORT
145#else
146#define ARCANE_MESH_EXPORT ARCANE_IMPORT
147#endif
148
149#ifdef ARCANE_COMPONENT_arcane_std
150#define ARCANE_STD_EXPORT ARCANE_EXPORT
151#else
152#define ARCANE_STD_EXPORT ARCANE_IMPORT
153#endif
154
155#ifdef ARCANE_COMPONENT_arcane_script
156#define ARCANE_SCRIPT_EXPORT ARCANE_EXPORT
157#else
158#define ARCANE_SCRIPT_EXPORT ARCANE_IMPORT
159#endif
160
161#ifdef ARCANE_COMPONENT_arcane_solvers
162#define ARCANE_SOLVERS_EXPORT ARCANE_EXPORT
163#else
164#define ARCANE_SOLVERS_EXPORT ARCANE_IMPORT
165#endif
166
167#ifdef ARCANE_COMPONENT_arcane_geometry
168#define ARCANE_GEOMETRY_EXPORT ARCANE_EXPORT
169#else
170#define ARCANE_GEOMETRY_EXPORT ARCANE_IMPORT
171#endif
172
173#ifdef ARCANE_COMPONENT_arcane_thread
174#define ARCANE_THREAD_EXPORT ARCANE_EXPORT
175#else
176#define ARCANE_THREAD_EXPORT ARCANE_IMPORT
177#endif
178
179#ifdef ARCANE_COMPONENT_arcane_mpi
180#define ARCANE_MPI_EXPORT ARCANE_EXPORT
181#else
182#define ARCANE_MPI_EXPORT ARCANE_IMPORT
183#endif
184
185#ifdef ARCANE_COMPONENT_arcane_hyoda
186#define ARCANE_HYODA_EXPORT ARCANE_EXPORT
187#else
188#define ARCANE_HYODA_EXPORT ARCANE_IMPORT
189#endif
190
191#ifdef ARCANE_REAL_USE_APFLOAT
192#include <apfloat.h>
193#endif
194
195/*---------------------------------------------------------------------------*/
196/*---------------------------------------------------------------------------*/
197
198namespace Arcane
199{
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203
204#define ARCANE_HAS_LONG_LONG
205
206/*---------------------------------------------------------------------------*/
207/*---------------------------------------------------------------------------*/
208
209const double cgrEPSILON_DELTA = 1.0e-2;
210const double cgrPI = 3.14159265358979323846;
211
212/*---------------------------------------------------------------------------*/
213/*---------------------------------------------------------------------------*/
214
215#define ARCANE_REAL(val) ARCCORE_REAL(val)
216
217#ifdef ARCCORE_REAL_NOT_BUILTIN
218# define ARCANE_REAL_NOT_BUILTIN
219#endif
220
221#ifdef ARCCORE_REAL_LONG
222# define ARCANE_REAL_LONG
223#endif
224
225#ifdef ARCCORE_REAL_IS_DOUBLE
226# define ARCANE_REAL_IS_DOUBLE
227#endif
228
229/*!
230 * \brief Type des entiers utilisés pour stocker les identifiants locaux
231 * des entités.
232 *
233 * Les valeurs que peut prendre ce type indique combien d'entités
234 * pourront être présentes sur un sous-domaine.
235 */
237
238/*!
239 * \brief Type des entiers utilisés pour stocker les identifiants uniques
240 * (globaux) des entités.
241 *
242 * Les valeurs que peut prendre ce type indique combien d'entités
243 * pourront être présentes sur le domaine initial.
244 */
246
247/*!
248 * \def ARCANE_INTEGER_MAX
249 * \brief Macro indiquant la valeur maximal que peut prendre le type #Integer
250 */
251
252/*!
253 * \typedef Int64
254 * \brief Type entier signé sur 64 bits.
255 */
256/*!
257 * \typedef Int32
258 * \brief Type entier signé sur 32 bits.
259 */
260/*!
261 * \typedef Int16
262 * \brief Type entier signé sur 16 bits.
263 */
264/*!
265 * \typedef Integer
266 * \brief Type représentant un entier
267 *
268 * Si la macro ARCANE_64BIT est définie, le type Integer correspond à un
269 * entier Int64, sinon à un entier Int32.
270 */
271
272/*---------------------------------------------------------------------------*/
273/*---------------------------------------------------------------------------*/
274
275//! Encapsulation de la fonction C printf
276extern "C++" ARCANE_UTILS_EXPORT void
277arcanePrintf(const char*,...);
278
279/*---------------------------------------------------------------------------*/
280/*---------------------------------------------------------------------------*/
281
282/*!
283 * \brief Passe en mode pause ou lance une erreur fatale.
284 *
285 * Si le code est compilé en mode \a debug (ARCANE_DEBUG est définie) ou
286 * en mode \a check (ARCANE_CHECK est définie), met le programme en pause
287 * pour éventuellement connecter un débugger dessus.
288 *
289 * En mode normal, lance une exception FatalErrorException avec le message
290 * \a msg comme argument.
291 */
292extern "C++" ARCANE_UTILS_EXPORT void
293arcaneDebugPause(const char* msg);
294
295/*---------------------------------------------------------------------------*/
296/*---------------------------------------------------------------------------*/
297
298extern "C++" ARCANE_UTILS_EXPORT void
299_internalArcaneMathError(long double arg_value,const char* func_name);
300
301extern "C++" ARCANE_UTILS_EXPORT void
302_internalArcaneMathError(long double arg_value1,long double arg_value2,const char* func_name);
303
304/*---------------------------------------------------------------------------*/
305/*---------------------------------------------------------------------------*/
306/*!
307 * \brief Signale un argument invalide d'une fonction mathématique.
308 *
309 * Une fois le message affiché, appelle arcaneDebugPause()
310 *
311 * \param arg_value valeur de l'argument invalide.
312 * \param func_name nom de la fonction mathématique.
313 */
314ARCCORE_HOST_DEVICE inline void
315arcaneMathError(long double arg_value,const char* func_name)
316{
317#ifndef ARCCORE_DEVICE_CODE
318 _internalArcaneMathError(arg_value,func_name);
319#else
320 ARCANE_UNUSED(arg_value);
321 ARCANE_UNUSED(func_name);
322#endif
323}
324
325/*!
326 * \brief Signale un argument invalide d'une fonction mathématique.
327 *
328 * Une fois le message affiché, appelle arcaneDebugPause()
329 *
330 * \param arg_value1 valeur du premier argument invalide.
331 * \param arg_value2 valeur du second argument invalide.
332 * \param func_name nom de la fonction mathématique.
333 */
334ARCCORE_HOST_DEVICE inline void
335arcaneMathError(long double arg_value1,long double arg_value2,const char* func_name)
336{
337#ifndef ARCCORE_DEVICE_CODE
338 _internalArcaneMathError(arg_value1,arg_value2,func_name);
339#else
340 ARCANE_UNUSED(arg_value1);
341 ARCANE_UNUSED(arg_value2);
342 ARCANE_UNUSED(func_name);
343#endif
344}
345
346/*---------------------------------------------------------------------------*/
347/*---------------------------------------------------------------------------*/
348/*!
349 * \brief Signale une fonction non implémentée.
350 *
351 * Une fois le message affiché, appelle arcaneDebugPause()
352 *
353 * \param file nom du fichier contenant la fonction
354 * \param func nom de la fonction
355 * \param numéro de ligne
356 * \param msg message éventuel à afficher (0 si aucun)
357 */
358extern "C++" ARCANE_UTILS_EXPORT void
359arcaneNotYetImplemented(const char* file,const char* func,unsigned long line,const char* msg);
360
361/*---------------------------------------------------------------------------*/
362/*---------------------------------------------------------------------------*/
363
364//! Signale l'utilisation d'une fonction obsolète
365extern "C++" ARCANE_UTILS_EXPORT void
366arcaneDeprecated(const char* file,const char* func,unsigned long line,const char* text);
367
368/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370
371/*!
372 * \brief Utilisation d'un objet non référencé.
373 *
374 * Signale une tentative d'utilisation d'un objet qui ne devrait plus être
375 * référencé. Affiche un message et appelle arcaneDebugPause() si demandé et
376 * ensuite lance une exception FatalErrorException.
377 *
378 * \param ptr adresse de l'objet
379 */
380extern "C++" ARCANE_UTILS_EXPORT void
381arcaneNoReferenceError(const void* ptr);
382
383/*!
384 * \brief Utilisation d'un objet non référencé.
385 *
386 * Signale une tentative d'utilisation d'un objet qui ne devrait plus être
387 * référencé. Affiche un message et appelle arcaneDebugPause() si demandé et
388 * ensuite appelle std::terminate().
389 *
390 * \param ptr adresse de l'objet
391 */
392extern "C++" ARCANE_UTILS_EXPORT void
394
395/*!
396 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
397 * de taille à un tableau.
398 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
399 * une exception de type ArgumentException.
400 */
401extern "C++" ARCANE_UTILS_EXPORT Integer
402arcaneCheckArraySize(unsigned long long size);
403
404/*!
405 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
406 * de taille à un tableau.
407 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
408 * une exception de type ArgumentException.
409 */
410extern "C++" ARCANE_UTILS_EXPORT Integer
411arcaneCheckArraySize(long long size);
412
413/*!
414 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
415 * de taille à un tableau.
416 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
417 * une exception de type ArgumentException.
418 */
419extern "C++" ARCANE_UTILS_EXPORT Integer
420arcaneCheckArraySize(unsigned long size);
421
422/*!
423 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
424 * de taille à un tableau.
425 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
426 * une exception de type ArgumentException.
427 */
428extern "C++" ARCANE_UTILS_EXPORT Integer
429arcaneCheckArraySize(long size);
430
431/*!
432 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
433 * de taille à un tableau.
434 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
435 * une exception de type ArgumentException.
436 */
437extern "C++" ARCANE_UTILS_EXPORT Integer
438arcaneCheckArraySize(unsigned int size);
439
440/*!
441 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
442 * de taille à un tableau.
443 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
444 * une exception de type ArgumentException.
445 */
446extern "C++" ARCANE_UTILS_EXPORT Integer
447arcaneCheckArraySize(int size);
448
449/*!
450 * \brief Vérifie que \a ptr est aligné sur \a alignment octets.
451 * Si ce n'est pas le cas, Sinon, lance une exception de type BadAlignmentException.
452 */
453extern "C++" ARCANE_UTILS_EXPORT void
454arcaneCheckAlignment(const void* ptr,Integer alignment);
455
456/*!
457 * \brief Vrai si on est en mode vérification.
458 *
459 * Ce mode est actif si la macro ARCANE_CHECK est définie
460 * ou si la méthode arcaneSetCheck() a été positionnée a vrai.
461 */
462extern "C++" ARCANE_UTILS_EXPORT
463bool arcaneIsCheck();
464
465/*!
466 * \brief Active ou désactive le mode vérification.
467 *
468 * Le mode vérification est toujours actif si la macro ARCANE_CHECK est définie.
469 * Sinon, il est possible de l'activer avec cette méthode. Cela permet
470 * d'activer certains tests même en mode optimisé.
471 */
472extern "C++" ARCANE_UTILS_EXPORT
473void arcaneSetCheck(bool v);
474
475/*!
476 * \brief Vrai si la macro ARCANE_DEBUG est définie
477 */
478extern "C++" ARCANE_UTILS_EXPORT
479bool arcaneIsDebug();
480
481/*!
482 * \brief Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs
483 */
484extern "C++" ARCANE_UTILS_EXPORT
485bool arcaneHasThread();
486
487/*!
488 * \brief Active ou désactive le support des threads.
489 *
490 * Cette fonction ne doit être appelée que lors de l'initialisation
491 * de l'application (ou avant) et ne pas être modifiée par la suite.
492 * L'activation des threads n'est possible que si une implémentation
493 * des threads existe sur la plate-forme et que Arcane a été compilé
494 * avec ce support.
495 */
496extern "C++" ARCANE_UTILS_EXPORT
497void arcaneSetHasThread(bool v);
498
499/*!
500 * \brief Retourne l'identifiant du thread courant.
501 *
502 * Retourne toujours 0 si arcaneHasThread() est faux.
503 */
504extern "C++" ARCANE_UTILS_EXPORT
506
507/*---------------------------------------------------------------------------*/
508/*---------------------------------------------------------------------------*/
509
510#ifdef ARCANE_DEBUG
511extern "C++" ARCANE_UTILS_EXPORT bool _checkDebug(size_t);
512#define ARCANE_DEBUGP(a,b) if (_checkDebug(a)) { arcanePrintf b; }
513#else
514#define ARCANE_DEBUGP(a,b)
515#endif
516
517/*---------------------------------------------------------------------------*/
518/*---------------------------------------------------------------------------*/
519
520#ifdef __GNUG__
521# define ARCANE_NOT_YET_IMPLEMENTED(a) \
522{ arcaneNotYetImplemented(__FILE__,__PRETTY_FUNCTION__,__LINE__,(a)); }
523#else
524# define ARCANE_NOT_YET_IMPLEMENTED(a) \
525{ arcaneNotYetImplemented(__FILE__,"(NoInfo)",__LINE__,(a)); }
526#endif
527
528#define ARCANE_DEPRECATED ARCCORE_DEPRECATED
529
530#define ARCANE_DEPRECATED_112 ARCANE_DEPRECATED
531#define ARCANE_DEPRECATED_114 ARCANE_DEPRECATED
532#define ARCANE_DEPRECATED_116 ARCANE_DEPRECATED
533#define ARCANE_DEPRECATED_118 ARCANE_DEPRECATED
534#define ARCANE_DEPRECATED_120 ARCANE_DEPRECATED
535#define ARCANE_DEPRECATED_122 ARCANE_DEPRECATED
536#define ARCANE_DEPRECATED_200 ARCANE_DEPRECATED
537#define ARCANE_DEPRECATED_220 ARCANE_DEPRECATED
538#define ARCANE_DEPRECATED_240 ARCANE_DEPRECATED
539#define ARCANE_DEPRECATED_260 ARCANE_DEPRECATED
540#define ARCANE_DEPRECATED_280 ARCANE_DEPRECATED
541#define ARCANE_DEPRECATED_2018 ARCANE_DEPRECATED
542#define ARCANE_DEPRECATED_2018_R(reason) [[deprecated(reason)]]
543
544#ifndef ARCCORE_DEPRECATED_2021
545#define ARCCORE_DEPRECATED_2021(reason) [[deprecated(reason)]]
546#endif
547
548#define ARCANE_DEPRECATED_REASON(reason) [[deprecated(reason)]]
549
550#ifdef ARCANE_NO_DEPRECATED_LONG_TERM
551#define ARCANE_DEPRECATED_LONG_TERM(reason)
552#else
553/*!
554 * \brief Macro pour l'attribut 'deprecated' à long terme.
555 *
556 * Cette macro est pour indiquer les types ou fonctions
557 * obsolète et donc qu'il est préférable de ne pas utiliser mais qui
558 * ne seront pas supprimés avant plusieurs versions.
559 */
560#define ARCANE_DEPRECATED_LONG_TERM(reason) [[deprecated(reason)]]
561#endif
562
563// Définir cette macro si on souhaite supprimer de la compilation les
564// méthodes et types obsolètes.
565#define ARCANE_NO_DEPRECATED
566
567// Si la macro est définie, ne notifie pas des méthodes obsolètes des anciennes
568// classes tableaux.
569#ifdef ARCANE_NO_NOTIFY_DEPRECATED_ARRAY
570#define ARCANE_DEPRECATED_ARRAY
571#else
572#define ARCANE_DEPRECATED_ARRAY ARCANE_DEPRECATED
573#endif
574
575/*---------------------------------------------------------------------------*/
576/*---------------------------------------------------------------------------*/
577
578// Les macros suivantes permettent de de créer un identifiant en suffixant
579// le numéro de ligne du fichier. Cela permet d'avoir un identifiant unique
580// pour un fichier et est utilisé par exemple pour générer des noms
581// de variable globale pour l'enregistrement des services.
582// La macro a utiliser est ARCANE_JOIN_WITH_LINE(name).
583#define ARCANE_JOIN_HELPER2(a,b) a ## b
584#define ARCANE_JOIN_HELPER(a,b) ARCANE_JOIN_HELPER2(a,b)
585#define ARCANE_JOIN_WITH_LINE(a) ARCANE_JOIN_HELPER(a,__LINE__)
586
587/*---------------------------------------------------------------------------*/
588/*---------------------------------------------------------------------------*/
589// La macro ARCANE_NORETURN utilise l'attribut [[noreturn]] du C++11 pour
590// indiquer qu'une fonction ne retourne pas.
591#define ARCANE_NORETURN ARCCORE_NORETURN
592
593//! Macro permettant de spécifier le mot-clé 'constexpr' du C++11
594#define ARCANE_CONSTEXPR ARCCORE_CONSTEXPR
595
596// Le C++11 définit un mot clé 'noexcept' pour indiquer qu'une méthode ne
597// renvoie pas d'exceptions. Malheureusement, comme le support du C++11
598// est fait de manière partielle par les compilateurs, cela ne marche pas
599// pour tous. En particulier, icc 13, 14 et 15 ne supportent pas cela, ni
600// Visual Studio 2013 et antérieurs.
601#define ARCANE_NOEXCEPT ARCCORE_NOEXCEPT
602#define ARCANE_NOEXCEPT_FALSE ARCCORE_NOEXCEPT_FALSE
603
604/*---------------------------------------------------------------------------*/
605/*---------------------------------------------------------------------------*/
606
607// Support pour l'alignement.
608// le C++11 utilise le mot clé alignas pour spécifier l'alignement.
609// Cela fonctionne avec GCC 4.9+ et Visual Studio 2015. Cela ne fonctionne
610// pas avec Visual Studio 2013. Donc pour Visual Studio on utilise dans tous
611// les cas __declspec qui fonctionne toujours. Sous Linux, __attribute__ fonctionne
612// aussi toujours donc on utilise cela. A noter que les structures Simd ont besoin
613// de l'attribut 'packed' qui n'existe que avec GCC et Intel. Il ne semble pas y avoir
614// d'équivalent avec MSVC.
615#ifdef _MSC_VER
616//! Macro pour garantir le compactage et l'alignement d'une classe sur \a value octets
617# define ARCANE_ALIGNAS(value) __declspec(align(value))
618//! Macro pour garantir l'alignement d'une classe sur \a value octets
619# define ARCANE_ALIGNAS_PACKED(value) __declspec(align(value))
620#else
621//! Macro pour garantir le compactage et l'alignement d'une classe sur \a value octets
622# define ARCANE_ALIGNAS_PACKED(value) __attribute__ ((aligned (value),packed))
623//! Macro pour garantir l'alignement d'une classe sur \a value octets
624# define ARCANE_ALIGNAS(value) __attribute__ ((aligned (value)))
625#endif
626
627/*---------------------------------------------------------------------------*/
628/*---------------------------------------------------------------------------*/
629
630#ifdef ARCANE_SWIG
631#ifdef ARCANE_DEPRECATED
632#undef ARCANE_DEPRECATED
633#endif
634#endif
635
636/*---------------------------------------------------------------------------*/
637/*---------------------------------------------------------------------------*/
638
639#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
640#ifndef ARCANE_DEBUG_ASSERT
641#define ARCANE_DEBUG_ASSERT
642#endif
643#endif
644
645/*---------------------------------------------------------------------------*/
646/*---------------------------------------------------------------------------*/
647/*!
648 * \brief Signalue l'utilisation d'un pointeur nul.
649 *
650 * Signale une tentative d'utilisation d'un pointeur nul.
651 * Affiche un message, appelle arcaneDebugPause() et lance une exception
652 * de type FatalErrorException.
653 */
654extern "C++" ARCANE_UTILS_EXPORT void
655arcaneNullPointerError [[noreturn]] ();
656
657/*---------------------------------------------------------------------------*/
658/*---------------------------------------------------------------------------*/
659/*!
660 * \brief Signalee l'utilisation d'un pointeur nul en envoyant une exception
661 *
662 * Signale une tentative d'utilisation d'un pointeur nul.
663 * Lance une exception de type FatalErrorException.
664 *
665 * Dans l'exception, affiche \a text si non nul, sinon affiche \a ptr_name.
666 *
667 * Normalement cette méthode ne doit pas être appelée directement mais
668 * via la macro ARCANE_CHECK_POINTER.
669 */
670extern "C++" ARCANE_UTILS_EXPORT void
671arcaneThrowNullPointerError [[noreturn]] (const char* ptr_name,const char* text);
672
673/*---------------------------------------------------------------------------*/
674/*---------------------------------------------------------------------------*/
675/*!
676 * \brief Vérifie qu'un pointeur n'est pas nul.
677 */
678static inline void
679arcaneCheckNull(const void* ptr)
680{
681 if (!ptr)
683}
684
685/*---------------------------------------------------------------------------*/
686/*---------------------------------------------------------------------------*/
687/*!
688 * \brief Taille du padding pour les index dans les opérations SIMD.
689 *
690 * Afin d'avoir le même code quel que soit le mécanisme de vectorisation
691 * utilisé, cette valeur est fixe et correspond au plus grand vecteur SIMD.
692 *
693 * \sa arcanedoc_simd
694 */
695static const Integer SIMD_PADDING_SIZE = 8;
696
697/*---------------------------------------------------------------------------*/
698/*---------------------------------------------------------------------------*/
699/*!
700 * \brief Retourne la taille avec padding pour une taille \a size.
701 *
702 * La valeurs retournée est un multiple de SIMD_PADDING_SIZE et vaut:
703 * - 0 si \a size est inférieur ou égal à 0.
704 * - \a size si \a size est un multiple de SIMD_PADDING_SIZE.
705 * - le multiple de SIMD_PADDING_SIZE immédiatement supérieur à \a size sinon.
706 */
707extern "C++" ARCANE_UTILS_EXPORT Integer
709
710/*---------------------------------------------------------------------------*/
711/*---------------------------------------------------------------------------*/
712
713/*
714 * Macros utilisées pour le débug.
715 */
716#ifdef ARCANE_DEBUG_ASSERT
717extern "C++" ARCANE_UTILS_EXPORT void _doAssert(const char*,const char*,const char*,size_t);
718template<typename T> inline T*
719_checkPointer(T* t,const char* file,const char* func,size_t line)
720{
721 if (!t){
722 _doAssert("ARCANE_ASSERT",file,func,line);
723 arcanePrintf("Bad Pointer");
724 }
725 return t;
726}
727# ifdef __GNUG__
728# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,__PRETTY_FUNCTION__,__LINE__)
729# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,__PRETTY_FUNCTION__,__LINE__);
730# else
731# define ARCANE_D_WHERE(a) Arcane::_doAssert(a,__FILE__,"(NoInfo)",__LINE__)
732# define ARCANE_DCHECK_POINTER(a) Arcane::_checkPointer((a),__FILE__,"(NoInfo"),__LINE__);
733# endif
734# define ARCANE_CHECK_PTR(a) \
735 {if (!(a)){Arcane::arcanePrintf("Null value");ARCANE_D_WHERE("ARCANE_ASSERT");}}
736
737# define ARCANE_ASSERT(a,b) \
738 {if (!(a)){ Arcane::arcanePrintf("Assertion '%s' fails:",#a); Arcane::arcanePrintf b; ARCANE_D_WHERE("ARCANE_ASSERT");}}
739# define ARCANE_WARNING(a) \
740 { Arcane::arcanePrintf a; ARCANE_D_WHERE("ARCANE_WARNING"); }
741#else
742# define ARCANE_CHECK_PTR(a)
743# define ARCANE_ASSERT(a,b)
744# define ARCANE_WARNING(a)
745# define ARCANE_DCHECK_POINTER(a) (a);
746#endif
747
748/*---------------------------------------------------------------------------*/
749/*---------------------------------------------------------------------------*/
750/*!
751 * \brief Macro pour envoyer une exception avec formattage.
752 *
753 * \a exception_class est le type de l'exception. Les arguments suivants de
754 * la macro sont utilisés formatter un message d'erreur via la
755 * méthode String::format().
756 */
757#define ARCANE_THROW(exception_class,...) \
758 throw exception_class (A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
759
760/*---------------------------------------------------------------------------*/
761/*---------------------------------------------------------------------------*/
762/*!
763 * \brief Macro envoyant une exception FatalErrorException.
764 *
765 * Les arguments de la macro sont utilisés formatter un message
766 * d'erreur via la méthode String::format().
767 */
768#define ARCANE_FATAL(...)\
769 throw Arcane::FatalErrorException(A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
770
771/*---------------------------------------------------------------------------*/
772/*---------------------------------------------------------------------------*/
773/*!
774 * \brief Vérifie qu'un pointeur n'est pas nul.
775 *
776 * Si le pointeur est nul, appelle arcaneThrowNullPointerError().
777 * Sinon, retourne le pointeur.
778 */
779static inline void*
780arcaneThrowIfNull(void* ptr,const char* ptr_name,const char* text)
781{
782 if (!ptr)
783 arcaneThrowNullPointerError(ptr_name,text);
784 return ptr;
785}
786
787/*---------------------------------------------------------------------------*/
788/*---------------------------------------------------------------------------*/
789/*!
790 * \brief Vérifie qu'un pointeur n'est pas nul.
791 *
792 * Si le pointeur est nul, appelle à arcaneThrowNullPointerError().
793 * Sinon, retourne le pointeur.
794 */
795static inline const void*
796arcaneThrowIfNull(const void* ptr,const char* ptr_name,const char* text)
797{
798 if (!ptr)
799 arcaneThrowNullPointerError(ptr_name,text);
800 return ptr;
801}
802
803/*---------------------------------------------------------------------------*/
804/*---------------------------------------------------------------------------*/
805/*!
806 * \brief Vérifie qu'un pointeur n'est pas nul.
807 *
808 * Si le pointeur est nul, appelle à arcaneThrowNullPointerError().
809 * Sinon, retourne le pointeur.
810 */
811template<typename T> inline T*
812arcaneThrowIfNull(T* ptr,const char* ptr_name,const char* text)
813{
814 if (!ptr)
815 arcaneThrowNullPointerError(ptr_name,text);
816 return ptr;
817}
818
819/*---------------------------------------------------------------------------*/
820/*---------------------------------------------------------------------------*/
821/*!
822 * \brief Macro retournant le pointeur \a ptr s'il est non nul
823 * ou lancant une exception s'il est nul.
824 *
825 * \sa arcaneThrowIfNull().
826 */
827#define ARCANE_CHECK_POINTER(ptr) \
828 arcaneThrowIfNull(ptr,#ptr,nullptr)
829
830/*!
831 * \brief Macro retournant le pointeur \a ptr s'il est non nul
832 * ou lancant une exception s'il est nul.
833 *
834 * \sa arcaneThrowIfNull().
835 */
836#define ARCANE_CHECK_POINTER2(ptr,text)\
837 arcaneThrowIfNull(ptr,#ptr,text)
838
839/*---------------------------------------------------------------------------*/
840/*---------------------------------------------------------------------------*/
841/*!
842 * \brief Signale une erreur de débordement.
843 *
844 * Signale un débordement de tableau. Affiche un message et appelle
845 * arcaneDebugPause().
846 *
847 * \param i indice invalide
848 * \param max_size nombre d'éléments du tableau
849 */
850extern "C++" ARCANE_UTILS_EXPORT void
851arcaneRangeError [[noreturn]] (Int64 i,Int64 max_size);
852
853/*!
854 * \brief Vérifie un éventuel débordement de tableau.
855 */
856static inline constexpr ARCCORE_HOST_DEVICE void
857arcaneCheckAt(Int64 i,Int64 max_size)
858{
859#ifndef ARCCORE_DEVICE_CODE
860 if (i<0 || i>=max_size)
861 arcaneRangeError(i,max_size);
862#else
863 ARCANE_UNUSED(i);
864 ARCANE_UNUSED(max_size);
865#endif
866}
867
868#if defined(ARCANE_CHECK) || defined(ARCANE_DEBUG)
869#define ARCANE_CHECK_AT(a,b) ::Arcane::arcaneCheckAt((a),(b))
870#else
871#define ARCANE_CHECK_AT(a,b)
872#endif
873
874/*---------------------------------------------------------------------------*/
875/*---------------------------------------------------------------------------*/
876
877} // End namespace Arcane
878
879/*---------------------------------------------------------------------------*/
880/*---------------------------------------------------------------------------*/
881
882#endif
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
void arcaneNoReferenceErrorCallTerminate(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:182
Int64 arcaneCurrentThread()
Retourne l'identifiant du thread courant.
Definition Misc.cc:117
Integer arcaneCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:68
bool arcaneHasThread()
Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs.
Definition Misc.cc:99
Int64 UniqueIdType
Type des entiers utilisés pour stocker les identifiants uniques (globaux) des entités.
std::int64_t Int64
Type entier signé sur 64 bits.
void arcaneSetHasThread(bool v)
Active ou désactive le support des threads.
Definition Misc.cc:105
void arcaneNullPointerError()
Signalue l'utilisation d'un pointeur nul.
Int32 Integer
Type représentant un entier.
void arcanePrintf(const char *,...)
Encapsulation de la fonction C printf.
Definition Misc.cc:192
void arcaneNotYetImplemented(const char *file, const char *func, unsigned long line, const char *text)
Signale une fonction non implémentée.
Integer arcaneSizeWithPadding(Integer size)
Retourne la taille avec padding pour une taille size.
void arcaneDeprecated(const char *file, const char *func, unsigned long line, const char *text)
Signale l'utilisation d'une fonction obsolète.
bool arcaneIsDebug()
Vrai si la macro ARCANE_DEBUG est définie.
Definition Misc.cc:80
void arcaneSetCheck(bool v)
Active ou désactive le mode vérification.
Definition Misc.cc:74
void arcaneNoReferenceError(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:172
bool _checkDebug(unsigned int val)
Definition Misc.cc:252
__host__ __device__ void arcaneMathError(long double arg_value, const char *func_name)
Signale un argument invalide d'une fonction mathématique.
void _doAssert(const char *text, const char *file, const char *func, size_t line)
Definition Misc.cc:235
void arcaneDebugPause(const char *msg)
Passe en mode pause ou lance une erreur fatale.
Definition Misc.cc:137
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...
std::int32_t Int32
Type entier signé sur 32 bits.
void arcaneThrowNullPointerError(const char *ptr_name, const char *text)
Signalee l'utilisation d'un pointeur nul en envoyant une exception.