Arcane  v3.14.10.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-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__)
47/*!
48 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
49 * de CUDA et qu'on utilise le compilateur CUDA.
50 */
51#define ARCANE_COMPILING_CUDA
52#endif
53#if defined(ARCANE_HAS_HIP) && defined(__HIP__)
54/*!
55 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
56 * de HIP et qu'on utilise le compilateur HIP.
57 */
58#define ARCANE_COMPILING_HIP
59#endif
60
61#if defined(ARCANE_HAS_SYCL)
62# if defined(SYCL_LANGUAGE_VERSION) || defined(__ADAPTIVECPP__)
63/*!
64 * \brief Macro pour indiquer qu'on compile %Arcane avec le support
65 * de SYCL et qu'on utilise le compilateur SYCL.
66 */
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
243/*!
244 * \brief Type des entiers utilisés pour stocker les identifiants locaux
245 * des entités.
246 *
247 * Les valeurs que peut prendre ce type indique combien d'entités
248 * pourront être présentes sur un sous-domaine.
249 */
250using LocalIdType = Int32;
251
252/*!
253 * \brief Type des entiers utilisés pour stocker les identifiants uniques
254 * (globaux) des entités.
255 *
256 * Les valeurs que peut prendre ce type indique combien d'entités
257 * pourront être présentes sur le domaine initial.
258 */
259using UniqueIdType = Int64;
260
261//! Type 'Brain Float16'
263
264//! Type 'Float16' (binary16)
266
267//! Type flottant IEEE-753 simple précision (binary32)
268using Float32 = float;
269
270//! Type représentant un entier sur 8 bits
272
273/*!
274 * \def ARCANE_INTEGER_MAX
275 * \brief Macro indiquant la valeur maximal que peut prendre le type #Integer
276 */
277
278
279/*!
280 * \typedef Int64
281 * \brief Type entier signé sur 64 bits.
282 */
283/*!
284 * \typedef Int32
285 * \brief Type entier signé sur 32 bits.
286 */
287/*!
288 * \typedef Int16
289 * \brief Type entier signé sur 16 bits.
290 */
291/*!
292 * \typedef Integer
293 * \brief Type représentant un entier
294 *
295 * Si la macro ARCANE_64BIT est définie, le type Integer correspond à un
296 * entier Int64, sinon à un entier Int32.
297 */
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302//! Encapsulation de la fonction C printf
303extern "C++" ARCANE_UTILS_EXPORT void
304arcanePrintf(const char*,...);
305
306/*---------------------------------------------------------------------------*/
307/*---------------------------------------------------------------------------*/
308
309/*!
310 * \brief Passe en mode pause ou lance une erreur fatale.
311 *
312 * Si le code est compilé en mode \a debug (ARCANE_DEBUG est définie) ou
313 * en mode \a check (ARCANE_CHECK est définie), met le programme en pause
314 * pour éventuellement connecter un débugger dessus.
315 *
316 * En mode normal, lance une exception FatalErrorException avec le message
317 * \a msg comme argument.
318 */
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/*---------------------------------------------------------------------------*/
333/*!
334 * \brief Signale un argument invalide d'une fonction mathématique.
335 *
336 * Une fois le message affiché, appelle arcaneDebugPause()
337 *
338 * \param arg_value valeur de l'argument invalide.
339 * \param func_name nom de la fonction mathématique.
340 */
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
352/*!
353 * \brief Signale un argument invalide d'une fonction mathématique.
354 *
355 * Une fois le message affiché, appelle arcaneDebugPause()
356 *
357 * \param arg_value1 valeur du premier argument invalide.
358 * \param arg_value2 valeur du second argument invalide.
359 * \param func_name nom de la fonction mathématique.
360 */
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/*---------------------------------------------------------------------------*/
375/*!
376 * \brief Signale une fonction non implémentée.
377 *
378 * Une fois le message affiché, appelle arcaneDebugPause()
379 *
380 * \param file nom du fichier contenant la fonction
381 * \param func nom de la fonction
382 * \param numéro de ligne
383 * \param msg message éventuel à afficher (0 si aucun)
384 */
385extern "C++" ARCANE_UTILS_EXPORT void
386arcaneNotYetImplemented(const char* file,const char* func,unsigned long line,const char* msg);
387
388/*---------------------------------------------------------------------------*/
389/*---------------------------------------------------------------------------*/
390
391//! Signale l'utilisation d'une fonction obsolète
392extern "C++" ARCANE_UTILS_EXPORT void
393arcaneDeprecated(const char* file,const char* func,unsigned long line,const char* text);
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397
398/*!
399 * \brief Utilisation d'un objet non référencé.
400 *
401 * Signale une tentative d'utilisation d'un objet qui ne devrait plus être
402 * référencé. Affiche un message et appelle arcaneDebugPause() si demandé et
403 * ensuite lance une exception FatalErrorException.
404 *
405 * \param ptr adresse de l'objet
406 */
407extern "C++" ARCANE_UTILS_EXPORT void
408arcaneNoReferenceError(const void* ptr);
409
410/*!
411 * \brief Utilisation d'un objet non référencé.
412 *
413 * Signale une tentative d'utilisation d'un objet qui ne devrait plus être
414 * référencé. Affiche un message et appelle arcaneDebugPause() si demandé et
415 * ensuite appelle std::terminate().
416 *
417 * \param ptr adresse de l'objet
418 */
419extern "C++" ARCANE_UTILS_EXPORT void
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(unsigned long 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(long long 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(unsigned long size);
448
449/*!
450 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
451 * de taille à un tableau.
452 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
453 * une exception de type ArgumentException.
454 */
455extern "C++" ARCANE_UTILS_EXPORT Integer
456arcaneCheckArraySize(long size);
457
458/*!
459 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
460 * de taille à un tableau.
461 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
462 * une exception de type ArgumentException.
463 */
464extern "C++" ARCANE_UTILS_EXPORT Integer
465arcaneCheckArraySize(unsigned int size);
466
467/*!
468 * \brief Vérifie que \a size peut être converti dans un 'Integer' pour servir
469 * de taille à un tableau.
470 * Si possible, retourne \a size convertie en un 'Integer'. Sinon, lance
471 * une exception de type ArgumentException.
472 */
473extern "C++" ARCANE_UTILS_EXPORT Integer
474arcaneCheckArraySize(int size);
475
476/*!
477 * \brief Vérifie que \a ptr est aligné sur \a alignment octets.
478 * Si ce n'est pas le cas, Sinon, lance une exception de type BadAlignmentException.
479 */
480extern "C++" ARCANE_UTILS_EXPORT void
481arcaneCheckAlignment(const void* ptr,Integer alignment);
482
483/*!
484 * \brief Vrai si on est en mode vérification.
485 *
486 * Ce mode est actif si la macro ARCANE_CHECK est définie
487 * ou si la méthode arcaneSetCheck() a été positionnée a vrai.
488 */
489extern "C++" ARCANE_UTILS_EXPORT
490bool arcaneIsCheck();
491
492/*!
493 * \brief Active ou désactive le mode vérification.
494 *
495 * Le mode vérification est toujours actif si la macro ARCANE_CHECK est définie.
496 * Sinon, il est possible de l'activer avec cette méthode. Cela permet
497 * d'activer certains tests même en mode optimisé.
498 */
499extern "C++" ARCANE_UTILS_EXPORT
500void arcaneSetCheck(bool v);
501
502/*!
503 * \brief Vrai si la macro ARCANE_DEBUG est définie
504 */
505extern "C++" ARCANE_UTILS_EXPORT
506bool arcaneIsDebug();
507
508/*!
509 * \brief Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs
510 */
511extern "C++" ARCANE_UTILS_EXPORT
512bool arcaneHasThread();
513
514/*!
515 * \brief Active ou désactive le support des threads.
516 *
517 * Cette fonction ne doit être appelée que lors de l'initialisation
518 * de l'application (ou avant) et ne pas être modifiée par la suite.
519 * L'activation des threads n'est possible que si une implémentation
520 * des threads existe sur la plate-forme et que Arcane a été compilé
521 * avec ce support.
522 */
523extern "C++" ARCANE_UTILS_EXPORT
524void arcaneSetHasThread(bool v);
525
526/*!
527 * \brief Retourne l'identifiant du thread courant.
528 *
529 * Retourne toujours 0 si arcaneHasThread() est faux.
530 */
531extern "C++" ARCANE_UTILS_EXPORT
532Int64 arcaneCurrentThread();
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
537/*!
538 * \internal
539 * \brief Structure équivalente à la valeur booléenne \a vrai
540 */
541struct TrueType {};
542/*!
543 \internal
544 \brief Structure équivalente à la valeur booléenne \a vrai
545*/
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
594/*!
595 * \brief Macro pour l'attribut 'deprecated' à long terme.
596 *
597 * Cette macro est pour indiquer les types ou fonctions
598 * obsolète et donc qu'il est préférable de ne pas utiliser mais qui
599 * ne seront pas supprimés avant plusieurs versions.
600 */
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
634//! Macro permettant de spécifier le mot-clé 'constexpr' du C++11
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
657//! Macro pour garantir le compactage et l'alignement d'une classe sur \a value octets
658# define ARCANE_ALIGNAS(value) __declspec(align(value))
659//! Macro pour garantir l'alignement d'une classe sur \a value octets
660# define ARCANE_ALIGNAS_PACKED(value) __declspec(align(value))
661#else
662//! Macro pour garantir le compactage et l'alignement d'une classe sur \a value octets
663# define ARCANE_ALIGNAS_PACKED(value) __attribute__ ((aligned (value),packed))
664//! Macro pour garantir l'alignement d'une classe sur \a value octets
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/*---------------------------------------------------------------------------*/
688/*!
689 * \brief Signalue l'utilisation d'un pointeur nul.
690 *
691 * Signale une tentative d'utilisation d'un pointeur nul.
692 * Affiche un message, appelle arcaneDebugPause() et lance une exception
693 * de type FatalErrorException.
694 */
695extern "C++" ARCANE_UTILS_EXPORT void
696arcaneNullPointerError [[noreturn]] ();
697
698/*---------------------------------------------------------------------------*/
699/*---------------------------------------------------------------------------*/
700/*!
701 * \brief Signalee l'utilisation d'un pointeur nul en envoyant une exception
702 *
703 * Signale une tentative d'utilisation d'un pointeur nul.
704 * Lance une exception de type FatalErrorException.
705 *
706 * Dans l'exception, affiche \a text si non nul, sinon affiche \a ptr_name.
707 *
708 * Normalement cette méthode ne doit pas être appelée directement mais
709 * via la macro ARCANE_CHECK_POINTER.
710 */
711extern "C++" ARCANE_UTILS_EXPORT void
712arcaneThrowNullPointerError [[noreturn]] (const char* ptr_name,const char* text);
713
714/*---------------------------------------------------------------------------*/
715/*---------------------------------------------------------------------------*/
716/*!
717 * \brief Vérifie qu'un pointeur n'est pas nul.
718 */
719static inline void
720arcaneCheckNull(const void* ptr)
721{
722 if (!ptr)
724}
725
726/*---------------------------------------------------------------------------*/
727/*---------------------------------------------------------------------------*/
728/*!
729 * \brief Taille du padding pour les index dans les opérations SIMD.
730 *
731 * Afin d'avoir le même code quel que soit le mécanisme de vectorisation
732 * utilisé, cette valeur est fixe et correspond au plus grand vecteur SIMD.
733 *
734 * \sa arcanedoc_simd
735 */
736static const Integer SIMD_PADDING_SIZE = 8;
737
738/*---------------------------------------------------------------------------*/
739/*---------------------------------------------------------------------------*/
740/*!
741 * \brief Retourne la taille avec padding pour une taille \a size.
742 *
743 * La valeurs retournée est un multiple de SIMD_PADDING_SIZE et vaut:
744 * - 0 si \a size est inférieur ou égal à 0.
745 * - \a size si \a size est un multiple de SIMD_PADDING_SIZE.
746 * - le multiple de SIMD_PADDING_SIZE immédiatement supérieur à \a size sinon.
747 */
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/*---------------------------------------------------------------------------*/
791/*!
792 * \brief Macro pour envoyer une exception avec formattage.
793 *
794 * \a exception_class est le type de l'exception. Les arguments suivants de
795 * la macro sont utilisés formatter un message d'erreur via la
796 * méthode String::format().
797 */
798#define ARCANE_THROW(exception_class,...) \
799 throw exception_class (A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
800
801/*---------------------------------------------------------------------------*/
802/*---------------------------------------------------------------------------*/
803/*!
804 * \brief Macro envoyant une exception FatalErrorException.
805 *
806 * Les arguments de la macro sont utilisés formatter un message
807 * d'erreur via la méthode String::format().
808 */
809#define ARCANE_FATAL(...)\
810 throw Arcane::FatalErrorException(A_FUNCINFO,Arcane::String::format(__VA_ARGS__))
811
812/*---------------------------------------------------------------------------*/
813/*---------------------------------------------------------------------------*/
814/*!
815 * \brief Vérifie qu'un pointeur n'est pas nul.
816 *
817 * Si le pointeur est nul, appelle arcaneThrowNullPointerError().
818 * Sinon, retourne le pointeur.
819 */
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/*---------------------------------------------------------------------------*/
830/*!
831 * \brief Vérifie qu'un pointeur n'est pas nul.
832 *
833 * Si le pointeur est nul, appelle à arcaneThrowNullPointerError().
834 * Sinon, retourne le pointeur.
835 */
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/*---------------------------------------------------------------------------*/
846/*!
847 * \brief Vérifie qu'un pointeur n'est pas nul.
848 *
849 * Si le pointeur est nul, appelle à arcaneThrowNullPointerError().
850 * Sinon, retourne le pointeur.
851 */
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/*---------------------------------------------------------------------------*/
862/*!
863 * \brief Macro retournant le pointeur \a ptr s'il est non nul
864 * ou lancant une exception s'il est nul.
865 *
866 * \sa arcaneThrowIfNull().
867 */
868#define ARCANE_CHECK_POINTER(ptr) \
869 arcaneThrowIfNull(ptr,#ptr,nullptr)
870
871/*!
872 * \brief Macro retournant le pointeur \a ptr s'il est non nul
873 * ou lancant une exception s'il est nul.
874 *
875 * \sa arcaneThrowIfNull().
876 */
877#define ARCANE_CHECK_POINTER2(ptr,text)\
878 arcaneThrowIfNull(ptr,#ptr,text)
879
880/*---------------------------------------------------------------------------*/
881/*---------------------------------------------------------------------------*/
882/*!
883 * \brief Signale une erreur de débordement.
884 *
885 * Signale un débordement de tableau. Affiche un message et appelle
886 * arcaneDebugPause().
887 *
888 * \param i indice invalide
889 * \param max_size nombre d'éléments du tableau
890 */
891extern "C++" ARCANE_UTILS_EXPORT void
892arcaneRangeError [[noreturn]] (Int64 i,Int64 max_size);
893
894/*!
895 * \brief Vérifie un éventuel débordement de tableau.
896 */
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{
932using Arccore::String;
936}
937
938/*---------------------------------------------------------------------------*/
939/*---------------------------------------------------------------------------*/
940
941#endif
Emulation de réel en précision arbitraire.
Type flottant demi-précision.
Interface du gestionnaire de traces.
Constructeur de chaîne de caractère unicode.
Vue sur une chaîne de caractères UTF-8.
Definition StringView.h:47
Chaîne de caractères unicode.
-*- 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:265
Int64 arcaneCurrentThread()
Retourne l'identifiant du thread courant.
Definition Misc.cc:200
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:151
bool arcaneHasThread()
Vrai si arcane est compilé avec le support des threads ET qu'ils sont actifs.
Definition Misc.cc:182
void arcaneSetHasThread(bool v)
Active ou désactive le support des threads.
Definition Misc.cc:188
void arcaneNullPointerError()
Signalue l'utilisation d'un pointeur nul.
void arcanePrintf(const char *,...)
Encapsulation de la fonction C printf.
Definition Misc.cc:275
void arcaneNotYetImplemented(const char *file, const char *func, unsigned long line, const char *text)
Signale une fonction non implémentée.
Arccore::Int8 Int8
Type représentant un entier sur 8 bits.
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:163
void arcaneSetCheck(bool v)
Active ou désactive le mode vérification.
Definition Misc.cc:157
void arcaneNoReferenceError(const void *ptr)
Utilisation d'un objet non référencé.
Definition Misc.cc:255
bool _checkDebug(unsigned int val)
Definition Misc.cc:335
float Float32
Type flottant IEEE-753 simple précision (binary32)
Int32 LocalIdType
Type des entiers utilisés pour stocker les identifiants locaux des entités.
__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:318
void arcaneDebugPause(const char *msg)
Passe en mode pause ou lance une erreur fatale.
Definition Misc.cc:220
Int64 UniqueIdType
Type des entiers utilisés pour stocker les identifiants uniques (globaux) des entités.
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...
void arcaneThrowNullPointerError(const char *ptr_name, const char *text)
Signalee l'utilisation d'un pointeur nul en envoyant une exception.
Espace de nom de Arccore.
Definition ArcaneTypes.h:24
double Real
Type représentant un réel.
Int32 Integer
Type représentant un entier.
std::uint32_t UInt32
Type entier non signé sur 32 bits.
void * Pointer
Type représentant un pointeur.
std::int64_t Int64
Type entier signé sur 64 bits.
std::uint64_t UInt64
Type entier non signé sur 64 bits.
std::int32_t Int32
Type entier signé sur 32 bits.
std::int8_t Int8
Type entier signé sur 8 bits.
std::int16_t Int16
Type entier signé sur 16 bits.