chiark - git - ian - stressapptest/blob - src/logger.h

   1 // Copyright 2009 Google Inc. All Rights Reserved.
   2
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //      http://www.apache.org/licenses/LICENSE-2.0
   8
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #ifndef STRESSAPPTEST_LOGGER_H_
  16 #define STRESSAPPTEST_LOGGER_H_
  17
  18 #include <pthread.h>
  19 #include <stdarg.h>
  20
  21 #include <string>
  22 #include <vector>
  23
  24 // This file must work with autoconf on its public version,
  25 // so these includes are correct.
  26 #include "sattypes.h"
  27
  28 // Attempts to log additional lines will block when the queue reaches this size.
  29 // Due to how the logging thread works, up to twice this many log lines may be
  30 // outstanding at any point.
  31 static const size_t kMaxQueueSize = 250;
  32
  33
  34 // This is only for use by the Logger class, do not use it elsewhere!
  35 //
  36 // All Logger assertions should use this macro instead of sat_assert().
  37 //
  38 // This is like sat_assert() from sattypes.h, but whereas sat_assert() tries to
  39 // log the assertion after printing it to stderr, this only prints it to stderr.
  40 // Logging from within the wrong part of the logger would trigger a deadlock,
  41 // and even in places where it wouldn't there's a very good chance that the
  42 // logger is in no condition to handle new log lines.
  43 #define LOGGER_ASSERT(x) \
  44 {\
  45   if (!(x)) {\
  46     fprintf(stderr, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
  47     exit(1);\
  48   }\
  49 }
  50
  51
  52 // This class handles logging in SAT.  It is a singleton accessed via
  53 // GlobalLogger().
  54 //
  55 // By default log lines are written in the calling thread.  Call StartThread()
  56 // to launch a dedicated thread for the writes.
  57 class Logger {
  58  public:
  59   // Returns a pointer to the single global Logger instance.  Will not return
  60   // NULL.
  61   static Logger *GlobalLogger();
  62
  63   // Lines with a priority numerically greater than this will not be logged.
  64   // May not be called while multiple threads are running.
  65   void SetVerbosity(int verbosity) {
  66     verbosity_ = verbosity;
  67   }
  68
  69   // Sets a file to log to, in addition to stdout.  May not be called while
  70   // multiple threads are running.
  71   //
  72   // Args:
  73   //   log_fd: The file descriptor to write to.  Will not be closed by this
  74   //           object.
  75   void SetLogFd(int log_fd) {
  76     LOGGER_ASSERT(log_fd >= 0);
  77     log_fd_ = log_fd;
  78   }
  79
  80   // Set output to be written to stdout only.  This is the default mode.  May
  81   // not be called while multiple threads are running.
  82   void SetStdoutOnly() {
  83     log_fd_ = -1;
  84   }
  85
  86   // Logs a line, with a vprintf(3)-like interface.  This will block on writing
  87   // the line to stdout/disk iff the dedicated logging thread is not running.
  88   // This will block on adding the line to the queue if doing so would exceed
  89   // kMaxQueueSize.
  90   //
  91   // Args:
  92   //   priority: If this is numerically greater than the verbosity, the line
  93   //             will not be logged.
  94   //   format: see vprintf(3)
  95   //   args: see vprintf(3)
  96   void VLogF(int priority, const char *format, va_list args);
  97
  98   // Starts the dedicated logging thread.  May not be called while multiple
  99   // threads are already running.
 100   void StartThread();
 101
 102   // Stops the dedicated logging thread.  May only be called when the logging
 103   // thread is the only other thread running.  Any queued lines will be logged
 104   // before this returns.  Waits for the thread to finish before returning.
 105   void StopThread();
 106
 107  private:
 108   Logger();
 109
 110   ~Logger();
 111
 112   // Args:
 113   //   line: Must be non-NULL.  This function takes ownership of it.
 114   void QueueLogLine(string *line);
 115
 116   // Args:
 117   //   line: Must be non-NULL.  This function takes ownership of it.
 118   void WriteAndDeleteLogLine(string *line);
 119
 120   // Callback for pthread_create(3).
 121   static void *StartRoutine(void *ptr);
 122
 123   // Processes the log queue.
 124   void ThreadMain();
 125
 126   pthread_t thread_;
 127   int verbosity_;
 128   int log_fd_;
 129   bool thread_running_;
 130   vector<string*> queued_lines_;
 131   // This doubles as a mutex for log_fd_ when the logging thread is not running.
 132   pthread_mutex_t queued_lines_mutex_;
 133   // Lets the logging thread know that the queue is no longer empty.
 134   pthread_cond_t queued_lines_cond_;
 135   // Lets the threads blocked on the queue having reached kMaxQueueSize know
 136   // that the queue has been emptied.
 137   pthread_cond_t full_queue_cond_;
 138
 139   DISALLOW_COPY_AND_ASSIGN(Logger);
 140 };
 141
 142 #endif  // STRESSAPPTEST_LOGGER_H_