aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/common')
-rw-r--r--src/common/CMakeLists.txt2
-rw-r--r--src/common/assert.h10
-rw-r--r--src/common/common_types.h26
-rw-r--r--src/common/concurrent_ring_buffer.h163
-rw-r--r--src/common/logging/backend.cpp56
-rw-r--r--src/common/logging/backend.h92
-rw-r--r--src/common/logging/filter.cpp41
-rw-r--r--src/common/logging/filter.h20
-rw-r--r--src/common/logging/log.h6
-rw-r--r--src/common/logging/text_formatter.cpp19
-rw-r--r--src/common/logging/text_formatter.h8
-rw-r--r--src/common/math_util.cpp211
-rw-r--r--src/common/math_util.h174
13 files changed, 38 insertions, 790 deletions
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 11659c3c..dbaaac77 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -9,7 +9,6 @@ set(SRCS
logging/filter.cpp
logging/text_formatter.cpp
logging/backend.cpp
- math_util.cpp
memory_util.cpp
misc.cpp
profiler.cpp
@@ -28,7 +27,6 @@ set(HEADERS
common_funcs.h
common_paths.h
common_types.h
- concurrent_ring_buffer.h
cpu_detect.h
debug_interface.h
emu_window.h
diff --git a/src/common/assert.h b/src/common/assert.h
index 4f26c63e..7b7d8bf2 100644
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -8,6 +8,7 @@
#include <cstdlib>
#include "common/common_funcs.h"
+#include "common/logging/log.h"
// For asserts we'd like to keep all the junk executed when an assert happens away from the
// important code in the function. One way of doing this is to put all the relevant code inside a
@@ -28,19 +29,14 @@ static void assert_noinline_call(const Fn& fn) {
exit(1); // Keeps GCC's mouth shut about this actually returning
}
-// TODO (yuriks) allow synchronous logging so we don't need printf
#define ASSERT(_a_) \
do if (!(_a_)) { assert_noinline_call([] { \
- fprintf(stderr, "Assertion Failed!\n\n Line: %d\n File: %s\n Time: %s\n", \
- __LINE__, __FILE__, __TIME__); \
+ LOG_CRITICAL(Debug, "Assertion Failed!"); \
}); } while (0)
#define ASSERT_MSG(_a_, ...) \
do if (!(_a_)) { assert_noinline_call([&] { \
- fprintf(stderr, "Assertion Failed!\n\n Line: %d\n File: %s\n Time: %s\n", \
- __LINE__, __FILE__, __TIME__); \
- fprintf(stderr, __VA_ARGS__); \
- fprintf(stderr, "\n"); \
+ LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); \
}); } while (0)
#define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
diff --git a/src/common/common_types.h b/src/common/common_types.h
index 644709ba..f6de0adf 100644
--- a/src/common/common_types.h
+++ b/src/common/common_types.h
@@ -87,29 +87,3 @@ protected:
NonCopyable(NonCopyable&) = delete;
NonCopyable& operator=(NonCopyable&) = delete;
};
-
-namespace Common {
-/// Rectangle data structure
-class Rect {
-public:
- Rect(int x0=0, int y0=0, int x1=0, int y1=0) {
- x0_ = x0;
- y0_ = y0;
- x1_ = x1;
- y1_ = y1;
- }
- ~Rect() { }
-
- int x0_; ///< Rect top left X-coordinate
- int y0_; ///< Rect top left Y-coordinate
- int x1_; ///< Rect bottom left X-coordinate
- int y1_; ///< Rect bottom right Y-coordinate
-
- inline u32 width() const { return std::abs(x1_ - x0_); }
- inline u32 height() const { return std::abs(y1_ - y0_); }
-
- inline bool operator == (const Rect& val) const {
- return (x0_ == val.x0_ && y0_ == val.y0_ && x1_ == val.x1_ && y1_ == val.y1_);
- }
-};
-}
diff --git a/src/common/concurrent_ring_buffer.h b/src/common/concurrent_ring_buffer.h
deleted file mode 100644
index c5889513..00000000
--- a/src/common/concurrent_ring_buffer.h
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <condition_variable>
-#include <cstdint>
-#include <mutex>
-#include <thread>
-
-#include "common/common_types.h" // for NonCopyable
-
-namespace Common {
-
-/**
- * A MPMC (Multiple-Producer Multiple-Consumer) concurrent ring buffer. This data structure permits
- * multiple threads to push and pop from a queue of bounded size.
- */
-template <typename T, size_t ArraySize>
-class ConcurrentRingBuffer : private NonCopyable {
-public:
- /// Value returned by the popping functions when the queue has been closed.
- static const size_t QUEUE_CLOSED = -1;
-
- ConcurrentRingBuffer() {}
-
- ~ConcurrentRingBuffer() {
- // If for whatever reason the queue wasn't completely drained, destroy the left over items.
- for (size_t i = reader_index, end = writer_index; i != end; i = (i + 1) % ArraySize) {
- Data()[i].~T();
- }
- }
-
- /**
- * Pushes a value to the queue. If the queue is full, this method will block. Does nothing if
- * the queue is closed.
- */
- void Push(T val) {
- std::unique_lock<std::mutex> lock(mutex);
- if (closed) {
- return;
- }
-
- // If the buffer is full, wait
- writer.wait(lock, [&]{
- return (writer_index + 1) % ArraySize != reader_index;
- });
-
- T* item = &Data()[writer_index];
- new (item) T(std::move(val));
-
- writer_index = (writer_index + 1) % ArraySize;
-
- // Wake up waiting readers
- lock.unlock();
- reader.notify_one();
- }
-
- /**
- * Pops up to `dest_len` items from the queue, storing them in `dest`. This function will not
- * block, and might return 0 values if there are no elements in the queue when it is called.
- *
- * @return The number of elements stored in `dest`. If the queue has been closed, returns
- * `QUEUE_CLOSED`.
- */
- size_t Pop(T* dest, size_t dest_len) {
- std::unique_lock<std::mutex> lock(mutex);
- if (closed && !CanRead()) {
- return QUEUE_CLOSED;
- }
- return PopInternal(dest, dest_len);
- }
-
- /**
- * Pops up to `dest_len` items from the queue, storing them in `dest`. This function will block
- * if there are no elements in the queue when it is called.
- *
- * @return The number of elements stored in `dest`. If the queue has been closed, returns
- * `QUEUE_CLOSED`.
- */
- size_t BlockingPop(T* dest, size_t dest_len) {
- std::unique_lock<std::mutex> lock(mutex);
- if (closed && !CanRead()) {
- return QUEUE_CLOSED;
- }
-
- while (!CanRead()) {
- reader.wait(lock);
- if (closed && !CanRead()) {
- return QUEUE_CLOSED;
- }
- }
- DEBUG_ASSERT(CanRead());
- return PopInternal(dest, dest_len);
- }
-
- /**
- * Closes the queue. After calling this method, `Push` operations won't have any effect, and
- * `PopMany` and `PopManyBlock` will start returning `QUEUE_CLOSED`. This is intended to allow
- * a graceful shutdown of all consumers.
- */
- void Close() {
- std::unique_lock<std::mutex> lock(mutex);
- closed = true;
- // We need to wake up any reader that are waiting for an item that will never come.
- lock.unlock();
- reader.notify_all();
- }
-
- /// Returns true if `Close()` has been called.
- bool IsClosed() const {
- return closed;
- }
-
-private:
- size_t PopInternal(T* dest, size_t dest_len) {
- size_t output_count = 0;
- while (output_count < dest_len && CanRead()) {
- DEBUG_ASSERT(CanRead());
-
- T* item = &Data()[reader_index];
- T out_val = std::move(*item);
- item->~T();
-
- size_t prev_index = (reader_index + ArraySize - 1) % ArraySize;
- reader_index = (reader_index + 1) % ArraySize;
- if (writer_index == prev_index) {
- writer.notify_one();
- }
- dest[output_count++] = std::move(out_val);
- }
- return output_count;
- }
-
- bool CanRead() const {
- return reader_index != writer_index;
- }
-
- T* Data() {
- return static_cast<T*>(static_cast<void*>(&storage));
- }
-
- /// Storage for entries
- typename std::aligned_storage<ArraySize * sizeof(T),
- std::alignment_of<T>::value>::type storage;
-
- /// Data is valid in the half-open interval [reader, writer). If they are `QUEUE_CLOSED` then the
- /// queue has been closed.
- size_t writer_index = 0, reader_index = 0;
- // True if the queue has been closed.
- bool closed = false;
-
- /// Mutex that protects the entire data structure.
- std::mutex mutex;
- /// Signaling wakes up reader which is waiting for storage to be non-empty.
- std::condition_variable reader;
- /// Signaling wakes up writer which is waiting for storage to be non-full.
- std::condition_variable writer;
-};
-
-} // namespace
diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index 7d3534a4..bd2c6a15 100644
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -3,17 +3,17 @@
// Refer to the license.txt file included.
#include <algorithm>
+#include <array>
+#include <cstdio>
-#include "common/assert.h"
-
+#include "common/common_funcs.h" // snprintf compatibility define
#include "common/logging/backend.h"
+#include "common/logging/filter.h"
#include "common/logging/log.h"
#include "common/logging/text_formatter.h"
namespace Log {
-static std::shared_ptr<Logger> global_logger;
-
/// Macro listing all log classes. Code should define CLS and SUB as desired before invoking this.
#define ALL_LOG_CLASSES() \
CLS(Log) \
@@ -55,28 +55,8 @@ static std::shared_ptr<Logger> global_logger;
SUB(Render, OpenGL) \
CLS(Loader)
-Logger::Logger() {
- // Register logging classes so that they can be queried at runtime
- size_t parent_class;
- all_classes.reserve((size_t)Class::Count);
-
-#define CLS(x) \
- all_classes.push_back(Class::x); \
- parent_class = all_classes.size() - 1;
-#define SUB(x, y) \
- all_classes.push_back(Class::x##_##y); \
- all_classes[parent_class].num_children += 1;
-
- ALL_LOG_CLASSES()
-#undef CLS
-#undef SUB
-
- // Ensures that ALL_LOG_CLASSES isn't missing any entries.
- DEBUG_ASSERT(all_classes.size() == (size_t)Class::Count);
-}
-
// GetClassName is a macro defined by Windows.h, grrr...
-const char* Logger::GetLogClassName(Class log_class) {
+const char* GetLogClassName(Class log_class) {
switch (log_class) {
#define CLS(x) case Class::x: return #x;
#define SUB(x, y) case Class::x##_##y: return #x "." #y;
@@ -87,7 +67,7 @@ const char* Logger::GetLogClassName(Class log_class) {
return "Unknown";
}
-const char* Logger::GetLevelName(Level log_level) {
+const char* GetLevelName(Level log_level) {
#define LVL(x) case Level::x: return #x
switch (log_level) {
LVL(Trace);
@@ -101,19 +81,6 @@ const char* Logger::GetLevelName(Level log_level) {
#undef LVL
}
-void Logger::LogMessage(Entry entry) {
- ring_buffer.Push(std::move(entry));
-}
-
-size_t Logger::GetEntries(Entry* out_buffer, size_t buffer_len) {
- return ring_buffer.BlockingPop(out_buffer, buffer_len);
-}
-
-std::shared_ptr<Logger> InitGlobalLogger() {
- global_logger = std::make_shared<Logger>();
- return global_logger;
-}
-
Entry CreateEntry(Class log_class, Level log_level,
const char* filename, unsigned int line_nr, const char* function,
const char* format, va_list args) {
@@ -138,7 +105,7 @@ Entry CreateEntry(Class log_class, Level log_level,
return std::move(entry);
}
-static Filter* filter;
+static Filter* filter = nullptr;
void SetFilter(Filter* new_filter) {
filter = new_filter;
@@ -147,7 +114,7 @@ void SetFilter(Filter* new_filter) {
void LogMessage(Class log_class, Level log_level,
const char* filename, unsigned int line_nr, const char* function,
const char* format, ...) {
- if (!filter->CheckMessage(log_class, log_level))
+ if (filter != nullptr && !filter->CheckMessage(log_class, log_level))
return;
va_list args;
@@ -156,12 +123,7 @@ void LogMessage(Class log_class, Level log_level,
filename, line_nr, function, format, args);
va_end(args);
- if (global_logger != nullptr && !global_logger->IsClosed()) {
- global_logger->LogMessage(std::move(entry));
- } else {
- // Fall back to directly printing to stderr
- PrintMessage(entry);
- }
+ PrintColoredMessage(entry);
}
}
diff --git a/src/common/logging/backend.h b/src/common/logging/backend.h
index 3114f864..c1f4d08e 100644
--- a/src/common/logging/backend.h
+++ b/src/common/logging/backend.h
@@ -4,17 +4,17 @@
#pragma once
+#include <chrono>
#include <cstdarg>
-#include <memory>
-#include <vector>
+#include <string>
+#include <utility>
-#include "common/concurrent_ring_buffer.h"
-
-#include "common/logging/filter.h"
#include "common/logging/log.h"
namespace Log {
+class Filter;
+
/**
* A log entry. Log entries are store in a structured format to permit more varied output
* formatting on different frontends, as well as facilitating filtering and aggregation.
@@ -48,89 +48,21 @@ struct Entry {
}
};
-struct ClassInfo {
- Class log_class;
-
- /**
- * Total number of (direct or indirect) sub classes this class has. If any, they follow in
- * sequence after this class in the class list.
- */
- unsigned int num_children = 0;
-
- ClassInfo(Class log_class) : log_class(log_class) {}
-};
-
/**
- * Logging management class. This class has the dual purpose of acting as an exchange point between
- * the logging clients and the log outputter, as well as containing reflection info about available
- * log classes.
+ * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
+ * instead of underscores as in the enumeration.
*/
-class Logger {
-private:
- using Buffer = Common::ConcurrentRingBuffer<Entry, 16 * 1024 / sizeof(Entry)>;
-
-public:
- static const size_t QUEUE_CLOSED = Buffer::QUEUE_CLOSED;
-
- Logger();
-
- /**
- * Returns a list of all vector classes and subclasses. The sequence returned is a pre-order of
- * classes and subclasses, which together with the `num_children` field in ClassInfo, allows
- * you to recover the hierarchy.
- */
- const std::vector<ClassInfo>& GetClasses() const { return all_classes; }
+const char* GetLogClassName(Class log_class);
- /**
- * Returns the name of the passed log class as a C-string. Subclasses are separated by periods
- * instead of underscores as in the enumeration.
- */
- static const char* GetLogClassName(Class log_class);
-
- /**
- * Returns the name of the passed log level as a C-string.
- */
- static const char* GetLevelName(Level log_level);
-
- /**
- * Appends a messages to the log buffer.
- * @note This function is thread safe.
- */
- void LogMessage(Entry entry);
-
- /**
- * Retrieves a batch of messages from the log buffer, blocking until they are available.
- * @note This function is thread safe.
- *
- * @param out_buffer Destination buffer that will receive the log entries.
- * @param buffer_len The maximum size of `out_buffer`.
- * @return The number of entries stored. In case the logger is shutting down, `QUEUE_CLOSED` is
- * returned, no entries are stored and the logger should shutdown.
- */
- size_t GetEntries(Entry* out_buffer, size_t buffer_len);
-
- /**
- * Initiates a shutdown of the logger. This will indicate to log output clients that they
- * should shutdown.
- */
- void Close() { ring_buffer.Close(); }
-
- /**
- * Returns true if Close() has already been called on the Logger.
- */
- bool IsClosed() const { return ring_buffer.IsClosed(); }
-
-private:
- Buffer ring_buffer;
- std::vector<ClassInfo> all_classes;
-};
+/**
+ * Returns the name of the passed log level as a C-string.
+ */
+const char* GetLevelName(Level log_level);
/// Creates a log entry by formatting the given source location, and message.
Entry CreateEntry(Class log_class, Level log_level,
const char* filename, unsigned int line_nr, const char* function,
const char* format, va_list args);
-/// Initializes the default Logger.
-std::shared_ptr<Logger> InitGlobalLogger();
void SetFilter(Filter* filter);
diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp
index 50f2e13f..55cc8888 100644
--- a/src/common/logging/filter.cpp
+++ b/src/common/logging/filter.cpp
@@ -22,16 +22,6 @@ void Filter::SetClassLevel(Class log_class, Level level) {
class_levels[static_cast<size_t>(log_class)] = level;
}
-void Filter::SetSubclassesLevel(const ClassInfo& log_class, Level level) {
- const size_t log_class_i = static_cast<size_t>(log_class.log_class);
-
- const size_t begin = log_class_i + 1;
- const size_t end = begin + log_class.num_children;
- for (size_t i = begin; begin < end; ++i) {
- class_levels[i] = level;
- }
-}
-
void Filter::ParseFilterString(const std::string& filter_str) {
auto clause_begin = filter_str.cbegin();
while (clause_begin != filter_str.cend()) {
@@ -53,7 +43,7 @@ void Filter::ParseFilterString(const std::string& filter_str) {
template <typename It>
static Level GetLevelByName(const It begin, const It end) {
for (u8 i = 0; i < static_cast<u8>(Level::Count); ++i) {
- const char* level_name = Logger::GetLevelName(static_cast<Level>(i));
+ const char* level_name = GetLevelName(static_cast<Level>(i));
if (Common::ComparePartialString(begin, end, level_name)) {
return static_cast<Level>(i);
}
@@ -64,7 +54,7 @@ static Level GetLevelByName(const It begin, const It end) {
template <typename It>
static Class GetClassByName(const It begin, const It end) {
for (ClassType i = 0; i < static_cast<ClassType>(Class::Count); ++i) {
- const char* level_name = Logger::GetLogClassName(static_cast<Class>(i));
+ const char* level_name = GetLogClassName(static_cast<Class>(i));
if (Common::ComparePartialString(begin, end, level_name)) {
return static_cast<Class>(i);
}
@@ -72,20 +62,6 @@ static Class GetClassByName(const It begin, const It end) {
return Class::Count;
}
-template <typename InputIt, typename T>
-static InputIt find_last(InputIt begin, const InputIt end, const T& value) {
- auto match = end;
- while (begin != end) {
- auto new_match = std::find(begin, end, value);
- if (new_match != end) {
- match = new_match;
- ++new_match;
- }
- begin = new_match;
- }
- return match;
-}
-
bool Filter::ParseFilterRule(const std::string::const_iterator begin,
const std::string::const_iterator end) {
auto level_separator = std::find(begin, end, ':');
@@ -106,22 +82,13 @@ bool Filter::ParseFilterRule(const std::string::const_iterator begin,
return true;
}
- auto class_name_end = find_last(begin, level_separator, '.');
- if (class_name_end != level_separator &&
- !Common::ComparePartialString(class_name_end + 1, level_separator, "*")) {
- class_name_end = level_separator;
- }
-
- const Class log_class = GetClassByName(begin, class_name_end);
+ const Class log_class = GetClassByName(begin, level_separator);
if (log_class == Class::Count) {
LOG_ERROR(Log, "Unknown log class in filter: %s", std::string(begin, end).c_str());
return false;
}
- if (class_name_end == level_separator) {
- SetClassLevel(log_class, level);
- }
- SetSubclassesLevel(log_class, level);
+ SetClassLevel(log_class, level);
return true;
}
diff --git a/src/common/logging/filter.h b/src/common/logging/filter.h
index b53e4e63..0b71ea3b 100644
--- a/src/common/logging/filter.h
+++ b/src/common/logging/filter.h
@@ -11,8 +11,6 @@
namespace Log {
-struct ClassInfo;
-
/**
* Implements a log message filter which allows different log classes to have different minimum
* severity levels. The filter can be changed at runtime and can be parsed from a string to allow
@@ -27,29 +25,19 @@ public:
void ResetAll(Level level);
/// Sets the minimum level of `log_class` (and not of its subclasses) to `level`.
void SetClassLevel(Class log_class, Level level);
- /**
- * Sets the minimum level of all of `log_class` subclasses to `level`. The level of `log_class`
- * itself is not changed.
- */
- void SetSubclassesLevel(const ClassInfo& log_class, Level level);
/**
* Parses a filter string and applies it to this filter.
*
* A filter string consists of a space-separated list of filter rules, each of the format
* `<class>:<level>`. `<class>` is a log class name, with subclasses separated using periods.
- * A rule for a given class also affects all of its subclasses. `*` wildcards are allowed and
- * can be used to apply a rule to all classes or to all subclasses of a class without affecting
- * the parent class. `<level>` a severity level name which will be set as the minimum logging
- * level of the matched classes. Rules are applied left to right, with each rule overriding
- * previous ones in the sequence.
+ * `*` is allowed as a class name and will reset all filters to the specified level. `<level>`
+ * a severity level name which will be set as the minimum logging level of the matched classes.
+ * Rules are applied left to right, with each rule overriding previous ones in the sequence.
*
* A few examples of filter rules:
* - `*:Info` -- Resets the level of all classes to Info.
- * - `Service:Info` -- Sets the level of Service and all subclasses (Service.FS, Service.APT,
- * etc.) to Info.
- * - `Service.*:Debug` -- Sets the level of all Service subclasses to Debug, while leaving the
- * level of Service unchanged.
+ * - `Service:Info` -- Sets the level of Service to Info.
* - `Service.FS:Trace` -- Sets the level of the Service.FS class to Trace.
*/
void ParseFilterString(const std::string& filter_str);
diff --git a/src/common/logging/log.h b/src/common/logging/log.h
index 123641cb..fd87ddbe 100644
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -78,11 +78,7 @@ enum class Class : ClassType {
Count ///< Total number of logging classes
};
-/**
- * Logs a message to the global logger. This proxy exists to avoid exposing the details of the
- * Logger class, including the ConcurrentRingBuffer template, to all files that desire to log
- * messages, reducing unecessary recompilations.
- */
+/// Logs a message to the global logger.
void LogMessage(Class log_class, Level log_level,
const char* filename, unsigned int line_nr, const char* function,
#ifdef _MSC_VER
diff --git a/src/common/logging/text_formatter.cpp b/src/common/logging/text_formatter.cpp
index 45be6d0a..94f3dfc1 100644
--- a/src/common/logging/text_formatter.cpp
+++ b/src/common/logging/text_formatter.cpp
@@ -46,8 +46,8 @@ void FormatLogMessage(const Entry& entry, char* out_text, size_t text_len) {
unsigned int time_seconds = static_cast<unsigned int>(entry.timestamp.count() / 1000000);
unsigned int time_fractional = static_cast<unsigned int>(entry.timestamp.count() % 1000000);
- const char* class_name = Logger::GetLogClassName(entry.log_class);
- const char* level_name = Logger::GetLevelName(entry.log_level);
+ const char* class_name = GetLogClassName(entry.log_class);
+ const char* level_name = GetLevelName(entry.log_level);
snprintf(out_text, text_len, "[%4u.%06u] %s <%s> %s: %s",
time_seconds, time_fractional, class_name, level_name,
@@ -116,19 +116,4 @@ void PrintColoredMessage(const Entry& entry) {
#endif
}
-void TextLoggingLoop(std::shared_ptr<Logger> logger) {
- std::array<Entry, 256> entry_buffer;
-
- while (true) {
- size_t num_entries = logger->GetEntries(entry_buffer.data(), entry_buffer.size());
- if (num_entries == Logger::QUEUE_CLOSED) {
- break;
- }
- for (size_t i = 0; i < num_entries; ++i) {
- const Entry& entry = entry_buffer[i];
- PrintColoredMessage(entry);
- }
- }
-}
-
}
diff --git a/src/common/logging/text_formatter.h b/src/common/logging/text_formatter.h
index 8474a190..5b82f043 100644
--- a/src/common/logging/text_formatter.h
+++ b/src/common/logging/text_formatter.h
@@ -5,11 +5,9 @@
#pragma once
#include <cstddef>
-#include <memory>
namespace Log {
-class Logger;
struct Entry;
/**
@@ -31,10 +29,4 @@ void PrintMessage(const Entry& entry);
/// Prints the same message as `PrintMessage`, but colored acoording to the severity level.
void PrintColoredMessage(const Entry& entry);
-/**
- * Logging loop that repeatedly reads messages from the provided logger and prints them to the
- * console. It is the baseline barebones log outputter.
- */
-void TextLoggingLoop(std::shared_ptr<Logger> logger);
-
}
diff --git a/src/common/math_util.cpp b/src/common/math_util.cpp
deleted file mode 100644
index bcb70cae..00000000
--- a/src/common/math_util.cpp
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <cstring>
-#include <numeric> // Necessary on OS X, but not Linux
-
-#include "common/common_types.h"
-#include "common/math_util.h"
-
-namespace MathUtil
-{
-
-u32 ClassifyDouble(double dvalue)
-{
- // TODO: Optimize the below to be as fast as possible.
- IntDouble value;
- value.d = dvalue;
- u64 sign = value.i & DOUBLE_SIGN;
- u64 exp = value.i & DOUBLE_EXP;
- if (exp > DOUBLE_ZERO && exp < DOUBLE_EXP)
- {
- // Nice normalized number.
- return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;
- }
- else
- {
- u64 mantissa = value.i & DOUBLE_FRAC;
- if (mantissa)
- {
- if (exp)
- {
- return PPC_FPCLASS_QNAN;
- }
- else
- {
- // Denormalized number.
- return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;
- }
- }
- else if (exp)
- {
- //Infinite
- return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;
- }
- else
- {
- //Zero
- return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ;
- }
- }
-}
-
-u32 ClassifyFloat(float fvalue)
-{
- // TODO: Optimize the below to be as fast as possible.
- IntFloat value;
- value.f = fvalue;
- u32 sign = value.i & FLOAT_SIGN;
- u32 exp = value.i & FLOAT_EXP;
- if (exp > FLOAT_ZERO && exp < FLOAT_EXP)
- {
- // Nice normalized number.
- return sign ? PPC_FPCLASS_NN : PPC_FPCLASS_PN;
- }
- else
- {
- u32 mantissa = value.i & FLOAT_FRAC;
- if (mantissa)
- {
- if (exp)
- {
- return PPC_FPCLASS_QNAN; // Quiet NAN
- }
- else
- {
- // Denormalized number.
- return sign ? PPC_FPCLASS_ND : PPC_FPCLASS_PD;
- }
- }
- else if (exp)
- {
- // Infinite
- return sign ? PPC_FPCLASS_NINF : PPC_FPCLASS_PINF;
- }
- else
- {
- //Zero
- return sign ? PPC_FPCLASS_NZ : PPC_FPCLASS_PZ;
- }
- }
-}
-
-
-} // namespace
-
-inline void MatrixMul(int n, const float *a, const float *b, float *result)
-{
- for (int i = 0; i < n; ++i)
- {
- for (int j = 0; j < n; ++j)
- {
- float temp = 0;
- for (int k = 0; k < n; ++k)
- {
- temp += a[i * n + k] * b[k * n + j];
- }
- result[i * n + j] = temp;
- }
- }
-}
-
-// Calculate sum of a float list
-float MathFloatVectorSum(const std::vector<float>& Vec)
-{
- return std::accumulate(Vec.begin(), Vec.end(), 0.0f);
-}
-
-void Matrix33::LoadIdentity(Matrix33 &mtx)
-{
- memset(mtx.data, 0, sizeof(mtx.data));
- mtx.data[0] = 1.0f;
- mtx.data[4] = 1.0f;
- mtx.data[8] = 1.0f;
-}
-
-void Matrix33::RotateX(Matrix33 &mtx, float rad)
-{
- float s = sin(rad);
- float c = cos(rad);
- memset(mtx.data, 0, sizeof(mtx.data));
- mtx.data[0] = 1;
- mtx.data[4] = c;
- mtx.data[5] = -s;
- mtx.data[7] = s;
- mtx.data[8] = c;
-}
-void Matrix33::RotateY(Matrix33 &mtx, float rad)
-{
- float s = sin(rad);
- float c = cos(rad);
- memset(mtx.data, 0, sizeof(mtx.data));
- mtx.data[0] = c;
- mtx.data[2] = s;
- mtx.data[4] = 1;
- mtx.data[6] = -s;
- mtx.data[8] = c;
-}
-
-void Matrix33::Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result)
-{
- MatrixMul(3, a.data, b.data, result.data);
-}
-
-void Matrix33::Multiply(const Matrix33 &a, const float vec[3], float result[3])
-{
- for (int i = 0; i < 3; ++i) {
- result[i] = 0;
- for (int k = 0; k < 3; ++k) {
- result[i] += a.data[i * 3 + k] * vec[k];
- }
- }
-}
-
-void Matrix44::LoadIdentity(Matrix44 &mtx)
-{
- memset(mtx.data, 0, sizeof(mtx.data));
- mtx.data[0] = 1.0f;
- mtx.data[5] = 1.0f;
- mtx.data[10] = 1.0f;
- mtx.data[15] = 1.0f;
-}
-
-void Matrix44::LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33)
-{
- for (int i = 0; i < 3; ++i)
- {
- for (int j = 0; j < 3; ++j)
- {
- mtx.data[i * 4 + j] = m33.data[i * 3 + j];
- }
- }
-
- for (int i = 0; i < 3; ++i)
- {
- mtx.data[i * 4 + 3] = 0;
- mtx.data[i + 12] = 0;
- }
- mtx.data[15] = 1.0f;
-}
-
-void Matrix44::Set(Matrix44 &mtx, const float mtxArray[16])
-{
- for(int i = 0; i < 16; ++i) {
- mtx.data[i] = mtxArray[i];
- }
-}
-
-void Matrix44::Translate(Matrix44 &mtx, const float vec[3])
-{
- LoadIdentity(mtx);
- mtx.data[3] = vec[0];
- mtx.data[7] = vec[1];
- mtx.data[11] = vec[2];
-}
-
-void Matrix44::Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result)
-{
- MatrixMul(4, a.data, b.data, result.data);
-}
-
diff --git a/src/common/math_util.h b/src/common/math_util.h
index 52f579cf..0b1400b4 100644
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -4,11 +4,9 @@
#pragma once
-#include "common/common_types.h"
-
#include <algorithm>
+#include <cstdlib>
#include <type_traits>
-#include <vector>
namespace MathUtil
{
@@ -19,83 +17,6 @@ inline T Clamp(const T val, const T& min, const T& max)
return std::max(min, std::min(max, val));
}
-static const u64 DOUBLE_SIGN = 0x8000000000000000ULL,
- DOUBLE_EXP = 0x7FF0000000000000ULL,
- DOUBLE_FRAC = 0x000FFFFFFFFFFFFFULL,
- DOUBLE_ZERO = 0x0000000000000000ULL;
-
-static const u32 FLOAT_SIGN = 0x80000000,
- FLOAT_EXP = 0x7F800000,
- FLOAT_FRAC = 0x007FFFFF,
- FLOAT_ZERO = 0x00000000;
-
-union IntDouble {
- double d;
- u64 i;
-};
-union IntFloat {
- float f;
- u32 i;
-};
-
-inline bool IsNAN(double d)
-{
- IntDouble x; x.d = d;
- return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
- ((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) );
-}
-
-inline bool IsQNAN(double d)
-{
- IntDouble x; x.d = d;
- return ( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
- ((x.i & 0x0007fffffffffffULL) == 0x000000000000000ULL) &&
- ((x.i & 0x000800000000000ULL) == 0x000800000000000ULL) );
-}
-
-inline bool IsSNAN(double d)
-{
- IntDouble x; x.d = d;
- return( ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
- ((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) &&
- ((x.i & 0x0008000000000000ULL) == DOUBLE_ZERO) );
-}
-
-inline float FlushToZero(float f)
-{
- IntFloat x; x.f = f;
- if ((x.i & FLOAT_EXP) == 0)
- x.i &= FLOAT_SIGN; // turn into signed zero
- return x.f;
-}
-
-inline double FlushToZeroAsFloat(double d)
-{
- IntDouble x; x.d = d;
- if ((x.i & DOUBLE_EXP) < 0x3800000000000000ULL)
- x.i &= DOUBLE_SIGN; // turn into signed zero
- return x.d;
-}
-
-enum PPCFpClass
-{
- PPC_FPCLASS_QNAN = 0x11,
- PPC_FPCLASS_NINF = 0x9,
- PPC_FPCLASS_NN = 0x8,
- PPC_FPCLASS_ND = 0x18,
- PPC_FPCLASS_NZ = 0x12,
- PPC_FPCLASS_PZ = 0x2,
- PPC_FPCLASS_PD = 0x14,
- PPC_FPCLASS_PN = 0x4,
- PPC_FPCLASS_PINF = 0x5,
-};
-
-// Uses PowerPC conventions for the return value, so it can be easily
-// used directly in CPU emulation.
-u32 ClassifyDouble(double dvalue);
-// More efficient float version.
-u32 ClassifyFloat(float fvalue);
-
template<class T>
struct Rectangle
{
@@ -104,101 +25,12 @@ struct Rectangle
T right;
T bottom;
- Rectangle()
- { }
+ Rectangle() {}
- Rectangle(T theLeft, T theTop, T theRight, T theBottom)
- : left(theLeft), top(theTop), right(theRight), bottom(theBottom)
- { }
-
- bool operator==(const Rectangle& r) { return left==r.left && top==r.top && right==r.right && bottom==r.bottom; }
+ Rectangle(T left, T top, T right, T bottom) : left(left), top(top), right(right), bottom(bottom) {}
T GetWidth() const { return std::abs(static_cast<typename std::make_signed<T>::type>(right - left)); }
T GetHeight() const { return std::abs(static_cast<typename std::make_signed<T>::type>(bottom - top)); }
-
- // If the rectangle is in a coordinate system with a lower-left origin, use
- // this Clamp.
- void ClampLL(T x1, T y1, T x2, T y2)
- {
- if (left < x1) left = x1;
- if (right > x2) right = x2;
- if (top > y1) top = y1;
- if (bottom < y2) bottom = y2;
- }
-
- // If the rectangle is in a coordinate system with an upper-left origin,
- // use this Clamp.
- void ClampUL(T x1, T y1, T x2, T y2)
- {
- if (left < x1) left = x1;
- if (right > x2) right = x2;
- if (top < y1) top = y1;
- if (bottom > y2) bottom = y2;
- }
};
} // namespace MathUtil
-
-inline float pow2f(float x) {return x * x;}
-inline double pow2(double x) {return x * x;}
-
-float MathFloatVectorSum(const std::vector<float>&);
-
-#define ROUND_UP(x, a) (((x) + (a) - 1) & ~((a) - 1))
-#define ROUND_DOWN(x, a) ((x) & ~((a) - 1))
-
-// Rounds down. 0 -> undefined
-inline u64 Log2(u64 val)
-{
-#if defined(__GNUC__)
- return 63 - __builtin_clzll(val);
-
-#elif defined(_MSC_VER) && defined(_M_X64)
- unsigned long result = -1;
- _BitScanReverse64(&result, val);
- return result;
-
-#else
- u64 result = -1;
- while (val != 0)
- {
- val >>= 1;
- ++result;
- }
- return result;
-#endif
-}
-
-// Tiny matrix/vector library.
-// Used for things like Free-Look in the gfx backend.
-
-class Matrix33
-{
-public:
- static void LoadIdentity(Matrix33 &mtx);
-
- // set mtx to be a rotation matrix around the x axis
- static void RotateX(Matrix33 &mtx, float rad);
- // set mtx to be a rotation matrix around the y axis
- static void RotateY(Matrix33 &mtx, float rad);
-
- // set result = a x b
- static void Multiply(const Matrix33 &a, const Matrix33 &b, Matrix33 &result);
- static void Multiply(const Matrix33 &a, const float vec[3], float result[3]);
-
- float data[9];
-};
-
-class Matrix44
-{
-public:
- static void LoadIdentity(Matrix44 &mtx);
- static void LoadMatrix33(Matrix44 &mtx, const Matrix33 &m33);
- static void Set(Matrix44 &mtx, const float mtxArray[16]);
-
- static void Translate(Matrix44 &mtx, const float vec[3]);
-
- static void Multiply(const Matrix44 &a, const Matrix44 &b, Matrix44 &result);
-
- float data[16];
-};
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-27 09:02:51 +0000