// Copyright 2009 Google Inc. All Rights Reserved.
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#ifndef STRESSAPPTEST_LOGGER_H_
|
#define STRESSAPPTEST_LOGGER_H_
|
|
#include <pthread.h>
|
#include <stdarg.h>
|
|
#include <string>
|
#include <vector>
|
|
// This file must work with autoconf on its public version,
|
// so these includes are correct.
|
#include "sattypes.h"
|
|
// Attempts to log additional lines will block when the queue reaches this size.
|
// Due to how the logging thread works, up to twice this many log lines may be
|
// outstanding at any point.
|
static const size_t kMaxQueueSize = 250;
|
|
|
// This is only for use by the Logger class, do not use it elsewhere!
|
//
|
// All Logger assertions should use this macro instead of sat_assert().
|
//
|
// This is like sat_assert() from sattypes.h, but whereas sat_assert() tries to
|
// log the assertion after printing it to stderr, this only prints it to stderr.
|
// Logging from within the wrong part of the logger would trigger a deadlock,
|
// and even in places where it wouldn't there's a very good chance that the
|
// logger is in no condition to handle new log lines.
|
#define LOGGER_ASSERT(x) \
|
{\
|
if (!(x)) {\
|
fprintf(stderr, "Assertion failed at %s:%d\n", __FILE__, __LINE__);\
|
exit(1);\
|
}\
|
}
|
|
|
// This class handles logging in SAT. It is a singleton accessed via
|
// GlobalLogger().
|
//
|
// By default log lines are written in the calling thread. Call StartThread()
|
// to launch a dedicated thread for the writes.
|
class Logger {
|
public:
|
// Returns a pointer to the single global Logger instance. Will not return
|
// NULL.
|
static Logger *GlobalLogger();
|
|
// Lines with a priority numerically greater than this will not be logged.
|
// May not be called while multiple threads are running.
|
virtual void SetVerbosity(int verbosity) {
|
verbosity_ = verbosity;
|
}
|
|
// Sets a file to log to, in addition to stdout. May not be called while
|
// multiple threads are running.
|
//
|
// Args:
|
// log_fd: The file descriptor to write to. Will not be closed by this
|
// object.
|
virtual void SetLogFd(int log_fd) {
|
LOGGER_ASSERT(log_fd >= 0);
|
log_fd_ = log_fd;
|
}
|
|
// Set output to be written to stdout only. This is the default mode. May
|
// not be called while multiple threads are running.
|
virtual void SetStdoutOnly() {
|
log_fd_ = -1;
|
}
|
|
// Enable or disable logging of timestamps.
|
void SetTimestampLogging(bool log_ts_enabled) {
|
log_timestamps_ = log_ts_enabled;
|
}
|
|
// Logs a line, with a vprintf(3)-like interface. This will block on writing
|
// the line to stdout/disk iff the dedicated logging thread is not running.
|
// This will block on adding the line to the queue if doing so would exceed
|
// kMaxQueueSize.
|
//
|
// Args:
|
// priority: If this is numerically greater than the verbosity, the line
|
// will not be logged.
|
// format: see vprintf(3)
|
// args: see vprintf(3)
|
void VLogF(int priority, const char *format, va_list args);
|
|
// Starts the dedicated logging thread. May not be called while multiple
|
// threads are already running.
|
void StartThread();
|
|
// Stops the dedicated logging thread. May only be called when the logging
|
// thread is the only other thread running. Any queued lines will be logged
|
// before this returns. Waits for the thread to finish before returning.
|
void StopThread();
|
|
protected:
|
Logger();
|
|
virtual ~Logger();
|
|
private:
|
// Args:
|
// line: Must be non-NULL. This function takes ownership of it.
|
void QueueLogLine(string *line);
|
|
// Args:
|
// line: Must be non-NULL. This function takes ownership of it.
|
void WriteAndDeleteLogLine(string *line);
|
|
// Callback for pthread_create(3).
|
static void *StartRoutine(void *ptr);
|
|
// Processes the log queue.
|
void ThreadMain();
|
|
pthread_t thread_;
|
int verbosity_;
|
int log_fd_;
|
bool thread_running_;
|
bool log_timestamps_;
|
vector<string*> queued_lines_;
|
// This doubles as a mutex for log_fd_ when the logging thread is not running.
|
pthread_mutex_t queued_lines_mutex_;
|
// Lets the logging thread know that the queue is no longer empty.
|
pthread_cond_t queued_lines_cond_;
|
// Lets the threads blocked on the queue having reached kMaxQueueSize know
|
// that the queue has been emptied.
|
pthread_cond_t full_queue_cond_;
|
|
DISALLOW_COPY_AND_ASSIGN(Logger);
|
};
|
|
#endif // STRESSAPPTEST_LOGGER_H_
|
