You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
141 lines
5.3 KiB
141 lines
5.3 KiB
/*
|
|
*
|
|
* Copyright 2017, The Android Open Source Project
|
|
*
|
|
* 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 ANDROID_TYPED_LOGGER_H
|
|
#define ANDROID_TYPED_LOGGER_H
|
|
|
|
// This is the client API for the typed logger.
|
|
|
|
#include <media/nblog/NBLog.h>
|
|
#include <algorithm>
|
|
|
|
/*
|
|
Fowler-Noll-Vo (FNV-1a) hash function for the file name.
|
|
Hashes at compile time. FNV-1a iterative function:
|
|
|
|
hash = offset_basis
|
|
for each byte to be hashed
|
|
hash = hash xor byte
|
|
hash = hash * FNV_prime
|
|
return hash
|
|
|
|
offset_basis and FNV_prime values depend on the size of the hash output
|
|
Following values are defined by FNV and should not be changed arbitrarily
|
|
*/
|
|
|
|
template<typename T>
|
|
constexpr T offset_basis();
|
|
|
|
template<typename T>
|
|
constexpr T FNV_prime();
|
|
|
|
template<>
|
|
constexpr uint32_t offset_basis<uint32_t>() {
|
|
return 2166136261u;
|
|
}
|
|
|
|
template<>
|
|
constexpr uint32_t FNV_prime<uint32_t>() {
|
|
return 16777619u;
|
|
}
|
|
|
|
template<>
|
|
constexpr uint64_t offset_basis<uint64_t>() {
|
|
return 14695981039346656037ull;
|
|
}
|
|
|
|
template<>
|
|
constexpr uint64_t FNV_prime<uint64_t>() {
|
|
return 1099511628211ull;
|
|
}
|
|
|
|
template <typename T, size_t n>
|
|
__attribute__((no_sanitize("unsigned-integer-overflow")))
|
|
constexpr T fnv1a(const char (&file)[n], ssize_t i = (ssize_t)n - 1) {
|
|
return i == -1 ? offset_basis<T>() : (fnv1a<T>(file, i - 1) ^ file[i]) * FNV_prime<T>();
|
|
}
|
|
|
|
template <size_t n>
|
|
constexpr uint64_t hash(const char (&file)[n], uint32_t line) {
|
|
// Line numbers over or equal to 2^16 are clamped to 2^16 - 1. This way increases collisions
|
|
// compared to wrapping around, but is easy to identify because it doesn't produce aliasing.
|
|
// It's a very unlikely case anyways.
|
|
return ((fnv1a<uint64_t>(file) << 16) ^ ((fnv1a<uint64_t>(file) >> 32) & 0xFFFF0000)) |
|
|
std::min(line, 0xFFFFu);
|
|
}
|
|
|
|
// TODO Permit disabling of logging at compile-time.
|
|
|
|
// TODO A non-nullptr dummy implementation that is a nop would be faster than checking for nullptr
|
|
// in the case when logging is enabled at compile-time and enabled at runtime, but it might be
|
|
// slower than nullptr check when logging is enabled at compile-time and disabled at runtime.
|
|
|
|
// Write formatted entry to log
|
|
#define LOGT(fmt, ...) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->logFormat((fmt), hash(__FILE__, __LINE__), ##__VA_ARGS__); } \
|
|
while (0)
|
|
|
|
// Write histogram timestamp entry
|
|
#define LOG_HIST_TS() do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->logEventHistTs(NBLog::EVENT_HISTOGRAM_ENTRY_TS, hash(__FILE__, __LINE__)); } while(0)
|
|
|
|
// Record that audio was turned on/off
|
|
#define LOG_AUDIO_STATE() do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->logEventHistTs(NBLog::EVENT_AUDIO_STATE, hash(__FILE__, __LINE__)); } while(0)
|
|
|
|
// Log the difference bewteen frames presented by HAL and frames written to HAL output sink,
|
|
// divided by the sample rate. Parameter ms is of type double.
|
|
#define LOG_LATENCY(ms) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->log<NBLog::EVENT_LATENCY>(ms); } while (0)
|
|
|
|
// Record thread overrun event nanosecond timestamp. Parameter ns is an int64_t.
|
|
#define LOG_OVERRUN(ns) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->log<NBLog::EVENT_OVERRUN>(ns); } while (0)
|
|
|
|
// Record thread info. This currently includes type, frameCount, and sampleRate.
|
|
// Parameter type is thread_info_t as defined in NBLog.h.
|
|
#define LOG_THREAD_INFO(info) do { NBLog::Writer *x = tlNBLogWriter; \
|
|
if (x != nullptr) x->log<NBLog::EVENT_THREAD_INFO>(info); } while (0)
|
|
|
|
#define LOG_THREAD_PARAMS(params) do {NBLog::Writer *x = tlNBLogWriter; \
|
|
if (x != nullptr) x->log<NBLog::EVENT_THREAD_PARAMS>(params); } while (0)
|
|
|
|
// Record thread underrun event nanosecond timestamp. Parameter ns is an int64_t.
|
|
#define LOG_UNDERRUN(ns) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->log<NBLog::EVENT_UNDERRUN>(ns); } while (0)
|
|
|
|
// Record thread warmup time in milliseconds. Parameter ms is of type double.
|
|
#define LOG_WARMUP_TIME(ms) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->log<NBLog::EVENT_WARMUP_TIME>(ms); } while (0)
|
|
|
|
// Record a typed entry that represents a thread's work time in nanoseconds.
|
|
// Parameter ns should be of type uint32_t.
|
|
#define LOG_WORK_TIME(ns) do { NBLog::Writer *x = tlNBLogWriter; if (x != nullptr) \
|
|
x->log<NBLog::EVENT_WORK_TIME>(ns); } while (0)
|
|
|
|
namespace android {
|
|
extern "C" {
|
|
// TODO consider adding a thread_local NBLog::Writer tlDummyNBLogWriter and then
|
|
// initialize below tlNBLogWriter to &tlDummyNBLogWriter to remove the need to
|
|
// check for nullptr every time. Also reduces the need to add a new logging macro above
|
|
// each time we want to log a new type.
|
|
extern thread_local NBLog::Writer *tlNBLogWriter;
|
|
}
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_TYPED_LOGGER_H
|