openmp/runtime/src/kmp_io.cpp

   1 /*
   2  * kmp_io.cpp -- RTL IO
   3  */
   4
   5 //===----------------------------------------------------------------------===//
   6 //
   7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   8 // See https://llvm.org/LICENSE.txt for license information.
   9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include <stdarg.h>
  14 #include <stddef.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #ifndef __ABSOFT_WIN
  19 #include <sys/types.h>
  20 #endif
  21
  22 #include "kmp.h" // KMP_GTID_DNE, __kmp_debug_buf, etc
  23 #include "kmp_io.h"
  24 #include "kmp_lock.h"
  25 #include "kmp_os.h"
  26 #include "kmp_str.h"
  27
  28 #if KMP_OS_WINDOWS
  29 #if KMP_MSVC_COMPAT
  30 #pragma warning(push)
  31 #pragma warning(disable : 271 310)
  32 #endif
  33 #include <windows.h>
  34 #if KMP_MSVC_COMPAT
  35 #pragma warning(pop)
  36 #endif
  37 #endif
  38
  39 /* ------------------------------------------------------------------------ */
  40
  41 kmp_bootstrap_lock_t __kmp_stdio_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
  42     __kmp_stdio_lock); /* Control stdio functions */
  43 kmp_bootstrap_lock_t __kmp_console_lock = KMP_BOOTSTRAP_LOCK_INITIALIZER(
  44     __kmp_console_lock); /* Control console initialization */
  45
  46 #if KMP_OS_WINDOWS
  47
  48 static HANDLE __kmp_stdout = NULL;
  49 static HANDLE __kmp_stderr = NULL;
  50 static int __kmp_console_exists = FALSE;
  51 static kmp_str_buf_t __kmp_console_buf;
  52
  53 void __kmp_close_console(void) {
  54   /* wait until user presses return before closing window */
  55   /* TODO only close if a window was opened */
  56   if (__kmp_console_exists) {
  57     __kmp_stdout = NULL;
  58     __kmp_stderr = NULL;
  59     __kmp_str_buf_free(&__kmp_console_buf);
  60     __kmp_console_exists = FALSE;
  61   }
  62 }
  63
  64 /* For windows, call this before stdout, stderr, or stdin are used.
  65    It opens a console window and starts processing */
  66 static void __kmp_redirect_output(void) {
  67   __kmp_acquire_bootstrap_lock(&__kmp_console_lock);
  68
  69   if (!__kmp_console_exists) {
  70     HANDLE ho;
  71     HANDLE he;
  72
  73     __kmp_str_buf_init(&__kmp_console_buf);
  74
  75     AllocConsole();
  76     // We do not check the result of AllocConsole because
  77     //  1. the call is harmless
  78     //  2. it is not clear how to communicate failue
  79     //  3. we will detect failure later when we get handle(s)
  80
  81     ho = GetStdHandle(STD_OUTPUT_HANDLE);
  82     if (ho == INVALID_HANDLE_VALUE || ho == NULL) {
  83
  84       DWORD err = GetLastError();
  85       // TODO: output error somehow (maybe message box)
  86       (void)err;
  87       __kmp_stdout = NULL;
  88
  89     } else {
  90
  91       __kmp_stdout = ho; // temporary code, need new global for ho
  92     }
  93     he = GetStdHandle(STD_ERROR_HANDLE);
  94     if (he == INVALID_HANDLE_VALUE || he == NULL) {
  95
  96       DWORD err = GetLastError();
  97       // TODO: output error somehow (maybe message box)
  98       (void)err;
  99       __kmp_stderr = NULL;
 100
 101     } else {
 102
 103       __kmp_stderr = he; // temporary code, need new global
 104     }
 105     __kmp_console_exists = TRUE;
 106   }
 107   __kmp_release_bootstrap_lock(&__kmp_console_lock);
 108 }
 109
 110 #else
 111 #define __kmp_stderr (stderr)
 112 #define __kmp_stdout (stdout)
 113 #endif /* KMP_OS_WINDOWS */
 114
 115 void __kmp_vprintf(enum kmp_io out_stream, char const *format, va_list ap) {
 116 #if KMP_OS_WINDOWS
 117   if (!__kmp_console_exists) {
 118     __kmp_redirect_output();
 119   }
 120   if (!__kmp_stderr && out_stream == kmp_err) {
 121     return;
 122   }
 123   if (!__kmp_stdout && out_stream == kmp_out) {
 124     return;
 125   }
 126 #endif /* KMP_OS_WINDOWS */
 127   auto stream = ((out_stream == kmp_out) ? __kmp_stdout : __kmp_stderr);
 128
 129   if (__kmp_debug_buf && __kmp_debug_buffer != NULL) {
 130
 131     int dc = __kmp_debug_count++ % __kmp_debug_buf_lines;
 132     char *db = &__kmp_debug_buffer[dc * __kmp_debug_buf_chars];
 133     int chars = 0;
 134
 135 #ifdef KMP_DEBUG_PIDS
 136     chars = KMP_SNPRINTF(db, __kmp_debug_buf_chars,
 137                          "pid=%d: ", (kmp_int32)getpid());
 138 #endif
 139     chars += KMP_VSNPRINTF(db, __kmp_debug_buf_chars, format, ap);
 140
 141     if (chars + 1 > __kmp_debug_buf_chars) {
 142       if (chars + 1 > __kmp_debug_buf_warn_chars) {
 143 #if KMP_OS_WINDOWS
 144         DWORD count;
 145         __kmp_str_buf_print(&__kmp_console_buf,
 146                             "OMP warning: Debugging buffer "
 147                             "overflow; increase "
 148                             "KMP_DEBUG_BUF_CHARS to %d\n",
 149                             chars + 1);
 150         WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
 151                   NULL);
 152         __kmp_str_buf_clear(&__kmp_console_buf);
 153 #else
 154         fprintf(stream,
 155                 "OMP warning: Debugging buffer overflow; "
 156                 "increase KMP_DEBUG_BUF_CHARS to %d\n",
 157                 chars + 1);
 158         fflush(stream);
 159 #endif
 160         __kmp_debug_buf_warn_chars = chars + 1;
 161       }
 162       /* terminate string if overflow occurred */
 163       db[__kmp_debug_buf_chars - 2] = '\n';
 164       db[__kmp_debug_buf_chars - 1] = '\0';
 165     }
 166   } else {
 167 #if KMP_OS_WINDOWS
 168     DWORD count;
 169 #ifdef KMP_DEBUG_PIDS
 170     __kmp_str_buf_print(&__kmp_console_buf, "pid=%d: ", (kmp_int32)getpid());
 171 #endif
 172     __kmp_str_buf_vprint(&__kmp_console_buf, format, ap);
 173     WriteFile(stream, __kmp_console_buf.str, __kmp_console_buf.used, &count,
 174               NULL);
 175     __kmp_str_buf_clear(&__kmp_console_buf);
 176 #else
 177 #ifdef KMP_DEBUG_PIDS
 178     fprintf(stream, "pid=%d: ", (kmp_int32)getpid());
 179 #endif
 180     vfprintf(stream, format, ap);
 181     fflush(stream);
 182 #endif
 183   }
 184 }
 185
 186 void __kmp_printf(char const *format, ...) {
 187   va_list ap;
 188   va_start(ap, format);
 189
 190   __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
 191   __kmp_vprintf(kmp_err, format, ap);
 192   __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
 193
 194   va_end(ap);
 195 }
 196
 197 void __kmp_printf_no_lock(char const *format, ...) {
 198   va_list ap;
 199   va_start(ap, format);
 200
 201   __kmp_vprintf(kmp_err, format, ap);
 202
 203   va_end(ap);
 204 }
 205
 206 void __kmp_fprintf(enum kmp_io stream, char const *format, ...) {
 207   va_list ap;
 208   va_start(ap, format);
 209
 210   __kmp_acquire_bootstrap_lock(&__kmp_stdio_lock);
 211   __kmp_vprintf(stream, format, ap);
 212   __kmp_release_bootstrap_lock(&__kmp_stdio_lock);
 213
 214   va_end(ap);
 215 }