libsc 2.8.5.210-64a7
The SC library provides support for parallel scientific applications.
sc.h
Go to the documentation of this file.
1/*
2 This file is part of the SC Library.
3 The SC Library provides support for parallel scientific applications.
4
5 Copyright (C) 2010 The University of Texas System
6 Additional copyright (C) 2011 individual authors
7
8 The SC Library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12
13 The SC Library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public
19 License along with the SC Library; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.
22*/
23
34#ifndef SC_H
35#define SC_H
36
37/* we set the GNU feature test macro before including anything */
38#ifndef _GNU_SOURCE
39#define _GNU_SOURCE
40#endif
41
42/* include the libsc config header first */
43#include <sc_config.h>
44#ifndef _sc_const
46#define _sc_const const
47#endif
48#ifndef _sc_restrict
50#define _sc_restrict restrict
51#endif
52
54#define SC_CALC_VERSION(major,minor,patchlevel) \
55 (((major) * 1000 + (minor)) * 1000 + (patchlevel))
56#ifdef __GNUC__
57#define SC_GCC_VERSION \
58 SC_CALC_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
59#else
61#define SC_GCC_VERSION \
62 SC_CALC_VERSION (0, 0, 0)
63#endif
64
65/* use this feature macro, be minimally invasive */
66#ifdef SC_ENABLE_MEMALIGN
67/* we disable the system-provided functions for the time being */
68#ifdef SC_HAVE_ANY_MEMALIGN
69#undef SC_HAVE_ANY_MEMALIGN
70#endif
71/* if system-provided functions are needed, give them the prototype */
72#ifdef SC_HAVE_ANY_MEMALIGN
73#ifndef SC_HAVE_POSIX_MEMALIGN
74#ifdef SC_HAVE_ALIGNED_ALLOC
75#define _ISOC11_SOURCE
76#endif
77#endif
78#endif
79/* done with memalign macros */
80#endif
81
82/* disable global counters that are not thread-safe (say when using TBB) */
83#ifndef SC_ENABLE_USE_COUNTERS
84#define SC_NOCOUNT_MALLOC
85#define SC_NOCOUNT_REFCOUNT
86#define SC_NOCOUNT_LOGINDENT
87#endif
88
89/* use this in case mpi.h includes stdint.h */
90
91#ifndef __STDC_LIMIT_MACROS
93#define __STDC_LIMIT_MACROS
94#endif
95#ifndef __STDC_CONSTANT_MACROS
97#define __STDC_CONSTANT_MACROS
98#endif
99
100/* include MPI before stdio.h */
101
102#ifdef SC_ENABLE_MPI
103#include <mpi.h>
104#else
105#ifdef MPI_SUCCESS
106#error "mpi.h is included. Use --enable-mpi."
107#endif
108#endif
109
110/* include system headers */
111
112#define _USE_MATH_DEFINES
113#include <math.h>
114#ifndef M_E
115#define M_E 2.71828182845904523536
116#endif
117#ifndef M_LOG2E
118#define M_LOG2E 1.44269504088896340736
119#endif
120#ifndef M_LOG10E
121#define M_LOG10E 0.434294481903251827651
122#endif
123#ifndef M_LN2
124#define M_LN2 0.693147180559945309417
125#endif
126#ifndef M_LN10
127#define M_LN10 2.30258509299404568402
128#endif
129#ifndef M_PI
130#define M_PI 3.14159265358979323846
131#endif
132#ifndef M_PI_2
133#define M_PI_2 1.57079632679489661923
134#endif
135#ifndef M_PI_4
136#define M_PI_4 0.785398163397448309616
137#endif
138#ifndef M_1_PI
139#define M_1_PI 0.318309886183790671538
140#endif
141#ifndef M_2_PI
142#define M_2_PI 0.636619772367581343076
143#endif
144#ifndef M_2_SQRTPI
145#define M_2_SQRTPI 1.12837916709551257390
146#endif
147#ifndef M_SQRT2
148#define M_SQRT2 1.41421356237309504880
149#endif
150#ifndef M_SQRT1_2
151#define M_SQRT1_2 0.707106781186547524401
152#endif
153#include <ctype.h>
154#include <float.h>
155#if defined SC_HAVE_LIBGEN_H && !defined _MSC_VER
156#include <libgen.h>
157#endif
158#include <limits.h>
159#include <stdarg.h>
160#include <stddef.h>
161#ifdef SC_HAVE_STDINT_H
162#include <stdint.h>
163#endif
164#include <stdio.h>
165#ifdef SC_HAVE_STDLIB_H
166#include <stdlib.h>
167#endif
168#ifdef SC_HAVE_STRING_H
169#include <string.h>
170#endif
171#ifdef SC_HAVE_SYS_TIME_H
172#include <sys/time.h>
173#endif
174#ifdef SC_HAVE_UNISTD_H
175#include <unistd.h>
176#elif defined _WIN32
177#include <BaseTsd.h>
178typedef SSIZE_T ssize_t;
179#endif
180
181/* definitions to allow user code to query the sc library */
183#define SC_INIT_COMM_CLEAN
184
185/* provide extern C defines */
186
187/* The hacks below enable semicolons after the SC_EXTERN_C_ macros
188 * and also take care of the different semantics of () / (...) */
189#ifdef __cplusplus
190#define SC_EXTERN_C_BEGIN extern "C" { void sc_extern_c_hack_1 (void)
191#define SC_EXTERN_C_END } void sc_extern_c_hack_2 (void)
192#define SC_NOARGS ...
193#else
194#define SC_EXTERN_C_BEGIN void sc_extern_c_hack_3 (void)
195#define SC_EXTERN_C_END void sc_extern_c_hack_4 (void)
197#define SC_NOARGS
198#endif
199
200/* this header is always included */
201#include <sc_mpi.h>
202
203SC_EXTERN_C_BEGIN;
204
205/* extern variables */
206
208extern const int sc_log2_lookup_table[256];
209
215extern int sc_package_id;
216
219extern FILE *sc_trace_file;
220
222extern int sc_trace_prio;
223
225#define SC_EPS 2.220446049250313e-16
226
228#define SC_1000_EPS (1000. * 2.220446049250313e-16)
229
230/* check macros, always enabled */
231
233#define SC_NOOP() ((void) (0))
234#define SC_ABORT(s) \
235 sc_abort_verbose (__FILE__, __LINE__, (s))
236#define SC_ABORT_NOT_REACHED() SC_ABORT ("Unreachable code")
237#define SC_CHECK_ABORT(q,s) \
238 ((q) ? (void) 0 : SC_ABORT (s))
239#define SC_CHECK_MPI(r) SC_CHECK_ABORT ((r) == sc_MPI_SUCCESS, "MPI error")
240
241/*
242 * C++98 does not allow variadic macros
243 * 1. Declare a default variadic function for C and C++
244 * 2. Use macros in C instead of the function
245 * This loses __FILE__ and __LINE__ in the C++ ..F log functions
246 */
247void SC_ABORTF (const char *fmt, ...)
248 __attribute__ ((format (printf, 1, 2)))
249 __attribute__ ((noreturn));
250void SC_CHECK_ABORTF (int success, const char *fmt, ...)
251 __attribute__ ((format (printf, 2, 3)));
252#ifndef __cplusplus
253#define SC_ABORTF(fmt,...) \
254 sc_abort_verbosef (__FILE__, __LINE__, (fmt), __VA_ARGS__)
255#define SC_CHECK_ABORTF(q,fmt,...) \
256 ((q) ? (void) 0 : SC_ABORTF (fmt, __VA_ARGS__))
257#endif
258#define SC_ABORT1(fmt,a) \
259 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a))
260#define SC_ABORT2(fmt,a,b) \
261 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a), (b))
262#define SC_ABORT3(fmt,a,b,c) \
263 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a), (b), (c))
264#define SC_ABORT4(fmt,a,b,c,d) \
265 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a), (b), (c), (d))
266#define SC_ABORT5(fmt,a,b,c,d,e) \
267 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a), (b), (c), (d), (e))
268#define SC_ABORT6(fmt,a,b,c,d,e,f) \
269 sc_abort_verbosef (__FILE__, __LINE__, (fmt), (a), (b), (c), (d), (e), (f))
270#define SC_CHECK_ABORT1(q,fmt,a) \
271 ((q) ? (void) 0 : SC_ABORT1 ((fmt), (a)))
272#define SC_CHECK_ABORT2(q,fmt,a,b) \
273 ((q) ? (void) 0 : SC_ABORT2 ((fmt), (a), (b)))
274#define SC_CHECK_ABORT3(q,fmt,a,b,c) \
275 ((q) ? (void) 0 : SC_ABORT3 ((fmt), (a), (b), (c)))
276#define SC_CHECK_ABORT4(q,fmt,a,b,c,d) \
277 ((q) ? (void) 0 : SC_ABORT4 ((fmt), (a), (b), (c), (d)))
278#define SC_CHECK_ABORT5(q,fmt,a,b,c,d,e) \
279 ((q) ? (void) 0 : SC_ABORT5 ((fmt), (a), (b), (c), (d), (e)))
280#define SC_CHECK_ABORT6(q,fmt,a,b,c,d,e,f) \
281 ((q) ? (void) 0 : SC_ABORT6 ((fmt), (a), (b), (c), (d), (e), (f)))
282
283/* assertions, only enabled in debug mode */
284
285#ifdef SC_ENABLE_DEBUG
286#define SC_ASSERT(c) SC_CHECK_ABORT ((c), "Assertion '" #c "'")
287#define SC_EXECUTE_ASSERT_FALSE(expression) \
288 do { int _sc_i = (int) (expression); \
289 SC_CHECK_ABORT (!_sc_i, "Expected false: '" #expression "'"); \
290 } while (0)
291#define SC_EXECUTE_ASSERT_TRUE(expression) \
292 do { int _sc_i = (int) (expression); \
293 SC_CHECK_ABORT (_sc_i, "Expected true: '" #expression "'"); \
294 } while (0)
295#else
296#define SC_ASSERT(c) SC_NOOP ()
297#define SC_EXECUTE_ASSERT_FALSE(expression) \
298 do { (void) (expression); } while (0)
299#define SC_EXECUTE_ASSERT_TRUE(expression) \
300 do { (void) (expression); } while (0)
301#endif
302
303/* macros for memory allocation, will abort if out of memory */
304
305#define SC_ALLOC(t,n) (t *) sc_malloc (sc_package_id, (n) * sizeof(t))
306#define SC_ALLOC_ZERO(t,n) (t *) sc_calloc (sc_package_id, \
307 (size_t) (n), sizeof(t))
308#define SC_REALLOC(p,t,n) (t *) sc_realloc (sc_package_id, \
309 (p), (n) * sizeof(t))
310#define SC_STRDUP(s) sc_strdup (sc_package_id, (s))
311#define SC_FREE(p) sc_free (sc_package_id, (p))
312
313/* macros for memory alignment */
314/* some copied from bfam: https://github.com/bfam/bfam */
315
316#define SC_ALIGN_UP(x,n) ( ((n) <= 0) ? (x) : ((x) + (n) - 1) / (n) * (n) )
317
318#if defined (__bgq__)
319#define SC_ARG_ALIGN(p,t,n) __alignx((n), (p))
320#elif defined (__ICC)
321#define SC_ARG_ALIGN(p,t,n) __assume_aligned((p), (n))
322#elif defined (__clang__)
323#define SC_ARG_ALIGN(p,t,n) SC_NOOP ()
324#elif defined (__GNUC__) || defined (__GNUG__)
325
326#if SC_GCC_VERSION >= SC_CALC_VERSION (4, 7, 0)
327#define SC_ARG_ALIGN(p,t,n) do { \
328 (p) = (t) __builtin_assume_aligned((void *) (p), (n)); \
329} while (0)
330#else
331#define SC_ARG_ALIGN(p,t,n) SC_NOOP ()
332#endif
333
334#else
335#define SC_ARG_ALIGN(p,t,n) SC_NOOP ()
336#endif
337
338#if (defined __GNUC__) || (defined __PGI) || (defined __IBMC__)
339#define SC_ATTR_ALIGN(n) __attribute__ ((aligned(n)))
340#else
341#define SC_ATTR_ALIGN(n)
342#endif
343
348#define SC_BZERO(p,n) ((void) memset ((p), 0, (n) * sizeof (*(p))))
349
350/* min, max and square helper macros */
351
352#define SC_MIN(a,b) (((a) < (b)) ? (a) : (b))
353#define SC_MAX(a,b) (((a) > (b)) ? (a) : (b))
354#define SC_SQR(a) ((a) * (a))
355
356/* hopefully fast binary logarithms and binary round up */
357
358#define SC_LOG2_8(x) (sc_log2_lookup_table[(x)])
359#define SC_LOG2_16(x) (((x) > 0xff) ? \
360 (SC_LOG2_8 ((x) >> 8) + 8) : SC_LOG2_8 (x))
361#define SC_LOG2_32(x) (((x) > 0xffff) ? \
362 (SC_LOG2_16 ((x) >> 16)) + 16 : SC_LOG2_16 (x))
363#define SC_LOG2_64(x) (((x) > 0xffffffffLL) ? \
364 (SC_LOG2_32 ((x) >> 32)) + 32 : SC_LOG2_32 (x))
365#define SC_ROUNDUP2_32(x) \
366 (((x) <= 0) ? 0 : (1 << (SC_LOG2_32 ((x) - 1) + 1)))
367#define SC_ROUNDUP2_64(x) \
368 (((x) <= 0) ? 0 : (1LL << (SC_LOG2_64 ((x) - 1LL) + 1)))
369
370/* log categories */
371
372#define SC_LC_GLOBAL 1
373#define SC_LC_NORMAL 2
403#define SC_LP_DEFAULT (-1)
404#define SC_LP_ALWAYS 0
405#define SC_LP_TRACE 1
406#define SC_LP_DEBUG 2
407#define SC_LP_VERBOSE 3
408#define SC_LP_INFO 4
409#define SC_LP_STATISTICS 5
410#define SC_LP_PRODUCTION 6
411#define SC_LP_ESSENTIAL 7
412#define SC_LP_ERROR 8
413#define SC_LP_SILENT 9
419#ifdef SC_LOG_PRIORITY
420#define SC_LP_THRESHOLD SC_LOG_PRIORITY
421#else
422#ifdef SC_ENABLE_DEBUG
423#define SC_LP_THRESHOLD SC_LP_TRACE
424#else
425#define SC_LP_THRESHOLD SC_LP_INFO
426#endif
427#endif
428
429/* generic log macros */
430#define SC_GEN_LOG(package,category,priority,s) \
431 ((priority) < SC_LP_THRESHOLD ? (void) 0 : \
432 sc_log (__FILE__, __LINE__, (package), (category), (priority), (s)))
433#define SC_GLOBAL_LOG(p,s) SC_GEN_LOG (sc_package_id, SC_LC_GLOBAL, (p), (s))
434#define SC_LOG(p,s) SC_GEN_LOG (sc_package_id, SC_LC_NORMAL, (p), (s))
435void SC_GEN_LOGF (int package, int category, int priority,
436 const char *fmt, ...)
437 __attribute__ ((format (printf, 4, 5)));
438void SC_GLOBAL_LOGF (int priority, const char *fmt, ...)
439 __attribute__ ((format (printf, 2, 3)));
440void SC_LOGF (int priority, const char *fmt, ...)
441 __attribute__ ((format (printf, 2, 3)));
442#ifndef __cplusplus
443#define SC_GEN_LOGF(package,category,priority,fmt,...) \
444 ((priority) < SC_LP_THRESHOLD ? (void) 0 : \
445 sc_logf (__FILE__, __LINE__, (package), (category), (priority), \
446 (fmt), __VA_ARGS__))
447#define SC_GLOBAL_LOGF(p,fmt,...) \
448 SC_GEN_LOGF (sc_package_id, SC_LC_GLOBAL, (p), (fmt), __VA_ARGS__)
449#define SC_LOGF(p,fmt,...) \
450 SC_GEN_LOGF (sc_package_id, SC_LC_NORMAL, (p), (fmt), __VA_ARGS__)
451#endif
452
453/* convenience global log macros will only output if identifier <= 0 */
454#define SC_GLOBAL_TRACE(s) SC_GLOBAL_LOG (SC_LP_TRACE, (s))
455#define SC_GLOBAL_LDEBUG(s) SC_GLOBAL_LOG (SC_LP_DEBUG, (s))
456#define SC_GLOBAL_VERBOSE(s) SC_GLOBAL_LOG (SC_LP_VERBOSE, (s))
457#define SC_GLOBAL_INFO(s) SC_GLOBAL_LOG (SC_LP_INFO, (s))
458#define SC_GLOBAL_STATISTICS(s) SC_GLOBAL_LOG (SC_LP_STATISTICS, (s))
459#define SC_GLOBAL_PRODUCTION(s) SC_GLOBAL_LOG (SC_LP_PRODUCTION, (s))
460#define SC_GLOBAL_ESSENTIAL(s) SC_GLOBAL_LOG (SC_LP_ESSENTIAL, (s))
461#define SC_GLOBAL_LERROR(s) SC_GLOBAL_LOG (SC_LP_ERROR, (s))
462void SC_GLOBAL_TRACEF (const char *fmt, ...)
463 __attribute__ ((format (printf, 1, 2)));
464void SC_GLOBAL_LDEBUGF (const char *fmt, ...)
465 __attribute__ ((format (printf, 1, 2)));
466void SC_GLOBAL_VERBOSEF (const char *fmt, ...)
467 __attribute__ ((format (printf, 1, 2)));
468void SC_GLOBAL_INFOF (const char *fmt, ...)
469 __attribute__ ((format (printf, 1, 2)));
470void SC_GLOBAL_STATISTICSF (const char *fmt, ...)
471 __attribute__ ((format (printf, 1, 2)));
472void SC_GLOBAL_PRODUCTIONF (const char *fmt, ...)
473 __attribute__ ((format (printf, 1, 2)));
474void SC_GLOBAL_ESSENTIALF (const char *fmt, ...)
475 __attribute__ ((format (printf, 1, 2)));
476void SC_GLOBAL_LERRORF (const char *fmt, ...)
477 __attribute__ ((format (printf, 1, 2)));
478#ifndef __cplusplus
479#define SC_GLOBAL_TRACEF(fmt,...) \
480 SC_GLOBAL_LOGF (SC_LP_TRACE, (fmt), __VA_ARGS__)
481#define SC_GLOBAL_LDEBUGF(fmt,...) \
482 SC_GLOBAL_LOGF (SC_LP_DEBUG, (fmt), __VA_ARGS__)
483#define SC_GLOBAL_VERBOSEF(fmt,...) \
484 SC_GLOBAL_LOGF (SC_LP_VERBOSE, (fmt), __VA_ARGS__)
485#define SC_GLOBAL_INFOF(fmt,...) \
486 SC_GLOBAL_LOGF (SC_LP_INFO, (fmt), __VA_ARGS__)
487#define SC_GLOBAL_STATISTICSF(fmt,...) \
488 SC_GLOBAL_LOGF (SC_LP_STATISTICS, (fmt), __VA_ARGS__)
489#define SC_GLOBAL_PRODUCTIONF(fmt,...) \
490 SC_GLOBAL_LOGF (SC_LP_PRODUCTION, (fmt), __VA_ARGS__)
491#define SC_GLOBAL_ESSENTIALF(fmt,...) \
492 SC_GLOBAL_LOGF (SC_LP_ESSENTIAL, (fmt), __VA_ARGS__)
493#define SC_GLOBAL_LERRORF(fmt,...) \
494 SC_GLOBAL_LOGF (SC_LP_ERROR, (fmt), __VA_ARGS__)
495#endif
496
497/* convenience log macros that output regardless of identifier */
498#define SC_TRACE(s) SC_LOG (SC_LP_TRACE, (s))
499#define SC_LDEBUG(s) SC_LOG (SC_LP_DEBUG, (s))
500#define SC_VERBOSE(s) SC_LOG (SC_LP_VERBOSE, (s))
501#define SC_INFO(s) SC_LOG (SC_LP_INFO, (s))
502#define SC_STATISTICS(s) SC_LOG (SC_LP_STATISTICS, (s))
503#define SC_PRODUCTION(s) SC_LOG (SC_LP_PRODUCTION, (s))
504#define SC_ESSENTIAL(s) SC_LOG (SC_LP_ESSENTIAL, (s))
505#define SC_LERROR(s) SC_LOG (SC_LP_ERROR, (s))
506void SC_TRACEF (const char *fmt, ...)
507 __attribute__ ((format (printf, 1, 2)));
508void SC_LDEBUGF (const char *fmt, ...)
509 __attribute__ ((format (printf, 1, 2)));
510void SC_VERBOSEF (const char *fmt, ...)
511 __attribute__ ((format (printf, 1, 2)));
512void SC_INFOF (const char *fmt, ...)
513 __attribute__ ((format (printf, 1, 2)));
514void SC_STATISTICSF (const char *fmt, ...)
515 __attribute__ ((format (printf, 1, 2)));
516void SC_PRODUCTIONF (const char *fmt, ...)
517 __attribute__ ((format (printf, 1, 2)));
518void SC_ESSENTIALF (const char *fmt, ...)
519 __attribute__ ((format (printf, 1, 2)));
520void SC_LERRORF (const char *fmt, ...)
521 __attribute__ ((format (printf, 1, 2)));
522#ifndef __cplusplus
523#define SC_TRACEF(fmt,...) \
524 SC_LOGF (SC_LP_TRACE, (fmt), __VA_ARGS__)
525#define SC_LDEBUGF(fmt,...) \
526 SC_LOGF (SC_LP_DEBUG, (fmt), __VA_ARGS__)
527#define SC_VERBOSEF(fmt,...) \
528 SC_LOGF (SC_LP_VERBOSE, (fmt), __VA_ARGS__)
529#define SC_INFOF(fmt,...) \
530 SC_LOGF (SC_LP_INFO, (fmt), __VA_ARGS__)
531#define SC_STATISTICSF(fmt,...) \
532 SC_LOGF (SC_LP_STATISTICS, (fmt), __VA_ARGS__)
533#define SC_PRODUCTIONF(fmt,...) \
534 SC_LOGF (SC_LP_PRODUCTION, (fmt), __VA_ARGS__)
535#define SC_ESSENTIALF(fmt,...) \
536 SC_LOGF (SC_LP_ESSENTIAL, (fmt), __VA_ARGS__)
537#define SC_LERRORF(fmt,...) \
538 SC_LOGF (SC_LP_ERROR, (fmt), __VA_ARGS__)
539#endif
540
543#define _SC_TOSTRING(x) #x
544
547#define SC_TOSTRING(x) _SC_TOSTRING(x)
548
549/* callback typedefs */
550
551typedef void (*sc_handler_t) (void *data);
552typedef void (*sc_log_handler_t) (FILE * log_stream,
553 const char *filename, int lineno,
554 int package, int category,
555 int priority, const char *msg);
556
558typedef void (*sc_abort_handler_t) (void);
559
560/* memory allocation functions, will abort if out of memory */
561
562void *sc_malloc (int package, size_t size);
563void *sc_calloc (int package, size_t nmemb, size_t size);
564void *sc_realloc (int package, void *ptr, size_t size);
565char *sc_strdup (int package, const char *s);
566void sc_free (int package, void *ptr);
567int sc_memory_status (int package);
568void sc_memory_check (int package);
569
571int sc_memory_check_noerr (int package);
572
573/* comparison functions for various integer sizes */
574
575int sc_int_compare (const void *v1, const void *v2);
576int sc_int8_compare (const void *v1, const void *v2);
577int sc_int16_compare (const void *v1, const void *v2);
578int sc_int32_compare (const void *v1, const void *v2);
579int sc_int64_compare (const void *v1, const void *v2);
580int sc_double_compare (const void *v1, const void *v2);
581
587int sc_atoi (const char *nptr);
588
594long sc_atol (const char *nptr);
595
602void sc_set_log_defaults (FILE * log_stream,
603 sc_log_handler_t log_handler,
604 int log_threshold);
605
611
618void sc_log (const char *filename, int lineno,
619 int package, int category, int priority,
620 const char *msg);
621void sc_logf (const char *filename, int lineno,
622 int package, int category, int priority,
623 const char *fmt, ...)
624 __attribute__ ((format (printf, 6, 7)));
625void sc_logv (const char *filename, int lineno,
626 int package, int category, int priority,
627 const char *fmt, va_list ap);
628
630void sc_log_indent_push_count (int package, int count);
631
633void sc_log_indent_pop_count (int package, int count);
634
637
640
642void sc_abort (void)
643 __attribute__ ((noreturn));
644
646void sc_abort_verbose (const char *filename, int lineno,
647 const char *msg)
648 __attribute__ ((noreturn));
649
651void sc_abort_verbosef (const char *filename, int lineno,
652 const char *fmt, ...)
653 __attribute__ ((format (printf, 3, 4)))
654 __attribute__ ((noreturn));
655
657void sc_abort_verbosev (const char *filename, int lineno,
658 const char *fmt, va_list ap)
659 __attribute__ ((noreturn));
660
662void sc_abort_collective (const char *msg)
663 __attribute__ ((noreturn));
664
670int sc_package_register (sc_log_handler_t log_handler,
671 int log_threshold,
672 const char *name, const char *full);
673
679int sc_package_is_registered (int package_id);
680
690void sc_package_lock (int package_id);
691
701void sc_package_unlock (int package_id);
702
708void sc_package_set_verbosity (int package_id,
709 int log_priority);
710
720 int set_abort);
721
725void sc_package_unregister (int package_id);
726
731void sc_package_print_summary (int log_priority);
732
748void sc_init (sc_MPI_Comm mpicomm,
749 int catch_signals, int print_backtrace,
750 sc_log_handler_t log_handler, int log_threshold);
751
759
767
776void sc_finalize (void);
777
787
794int sc_is_root (void);
795
807void sc_strcopy (char *dest, size_t size, const char *src);
808
822void sc_snprintf (char *str, size_t size,
823 const char *format, ...)
824 __attribute__ ((format (printf, 3, 4)));
825
834const char *sc_version (void);
835
841
847
848#if 0
849/* Sadly, the point version macro by autoconf doesn't work with vX and vX.Y.
850 The remaining option is to use sc_version and parse its return string. */
857int sc_version_point (void);
858#endif /* 0 */
859
865int sc_have_zlib (void);
866
870int sc_have_json (void);
871
872SC_EXTERN_C_END;
873
874#endif /* SC_H */
int sc_have_json(void)
Return whether we have found a JSON library at configure time.
void sc_set_log_defaults(FILE *log_stream, sc_log_handler_t log_handler, int log_threshold)
Controls the default SC log behavior.
int sc_atoi(const char *nptr)
Safe version of the standard library atoi (3) function.
void sc_log_indent_pop(void)
Remove one space from the start of a sc's default log format.
void sc_package_unregister(int package_id)
Unregister a software package with SC.
int sc_have_zlib(void)
Return a boolean indicating whether zlib has been configured.
void sc_finalize(void)
Unregisters all packages, runs the memory check, removes the signal handlers and resets sc_identifier...
int sc_package_is_registered(int package_id)
Query whether an identifier matches a registered package.
int sc_memory_check_noerr(int package)
Return error count or zero if all is ok.
void sc_package_set_verbosity(int package_id, int log_priority)
Set the logging verbosity of a registered package.
void(* sc_abort_handler_t)(void)
Type of the abort handler function.
Definition: sc.h:558
int sc_finalize_noabort(void)
Unregisters all packages, runs the memory check, removes the signal handlers and resets sc_identifier...
void sc_package_unlock(int package_id)
Release a pthread mutex lock.
void sc_log_indent_pop_count(int package, int count)
Remove spaces from the start of a package's default log format.
void sc_log(const char *filename, int lineno, int package, int category, int priority, const char *msg)
The central log function to be called by all packages.
void sc_init(sc_MPI_Comm mpicomm, int catch_signals, int print_backtrace, sc_log_handler_t log_handler, int log_threshold)
Sets the global program identifier (e.g.
void sc_set_abort_handler(sc_abort_handler_t abort_handler)
Set the default SC abort behavior.
int sc_get_package_id(void)
Query SC's own package identity.
void sc_package_lock(int package_id)
Acquire a pthread mutex lock.
const char * sc_version(void)
Return the full version of libsc.
int sc_is_initialized(void)
Return whether SC has been initialized or not.
void sc_abort_verbosef(const char *filename, int lineno, const char *fmt,...)
Print a message to stderr and then call sc_abort ().
int sc_package_id
libsc allows for multiple packages to use their own log priorities etc.
FILE * sc_trace_file
Optional trace file for logging (see sc_init).
void sc_log_indent_push_count(int package, int count)
Add spaces to the start of a package's default log format.
int sc_version_major(void)
Return the major version of libsc.
const int sc_log2_lookup_table[256]
Lookup table to provide fast base-2 logarithm of integers.
int sc_package_register(sc_log_handler_t log_handler, int log_threshold, const char *name, const char *full)
Register a software package with SC.
void sc_strcopy(char *dest, size_t size, const char *src)
Provide a string copy function.
void sc_package_set_abort_alloc_mismatch(int package_id, int set_abort)
Set the unregister behavior of sc_package_unregister().
void sc_log_indent_push(void)
Add one space to the start of sc's default log format.
int sc_trace_prio
Optional minimum log priority for messages that go into the trace file.
int sc_version_minor(void)
Return the minor version of libsc.
int sc_is_root(void)
Identify the root process.
void sc_abort_verbose(const char *filename, int lineno, const char *msg)
Print a message to stderr and then call sc_abort ().
void sc_abort(void)
Print a stack trace, call the abort handler and then call abort ().
long sc_atol(const char *nptr)
Safe version of the standard library atol (3) function.
void sc_abort_verbosev(const char *filename, int lineno, const char *fmt, va_list ap)
Print a message to stderr and then call sc_abort ().
void sc_package_print_summary(int log_priority)
Print a summary of all packages registered with SC.
void sc_abort_collective(const char *msg)
Collective abort where only root prints a message.
void sc_snprintf(char *str, size_t size, const char *format,...)
Wrap the system snprintf function, allowing for truncation.
Provide a consistent MPI interface with and without MPI configured.
sc3_MPI_Comm_t sc_MPI_Comm
Emulate an MPI communicator.
Definition: sc_mpi.h:391