From 5e9a2b11b248aaa2f6f353bbcf9f600d65bcaf51 Mon Sep 17 00:00:00 2001 From: Jose Fonseca Date: Thu, 5 May 2016 15:20:03 +0100 Subject: trace: Move the rest of common to lib/trace. Renaming the library to something else is left to another change, as there's already a trace lib in the wrappers dir. --- lib/CMakeLists.txt | 1 + lib/trace/CMakeLists.txt | 37 ++ lib/trace/trace_api.hpp | 56 ++ lib/trace/trace_callset.cpp | 264 +++++++++ lib/trace/trace_callset.hpp | 195 +++++++ lib/trace/trace_dump.cpp | 327 +++++++++++ lib/trace/trace_dump.hpp | 76 +++ lib/trace/trace_dump_internal.hpp | 81 +++ lib/trace/trace_fast_callset.cpp | 210 +++++++ lib/trace/trace_fast_callset.hpp | 140 +++++ lib/trace/trace_file.cpp | 60 ++ lib/trace/trace_file.hpp | 169 ++++++ lib/trace/trace_file_brotli.cpp | 150 +++++ lib/trace/trace_file_read.cpp | 70 +++ lib/trace/trace_file_snappy.cpp | 353 +++++++++++ lib/trace/trace_file_zlib.cpp | 144 +++++ lib/trace/trace_format.hpp | 83 +++ lib/trace/trace_lookup.hpp | 109 ++++ lib/trace/trace_model.cpp | 301 ++++++++++ lib/trace/trace_model.hpp | 593 +++++++++++++++++++ lib/trace/trace_option.cpp | 62 ++ lib/trace/trace_option.hpp | 38 ++ lib/trace/trace_ostream.hpp | 52 ++ lib/trace/trace_ostream_snappy.cpp | 207 +++++++ lib/trace/trace_ostream_zlib.cpp | 93 +++ lib/trace/trace_parser.cpp | 1039 +++++++++++++++++++++++++++++++++ lib/trace/trace_parser.hpp | 248 ++++++++ lib/trace/trace_parser_flags.cpp | 550 +++++++++++++++++ lib/trace/trace_parser_flags_test.cpp | 644 ++++++++++++++++++++ lib/trace/trace_parser_loop.cpp | 111 ++++ lib/trace/trace_profiler.cpp | 259 ++++++++ lib/trace/trace_profiler.hpp | 143 +++++ lib/trace/trace_snappy.hpp | 34 ++ lib/trace/trace_writer.cpp | 372 ++++++++++++ lib/trace/trace_writer.hpp | 116 ++++ lib/trace/trace_writer_local.cpp | 287 +++++++++ lib/trace/trace_writer_local.hpp | 121 ++++ lib/trace/trace_writer_model.cpp | 149 +++++ 38 files changed, 7944 insertions(+) create mode 100644 lib/trace/CMakeLists.txt create mode 100644 lib/trace/trace_api.hpp create mode 100644 lib/trace/trace_callset.cpp create mode 100644 lib/trace/trace_callset.hpp create mode 100644 lib/trace/trace_dump.cpp create mode 100644 lib/trace/trace_dump.hpp create mode 100644 lib/trace/trace_dump_internal.hpp create mode 100644 lib/trace/trace_fast_callset.cpp create mode 100644 lib/trace/trace_fast_callset.hpp create mode 100644 lib/trace/trace_file.cpp create mode 100644 lib/trace/trace_file.hpp create mode 100644 lib/trace/trace_file_brotli.cpp create mode 100644 lib/trace/trace_file_read.cpp create mode 100644 lib/trace/trace_file_snappy.cpp create mode 100644 lib/trace/trace_file_zlib.cpp create mode 100644 lib/trace/trace_format.hpp create mode 100644 lib/trace/trace_lookup.hpp create mode 100644 lib/trace/trace_model.cpp create mode 100644 lib/trace/trace_model.hpp create mode 100644 lib/trace/trace_option.cpp create mode 100644 lib/trace/trace_option.hpp create mode 100644 lib/trace/trace_ostream.hpp create mode 100644 lib/trace/trace_ostream_snappy.cpp create mode 100644 lib/trace/trace_ostream_zlib.cpp create mode 100644 lib/trace/trace_parser.cpp create mode 100644 lib/trace/trace_parser.hpp create mode 100644 lib/trace/trace_parser_flags.cpp create mode 100644 lib/trace/trace_parser_flags_test.cpp create mode 100644 lib/trace/trace_parser_loop.cpp create mode 100644 lib/trace/trace_profiler.cpp create mode 100644 lib/trace/trace_profiler.hpp create mode 100644 lib/trace/trace_snappy.hpp create mode 100644 lib/trace/trace_writer.cpp create mode 100644 lib/trace/trace_writer.hpp create mode 100644 lib/trace/trace_writer_local.cpp create mode 100644 lib/trace/trace_writer_local.hpp create mode 100644 lib/trace/trace_writer_model.cpp (limited to 'lib') diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 23be7605..be8a4454 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -2,3 +2,4 @@ add_subdirectory (os) add_subdirectory (highlight) add_subdirectory (guids) add_subdirectory (image) +add_subdirectory (trace) diff --git a/lib/trace/CMakeLists.txt b/lib/trace/CMakeLists.txt new file mode 100644 index 00000000..a3615616 --- /dev/null +++ b/lib/trace/CMakeLists.txt @@ -0,0 +1,37 @@ +include_directories ( + ${CMAKE_SOURCE_DIR}/lib/guids + ${CMAKE_SOURCE_DIR}/lib/highlight + ${CMAKE_SOURCE_DIR}/thirdparty +) + +add_convenience_library (common + trace_callset.cpp + trace_dump.cpp + trace_fast_callset.cpp + trace_file.cpp + trace_file_read.cpp + trace_file_zlib.cpp + trace_file_brotli.cpp + trace_file_snappy.cpp + trace_model.cpp + trace_parser.cpp + trace_parser_flags.cpp + trace_parser_loop.cpp + trace_writer.cpp + trace_writer_local.cpp + trace_writer_model.cpp + trace_profiler.cpp + trace_option.cpp + trace_ostream_snappy.cpp + trace_ostream_zlib.cpp +) + +target_link_libraries (common + guids + highlight + os + brotli_dec_bundled +) + +add_gtest (trace_parser_flags_test trace_parser_flags_test.cpp) +target_link_libraries (trace_parser_flags_test common) diff --git a/lib/trace/trace_api.hpp b/lib/trace/trace_api.hpp new file mode 100644 index 00000000..3b119f8e --- /dev/null +++ b/lib/trace/trace_api.hpp @@ -0,0 +1,56 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#pragma once + + +#include + +#include "os_string.hpp" + + +namespace trace { + + +/** + * Enum to distuinguish the API for tools. + * + * It should never be embedded in the trace file. + */ +enum API { + API_UNKNOWN = 0, + API_GL, // GL + GLX/WGL/CGL + API_EGL, // GL/GLES1/GLES2/VG + EGL + API_DX, // All DirectX + API_D3D7, + API_D3D8, + API_D3D9, + API_DXGI, // D3D10.x, D3D11.x + API_D2D1, // Direct2D +}; + + +} /* namespace trace */ + diff --git a/lib/trace/trace_callset.cpp b/lib/trace/trace_callset.cpp new file mode 100644 index 00000000..28cbf24c --- /dev/null +++ b/lib/trace/trace_callset.cpp @@ -0,0 +1,264 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include +#include + +#include +#include +#include + +#include + +using namespace trace; + + +// Parser class for call sets +class CallSetParser +{ + CallSet &set; + +protected: + char lookahead; + + CallSetParser(CallSet &_set) : + set(_set), + lookahead(0) + {} + +public: + void parse() { + skipWhiteSpace(); + while (lookahead) { + assert(!isSpace()); + parseRange(); + // skip any comma + isOperator(','); + } + } + +private: + void parseRange() { + CallNo start = std::numeric_limits::min(); + CallNo stop = std::numeric_limits::max(); + CallNo step = 1; + CallFlags freq = FREQUENCY_ALL; + if (isAlpha()) { + freq = parseFrequency(); + } else { + if (isOperator('*')) { + // no-change + } else { + start = parseCallNo(); + if (isOperator('-')) { + if (isDigit()) { + stop = parseCallNo(); + } else { + // no-change + } + } else { + stop = start; + } + } + if (isOperator('/')) { + if (isDigit()) { + step = parseCallNo(); + } else { + freq = parseFrequency(); + } + } + } + set.addRange(CallRange(start, stop, step, freq)); + } + + // match and consume an operator + bool isOperator(char c) { + if (lookahead == c) { + consume(); + skipWhiteSpace(); + return true; + } else { + return false; + } + } + + CallNo parseCallNo() { + CallNo number = 0; + if (isDigit()) { + do { + CallNo digit = consume() - '0'; + number = number * 10 + digit; + } while (isDigit()); + } else { + std::cerr << "error: expected digit, found '" << lookahead << "'\n"; + exit(0); + } + skipWhiteSpace(); + return number; + } + + CallFlags parseFrequency() { + std::string freq; + if (isAlpha()) { + do { + freq.push_back(consume()); + } while (isAlpha()); + } else { + std::cerr << "error: expected frequency, found '" << lookahead << "'\n"; + exit(0); + } + skipWhiteSpace(); + if (freq == "frame") { + return FREQUENCY_FRAME; + } else if (freq == "rendertarget" || freq == "fbo") { + return FREQUENCY_RENDERTARGET; + } else if (freq == "render" || freq == "draw") { + return FREQUENCY_RENDER; + } else { + std::cerr << "error: expected frequency, found '" << freq << "'\n"; + exit(0); + return FREQUENCY_NONE; + } + } + + // match lookahead with a digit (does not consume) + bool isDigit() const { + return lookahead >= '0' && lookahead <= '9'; + } + + bool isAlpha() const { + return lookahead >= 'a' && lookahead <= 'z'; + } + + void skipWhiteSpace() { + while (isSpace()) { + consume(); + } + } + + bool isSpace() const { + return lookahead == ' ' || + lookahead == '\t' || + lookahead == '\r' || + lookahead == '\n'; + } + + virtual char consume() = 0; +}; + + +class StringCallSetParser : public CallSetParser +{ + const char *buf; + +public: + StringCallSetParser(CallSet &_set, const char *_buf) : + CallSetParser(_set), + buf(_buf) + { + lookahead = *buf; + } + + char consume() override { + char c = lookahead; + if (lookahead) { + ++buf; + lookahead = *buf; + } + return c; + } +}; + + +class FileCallSetParser : public CallSetParser +{ + std::ifstream stream; + +public: + FileCallSetParser(CallSet &_set, const char *filename) : + CallSetParser(_set) + { + stream.open(filename); + if (!stream.is_open()) { + std::cerr << "error: failed to open \"" << filename << "\"\n"; + exit(1); + } + + stream.get(lookahead); + } + + char consume() override { + char c = lookahead; + if (stream.eof()) { + lookahead = 0; + } else { + stream.get(lookahead); + } + return c; + } +}; + + +void +CallSet::merge(const char *string) +{ + if (firstmerge) { + if (!empty()) { + *this = CallSet(); + } + firstmerge = false; + } + + /* + * Parse a comma-separated list of files or ranges + */ + std::stringstream calls_arg(string); + std::string token; + const char *str; + + while (std::getline(calls_arg, token, ',')) { + str = token.c_str(); + if (str[0] == '@') { + FileCallSetParser parser(*this, &str[1]); + parser.parse(); + } else { + StringCallSetParser parser(*this, str); + parser.parse(); + } + } +} + + +CallSet::CallSet(CallFlags freq): limits(std::numeric_limits::min(), std::numeric_limits::max()), firstmerge(true) { + if (freq != FREQUENCY_NONE) { + CallNo start = std::numeric_limits::min(); + CallNo stop = std::numeric_limits::max(); + CallNo step = 1; + addRange(CallRange(start, stop, step, freq)); + assert(!empty()); + } +} + diff --git a/lib/trace/trace_callset.hpp b/lib/trace/trace_callset.hpp new file mode 100644 index 00000000..4070a4b8 --- /dev/null +++ b/lib/trace/trace_callset.hpp @@ -0,0 +1,195 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Representation of call sets. + * + * Grammar: + * + * set = '@' filename + * | range ( ',' ? range ) * + * + * range = interval ( '/' frequency ) + * + * interval = '*' + * | number + * | start_number '-' end_number + * + * frequency = divisor + * | "frame" + * | "rendertarget" | "fbo" + * | "render | "draw" + * + */ + +#pragma once + + +#include +#include + +#include "trace_model.hpp" +#include "trace_fast_callset.hpp" + +namespace trace { + + // Aliases for call flags + enum { + FREQUENCY_NONE = 0, + FREQUENCY_FRAME = CALL_FLAG_END_FRAME, + FREQUENCY_RENDERTARGET = CALL_FLAG_END_FRAME | CALL_FLAG_SWAP_RENDERTARGET, + FREQUENCY_RENDER = CALL_FLAG_RENDER, + FREQUENCY_ALL = 0xffffffff + }; + + // A linear range of calls + class CallRange + { + public: + CallNo start; + CallNo stop; + CallNo step; + CallFlags freq; + + CallRange(CallNo callNo) : + start(callNo), + stop(callNo), + step(1), + freq(FREQUENCY_ALL) + {} + + CallRange(CallNo _start, CallNo _stop, CallNo _step = 1, CallFlags _freq = FREQUENCY_ALL) : + start(_start), + stop(_stop), + step(_step), + freq(_freq) + {} + + bool + contains(CallNo callNo, CallFlags callFlags) const { + return callNo >= start && + callNo <= stop && + ((callNo - start) % step) == 0 && + ((callFlags & freq) || + freq == FREQUENCY_ALL); + } + }; + + + // A collection of call ranges + class CallSet + { + private: + CallRange limits; + bool firstmerge; + + public: + FastCallSet fast_call_set; + + // TODO: use binary tree to speed up lookups, (less important + // now that we are using FastCallSet for ranges without step + // or freq). + typedef std::list< CallRange > RangeList; + RangeList ranges; + + CallSet(): limits(std::numeric_limits::min(), std::numeric_limits::max()), firstmerge(true) {} + + CallSet(CallFlags freq); + + void + merge(const char *str); + + // Not empty set + inline bool + empty() const { + return fast_call_set.empty() && ranges.empty(); + } + + void + addRange(const CallRange & range) { + if (range.start <= range.stop && + range.freq != FREQUENCY_NONE) { + + if (empty()) { + limits.start = range.start; + limits.stop = range.stop; + } else { + if (range.start < limits.start) + limits.start = range.start; + if (range.stop > limits.stop) + limits.stop = range.stop; + } + + /* Optimize by using fast_call_set whenever possible */ + if (range.step == 1 && range.freq == FREQUENCY_ALL) { + fast_call_set.add(range.start, range.stop); + } else { + RangeList::iterator it = ranges.begin(); + while (it != ranges.end() && it->start < range.start) { + ++it; + } + + ranges.insert(it, range); + } + } + } + + inline bool + contains(CallNo callNo, CallFlags callFlags = FREQUENCY_ALL) const { + if (empty()) { + return false; + } + if (fast_call_set.contains(callNo)) + return true; + RangeList::const_iterator it; + for (it = ranges.begin(); it != ranges.end() && it->start <= callNo; ++it) { + if (it->contains(callNo, callFlags)) { + return true; + } + } + return false; + } + + inline bool + contains(const trace::Call &call) { + return contains(call.no, call.flags); + } + + CallNo getFirst() { + return limits.start; + } + + CallNo getLast() { + return limits.stop; + } + }; + + + CallSet parse(const char *string); + + +} /* namespace trace */ + + diff --git a/lib/trace/trace_dump.cpp b/lib/trace/trace_dump.cpp new file mode 100644 index 00000000..6b73c930 --- /dev/null +++ b/lib/trace/trace_dump.cpp @@ -0,0 +1,327 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_dump_internal.hpp" + +#include + +#include +#include + +#include "highlight.hpp" +#include "guids.hpp" + + +namespace trace { + + +Dumper::Dumper(std::ostream &_os, DumpFlags _flags) : + os(_os), + dumpFlags(_flags), + highlighter(highlight::defaultHighlighter(!(dumpFlags & DUMP_FLAG_NO_COLOR))), + normal(highlighter.normal()), + bold(highlighter.bold()), + italic(highlighter.italic()), + strike(highlighter.strike()), + red(highlighter.color(highlight::RED)), + pointer(highlighter.color(highlight::GREEN)), + literal(highlighter.color(highlight::BLUE)) +{ +} + +Dumper::~Dumper() { +} + +void Dumper::visit(Null *) { + os << literal << "NULL" << normal; +} + +void Dumper::visit(Bool *node) { + os << literal << (node->value ? "true" : "false") << normal; +} + +void Dumper::visit(SInt *node) { + os << literal << node->value << normal; +} + +void Dumper::visit(UInt *node) { + os << literal << node->value << normal; +} + +void Dumper::visit(Float *node) { + std::streamsize oldPrecision = os.precision(std::numeric_limits::digits10 + 1); + os << literal << node->value << normal; + os.precision(oldPrecision); +} + +void Dumper::visit(Double *node) { + std::streamsize oldPrecision = os.precision(std::numeric_limits::digits10 + 1); + os << literal << node->value << normal; + os.precision(oldPrecision); +} + +template< typename C > +void Dumper::visitString(const C *value) { + os << literal << "\""; + for (const C *it = value; *it; ++it) { + unsigned c = (unsigned) *it; + if (c == '\"') + os << "\\\""; + else if (c == '\\') + os << "\\\\"; + else if (c >= 0x20 && c <= 0x7e) + os << (char)c; + else if (c == '\t') { + os << "\t"; + } else if (c == '\r') { + // Ignore carriage-return + } else if (c == '\n') { + if (dumpFlags & DUMP_FLAG_NO_MULTILINE) { + os << "\\n"; + } else { + // Reset formatting so that it looks correct with 'less -R' + os << normal << '\n' << literal; + } + } else { + // FIXME: handle wchar_t octals properly + unsigned octal0 = c & 0x7; + unsigned octal1 = (c >> 3) & 0x7; + unsigned octal2 = (c >> 3) & 0x7; + os << "\\"; + if (octal2) + os << octal2; + if (octal1) + os << octal1; + os << octal0; + } + } + os << "\"" << normal; +} + +void Dumper::visit(String *node) { + visitString(node->value); +} + +void Dumper::visit(WString *node) { + os << literal << "L"; + visitString(node->value); +} + +void Dumper::visit(Enum *node) { + const EnumValue *it = node->lookup(); + if (it) { + os << literal << it->name << normal; + return; + } + os << literal << node->value << normal; +} + +void Dumper::visit(Bitmask *bitmask) { + unsigned long long value = bitmask->value; + const BitmaskSig *sig = bitmask->sig; + bool first = true; + for (const BitmaskFlag *it = sig->flags; it != sig->flags + sig->num_flags; ++it) { + assert(it->value || first); + if ((it->value && (value & it->value) == it->value) || + (!it->value && value == 0)) { + if (!first) { + os << " | "; + } + os << literal << it->name << normal; + value &= ~it->value; + first = false; + } + if (value == 0) { + break; + } + } + if (value || first) { + if (!first) { + os << " | "; + } + os << literal << "0x" << std::hex << value << std::dec << normal; + } +} + +const char * +Dumper::visitMembers(Struct *s, const char *sep) { + for (unsigned i = 0; i < s->members.size(); ++i) { + const char *memberName = s->sig->member_names[i]; + Value *memberValue = s->members[i]; + + if (!memberName || !*memberName) { + // Anonymous structure + Struct *memberStruct = memberValue->toStruct(); + assert(memberStruct); + if (memberStruct) { + sep = visitMembers(memberStruct, sep); + continue; + } + } + + os << sep << italic << memberName << normal << " = ", + _visit(memberValue); + sep = ", "; + } + return sep; +} + +void Dumper::visit(Struct *s) { + // Replace GUIDs with their symbolic name + // TODO: Move this to parsing, so it can be shared everywhere + if (s->members.size() == 4 && + strcmp(s->sig->name, "GUID") == 0) { + GUID guid; + guid.Data1 = s->members[0]->toUInt(); + guid.Data2 = s->members[1]->toUInt(); + guid.Data3 = s->members[2]->toUInt(); + Array *data4 = s->members[3]->toArray(); + assert(data4); + assert(data4->values.size() == 8); + for (int i = 0; i < sizeof guid.Data4; ++i) { + guid.Data4[i] = data4->values[i]->toUInt(); + } + const char *name = getGuidName(guid); + os << literal << name << normal; + return; + } + + os << "{"; + visitMembers(s); + os << "}"; +} + +void Dumper::visit(Array *array) { + if (array->values.size() == 1) { + os << "&"; + _visit(array->values[0]); + } + else { + const char *sep = ""; + os << "{"; + for (auto & value : array->values) { + os << sep; + _visit(value); + sep = ", "; + } + os << "}"; + } +} + +void Dumper::visit(Blob *blob) { + os << pointer << "blob(" << blob->size << ")" << normal; +} + +void Dumper::visit(Pointer *p) { + os << pointer << "0x" << std::hex << p->value << std::dec << normal; +} + +void Dumper::visit(Repr *r) { + _visit(r->humanValue); +} + +void Dumper::visit(StackFrame *frame) { + frame->dump(os); +} + +void Dumper::visit(Backtrace & backtrace) { + for (auto & frame : backtrace) { + visit(frame); + os << "\n"; + } +} + +void Dumper::visit(Call *call) { + CallFlags callFlags = call->flags; + + if (!(dumpFlags & DUMP_FLAG_NO_CALL_NO)) { + os << call->no << " "; + } + if (dumpFlags & DUMP_FLAG_THREAD_IDS) { + os << "@" << std::hex << call->thread_id << std::dec << " "; + } + + if (callFlags & CALL_FLAG_NON_REPRODUCIBLE) { + os << strike; + } else if (callFlags & (CALL_FLAG_FAKE | CALL_FLAG_NO_SIDE_EFFECTS)) { + os << normal; + } else { + os << bold; + } + os << call->sig->name << normal; + + os << "("; + const char *sep = ""; + for (unsigned i = 0; i < call->args.size(); ++i) { + os << sep; + if (!(dumpFlags & DUMP_FLAG_NO_ARG_NAMES)) { + os << italic << call->sig->arg_names[i] << normal << " = "; + } + if (call->args[i].value) { + _visit(call->args[i].value); + } else { + os << "?"; + } + sep = ", "; + } + os << ")"; + + if (call->ret) { + os << " = "; + _visit(call->ret); + } + + if (callFlags & CALL_FLAG_INCOMPLETE) { + os << " // " << red << "incomplete" << normal; + } + + if (!(dumpFlags & DUMP_FLAG_NO_MULTILINE)) { + os << "\n"; + + if (call->backtrace != NULL) { + os << bold << red << "Backtrace:\n" << normal; + visit(*call->backtrace); + } + if (callFlags & CALL_FLAG_END_FRAME) { + os << "\n"; + } + } +} + + +void dump(Value *value, std::ostream &os, DumpFlags flags) { + Dumper d(os, flags); + value->visit(d); +} + + +void dump(Call &call, std::ostream &os, DumpFlags flags) { + Dumper d(os, flags); + d.visit(&call); +} + + +} /* namespace trace */ diff --git a/lib/trace/trace_dump.hpp b/lib/trace/trace_dump.hpp new file mode 100644 index 00000000..4c756ca4 --- /dev/null +++ b/lib/trace/trace_dump.hpp @@ -0,0 +1,76 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Human-readible dumping. + */ + +#pragma once + + +#include + +#include "trace_model.hpp" + + +namespace trace { + + +typedef unsigned DumpFlags; + +enum { + DUMP_FLAG_NO_COLOR = (1 << 0), + DUMP_FLAG_NO_ARG_NAMES = (1 << 1), + DUMP_FLAG_NO_CALL_NO = (1 << 2), + DUMP_FLAG_THREAD_IDS = (1 << 3), + DUMP_FLAG_NO_MULTILINE = (1 << 4), +}; + + +void dump(Value *value, std::ostream &os, DumpFlags flags = 0); + + +inline std::ostream & +operator << (std::ostream &os, Value & value) { + dump(& value, os); + return os; +} + + +std::ostream & +operator << (std::ostream &os, Value *value); + + +void dump(Call &call, std::ostream &os, DumpFlags flags = 0); + + +inline std::ostream & operator <<(std::ostream &os, Call &call) { + dump(call, os); + return os; +} + + +} /* namespace trace */ + diff --git a/lib/trace/trace_dump_internal.hpp b/lib/trace/trace_dump_internal.hpp new file mode 100644 index 00000000..26ce10a9 --- /dev/null +++ b/lib/trace/trace_dump_internal.hpp @@ -0,0 +1,81 @@ +/************************************************************************** + * + * Copyright 2010-2016 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#pragma once + +#include "highlight.hpp" +#include "trace_dump.hpp" + + +namespace trace { + + +class Dumper : public Visitor +{ +protected: + std::ostream &os; + DumpFlags dumpFlags; + const highlight::Highlighter & highlighter; + const highlight::Attribute & normal; + const highlight::Attribute & bold; + const highlight::Attribute & italic; + const highlight::Attribute & strike; + const highlight::Attribute & red; + const highlight::Attribute & pointer; + const highlight::Attribute & literal; + +public: + Dumper(std::ostream &_os, DumpFlags _flags); + ~Dumper(); + + virtual void visit(Null *) override; + virtual void visit(Bool *node) override; + virtual void visit(SInt *node) override; + virtual void visit(UInt *node) override; + virtual void visit(Float *node) override; + virtual void visit(Double *node) override; + + template< typename C > + void visitString(const C *value); + virtual void visit(String *node) override; + virtual void visit(WString *node) override; + virtual void visit(Enum *node) override; + virtual void visit(Bitmask *bitmask) override; + virtual const char * + visitMembers(Struct *s, const char *sep = ""); + virtual void visit(Struct *s) override; + virtual void visit(Array *array) override; + virtual void visit(Blob *blob) override; + virtual void visit(Pointer *p) override; + virtual void visit(Repr *r) override; + virtual void visit(StackFrame *frame); + virtual void visit(Backtrace & backtrace); + virtual void visit(Call *call); +}; + + +} /* namespace trace */ + diff --git a/lib/trace/trace_fast_callset.cpp b/lib/trace/trace_fast_callset.cpp new file mode 100644 index 00000000..2ac5343a --- /dev/null +++ b/lib/trace/trace_fast_callset.cpp @@ -0,0 +1,210 @@ +/********************************************************************* + * + * Copyright 2006 Keith Packard and Carl Worth + * Copyright 2012 Intel Corporation + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + *********************************************************************/ + +#include +#include +#include +#include + +#include "os.hpp" +#include "trace_fast_callset.hpp" + +using namespace trace; + +#define MAX_LEVEL 16 + +FastCallRange::FastCallRange(CallNo first, CallNo last, int level) +: ref_counter(0) +{ + this->first = first; + this->last = last; + this->level = level; + + next.resize(level, 0); +} + +bool +FastCallRange::contains(CallNo call_no) const +{ + return (first <= call_no && last >= call_no); +} + +bool +FastCallSet::empty(void) const +{ + return max_level == 0; +} + +FastCallSet::FastCallSet(): head(0, 0, MAX_LEVEL) +{ + head.first = std::numeric_limits::max(); + head.last = std::numeric_limits::min(); + + max_level = 0; +} + +/* + * Generate a random level number, distributed + * so that each level is 1/4 as likely as the one before + * + * Note that level numbers run 1 <= level < MAX_LEVEL + */ +static int +random_level (void) +{ + /* tricky bit -- each bit is '1' 75% of the time */ + long int bits = os::random() | os::random(); + int level = 1; + + while (level < MAX_LEVEL) + { + if (bits & 1) + break; + level++; + bits >>= 1; + } + + return level; +} + +void +FastCallSet::add(CallNo first, CallNo last) +{ + std::vector update (MAX_LEVEL); + FastCallRange *node; + FastCallRangePtr new_node; + int i, level; + + /* Find node immediately before insertion point. + * NOTE: FastCallRangePtr(), e.g., next[i](), returns FastCallRange* */ + node = &head; // Can't reference &head as a FastCallRangePtr + for (i = max_level - 1; i >= 0; i--) { + while (node->next[i]() && first > node->next[i]->last) { + node = node->next[i](); + } + update[i] = &node->next[i]; + } + + /* Can we contain first by expanding tail of current range by 1? */ + if (node != &head && node->last == first - 1) { + + new_node = FastCallRangePtr(node); + new_node->last = last; + goto MERGE_NODE_WITH_SUBSEQUENT_COVERED_NODES; + + } + + /* Current range could not contain first, look at next. */ + node = node->next[0](); + + if (node) { + /* Do nothing if new range is already entirely contained. */ + if (node->first <= first && node->last >= last) { + return; + } + + /* If last is already included, we can simply expand + * node->first to fully include the range. */ + if (node->first <= last && node->last >= last) { + node->first = first; + return; + } + + /* This is our candidate node if first is contained */ + if (node->first <= first && node->last >= first) { + new_node = FastCallRangePtr(node); + new_node->last = last; + goto MERGE_NODE_WITH_SUBSEQUENT_COVERED_NODES; + } + } + + /* Not possible to expand any existing node, so create a new one. */ + + level = random_level(); + + /* Handle first node of this level. */ + if (level > max_level) { + level = max_level + 1; + update[max_level] = &head.next[max_level]; + max_level = level; + } + + new_node = FastCallRangePtr(new FastCallRange(first, last, level)); + + /* Perform insertion into all lists. */ + for (i = 0; i < level; i++) { + new_node->next[i] = *update[i]; + *update[i] = new_node; + } + +MERGE_NODE_WITH_SUBSEQUENT_COVERED_NODES: + FastCallRangePtr next = new_node->next[0]; + node = new_node(); + while (next() && next->first <= node->last + 1) { + if (next->last > node->last) + node->last = next->last; + + for (i = 0; i < node->level && i < next->level; i++) { + node->next[i] = next->next[i]; + } + + for (; i < next->level; i++) { + *update[i] = next->next[i]; + } + + next = node->next[0]; + } +} + +void +FastCallSet::add(CallNo call_no) +{ + this->add(call_no, call_no); +} + +bool +FastCallSet::contains(CallNo call_no) const +{ + FastCallRange *node; + int i; + + node = const_cast(&head); + for (i = max_level - 1; i >= 0; i--) { + while (node->next[i]() && call_no > node->next[i]->last) { + node = node->next[i](); + } + } + + node = node->next[0](); + + if (node == NULL) + return false; + + return node->contains(call_no); +} diff --git a/lib/trace/trace_fast_callset.hpp b/lib/trace/trace_fast_callset.hpp new file mode 100644 index 00000000..55d507df --- /dev/null +++ b/lib/trace/trace_fast_callset.hpp @@ -0,0 +1,140 @@ +/********************************************************************* + * + * Copyright 2012 Intel Corporation + * Copyright 2012 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + *********************************************************************/ + +#pragma once + +#include "trace_model.hpp" + +namespace trace { + +/* A set of call numbers. + * + * This was originally designed as a more efficient replacement for + * std::set which was used heavily within the trim code's + * TraceAnalyzer. This is quite similar to the trace::CallSet with the + * following differences: + * + * Simplifications: + * + * * There is no support here for the 'step' and 'freq' features + * supported by trace::CallSet. + * + * Sophistications: + * + * * This callset is implemented with a skip list for + * (probabilistically) logarithmic lookup times for + * out-of-order lookups. + * + * * This callset optimizes the addition of new calls which are + * within or adjacent to existing ranges, (by either doing + * nothing, expanding the limits of an existing range, or also + * merging two or more ranges). + * + * It would not be impossible to extend this code to support the + * missing features of trace::CallSet, (though the 'step' and 'freq' + * features would prevent some range-extending and merging + * optimizations in some cases). + */ + +class FastCallRangePtr; + +class FastCallRange { +public: + CallNo first; + CallNo last; + int level; + std::vector next; + + // (NOTE: Initalize ref_counter to 0 in all constructors) + FastCallRange(CallNo first, CallNo last, int level); + + bool contains(CallNo call_no) const; + +private: + friend class FastCallRangePtr; + size_t ref_counter; + // ref_counter must be initialized to 0 by all constructors + // ref_counter is the number of FastCallRangePtr objects that point at this +}; + +class FastCallRangePtr { +public: + FastCallRange* operator-> () { return this->ptr; } + FastCallRange& operator * () { return *this->ptr; } + FastCallRange* operator ()() { return this->ptr; } // get pointer + + + FastCallRangePtr () : ptr(0) {} + FastCallRangePtr(FastCallRange* _ptr) : ptr(_ptr) + { if (this->ptr) ++this->ptr->ref_counter; } + + ~FastCallRangePtr() { if (this->ptr) + if (--this->ptr->ref_counter == 0) + delete this->ptr; + } + + FastCallRangePtr(FastCallRangePtr const& _ptr) : ptr(_ptr.ptr) + { if (this->ptr) ++this->ptr->ref_counter; } + + FastCallRangePtr& operator= (FastCallRangePtr const& new_ptr) + { // DO NOT CHANGE THE ORDER OF THESE STATEMENTS! + // (This order properly handles self-assignment) + // (This order also properly handles recursion, e.g., + // if a FastCallRange contains FastCallRangePtrs) + FastCallRange* const old_ptr = this->ptr; + this->ptr = new_ptr.ptr; + if (this->ptr) + ++this->ptr->ref_counter; + if (old_ptr) { + if (--old_ptr->ref_counter == 0) + delete old_ptr; + } + return *this; + } +private: + FastCallRange* ptr; +}; + +class FastCallSet { +public: + FastCallRange head; + int max_level; + + FastCallSet(); + + bool empty(void) const; + + void add(CallNo first, CallNo last); + + void add(CallNo call_no); + + bool contains(CallNo call_no) const; +}; + +} /* namespace trace */ + diff --git a/lib/trace/trace_file.cpp b/lib/trace/trace_file.cpp new file mode 100644 index 00000000..ffe4983d --- /dev/null +++ b/lib/trace/trace_file.cpp @@ -0,0 +1,60 @@ +/************************************************************************** + * + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_file.hpp" + +#include + + +using namespace trace; + + +File::File(void) +{ +} + +File::~File() +{ + // We can't invoke any overriden virtual method here anymore + assert(!m_isOpened); +} + + +bool File::supportsOffsets(void) const +{ + return false; +} + +File::Offset File::currentOffset(void) const +{ + return 0; +} + +void File::setCurrentOffset(const File::Offset &offset) +{ + assert(0); +} + diff --git a/lib/trace/trace_file.hpp b/lib/trace/trace_file.hpp new file mode 100644 index 00000000..26b525c3 --- /dev/null +++ b/lib/trace/trace_file.hpp @@ -0,0 +1,169 @@ +/************************************************************************** + * + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#pragma once + +#include +#include + + +namespace trace { + +class File { +public: + struct Offset { + Offset(uint64_t _chunk = 0, uint32_t _offsetInChunk = 0) + : chunk(_chunk), + offsetInChunk(_offsetInChunk) + {} + uint64_t chunk; + uint32_t offsetInChunk; + }; + +public: + static File *createZLib(void); + static File *createBrotli(void); + static File *createSnappy(void); + static File *createForRead(const char *filename); +public: + File(void); + virtual ~File(); + + bool isOpened(void) const; + + bool open(const char *filename); + size_t read(void *buffer, size_t length); + void close(void); + int getc(void); + bool skip(size_t length); + int percentRead(void); + + virtual bool supportsOffsets(void) const; + virtual File::Offset currentOffset(void) const; + virtual void setCurrentOffset(const File::Offset &offset); +protected: + virtual bool rawOpen(const char *filename) = 0; + virtual size_t rawRead(void *buffer, size_t length) = 0; + virtual int rawGetc(void) = 0; + virtual void rawClose(void) = 0; + virtual bool rawSkip(size_t length) = 0; + virtual int rawPercentRead(void) = 0; + +protected: + bool m_isOpened = false; +}; + +inline bool File::isOpened(void) const +{ + return m_isOpened; +} + +inline bool File::open(const char *filename) +{ + if (m_isOpened) { + close(); + } + m_isOpened = rawOpen(filename); + + return m_isOpened; +} + +inline size_t File::read(void *buffer, size_t length) +{ + if (!m_isOpened) { + return 0; + } + return rawRead(buffer, length); +} + +inline int File::percentRead(void) +{ + if (!m_isOpened) { + return 0; + } + return rawPercentRead(); +} + +inline void File::close(void) +{ + if (m_isOpened) { + rawClose(); + m_isOpened = false; + } +} + +inline int File::getc(void) +{ + if (!m_isOpened) { + return -1; + } + return rawGetc(); +} + +inline bool File::skip(size_t length) +{ + if (!m_isOpened) { + return false; + } + return rawSkip(length); +} + + +inline bool +operator<(const File::Offset &one, const File::Offset &two) +{ + return one.chunk < two.chunk || + (one.chunk == two.chunk && one.offsetInChunk < two.offsetInChunk); +} + +inline bool +operator==(const File::Offset &one, const File::Offset &two) +{ + return one.chunk == two.chunk && + one.offsetInChunk == two.offsetInChunk; +} + +inline bool +operator>=(const File::Offset &one, const File::Offset &two) +{ + return one.chunk > two.chunk || + (one.chunk == two.chunk && one.offsetInChunk >= two.offsetInChunk); +} + +inline bool +operator>(const File::Offset &one, const File::Offset &two) +{ + return two < one; +} + +inline bool +operator<=(const File::Offset &one, const File::Offset &two) +{ + return two >= one; +} + + +} /* namespace trace */ diff --git a/lib/trace/trace_file_brotli.cpp b/lib/trace/trace_file_brotli.cpp new file mode 100644 index 00000000..e99b010e --- /dev/null +++ b/lib/trace/trace_file_brotli.cpp @@ -0,0 +1,150 @@ +/************************************************************************** + * + * Copyright 2016 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_file.hpp" + + +#include +#include + +#include + +#include + +#include "os.hpp" + + +using namespace trace; + + +class BrotliFile : public File { +public: + BrotliFile(void); + virtual ~BrotliFile(); + +protected: + virtual bool rawOpen(const char *filename) override; + virtual size_t rawRead(void *buffer, size_t length) override; + virtual int rawGetc(void) override; + virtual void rawClose(void) override; + virtual bool rawSkip(size_t length) override; + virtual int rawPercentRead(void) override; +private: + BrotliState state; + std::ifstream m_stream; + static const size_t kFileBufferSize = 65536; + uint8_t input[kFileBufferSize]; + const uint8_t* next_in; + size_t available_in; +}; + +BrotliFile::BrotliFile(void) +{ + BrotliStateInit(&state); + available_in = 0; + next_in = input; +} + +BrotliFile::~BrotliFile() +{ + close(); + BrotliStateCleanup(&state); +} + +bool BrotliFile::rawOpen(const char *filename) +{ + std::ios_base::openmode fmode = std::fstream::binary + | std::fstream::in; + + m_stream.open(filename, fmode); + return m_stream.is_open(); +} + +size_t BrotliFile::rawRead(void *buffer, size_t length) +{ + uint8_t* output = (uint8_t *)buffer; + size_t total_out; + size_t available_out = length; + uint8_t* next_out = output; + + while (true) { + BrotliResult result; + result = BrotliDecompressStream(&available_in, &next_in, + &available_out, &next_out, &total_out, + &state); + if (result == BROTLI_RESULT_NEEDS_MORE_INPUT) { + if (m_stream.fail()) { + break; + } + m_stream.read((char *)input, kFileBufferSize); + available_in = kFileBufferSize; + if (m_stream.fail()) { + available_in = m_stream.gcount(); + if (!available_in) { + break; + } + } + next_in = input; + } else { + assert(result == BROTLI_RESULT_NEEDS_MORE_OUTPUT || + result == BROTLI_RESULT_SUCCESS); + break; + } + } + + assert(next_out - output <= length); + + return next_out - output; +} + +int BrotliFile::rawGetc() +{ + unsigned char c; + if (rawRead(&c, 1) != 1) { + return -1; + } + return c; +} + +void BrotliFile::rawClose() +{ + m_stream.close(); +} + +bool BrotliFile::rawSkip(size_t) +{ + return false; +} + +int BrotliFile::rawPercentRead(void) +{ + return 0; +} + + +File * File::createBrotli(void) { + return new BrotliFile; +} diff --git a/lib/trace/trace_file_read.cpp b/lib/trace/trace_file_read.cpp new file mode 100644 index 00000000..fb303aa8 --- /dev/null +++ b/lib/trace/trace_file_read.cpp @@ -0,0 +1,70 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include + +#include "os.hpp" +#include "trace_file.hpp" +#include "trace_snappy.hpp" + + +using namespace trace; + + +File * +File::createForRead(const char *filename) +{ + std::ifstream stream(filename, std::ifstream::binary | std::ifstream::in); + if (!stream.is_open()) { + os::log("error: failed to open %s\n", filename); + return NULL; + } + unsigned char byte1, byte2; + stream >> byte1; + stream >> byte2; + stream.close(); + + File *file; + if (byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2) { + file = File::createSnappy(); + } else if (byte1 == 0x1f && byte2 == 0x8b) { + file = File::createZLib(); + } else { + // XXX: Brotli has no magic header + file = File::createBrotli(); + } + if (!file) { + return NULL; + } + + if (!file->open(filename)) { + os::log("error: could not open %s for reading\n", filename); + delete file; + return NULL; + } + + return file; +} diff --git a/lib/trace/trace_file_snappy.cpp b/lib/trace/trace_file_snappy.cpp new file mode 100644 index 00000000..119e4147 --- /dev/null +++ b/lib/trace/trace_file_snappy.cpp @@ -0,0 +1,353 @@ +/************************************************************************** + * + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Snappy file format. + * ------------------- + * + * Snappy at its core is just a compressoin algorithm so we're + * creating a new file format which uses snappy compression + * to hold the trace data. + * + * The file is composed of a number of chunks, they are: + * chunk { + * uint32 - specifying the length of the compressed data + * compressed data, in little endian + * } + * File can contain any number of such chunks. + * The default size of an uncompressed chunk is specified in + * SNAPPY_CHUNK_SIZE. + * + * Note: + * Currently the default size for a a to-be-compressed data is + * 1mb, meaning that the compressed data will be <= 1mb. + * The reason it's 1mb is because it seems + * to offer a pretty good compression/disk io speed ratio + * but that might change. + * + */ + + +#include +#include + +#include +#include + +#include +#include + +#include "trace_file.hpp" +#include "trace_snappy.hpp" + + +#define SNAPPY_CHUNK_SIZE (1 * 1024 * 1024) + + + +using namespace trace; + + +class SnappyFile : public File { +public: + SnappyFile(void); + virtual ~SnappyFile(); + + virtual bool supportsOffsets(void) const override; + virtual File::Offset currentOffset(void) const override; + virtual void setCurrentOffset(const File::Offset &offset) override; +protected: + virtual bool rawOpen(const char *filename) override; + virtual size_t rawRead(void *buffer, size_t length) override; + virtual int rawGetc(void) override; + virtual void rawClose(void) override; + virtual bool rawSkip(size_t length) override; + virtual int rawPercentRead(void) override; + +private: + inline size_t usedCacheSize(void) const + { + assert(m_cachePtr >= m_cache); + return m_cachePtr - m_cache; + } + inline size_t freeCacheSize(void) const + { + assert(m_cacheSize >= usedCacheSize()); + if (m_cacheSize > 0) { + return m_cacheSize - usedCacheSize(); + } else { + return 0; + } + } + inline bool endOfData(void) const + { + return m_stream.eof() && freeCacheSize() == 0; + } + void flushWriteCache(void); + void flushReadCache(size_t skipLength = 0); + void createCache(size_t size); + size_t readCompressedLength(); +private: + std::ifstream m_stream; + size_t m_cacheMaxSize; + size_t m_cacheSize; + char *m_cache; + char *m_cachePtr; + + char *m_compressedCache; + + uint64_t m_currentChunkOffset; + std::streampos m_endPos; +}; + +SnappyFile::SnappyFile(void) + : File(), + m_cacheMaxSize(SNAPPY_CHUNK_SIZE), + m_cacheSize(m_cacheMaxSize), + m_cache(new char [m_cacheMaxSize]), + m_cachePtr(m_cache) +{ + size_t maxCompressedLength = + snappy::MaxCompressedLength(SNAPPY_CHUNK_SIZE); + m_compressedCache = new char[maxCompressedLength]; +} + +SnappyFile::~SnappyFile() +{ + close(); + delete [] m_compressedCache; + delete [] m_cache; +} + +bool SnappyFile::rawOpen(const char *filename) +{ + std::ios_base::openmode fmode = std::fstream::binary + | std::fstream::in; + + m_stream.open(filename, fmode); + + //read in the initial buffer if we're reading + if (m_stream.is_open()) { + m_stream.seekg(0, std::ios::end); + m_endPos = m_stream.tellg(); + m_stream.seekg(0, std::ios::beg); + + // read the snappy file identifier + unsigned char byte1, byte2; + m_stream >> byte1; + m_stream >> byte2; + assert(byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2); + + flushReadCache(); + } + return m_stream.is_open(); +} + +size_t SnappyFile::rawRead(void *buffer, size_t length) +{ + if (endOfData()) { + return 0; + } + + if (freeCacheSize() >= length) { + memcpy(buffer, m_cachePtr, length); + m_cachePtr += length; + } else { + size_t sizeToRead = length; + size_t offset = 0; + while (sizeToRead) { + size_t chunkSize = std::min(freeCacheSize(), sizeToRead); + offset = length - sizeToRead; + memcpy((char*)buffer + offset, m_cachePtr, chunkSize); + m_cachePtr += chunkSize; + sizeToRead -= chunkSize; + if (sizeToRead > 0) { + flushReadCache(); + } + if (!m_cacheSize) { + return length - sizeToRead; + } + } + } + + return length; +} + +int SnappyFile::rawGetc(void) +{ + unsigned char c = 0; + if (rawRead(&c, 1) != 1) + return -1; + return c; +} + +void SnappyFile::rawClose(void) +{ + m_stream.close(); + delete [] m_cache; + m_cache = NULL; + m_cachePtr = NULL; +} + +void SnappyFile::flushReadCache(size_t skipLength) +{ + //assert(m_cachePtr == m_cache + m_cacheSize); + m_currentChunkOffset = m_stream.tellg(); + size_t compressedLength; + compressedLength = readCompressedLength(); + if (!compressedLength) { + // Reached end of file + createCache(0); + return; + } + + m_stream.read((char*)m_compressedCache, compressedLength); + if (m_stream.fail()) { + std::cerr << "warning: unexpected end of file while reading trace\n"; + + compressedLength = m_stream.gcount(); + if (!snappy::GetUncompressedLength(m_compressedCache, compressedLength, + &m_cacheSize)) { + createCache(0); + return; + } + + createCache(m_cacheSize); + snappy::ByteArraySource source(m_compressedCache, compressedLength); + + snappy::UncheckedByteArraySink sink(m_cache); + m_cacheSize = snappy::UncompressAsMuchAsPossible(&source, &sink); + + return; + } + + if (!snappy::GetUncompressedLength(m_compressedCache, compressedLength, + &m_cacheSize)) { + createCache(0); + return; + } + + createCache(m_cacheSize); + if (skipLength < m_cacheSize) { + snappy::RawUncompress(m_compressedCache, compressedLength, + m_cache); + } +} + +void SnappyFile::createCache(size_t size) +{ + if (size > m_cacheMaxSize) { + do { + m_cacheMaxSize <<= 1; + } while (size > m_cacheMaxSize); + + delete [] m_cache; + m_cache = new char[size]; + m_cacheMaxSize = size; + } + + m_cachePtr = m_cache; + m_cacheSize = size; +} + +size_t SnappyFile::readCompressedLength() +{ + unsigned char buf[4]; + size_t length; + m_stream.read((char *)buf, sizeof buf); + if (m_stream.fail()) { + length = 0; + } else { + length = (size_t)buf[0]; + length |= ((size_t)buf[1] << 8); + length |= ((size_t)buf[2] << 16); + length |= ((size_t)buf[3] << 24); + } + return length; +} + +bool SnappyFile::supportsOffsets(void) const +{ + return true; +} + +File::Offset SnappyFile::currentOffset(void) const +{ + File::Offset offset; + offset.chunk = m_currentChunkOffset; + offset.offsetInChunk = m_cachePtr - m_cache; + return offset; +} + +void SnappyFile::setCurrentOffset(const File::Offset &offset) +{ + // to remove eof bit + m_stream.clear(); + // seek to the start of a chunk + m_stream.seekg(offset.chunk, std::ios::beg); + // load the chunk + flushReadCache(); + assert(m_cacheSize >= offset.offsetInChunk); + // seek within our cache to the correct location within the chunk + m_cachePtr = m_cache + offset.offsetInChunk; + +} + +bool SnappyFile::rawSkip(size_t length) +{ + if (endOfData()) { + return false; + } + + if (freeCacheSize() >= length) { + m_cachePtr += length; + } else { + size_t sizeToRead = length; + while (sizeToRead) { + size_t chunkSize = std::min(freeCacheSize(), sizeToRead); + m_cachePtr += chunkSize; + sizeToRead -= chunkSize; + if (sizeToRead > 0) { + flushReadCache(sizeToRead); + } + if (!m_cacheSize) { + break; + } + } + } + + return true; +} + +int SnappyFile::rawPercentRead(void) +{ + return int(100 * (double(m_stream.tellg()) / double(m_endPos))); +} + + +File* File::createSnappy(void) { + return new SnappyFile; +} diff --git a/lib/trace/trace_file_zlib.cpp b/lib/trace/trace_file_zlib.cpp new file mode 100644 index 00000000..f0dd4560 --- /dev/null +++ b/lib/trace/trace_file_zlib.cpp @@ -0,0 +1,144 @@ +/************************************************************************** + * + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_file.hpp" + + +#include +#include + +#include + +#include +#ifdef _WIN32 +#include +#else +#include +#include +#endif + +#include "os.hpp" + +#include + + +using namespace trace; + + +class ZLibFile : public File { +public: + ZLibFile(void); + virtual ~ZLibFile(); + +protected: + virtual bool rawOpen(const char *filename) override; + virtual size_t rawRead(void *buffer, size_t length) override; + virtual int rawGetc(void) override; + virtual void rawClose(void) override; + virtual bool rawSkip(size_t length) override; + virtual int rawPercentRead(void) override; +private: + int fd = 0; + gzFile m_gzFile = nullptr; + off_t m_endOffset = 0; +}; + +ZLibFile::ZLibFile(void) +{ +} + +ZLibFile::~ZLibFile() +{ + close(); +} + +bool ZLibFile::rawOpen(const char *filename) +{ + int flags = O_RDONLY; +#ifdef O_BINARY + flags |= O_BINARY; +#endif +#ifdef O_LARGEFILE + flags |= O_LARGEFILE; +#endif + +#ifdef _WIN32 + fd = _open(filename, flags, 0666); +#else + fd = ::open(filename, flags, 0666); +#endif + if (fd < 0) { + return false; + } + + m_gzFile = gzdopen(fd, "rb"); + + if (m_gzFile) { + //XXX: unfortunately zlib doesn't support + // SEEK_END or we could've done: + //m_endOffset = gzseek(m_gzFile, 0, SEEK_END); + //gzrewind(m_gzFile); + off_t loc = lseek(fd, 0, SEEK_CUR); + m_endOffset = lseek(fd, 0, SEEK_END); + lseek(fd, loc, SEEK_SET); + } + + return m_gzFile != NULL; +} + +size_t ZLibFile::rawRead(void *buffer, size_t length) +{ + int ret = gzread(m_gzFile, buffer, unsigned(length)); + return ret < 0 ? 0 : ret; +} + +int ZLibFile::rawGetc() +{ + return gzgetc(m_gzFile); +} + +void ZLibFile::rawClose() +{ + if (m_gzFile) { + gzclose(m_gzFile); + m_gzFile = NULL; + } +} + +bool ZLibFile::rawSkip(size_t) +{ + return false; +} + +int ZLibFile::rawPercentRead(void) +{ + return int(100 * (lseek(fd, 0, SEEK_CUR) / m_endOffset)); +} + + +File * File::createZLib(void) { + return new ZLibFile; +} diff --git a/lib/trace/trace_format.hpp b/lib/trace/trace_format.hpp new file mode 100644 index 00000000..4c6d821e --- /dev/null +++ b/lib/trace/trace_format.hpp @@ -0,0 +1,83 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Trace binary format definitions. + * + * See FORMAT.markdown for details. + */ + +#pragma once + +namespace trace { + + +#define TRACE_VERSION 5 + + +enum Event { + EVENT_ENTER = 0, + EVENT_LEAVE, +}; + +enum CallDetail { + CALL_END = 0, + CALL_ARG, + CALL_RET, + CALL_THREAD, + CALL_BACKTRACE, +}; + +enum Type { + TYPE_NULL = 0, + TYPE_FALSE, + TYPE_TRUE, + TYPE_SINT, + TYPE_UINT, + TYPE_FLOAT, + TYPE_DOUBLE, + TYPE_STRING, + TYPE_BLOB, + TYPE_ENUM, + TYPE_BITMASK, + TYPE_ARRAY, + TYPE_STRUCT, + TYPE_OPAQUE, + TYPE_REPR, + TYPE_WSTRING, +}; + +enum BacktraceDetail { + BACKTRACE_END = 0, + BACKTRACE_MODULE, + BACKTRACE_FUNCTION, + BACKTRACE_FILENAME, + BACKTRACE_LINENUMBER, + BACKTRACE_OFFSET, +}; + + +} /* namespace trace */ + diff --git a/lib/trace/trace_lookup.hpp b/lib/trace/trace_lookup.hpp new file mode 100644 index 00000000..55655027 --- /dev/null +++ b/lib/trace/trace_lookup.hpp @@ -0,0 +1,109 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Helper code for function name indexed lookup tables. + */ + +#pragma once + + +#include +#include + +#include +#include + + +namespace trace { + + +/** + * Generic type for (name, value) pairs. + */ +template< class T > +struct Entry +{ + const char *name; + T value; +}; + + +/** + * Function object which compare entries by name. + */ +template< class T > +struct EntryCompare { + inline bool + operator() (const Entry & a, const Entry & b) const { + return strcmp(a.name, b.name) < 0; + } +}; + + +/** + * Lookup the entry with the given name, . + * + * The entry table must be sorted alphabetically (the same rules used by + * strcmp). + */ +template< class T, std::size_t n > +inline const T & +entryLookup(const char *name, const Entry (& entries)[n], const T & default_) +{ + typedef const Entry * ConstIterator; + + ConstIterator first = &entries[0]; + ConstIterator last = &entries[n]; + + assert(first != last); + + Entry reference; + reference.name = name; + + EntryCompare compare; + +#ifndef NDEBUG + for (ConstIterator it = first; it != last; ++it) { + ConstIterator next = it + 1; + if (next != last && !compare(*it, *next)) { + std::cerr << "error: " << it->name << " and " << next->name << " not properly sorted\n"; + assert(0); + } + } +#endif + + first = std::lower_bound(first, last, reference, compare); + + if (first == last || compare(reference, *first)) { + return default_; + } + + return first->value; +} + + +} /* namespace trace */ + diff --git a/lib/trace/trace_model.cpp b/lib/trace/trace_model.cpp new file mode 100644 index 00000000..fbf3bdaa --- /dev/null +++ b/lib/trace/trace_model.cpp @@ -0,0 +1,301 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include +#include + +#include "trace_model.hpp" + + +namespace trace { + + +static Null null; + + +Call::~Call() { + for (auto & arg : args) { + delete arg.value; + } + + if (ret) { + delete ret; + } +} + +Value & +Call::argByName(const char *argName) { + for (unsigned i = 0; i < sig->num_args; ++i) { + if (strcmp(sig->arg_names[i], argName) == 0) { + return arg(i); + } + } + return null; +} + + +String::~String() { + delete [] value; +} + + +WString::~WString() { + delete [] value; +} + + +Struct::~Struct() { + for (auto & member : members) { + delete member; + } +} + + +Array::~Array() { + for (auto & value : values) { + delete value; + } +} + + +#define BLOB_MAX_BOUND_SIZE (1*1024*1024*1024) + +class BoundBlob { +public: + static size_t totalSize; + +private: + size_t size; + char *buf; + +public: + inline + BoundBlob(size_t _size, char *_buf) : + size(_size), + buf(_buf) + { + assert(totalSize + size >= totalSize); + totalSize += size; + } + + inline + ~BoundBlob() { + assert(totalSize >= size); + totalSize -= size; + delete [] buf; + } + + // Fake move constructor + // std::deque:push_back with move semantics was added only from c++11. + BoundBlob(const BoundBlob & other) + { + size = other.size; + buf = other.buf; + const_cast(other).size = 0; + const_cast(other).buf = 0; + } + + // Disallow assignment operator + BoundBlob& operator = (const BoundBlob &); +}; + +size_t BoundBlob::totalSize = 0; + +typedef std::deque BoundBlobQueue; +static BoundBlobQueue boundBlobQueue; + + +Blob::~Blob() { + // Blobs are often bound and referred during many calls, so we can't delete + // them here in that case. + // + // Once bound there is no way to know when they were unbound, which + // effectively means we have to leak them. But some applications + // (particularly OpenGL applications that use vertex arrays in user memory) + // we can easily exhaust all memory. So instead we maintain a queue of + // bound blobs and keep the total size bounded. + + if (!bound) { + delete [] buf; + return; + } + + while (!boundBlobQueue.empty() && + BoundBlob::totalSize + size > BLOB_MAX_BOUND_SIZE) { + boundBlobQueue.pop_front(); + } + + boundBlobQueue.push_back(BoundBlob(size, buf)); +} + +StackFrame::~StackFrame() { + if (module != NULL) { + delete [] module; + } + if (function != NULL) { + delete [] function; + } + if (filename != NULL) { + delete [] filename; + } +} + + +// bool cast +bool Null ::toBool(void) const { return false; } +bool Bool ::toBool(void) const { return value; } +bool SInt ::toBool(void) const { return value != 0; } +bool UInt ::toBool(void) const { return value != 0; } +bool Float ::toBool(void) const { return value != 0; } +bool Double ::toBool(void) const { return value != 0; } +bool String ::toBool(void) const { return true; } +bool WString::toBool(void) const { return true; } +bool Struct ::toBool(void) const { return true; } +bool Array ::toBool(void) const { return true; } +bool Blob ::toBool(void) const { return true; } +bool Pointer::toBool(void) const { return value != 0; } +bool Repr ::toBool(void) const { return static_cast(machineValue); } + + +// signed integer cast +signed long long Value ::toSInt(void) const { assert(0); return 0; } +signed long long Null ::toSInt(void) const { return 0; } +signed long long Bool ::toSInt(void) const { return static_cast(value); } +signed long long SInt ::toSInt(void) const { return value; } +signed long long UInt ::toSInt(void) const { assert(static_cast(value) >= 0); return static_cast(value); } +signed long long Float ::toSInt(void) const { return static_cast(value); } +signed long long Double ::toSInt(void) const { return static_cast(value); } +signed long long Repr ::toSInt(void) const { return machineValue->toSInt(); } + + +// unsigned integer cast +unsigned long long Value ::toUInt(void) const { assert(0); return 0; } +unsigned long long Null ::toUInt(void) const { return 0; } +unsigned long long Bool ::toUInt(void) const { return static_cast(value); } +unsigned long long SInt ::toUInt(void) const { assert(value >= 0); return static_cast(value); } +unsigned long long UInt ::toUInt(void) const { return value; } +unsigned long long Float ::toUInt(void) const { return static_cast(value); } +unsigned long long Double ::toUInt(void) const { return static_cast(value); } +unsigned long long Repr ::toUInt(void) const { return machineValue->toUInt(); } + + +// floating point cast +float Value ::toFloat(void) const { assert(0); return 0; } +float Null ::toFloat(void) const { return 0; } +float Bool ::toFloat(void) const { return static_cast(value); } +float SInt ::toFloat(void) const { return static_cast(value); } +float UInt ::toFloat(void) const { return static_cast(value); } +float Float ::toFloat(void) const { return value; } +float Double ::toFloat(void) const { return value; } +float Repr ::toFloat(void) const { return machineValue->toFloat(); } + + +// floating point cast +double Value ::toDouble(void) const { assert(0); return 0; } +double Null ::toDouble(void) const { return 0; } +double Bool ::toDouble(void) const { return static_cast(value); } +double SInt ::toDouble(void) const { return static_cast(value); } +double UInt ::toDouble(void) const { return static_cast(value); } +double Float ::toDouble(void) const { return value; } +double Double ::toDouble(void) const { return value; } +double Repr ::toDouble(void) const { return machineValue->toDouble(); } + + +// pointer cast +void * Value ::toPointer(void) const { assert(0); return NULL; } +void * Null ::toPointer(void) const { return NULL; } +void * Blob ::toPointer(void) const { return buf; } +void * Pointer::toPointer(void) const { return (void *)value; } +void * Repr ::toPointer(void) const { return machineValue->toPointer(); } + +void * Value ::toPointer(bool bind) { assert(0); return NULL; } +void * Null ::toPointer(bool bind) { return NULL; } +void * Blob ::toPointer(bool bind) { if (bind) bound = true; return buf; } +void * Pointer::toPointer(bool bind) { return (void *)value; } +void * Repr ::toPointer(bool bind) { return machineValue->toPointer(bind); } + + +// unsigned int pointer cast +unsigned long long Value ::toUIntPtr(void) const { assert(0); return 0; } +unsigned long long Null ::toUIntPtr(void) const { return 0; } +unsigned long long Pointer::toUIntPtr(void) const { return value; } +unsigned long long Repr ::toUIntPtr(void) const { return machineValue->toUIntPtr(); } + + +// string cast +const char * Value ::toString(void) const { assert(0); return NULL; } +const char * Null ::toString(void) const { return NULL; } +const char * String::toString(void) const { return value; } +const char * Repr ::toString(void) const { return machineValue->toString(); } + + +// virtual Value::visit() +void Null ::visit(Visitor &visitor) { visitor.visit(this); } +void Bool ::visit(Visitor &visitor) { visitor.visit(this); } +void SInt ::visit(Visitor &visitor) { visitor.visit(this); } +void UInt ::visit(Visitor &visitor) { visitor.visit(this); } +void Float ::visit(Visitor &visitor) { visitor.visit(this); } +void Double ::visit(Visitor &visitor) { visitor.visit(this); } +void String ::visit(Visitor &visitor) { visitor.visit(this); } +void WString::visit(Visitor &visitor) { visitor.visit(this); } +void Enum ::visit(Visitor &visitor) { visitor.visit(this); } +void Bitmask::visit(Visitor &visitor) { visitor.visit(this); } +void Struct ::visit(Visitor &visitor) { visitor.visit(this); } +void Array ::visit(Visitor &visitor) { visitor.visit(this); } +void Blob ::visit(Visitor &visitor) { visitor.visit(this); } +void Pointer::visit(Visitor &visitor) { visitor.visit(this); } +void Repr ::visit(Visitor &visitor) { visitor.visit(this); } + + +void Visitor::visit(Null *) { assert(0); } +void Visitor::visit(Bool *) { assert(0); } +void Visitor::visit(SInt *) { assert(0); } +void Visitor::visit(UInt *) { assert(0); } +void Visitor::visit(Float *) { assert(0); } +void Visitor::visit(Double *) { assert(0); } +void Visitor::visit(String *) { assert(0); } +void Visitor::visit(WString *) { assert(0); } +void Visitor::visit(Enum *node) { assert(0); } +void Visitor::visit(Bitmask *node) { visit(static_cast(node)); } +void Visitor::visit(Struct *) { assert(0); } +void Visitor::visit(Array *) { assert(0); } +void Visitor::visit(Blob *) { assert(0); } +void Visitor::visit(Pointer *) { assert(0); } +void Visitor::visit(Repr *node) { node->machineValue->visit(*this); } + + +Value & +Value::operator[] (size_t index) const { + const Array *array = toArray(); + if (array) { + if (index < array->values.size()) { + return *array->values[index]; + } + } + return null; +} + +} /* namespace trace */ diff --git a/lib/trace/trace_model.hpp b/lib/trace/trace_model.hpp new file mode 100644 index 00000000..6b224e76 --- /dev/null +++ b/lib/trace/trace_model.hpp @@ -0,0 +1,593 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Object hierarchy for describing the traces in memory. + */ + +#pragma once + + +#include +#include + +#include +#include +#include + + +namespace trace { + + +// Should match Call::no +typedef unsigned CallNo; + + +typedef unsigned Id; + + +struct FunctionSig { + Id id; + const char *name; + unsigned num_args; + const char **arg_names; +}; + + +struct StructSig { + Id id; + const char *name; + unsigned num_members; + const char **member_names; +}; + + +struct EnumValue { + const char *name; + signed long long value; +}; + + +struct EnumSig { + Id id; + unsigned num_values; + const EnumValue *values; +}; + + +struct BitmaskFlag { + const char *name; + unsigned long long value; +}; + + +struct BitmaskSig { + Id id; + unsigned num_flags; + const BitmaskFlag *flags; +}; + + +class Visitor; +class Null; +class Struct; +class Array; +class Blob; + + +class Value +{ +public: + virtual ~Value() {} + virtual void visit(Visitor &visitor) = 0; + + virtual bool toBool(void) const = 0; + virtual signed long long toSInt(void) const; + virtual unsigned long long toUInt(void) const; + virtual float toFloat(void) const; + virtual double toDouble(void) const; + + virtual void *toPointer(void) const; + virtual void *toPointer(bool bind); + virtual unsigned long long toUIntPtr(void) const; + virtual const char *toString(void) const; + + virtual const Null *toNull(void) const { return NULL; } + virtual Null *toNull(void) { return NULL; } + + virtual const Array *toArray(void) const { return NULL; } + virtual Array *toArray(void) { return NULL; } + + virtual const Struct *toStruct(void) const { return NULL; } + virtual Struct *toStruct(void) { return NULL; } + + virtual const Blob *toBlob(void) const { return NULL; } + virtual Blob *toBlob(void) { return NULL; } + + Value & operator[](size_t index) const; +}; + + +class Null : public Value +{ +public: + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void *toPointer(void) const override; + void *toPointer(bool bind) override; + unsigned long long toUIntPtr(void) const override; + const char *toString(void) const override; + void visit(Visitor &visitor) override; + + const Null *toNull(void) const override { return this; } + Null *toNull(void) override { return this; } +}; + + +class Bool : public Value +{ +public: + Bool(bool _value) : value(_value) {} + + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void visit(Visitor &visitor) override; + + bool value; +}; + + +class SInt : public Value +{ +public: + SInt(signed long long _value) : value(_value) {} + + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void visit(Visitor &visitor) override; + + signed long long value; +}; + + +class UInt : public Value +{ +public: + UInt(unsigned long long _value) : value(_value) {} + + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void visit(Visitor &visitor) override; + + unsigned long long value; +}; + + +class Float : public Value +{ +public: + Float(float _value) : value(_value) {} + + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void visit(Visitor &visitor) override; + + float value; +}; + + +class Double : public Value +{ +public: + Double(double _value) : value(_value) {} + + bool toBool(void) const override; + signed long long toSInt(void) const override; + unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + void visit(Visitor &visitor) override; + + double value; +}; + + +class String : public Value +{ +public: + String(const char * _value) : value(_value) {} + ~String(); + + bool toBool(void) const override; + const char *toString(void) const override; + void visit(Visitor &visitor) override; + + const char * value; +}; + + +class WString : public Value +{ +public: + WString(const wchar_t * _value) : value(_value) {} + ~WString(); + + bool toBool(void) const override; + void visit(Visitor &visitor) override; + + const wchar_t * value; +}; + + +class Enum : public SInt +{ +public: + Enum(const EnumSig *_sig, signed long long _value) : SInt(_value), sig(_sig) {} + + void visit(Visitor &visitor) override; + + const EnumSig *sig; + + const EnumValue * + lookup() { + // TODO: use a std::map + for (const EnumValue *it = sig->values; it != sig->values + sig->num_values; ++it) { + if (it->value == value) { + return it; + } + } + return NULL; + } +}; + + +class Bitmask : public UInt +{ +public: + Bitmask(const BitmaskSig *_sig, unsigned long long _value) : UInt(_value), sig(_sig) {} + + void visit(Visitor &visitor) override; + + const BitmaskSig *sig; +}; + + +class Struct : public Value +{ +public: + Struct(StructSig *_sig) : sig(_sig), members(_sig->num_members) { } + ~Struct(); + + bool toBool(void) const override; + void visit(Visitor &visitor) override; + + const Struct *toStruct(void) const override { return this; } + Struct *toStruct(void) override { return this; } + + const StructSig *sig; + std::vector members; +}; + + +class Array : public Value +{ +public: + Array(size_t len) : values(len) {} + ~Array(); + + bool toBool(void) const override; + void visit(Visitor &visitor) override; + + const Array *toArray(void) const override { return this; } + Array *toArray(void) override { return this; } + + std::vector values; + + inline size_t + size(void) const { + return values.size(); + } +}; + + +class Blob : public Value +{ +public: + Blob(size_t _size) { + size = _size; + buf = new char[_size]; + bound = false; + } + + ~Blob(); + + bool toBool(void) const override; + void *toPointer(void) const override; + void *toPointer(bool bind) override; + + void visit(Visitor &visitor) override; + + const Blob *toBlob(void) const override { return this; } + Blob *toBlob(void) override { return this; } + + size_t size; + char *buf; + bool bound; +}; + + +class Pointer : public UInt +{ +public: + Pointer(unsigned long long value) : UInt(value) {} + + bool toBool(void) const override; + void *toPointer(void) const override; + void *toPointer(bool bind) override; + unsigned long long toUIntPtr(void) const override; + void visit(Visitor &visitor) override; +}; + + +class Repr : public Value +{ +public: + Repr(Value *human, Value *machine) : + humanValue(human), + machineValue(machine) + {} + + /** Human-readible value */ + Value *humanValue; + + /** Machine-readible value */ + Value *machineValue; + + virtual bool toBool(void) const override; + virtual signed long long toSInt(void) const override; + virtual unsigned long long toUInt(void) const override; + virtual float toFloat(void) const override; + virtual double toDouble(void) const override; + + virtual void *toPointer(void) const override; + virtual void *toPointer(bool bind) override; + virtual unsigned long long toUIntPtr(void) const override; + virtual const char *toString(void) const override; + + void visit(Visitor &visitor) override; +}; + +struct RawStackFrame { + Id id; + const char * module; + const char * function; + const char * filename; + int linenumber; + long long offset; + RawStackFrame() : + module(0), + function(0), + filename(0), + linenumber(-1), + offset(-1) + { + } + + void dump(std::ostream &os) { + os << (this->module ? this->module : "?"); + if (this->function != NULL) { + os << ": " << this->function; + } + if (this->offset >= 0) { + os << "+0x" << std::hex << this->offset << std::dec; + } + if (this->filename != NULL) { + os << ": " << this->filename; + if (this->linenumber >= 0) { + os << ":" << this->linenumber; + } + } + } +}; + +class StackFrame : public RawStackFrame { +public: + ~StackFrame(); +}; + +typedef std::vector Backtrace; + +class Visitor +{ +public: + virtual void visit(Null *); + virtual void visit(Bool *); + virtual void visit(SInt *); + virtual void visit(UInt *); + virtual void visit(Float *); + virtual void visit(Double *); + virtual void visit(String *); + virtual void visit(WString *); + virtual void visit(Enum *); + virtual void visit(Bitmask *); + virtual void visit(Struct *); + virtual void visit(Array *); + virtual void visit(Blob *); + virtual void visit(Pointer *); + virtual void visit(Repr *); +protected: + inline void _visit(Value *value) { + if (value) { + value->visit(*this); + } + } +}; + + +typedef unsigned CallFlags; + +/** + * Call flags. + * + * TODO: It might be better to to record some of these (but not all) into the + * trace file. + */ +enum { + + /** + * Whether a call was really done by the application or not. + * + * This flag is set for fake calls -- calls not truly done by the application + * but emitted and recorded for completeness, to provide contextual information + * necessary for retracing, that would not be available through other ways. + * + * XXX: This one definetely needs to go into the trace file. + */ + CALL_FLAG_FAKE = (1 << 0), + + /** + * Whether this call should be retraced or ignored. + * + * This flag is set for calls which can't be safely replayed (due to incomplete + * information) or that have no sideffects. + * + * Some incomplete calls are unreproduceable, but not all. + */ + CALL_FLAG_NON_REPRODUCIBLE = (1 << 1), + + /** + * Whether this call has no side-effects, therefore don't need to be + * retraced. + * + * This flag is set for calls that merely query information which is not + * needed for posterior calls. + */ + CALL_FLAG_NO_SIDE_EFFECTS = (1 << 2), + + /** + * Whether this call renders into the bound rendertargets. + */ + CALL_FLAG_RENDER = (1 << 3), + + /** + * Whether this call causes render target to be swapped. + * + * This does not mark frame termination by itself -- that's solely the + * responsibility of `endOfFrame` bit. + * + * This mean that snapshots should be take prior to the call, and not + * after. + */ + CALL_FLAG_SWAP_RENDERTARGET = (1 << 4), + + /** + * Whether this call terminates a frame. + * + * XXX: This can't always be determined by the function name, so it should also + * go into the trace file eventually. + */ + CALL_FLAG_END_FRAME = (1 << 5), + + /** + * Whether this call is incomplete, i.e., it never returned. + */ + CALL_FLAG_INCOMPLETE = (1 << 6), + + /** + * Whether this call is verbose (i.e., not usually interesting). + */ + CALL_FLAG_VERBOSE = (1 << 7), + + /** + * String markers. + */ + CALL_FLAG_MARKER = (1 << 8), + CALL_FLAG_MARKER_PUSH = (1 << 9), + CALL_FLAG_MARKER_POP = (1 << 10), +}; + + +struct Arg +{ + Value *value; +}; + + +class Call +{ +public: + unsigned thread_id; + unsigned no; + const FunctionSig *sig; + std::vector args; + Value *ret; + + CallFlags flags; + Backtrace* backtrace; + + Call(const FunctionSig *_sig, const CallFlags &_flags, unsigned _thread_id) : + thread_id(_thread_id), + sig(_sig), + args(_sig->num_args), + ret(0), + flags(_flags), + backtrace(0) { + } + + ~Call(); + + inline const char * + name(void) const { + return sig->name; + } + + inline Value & + arg(unsigned index) { + assert(index < args.size()); + return *(args[index].value); + } + + Value & + argByName(const char *argName); +}; + + +} /* namespace trace */ + diff --git a/lib/trace/trace_option.cpp b/lib/trace/trace_option.cpp new file mode 100644 index 00000000..feae1496 --- /dev/null +++ b/lib/trace/trace_option.cpp @@ -0,0 +1,62 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#include "trace_option.hpp" + +#include +#include +#include + +namespace trace { + +bool +boolOption(const char *option, bool default_) { + if (!option) { + return default_; + } + if (strcmp(option, "0") == 0 || + strcmp(option, "no") == 0 || + strcmp(option, "false") == 0) { + return false; + } + if (strcmp(option, "0") == 0 || + strcmp(option, "yes") == 0 || + strcmp(option, "true") == 0) { + return true; + } + std::cerr << "error: unexpected bool " << option << "\n"; + return default_; +} + +int +intOption(const char *option, int default_) { + if (!option) { + return default_; + } + return atoi(option); +} + +} /* namespace trace */ diff --git a/lib/trace/trace_option.hpp b/lib/trace/trace_option.hpp new file mode 100644 index 00000000..f11d4658 --- /dev/null +++ b/lib/trace/trace_option.hpp @@ -0,0 +1,38 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#pragma once + +namespace trace { + +bool +boolOption(const char *option, bool default_ = true); + +int +intOption(const char *option, int default_ = 0); + +} /* namespace trace */ + diff --git a/lib/trace/trace_ostream.hpp b/lib/trace/trace_ostream.hpp new file mode 100644 index 00000000..502905b4 --- /dev/null +++ b/lib/trace/trace_ostream.hpp @@ -0,0 +1,52 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc. + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#pragma once + +#include + + +namespace trace { + + +class OutStream { +public: + virtual ~OutStream() {} + + virtual bool write(const void *buffer, size_t length) = 0; + virtual void flush(void) = 0; +}; + + +OutStream * +createSnappyStream(const char *filename); + +OutStream * +createZLibStream(const char *filename); + + +} /* namespace trace */ diff --git a/lib/trace/trace_ostream_snappy.cpp b/lib/trace/trace_ostream_snappy.cpp new file mode 100644 index 00000000..219e0934 --- /dev/null +++ b/lib/trace/trace_ostream_snappy.cpp @@ -0,0 +1,207 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_ostream.hpp" + +#include + +#include +#include + +#include + +#include "os.hpp" +#include "trace_snappy.hpp" + + +#define SNAPPY_CHUNK_SIZE (1 * 1024 * 1024) + + +using namespace trace; + + +class SnappyOutStream : public OutStream { +public: + SnappyOutStream(const char *filename); + ~SnappyOutStream(); + + SnappyOutStream(void); + bool write(const void *buffer, size_t length) override; + void flush(void) override; + bool isOpen(void) { + return m_stream.is_open(); + } + + +private: + void close(void); + + inline size_t usedCacheSize(void) const + { + assert(m_cachePtr >= m_cache); + return m_cachePtr - m_cache; + } + inline size_t freeCacheSize(void) const + { + assert(m_cacheSize >= usedCacheSize()); + if (m_cacheSize > 0) { + return m_cacheSize - usedCacheSize(); + } else { + return 0; + } + } + inline bool endOfData(void) const + { + return m_stream.eof() && freeCacheSize() == 0; + } + void flushWriteCache(void); + void createCache(size_t size); + void writeCompressedLength(size_t length); +private: + std::ofstream m_stream; + size_t m_cacheMaxSize; + size_t m_cacheSize; + char *m_cache; + char *m_cachePtr; + + char *m_compressedCache; +}; + +SnappyOutStream::SnappyOutStream(const char *filename) + : m_cacheMaxSize(SNAPPY_CHUNK_SIZE), + m_cacheSize(m_cacheMaxSize), + m_cache(new char [m_cacheMaxSize]), + m_cachePtr(m_cache) +{ + size_t maxCompressedLength = + snappy::MaxCompressedLength(SNAPPY_CHUNK_SIZE); + m_compressedCache = new char[maxCompressedLength]; + + std::ios_base::openmode fmode = std::fstream::binary + | std::fstream::out + | std::fstream::trunc; + m_stream.open(filename, fmode); + if (m_stream.is_open()) { + m_stream << SNAPPY_BYTE1; + m_stream << SNAPPY_BYTE2; + m_stream.flush(); + } +} + +SnappyOutStream::~SnappyOutStream() +{ + close(); + delete [] m_compressedCache; + delete [] m_cache; +} + +bool SnappyOutStream::write(const void *buffer, size_t length) +{ + if (freeCacheSize() > length) { + memcpy(m_cachePtr, buffer, length); + m_cachePtr += length; + } else if (freeCacheSize() == length) { + memcpy(m_cachePtr, buffer, length); + m_cachePtr += length; + flushWriteCache(); + } else { + size_t sizeToWrite = length; + + while (sizeToWrite >= freeCacheSize()) { + size_t endSize = freeCacheSize(); + size_t offset = length - sizeToWrite; + memcpy(m_cachePtr, (const char*)buffer + offset, endSize); + sizeToWrite -= endSize; + m_cachePtr += endSize; + flushWriteCache(); + } + if (sizeToWrite) { + size_t offset = length - sizeToWrite; + memcpy(m_cachePtr, (const char*)buffer + offset, sizeToWrite); + m_cachePtr += sizeToWrite; + } + } + + return true; +} + +void SnappyOutStream::close(void) +{ + flushWriteCache(); + m_stream.close(); + delete [] m_cache; + m_cache = NULL; + m_cachePtr = NULL; +} + +void SnappyOutStream::flush(void) +{ + flushWriteCache(); + m_stream.flush(); +} + +void SnappyOutStream::flushWriteCache(void) +{ + size_t inputLength = usedCacheSize(); + + if (inputLength) { + size_t compressedLength; + + ::snappy::RawCompress(m_cache, inputLength, + m_compressedCache, &compressedLength); + + writeCompressedLength(compressedLength); + m_stream.write(m_compressedCache, compressedLength); + m_cachePtr = m_cache; + } + assert(m_cachePtr == m_cache); +} + +void SnappyOutStream::writeCompressedLength(size_t length) +{ + unsigned char buf[4]; + buf[0] = length & 0xff; length >>= 8; + buf[1] = length & 0xff; length >>= 8; + buf[2] = length & 0xff; length >>= 8; + buf[3] = length & 0xff; length >>= 8; + assert(length == 0); + m_stream.write((const char *)buf, sizeof buf); +} + + +OutStream * +trace::createSnappyStream(const char *filename) +{ + SnappyOutStream *outStream = new SnappyOutStream(filename); + if (!outStream->isOpen()) { + os::log("error: could not open %s for writing\n", filename); + delete outStream; + outStream = nullptr; + } + + return outStream; +} diff --git a/lib/trace/trace_ostream_zlib.cpp b/lib/trace/trace_ostream_zlib.cpp new file mode 100644 index 00000000..a5bf04fd --- /dev/null +++ b/lib/trace/trace_ostream_zlib.cpp @@ -0,0 +1,93 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc. + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_ostream.hpp" + + +#include +#include + +#include + +#include "os.hpp" + +#include + + +using namespace trace; + + +class ZLibOutStream : public OutStream { +public: + ZLibOutStream(gzFile file); + virtual ~ZLibOutStream(); + +protected: + virtual bool write(const void *buffer, size_t length) override; + virtual void flush(void) override; +private: + gzFile m_gzFile; +}; + +ZLibOutStream::ZLibOutStream(gzFile file) + : m_gzFile(file) +{ +} + +ZLibOutStream::~ZLibOutStream() +{ + if (m_gzFile) { + gzclose(m_gzFile); + m_gzFile = nullptr; + } +} + +bool ZLibOutStream::write(const void *buffer, size_t length) +{ + return gzwrite(m_gzFile, buffer, unsigned(length)) != -1; +} + +void ZLibOutStream::flush(void) +{ + gzflush(m_gzFile, Z_SYNC_FLUSH); +} + + +OutStream * +trace::createZLibStream(const char *filename) +{ + gzFile file = gzopen(filename, "wb"); + if (!file) { + return nullptr; + } + + // Currently we only use gzip for offline compression, so aim for maximum + // compression + gzsetparams(file, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY); + + return new ZLibOutStream(file); +} diff --git a/lib/trace/trace_parser.cpp b/lib/trace/trace_parser.cpp new file mode 100644 index 00000000..7816aeb3 --- /dev/null +++ b/lib/trace/trace_parser.cpp @@ -0,0 +1,1039 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include +#include +#include + +#include "trace_file.hpp" +#include "trace_dump.hpp" +#include "trace_parser.hpp" + + +#define TRACE_VERBOSE 0 + + +namespace trace { + + +Parser::Parser() { + file = NULL; + next_call_no = 0; + version = 0; + api = API_UNKNOWN; + + glGetErrorSig = NULL; +} + + +Parser::~Parser() { + close(); +} + + +bool Parser::open(const char *filename) { + assert(!file); + file = File::createForRead(filename); + if (!file) { + return false; + } + + version = read_uint(); + if (version > TRACE_VERSION) { + std::cerr << "error: unsupported trace format version " << version << "\n"; + delete file; + file = NULL; + return false; + } + api = API_UNKNOWN; + + return true; +} + +template +inline void +deleteAll(Iter begin, Iter end) +{ + while (begin != end) { + delete *begin; + ++begin; + } +} + +template +inline void +deleteAll(Container &c) +{ + deleteAll(c.begin(), c.end()); + c.clear(); +} + +void Parser::close(void) { + if (file) { + file->close(); + delete file; + file = NULL; + } + + deleteAll(calls); + + // Delete all signature data. Signatures are mere structures which don't + // own their own memory, so we need to destroy all data we created here. + + for (auto sig : functions) { + if (sig) { + delete [] sig->name; + for (unsigned arg = 0; arg < sig->num_args; ++arg) { + delete [] sig->arg_names[arg]; + } + delete [] sig->arg_names; + delete sig; + } + } + functions.clear(); + + for (auto sig : structs) { + if (sig) { + delete [] sig->name; + for (unsigned member = 0; member < sig->num_members; ++member) { + delete [] sig->member_names[member]; + } + delete [] sig->member_names; + delete sig; + } + } + structs.clear(); + + for (auto sig : enums) { + if (sig) { + for (unsigned value = 0; value < sig->num_values; ++value) { + delete [] sig->values[value].name; + } + delete [] sig->values; + delete sig; + } + } + enums.clear(); + + for (auto sig : bitmasks) { + if (sig) { + for (unsigned flag = 0; flag < sig->num_flags; ++flag) { + delete [] sig->flags[flag].name; + } + delete [] sig->flags; + delete sig; + } + } + bitmasks.clear(); + + next_call_no = 0; +} + + +void Parser::getBookmark(ParseBookmark &bookmark) { + bookmark.offset = file->currentOffset(); + bookmark.next_call_no = next_call_no; +} + + +void Parser::setBookmark(const ParseBookmark &bookmark) { + file->setCurrentOffset(bookmark.offset); + next_call_no = bookmark.next_call_no; + + // Simply ignore all pending calls + deleteAll(calls); +} + + +Call *Parser::parse_call(Mode mode) { + do { + Call *call; + int c = read_byte(); + switch (c) { + case trace::EVENT_ENTER: +#if TRACE_VERBOSE + std::cerr << "\tENTER\n"; +#endif + parse_enter(mode); + break; + case trace::EVENT_LEAVE: +#if TRACE_VERBOSE + std::cerr << "\tLEAVE\n"; +#endif + call = parse_leave(mode); + if (call) { + adjust_call_flags(call); + return call; + } + break; + default: + std::cerr << "error: unknown event " << c << "\n"; + exit(1); + case -1: + if (!calls.empty()) { + call = calls.front(); + call->flags |= CALL_FLAG_INCOMPLETE; + calls.pop_front(); + adjust_call_flags(call); + return call; + } + return NULL; + } + } while(true); +} + + +/** + * Helper function to lookup an ID in a vector, resizing the vector if it doesn't fit. + */ +template +T *lookup(std::vector &map, size_t index) { + if (index >= map.size()) { + map.resize(index + 1); + return NULL; + } else { + return map[index]; + } +} + + +Parser::FunctionSigFlags * +Parser::parse_function_sig(void) { + size_t id = read_uint(); + + FunctionSigState *sig = lookup(functions, id); + + if (!sig) { + /* parse the signature */ + sig = new FunctionSigState; + sig->id = id; + sig->name = read_string(); + sig->num_args = read_uint(); + const char **arg_names = new const char *[sig->num_args]; + for (unsigned i = 0; i < sig->num_args; ++i) { + arg_names[i] = read_string(); + } + sig->arg_names = arg_names; + sig->flags = lookupCallFlags(sig->name); + sig->fileOffset = file->currentOffset(); + functions[id] = sig; + + /** + * Try to autodetect the API. + * + * XXX: Ideally we would allow to mix multiple APIs in a single trace, + * but as it stands today, retrace is done separately for each API. + */ + if (api == API_UNKNOWN) { + const char *n = sig->name; + if ((n[0] == 'g' && n[1] == 'l' && n[2] == 'X') || // glX* + (n[0] == 'w' && n[1] == 'g' && n[2] == 'l' && n[3] >= 'A' && n[3] <= 'Z') || // wgl[A-Z]* + (n[0] == 'C' && n[1] == 'G' && n[2] == 'L')) { // CGL* + api = trace::API_GL; + } else if (n[0] == 'e' && n[1] == 'g' && n[2] == 'l' && n[3] >= 'A' && n[3] <= 'Z') { // egl[A-Z]* + api = trace::API_EGL; + } else if ((n[0] == 'D' && + ((n[1] == 'i' && n[2] == 'r' && n[3] == 'e' && n[4] == 'c' && n[5] == 't') || // Direct* + (n[1] == '3' && n[2] == 'D'))) || // D3D* + (n[0] == 'C' && n[1] == 'r' && n[2] == 'e' && n[3] == 'a' && n[4] == 't' && n[5] == 'e')) { // Create* + api = trace::API_DX; + } else { + /* TODO */ + } + } + + /** + * Note down the signature of special functions for future reference. + * + * NOTE: If the number of comparisons increases we should move this to a + * separate function and use bisection. + */ + if (sig->num_args == 0 && + strcmp(sig->name, "glGetError") == 0) { + glGetErrorSig = sig; + } + + } else if (file->currentOffset() < sig->fileOffset) { + /* skip over the signature */ + skip_string(); /* name */ + unsigned num_args = read_uint(); + for (unsigned i = 0; i < num_args; ++i) { + skip_string(); /*arg_name*/ + } + } + + assert(sig); + return sig; +} + + +StructSig *Parser::parse_struct_sig() { + size_t id = read_uint(); + + StructSigState *sig = lookup(structs, id); + + if (!sig) { + /* parse the signature */ + sig = new StructSigState; + sig->id = id; + sig->name = read_string(); + sig->num_members = read_uint(); + const char **member_names = new const char *[sig->num_members]; + for (unsigned i = 0; i < sig->num_members; ++i) { + member_names[i] = read_string(); + } + sig->member_names = member_names; + sig->fileOffset = file->currentOffset(); + structs[id] = sig; + } else if (file->currentOffset() < sig->fileOffset) { + /* skip over the signature */ + skip_string(); /* name */ + unsigned num_members = read_uint(); + for (unsigned i = 0; i < num_members; ++i) { + skip_string(); /* member_name */ + } + } + + assert(sig); + return sig; +} + + +/* + * Old enum signatures would cover a single name/value only: + * + * enum_sig = id name value + * | id + */ +EnumSig *Parser::parse_old_enum_sig() { + size_t id = read_uint(); + + EnumSigState *sig = lookup(enums, id); + + if (!sig) { + /* parse the signature */ + sig = new EnumSigState; + sig->id = id; + sig->num_values = 1; + EnumValue *values = new EnumValue[sig->num_values]; + values->name = read_string(); + values->value = read_sint(); + sig->values = values; + sig->fileOffset = file->currentOffset(); + enums[id] = sig; + } else if (file->currentOffset() < sig->fileOffset) { + /* skip over the signature */ + skip_string(); /*name*/ + scan_value(); + } + + assert(sig); + return sig; +} + + +EnumSig *Parser::parse_enum_sig() { + size_t id = read_uint(); + + EnumSigState *sig = lookup(enums, id); + + if (!sig) { + /* parse the signature */ + sig = new EnumSigState; + sig->id = id; + sig->num_values = read_uint(); + EnumValue *values = new EnumValue[sig->num_values]; + for (EnumValue *it = values; it != values + sig->num_values; ++it) { + it->name = read_string(); + it->value = read_sint(); + } + sig->values = values; + sig->fileOffset = file->currentOffset(); + enums[id] = sig; + } else if (file->currentOffset() < sig->fileOffset) { + /* skip over the signature */ + int num_values = read_uint(); + for (int i = 0; i < num_values; ++i) { + skip_string(); /*name */ + skip_sint(); /* value */ + } + } + + assert(sig); + return sig; +} + + +BitmaskSig *Parser::parse_bitmask_sig() { + size_t id = read_uint(); + + BitmaskSigState *sig = lookup(bitmasks, id); + + if (!sig) { + /* parse the signature */ + sig = new BitmaskSigState; + sig->id = id; + sig->num_flags = read_uint(); + BitmaskFlag *flags = new BitmaskFlag[sig->num_flags]; + for (BitmaskFlag *it = flags; it != flags + sig->num_flags; ++it) { + it->name = read_string(); + it->value = read_uint(); + if (it->value == 0 && it != flags) { + std::cerr << "warning: bitmask " << it->name << " is zero but is not first flag\n"; + } + } + sig->flags = flags; + sig->fileOffset = file->currentOffset(); + bitmasks[id] = sig; + } else if (file->currentOffset() < sig->fileOffset) { + /* skip over the signature */ + int num_flags = read_uint(); + for (int i = 0; i < num_flags; ++i) { + skip_string(); /*name */ + skip_uint(); /* value */ + } + } + + assert(sig); + return sig; +} + + +void Parser::parse_enter(Mode mode) { + unsigned thread_id; + + if (version >= 4) { + thread_id = read_uint(); + } else { + thread_id = 0; + } + + FunctionSigFlags *sig = parse_function_sig(); + + Call *call = new Call(sig, sig->flags, thread_id); + + call->no = next_call_no++; + + if (parse_call_details(call, mode)) { + calls.push_back(call); + } else { + delete call; + } +} + + +Call *Parser::parse_leave(Mode mode) { + unsigned call_no = read_uint(); + Call *call = NULL; + for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) { + if ((*it)->no == call_no) { + call = *it; + calls.erase(it); + break; + } + } + if (!call) { + /* This might happen on random access, when an asynchronous call is stranded + * between two frames. We won't return this call, but we still need to skip + * over its data. + */ + const FunctionSig sig = {0, NULL, 0, NULL}; + call = new Call(&sig, 0, 0); + parse_call_details(call, SCAN); + delete call; + return NULL; + } + + if (parse_call_details(call, mode)) { + return call; + } else { + delete call; + return NULL; + } +} + + +bool Parser::parse_call_details(Call *call, Mode mode) { + do { + int c = read_byte(); + switch (c) { + case trace::CALL_END: +#if TRACE_VERBOSE + std::cerr << "\tCALL_END\n"; +#endif + return true; + case trace::CALL_ARG: +#if TRACE_VERBOSE + std::cerr << "\tCALL_ARG\n"; +#endif + parse_arg(call, mode); + break; + case trace::CALL_RET: +#if TRACE_VERBOSE + std::cerr << "\tCALL_RET\n"; +#endif + call->ret = parse_value(mode); + break; + case trace::CALL_BACKTRACE: +#if TRACE_VERBOSE + std::cerr << "\tCALL_BACKTRACE\n"; +#endif + parse_call_backtrace(call, mode); + break; + default: + std::cerr << "error: ("<name()<< ") unknown call detail " + << c << "\n"; + exit(1); + case -1: + return false; + } + } while(true); +} + +bool Parser::parse_call_backtrace(Call *call, Mode mode) { + unsigned num_frames = read_uint(); + Backtrace* backtrace = new Backtrace(num_frames); + for (unsigned i = 0; i < num_frames; ++i) { + (*backtrace)[i] = parse_backtrace_frame(mode); + } + call->backtrace = backtrace; + return true; +} + +StackFrame * Parser::parse_backtrace_frame(Mode mode) { + size_t id = read_uint(); + + StackFrameState *frame = lookup(frames, id); + + if (!frame) { + frame = new StackFrameState; + int c = read_byte(); + while (c != trace::BACKTRACE_END && + c != -1) { + switch (c) { + case trace::BACKTRACE_MODULE: + frame->module = read_string(); + break; + case trace::BACKTRACE_FUNCTION: + frame->function = read_string(); + break; + case trace::BACKTRACE_FILENAME: + frame->filename = read_string(); + break; + case trace::BACKTRACE_LINENUMBER: + frame->linenumber = read_uint(); + break; + case trace::BACKTRACE_OFFSET: + frame->offset = read_uint(); + break; + default: + std::cerr << "error: unknown backtrace detail " + << c << "\n"; + exit(1); + } + c = read_byte(); + } + + frame->fileOffset = file->currentOffset(); + frames[id] = frame; + } else if (file->currentOffset() < frame->fileOffset) { + int c = read_byte(); + while (c != trace::BACKTRACE_END && + c != -1) { + switch (c) { + case trace::BACKTRACE_MODULE: + scan_string(); + break; + case trace::BACKTRACE_FUNCTION: + scan_string(); + break; + case trace::BACKTRACE_FILENAME: + scan_string(); + break; + case trace::BACKTRACE_LINENUMBER: + scan_uint(); + break; + case trace::BACKTRACE_OFFSET: + scan_uint(); + break; + default: + std::cerr << "error: unknown backtrace detail " + << c << "\n"; + exit(1); + } + c = read_byte(); + } + } + + return frame; +} + +/** + * Make adjustments to this particular call flags. + * + * NOTE: This is called per-call so no string comparisons should be done here. + * All name comparisons should be done when the signature is parsed instead. + */ +void Parser::adjust_call_flags(Call *call) { + // Mark glGetError() = GL_NO_ERROR as verbose + if (call->sig == glGetErrorSig && + call->ret && + call->ret->toSInt() == 0) { + call->flags |= CALL_FLAG_VERBOSE; + } +} + +void Parser::parse_arg(Call *call, Mode mode) { + unsigned index = read_uint(); + Value *value = parse_value(mode); + if (value) { + if (index >= call->args.size()) { + call->args.resize(index + 1); + } + call->args[index].value = value; + } +} + + +Value *Parser::parse_value(void) { + int c; + Value *value; + c = read_byte(); + switch (c) { + case trace::TYPE_NULL: + value = new Null; + break; + case trace::TYPE_FALSE: + value = new Bool(false); + break; + case trace::TYPE_TRUE: + value = new Bool(true); + break; + case trace::TYPE_SINT: + value = parse_sint(); + break; + case trace::TYPE_UINT: + value = parse_uint(); + break; + case trace::TYPE_FLOAT: + value = parse_float(); + break; + case trace::TYPE_DOUBLE: + value = parse_double(); + break; + case trace::TYPE_STRING: + value = parse_string(); + break; + case trace::TYPE_ENUM: + value = parse_enum(); + break; + case trace::TYPE_BITMASK: + value = parse_bitmask(); + break; + case trace::TYPE_ARRAY: + value = parse_array(); + break; + case trace::TYPE_STRUCT: + value = parse_struct(); + break; + case trace::TYPE_BLOB: + value = parse_blob(); + break; + case trace::TYPE_OPAQUE: + value = parse_opaque(); + break; + case trace::TYPE_REPR: + value = parse_repr(); + break; + case trace::TYPE_WSTRING: + value = parse_wstring(); + break; + default: + std::cerr << "error: unknown type " << c << "\n"; + exit(1); + case -1: + value = NULL; + break; + } +#if TRACE_VERBOSE + if (value) { + std::cerr << "\tVALUE "; + trace::dump(value, std::cerr); + std::cerr << "\n"; + } +#endif + return value; +} + + +void Parser::scan_value(void) { + int c = read_byte(); + switch (c) { + case trace::TYPE_NULL: + case trace::TYPE_FALSE: + case trace::TYPE_TRUE: + break; + case trace::TYPE_SINT: + scan_sint(); + break; + case trace::TYPE_UINT: + scan_uint(); + break; + case trace::TYPE_FLOAT: + scan_float(); + break; + case trace::TYPE_DOUBLE: + scan_double(); + break; + case trace::TYPE_STRING: + scan_string(); + break; + case trace::TYPE_ENUM: + scan_enum(); + break; + case trace::TYPE_BITMASK: + scan_bitmask(); + break; + case trace::TYPE_ARRAY: + scan_array(); + break; + case trace::TYPE_STRUCT: + scan_struct(); + break; + case trace::TYPE_BLOB: + scan_blob(); + break; + case trace::TYPE_OPAQUE: + scan_opaque(); + break; + case trace::TYPE_REPR: + scan_repr(); + break; + case trace::TYPE_WSTRING: + scan_wstring(); + break; + default: + std::cerr << "error: unknown type " << c << "\n"; + exit(1); + case -1: + break; + } +} + + +Value *Parser::parse_sint() { + return new SInt(-(signed long long)read_uint()); +} + + +void Parser::scan_sint() { + skip_uint(); +} + + +Value *Parser::parse_uint() { + return new UInt(read_uint()); +} + + +void Parser::scan_uint() { + skip_uint(); +} + + +Value *Parser::parse_float() { + float value; + file->read(&value, sizeof value); + return new Float(value); +} + + +void Parser::scan_float() { + file->skip(sizeof(float)); +} + + +Value *Parser::parse_double() { + double value; + file->read(&value, sizeof value); + return new Double(value); +} + + +void Parser::scan_double() { + file->skip(sizeof(double)); +} + + +Value *Parser::parse_string() { + return new String(read_string()); +} + + +void Parser::scan_string() { + skip_string(); +} + + +Value *Parser::parse_enum() { + EnumSig *sig; + signed long long value; + if (version >= 3) { + sig = parse_enum_sig(); + value = read_sint(); + } else { + sig = parse_old_enum_sig(); + assert(sig->num_values == 1); + value = sig->values->value; + } + return new Enum(sig, value); +} + + +void Parser::scan_enum() { + if (version >= 3) { + parse_enum_sig(); + skip_sint(); + } else { + parse_old_enum_sig(); + } +} + + +Value *Parser::parse_bitmask() { + BitmaskSig *sig = parse_bitmask_sig(); + + unsigned long long value = read_uint(); + + return new Bitmask(sig, value); +} + + +void Parser::scan_bitmask() { + parse_bitmask_sig(); + skip_uint(); /* value */ +} + + +Value *Parser::parse_array(void) { + size_t len = read_uint(); + Array *array = new Array(len); + for (size_t i = 0; i < len; ++i) { + array->values[i] = parse_value(); + } + return array; +} + + +void Parser::scan_array(void) { + size_t len = read_uint(); + for (size_t i = 0; i < len; ++i) { + scan_value(); + } +} + + +Value *Parser::parse_blob(void) { + size_t size = read_uint(); + Blob *blob = new Blob(size); + if (size) { + file->read(blob->buf, size); + } + return blob; +} + + +void Parser::scan_blob(void) { + size_t size = read_uint(); + if (size) { + file->skip(size); + } +} + + +Value *Parser::parse_struct() { + StructSig *sig = parse_struct_sig(); + Struct *value = new Struct(sig); + + for (size_t i = 0; i < sig->num_members; ++i) { + value->members[i] = parse_value(); + } + + return value; +} + + +void Parser::scan_struct() { + StructSig *sig = parse_struct_sig(); + for (size_t i = 0; i < sig->num_members; ++i) { + scan_value(); + } +} + + +Value *Parser::parse_opaque() { + unsigned long long addr; + addr = read_uint(); + return new Pointer(addr); +} + + +void Parser::scan_opaque() { + skip_uint(); +} + + +Value *Parser::parse_repr() { + Value *humanValue = parse_value(); + Value *machineValue = parse_value(); + return new Repr(humanValue, machineValue); +} + + +void Parser::scan_repr() { + scan_value(); + scan_value(); +} + + +Value *Parser::parse_wstring() { + size_t len = read_uint(); + wchar_t * value = new wchar_t[len + 1]; + for (size_t i = 0; i < len; ++i) { + value[i] = read_uint(); + } + value[len] = 0; +#if TRACE_VERBOSE + std::cerr << "\tWSTRING \"" << value << "\"\n"; +#endif + return new WString(value); +} + + +void Parser::scan_wstring() { + size_t len = read_uint(); + for (size_t i = 0; i < len; ++i) { + skip_uint(); + } +} + + +const char * Parser::read_string(void) { + size_t len = read_uint(); + char * value = new char[len + 1]; + if (len) { + file->read(value, len); + } + value[len] = 0; +#if TRACE_VERBOSE + std::cerr << "\tSTRING \"" << value << "\"\n"; +#endif + return value; +} + + +void Parser::skip_string(void) { + size_t len = read_uint(); + file->skip(len); +} + + +/* + * For the time being, a signed int is encoded as any other value, but we here parse + * it without the extra baggage of the Value class. + */ +signed long long +Parser::read_sint(void) { + int c; + c = read_byte(); + switch (c) { + case trace::TYPE_SINT: + return -(signed long long)read_uint(); + case trace::TYPE_UINT: + return read_uint(); + default: + std::cerr << "error: unexpected type " << c << "\n"; + exit(1); + case -1: + return 0; + } +} + +void +Parser::skip_sint(void) { + skip_byte(); + skip_uint(); +} + +unsigned long long Parser::read_uint(void) { + unsigned long long value = 0; + int c; + unsigned shift = 0; + do { + c = file->getc(); + if (c == -1) { + break; + } + value |= (unsigned long long)(c & 0x7f) << shift; + shift += 7; + } while(c & 0x80); +#if TRACE_VERBOSE + std::cerr << "\tUINT " << value << "\n"; +#endif + return value; +} + + +void Parser::skip_uint(void) { + int c; + do { + c = file->getc(); + if (c == -1) { + break; + } + } while(c & 0x80); +} + + +inline int Parser::read_byte(void) { + int c = file->getc(); +#if TRACE_VERBOSE + if (c < 0) + std::cerr << "\tEOF" << "\n"; + else + std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n"; +#endif + return c; +} + + +inline void Parser::skip_byte(void) { + file->skip(1); +} + + +} /* namespace trace */ diff --git a/lib/trace/trace_parser.hpp b/lib/trace/trace_parser.hpp new file mode 100644 index 00000000..dad9f9cf --- /dev/null +++ b/lib/trace/trace_parser.hpp @@ -0,0 +1,248 @@ +/************************************************************************** + * + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#pragma once + + +#include +#include + +#include "trace_file.hpp" +#include "trace_format.hpp" +#include "trace_model.hpp" +#include "trace_api.hpp" + + +namespace trace { + + +struct ParseBookmark +{ + File::Offset offset; + unsigned next_call_no; +}; + + +// Parser interface +class AbstractParser +{ +public: + virtual ~AbstractParser() {} + virtual Call *parse_call(void) = 0; + virtual void getBookmark(ParseBookmark &bookmark) = 0; + virtual void setBookmark(const ParseBookmark &bookmark) = 0; + virtual bool open(const char *filename) = 0; + virtual void close(void) = 0; + virtual unsigned long long getVersion(void) const = 0; +}; + + +class Parser: public AbstractParser +{ +protected: + File *file; + + enum Mode { + FULL = 0, + SCAN, + SKIP + }; + + typedef std::list CallList; + CallList calls; + + struct FunctionSigFlags : public FunctionSig { + CallFlags flags; + }; + + // Helper template that extends a base signature structure, with additional + // parsing information. + template< class T > + struct SigState : public T { + // Offset in the file of where signature was defined. It is used when + // reparsing to determine whether the signature definition is to be + // expected next or not. + File::Offset fileOffset; + }; + + typedef SigState FunctionSigState; + typedef SigState StructSigState; + typedef SigState EnumSigState; + typedef SigState BitmaskSigState; + typedef SigState StackFrameState; + + typedef std::vector FunctionMap; + typedef std::vector StructMap; + typedef std::vector EnumMap; + typedef std::vector BitmaskMap; + typedef std::vector StackFrameMap; + + FunctionMap functions; + StructMap structs; + EnumMap enums; + BitmaskMap bitmasks; + StackFrameMap frames; + + FunctionSig *glGetErrorSig; + + unsigned next_call_no; + + unsigned long long version; +public: + API api; + + Parser(); + + ~Parser(); + + bool open(const char *filename) override; + + void close(void) override; + + Call *parse_call(void) override { + return parse_call(FULL); + } + + bool supportsOffsets() const + { + return file->supportsOffsets(); + } + + void getBookmark(ParseBookmark &bookmark) override; + + void setBookmark(const ParseBookmark &bookmark) override; + + unsigned long long getVersion(void) const override { + return version; + } + + int percentRead() + { + return file->percentRead(); + } + + Call *scan_call() { + return parse_call(SCAN); + } + +protected: + Call *parse_call(Mode mode); + + FunctionSigFlags *parse_function_sig(void); + StructSig *parse_struct_sig(); + EnumSig *parse_old_enum_sig(); + EnumSig *parse_enum_sig(); + BitmaskSig *parse_bitmask_sig(); + +public: + static CallFlags + lookupCallFlags(const char *name); + +protected: + Call *parse_Call(Mode mode); + + void parse_enter(Mode mode); + + Call *parse_leave(Mode mode); + + bool parse_call_details(Call *call, Mode mode); + + bool parse_call_backtrace(Call *call, Mode mode); + StackFrame * parse_backtrace_frame(Mode mode); + + void adjust_call_flags(Call *call); + + void parse_arg(Call *call, Mode mode); + + Value *parse_value(void); + void scan_value(void); + inline Value *parse_value(Mode mode) { + if (mode == FULL) { + return parse_value(); + } else { + scan_value(); + return NULL; + } + } + + Value *parse_sint(); + void scan_sint(); + + Value *parse_uint(); + void scan_uint(); + + Value *parse_float(); + void scan_float(); + + Value *parse_double(); + void scan_double(); + + Value *parse_string(); + void scan_string(); + + Value *parse_enum(); + void scan_enum(); + + Value *parse_bitmask(); + void scan_bitmask(); + + Value *parse_array(void); + void scan_array(void); + + Value *parse_blob(void); + void scan_blob(void); + + Value *parse_struct(); + void scan_struct(); + + Value *parse_opaque(); + void scan_opaque(); + + Value *parse_repr(); + void scan_repr(); + + Value *parse_wstring(); + void scan_wstring(); + + const char * read_string(void); + void skip_string(void); + + signed long long read_sint(void); + void skip_sint(void); + + unsigned long long read_uint(void); + void skip_uint(void); + + inline int read_byte(void); + inline void skip_byte(void); +}; + + +AbstractParser * +lastFrameLoopParser(AbstractParser *parser, int loopCount); + + +} /* namespace trace */ + diff --git a/lib/trace/trace_parser_flags.cpp b/lib/trace/trace_parser_flags.cpp new file mode 100644 index 00000000..69bd8376 --- /dev/null +++ b/lib/trace/trace_parser_flags.cpp @@ -0,0 +1,550 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc. + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +/* + * Label functions based on their name. + */ + + +#include "trace_parser.hpp" + +#include + +#include + +#include "trace_lookup.hpp" + + +using namespace trace; + + +/** + * Shortcut for SwapBuffers, which terminate and swap bound render buffer. + */ +#define CALL_FLAG_SWAPBUFFERS (CALL_FLAG_END_FRAME | CALL_FLAG_SWAP_RENDERTARGET) + + + +/** + * Default call flags. + */ +const CallFlags +defaultCallFlags = 0; + + +/** + * Call flags lookup table. + */ +const Entry +callFlagTable[] = { + { "CGLFlushDrawable", CALL_FLAG_END_FRAME }, + { "CGLGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "D3DPERF_BeginEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "D3DPERF_EndEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP }, + { "D3DPERF_SetMarker", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "ID3DUserDefinedAnnotation::BeginEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "ID3DUserDefinedAnnotation::EndEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP }, + { "ID3DUserDefinedAnnotation::SetMarker", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "IDirect3D8::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice2::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice2::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice8::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice8::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DDevice9::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice9::GetRenderTargetData", CALL_FLAG_END_FRAME }, + { "IDirect3DDevice9::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DDevice9Ex::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice9Ex::GetRenderTargetData", CALL_FLAG_END_FRAME }, + { "IDirect3DDevice9Ex::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9Ex::PresentEx", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9Ex::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DSwapChain9::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DSwapChain9Ex::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DViewport2::Clear", CALL_FLAG_RENDER }, + { "IDirect3DViewport3::Clear", CALL_FLAG_RENDER }, + { "IDirect3DViewport3::Clear2", CALL_FLAG_RENDER }, + { "IDirect3DViewport::Clear", CALL_FLAG_RENDER }, + { "eglGetConfigAttrib", CALL_FLAG_VERBOSE }, + { "eglGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "eglQueryString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "eglSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "eglSwapBuffersWithDamageEXT", CALL_FLAG_SWAPBUFFERS }, + { "eglSwapBuffersWithDamageKHR", CALL_FLAG_SWAPBUFFERS }, + { "glAreProgramsResidentNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glAreTexturesResident", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glAreTexturesResidentEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glBufferRegionEnabled", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageControl", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageControlARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageEnableAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageInsert", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertAMD", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertKHR", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glFrameTerminatorGREMEDY", CALL_FLAG_END_FRAME }, + { "glGetActiveAtomicCounterBufferiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveAttrib", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveAttribARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineUniformName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineUniformiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniform", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformBlockName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformBlockiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformsiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveVaryingNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetArrayObjectfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetArrayObjectivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetAttachedObjectsARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetAttachedShaders", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleanIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleani_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleanv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameteri64v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameterivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameterui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferPointerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferPointervARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferSubData", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferSubDataARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetClipPlane", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTable", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfvSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterivSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerInputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerInputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerOutputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerOutputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerStageParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionFilterEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDetailTexFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoubleIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoublei_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoublev", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetError", CALL_FLAG_NO_SIDE_EFFECTS }, // verbose will be set later for GL_NO_ERROR + { "glGetFenceivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFinalCombinerInputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFinalCombinerInputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFogFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragDataIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentLightfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentLightivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentMaterialfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentMaterialivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferAttachmentParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferAttachmentParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetGraphicsResetStatusARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHandleARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetImageTransformParameterfvHP", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetImageTransformParameterivHP", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInfoLogARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInstrumentsSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInternalformati64v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInternalformativ", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLightfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLightiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetListParameterfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetListParameterivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapAttribParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapAttribParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapControlPointsNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMaterialfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMaterialiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexEnvfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexEnvivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGendvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGenfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGenivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexLevelParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexLevelParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultisamplefv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultisamplefvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferParameterui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferSubDataEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedFramebufferAttachmentParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedFramebufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterdvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramStringEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedRenderbufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedStringARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedStringivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectBufferfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectBufferivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterivAPPLE", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectPtrLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetOcclusionQueryivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetOcclusionQueryuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterDataAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterInfoAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterStringAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCountersAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorGroupStringAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorGroupsAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPixelTexGenParameterfvSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPixelTexGenParameterivSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointerIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramBinary", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterIivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterIuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramInterfaceiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterIivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterIuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramNamedParameterdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramNamedParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramParameterdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramPipelineInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramPipelineiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceLocation", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceLocationIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStageiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStringARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStringNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramSubroutineParameteruivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryIndexediv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetRenderbufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetRenderbufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterIiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterIuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSeparableFilterEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderPrecisionFormat", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderSource", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderSourceARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSharpenTexFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glGetStringi", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glGetSynciv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexBumpParameterfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexBumpParameterivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexEnvfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexEnviv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexFilterFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGendv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGenfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGeniv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTrackMatrixivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVarying", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVaryingEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVaryingNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformIndices", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformSubroutineuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformi64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantArrayObjectfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantArrayObjectivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayIntegeri_vEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayPointeri_vEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoi64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideouivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformuivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glInsertEventMarkerEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glIsAsyncMarkerSGIX", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBufferARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBufferResidentNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabled", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabledIndexedEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabledi", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFenceAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFenceNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFramebuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFramebufferEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsList", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNameAMD", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNamedBufferResidentNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNamedStringARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsObjectBufferATI", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsOcclusionQueryNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgram", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramPipeline", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsQuery", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsQueryARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsRenderbuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsRenderbufferEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsSampler", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsShader", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsSync", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTexture", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTextureEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTransformFeedback", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTransformFeedbackNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVariantEnabledEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexArray", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexArrayAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexAttribEnabledAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glObjectLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectLabelKHR", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectPtrLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectPtrLabelKHR", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glPopDebugGroup", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPopDebugGroupKHR", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPopGroupMarkerEXT", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPushDebugGroup", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glPushDebugGroupKHR", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glPushGroupMarkerEXT", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glStringMarkerGREMEDY", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "glXGetClientString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetConfig", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDisplay", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDisplayEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDrawable", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentReadDrawable", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentReadDrawableSGI", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetFBConfigAttrib", CALL_FLAG_VERBOSE }, + { "glXGetFBConfigAttribSGIX", CALL_FLAG_VERBOSE }, + { "glXGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetProcAddressARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXIsDirect", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryExtension", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryExtensionsString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryVersion", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglDescribePixelFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetCurrentDC", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetDefaultProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetExtensionsStringARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetExtensionsStringEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetPixelFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetPixelFormatAttribivARB", CALL_FLAG_VERBOSE }, + { "wglGetPixelFormatAttribivEXT", CALL_FLAG_VERBOSE }, + { "wglGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglSwapLayerBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglSwapMultipleBuffers", CALL_FLAG_SWAPBUFFERS }, + // NOTE: New entries must be sorted alphabetically +}; + + + + + +/** + * Lookup call flags by name. + */ +CallFlags +Parser::lookupCallFlags(const char *name) +{ + using namespace std; + + if (name[0] == 'g') { + static const regex draw( + "^gl([A-Z][a-z]+)*Draw(Range|Mesh)?(Arrays|Elements)([A-Z][a-zA-Z]*)?$" + ); + + static const regex miscDraw( + "^gl(" + "CallLists?|" + "Clear|" + "End|" + "DrawPixels|" + "DrawTransformFeedback([A-Z][a-zA-Z]*)?|" + "BlitFramebuffer|" + "Rect[dfis]v?|" + "EvalMesh[0-9]+" + ")[0-9A-Z]*$" + ); + if (regex_match(name, draw) || + regex_match(name, miscDraw)) { + return CALL_FLAG_RENDER; + } + + static const regex fbo( "^glBindFramebuffer[0-9A-Z]*"); + if (regex_match(name, fbo)) { + return CALL_FLAG_SWAP_RENDERTARGET; + } + + static const regex get( + "^gl(" + "GetFloat|" + "GetInteger|" + "GetVertexAttrib|" + "GetTex(ture)?(Level)?Parameter" + ")\\w+$" + ); + if (regex_match(name, get)) { + return CALL_FLAG_NO_SIDE_EFFECTS; + } + } + + if (name[0] == 'I') { + static const regex present("^IDXGI(Decode)?SwapChain\\w*::Present\\w*$"); + static const regex draw ("^ID3D1(0Device|1DeviceContext)\\d*::(Draw\\w*|ExecuteCommandList)$"); + static const regex srt ("^ID3D1(0Device|1DeviceContext)\\d*::OMSetRenderTargets\\w*$"); + static const regex cmql ("^ID3D1[01]Device\\d*::CheckMultisampleQualityLevels$"); + + if (regex_match(name, draw)) return CALL_FLAG_RENDER; + if (regex_match(name, srt)) return CALL_FLAG_SWAP_RENDERTARGET; + if (regex_match(name, present)) return CALL_FLAG_END_FRAME /* | CALL_FLAG_SWAPBUFFERS */; + if (regex_match(name, cmql)) return CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE; + } + + return entryLookup(name, callFlagTable, defaultCallFlags); +} diff --git a/lib/trace/trace_parser_flags_test.cpp b/lib/trace/trace_parser_flags_test.cpp new file mode 100644 index 00000000..731dce1f --- /dev/null +++ b/lib/trace/trace_parser_flags_test.cpp @@ -0,0 +1,644 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_parser.hpp" + +#include "gtest/gtest.h" + +#include "trace_lookup.hpp" + +using namespace trace; + + +/** + * Shortcut for SwapBuffers, which terminate and swap bound render buffer. + */ +#define CALL_FLAG_SWAPBUFFERS (CALL_FLAG_END_FRAME | CALL_FLAG_SWAP_RENDERTARGET) + + + +/** + * Call flags lookup table. + */ +static const Entry +entries[] = { + { "CGLFlushDrawable", CALL_FLAG_END_FRAME }, + { "CGLGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "D3DPERF_BeginEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "D3DPERF_EndEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP }, + { "D3DPERF_SetMarker", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "ID3D10Device1::CheckMultisampleQualityLevels", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "ID3D10Device1::Draw", CALL_FLAG_RENDER }, + { "ID3D10Device1::DrawAuto", CALL_FLAG_RENDER }, + { "ID3D10Device1::DrawIndexed", CALL_FLAG_RENDER }, + { "ID3D10Device1::DrawIndexedInstanced", CALL_FLAG_RENDER }, + { "ID3D10Device1::DrawInstanced", CALL_FLAG_RENDER }, + { "ID3D10Device1::OMSetRenderTargets", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3D10Device::CheckMultisampleQualityLevels", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "ID3D10Device::Draw", CALL_FLAG_RENDER }, + { "ID3D10Device::DrawAuto", CALL_FLAG_RENDER }, + { "ID3D10Device::DrawIndexed", CALL_FLAG_RENDER }, + { "ID3D10Device::DrawIndexedInstanced", CALL_FLAG_RENDER }, + { "ID3D10Device::DrawInstanced", CALL_FLAG_RENDER }, + { "ID3D10Device::OMSetRenderTargets", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3D11Device::CheckMultisampleQualityLevels", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "ID3D11DeviceContext1::Draw", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawAuto", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawIndexed", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawIndexedInstanced", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawIndexedInstancedIndirect", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawInstanced", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::DrawInstancedIndirect", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::ExecuteCommandList", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext1::OMSetRenderTargets", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3D11DeviceContext1::OMSetRenderTargetsAndUnorderedAccessViews", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3D11DeviceContext::Draw", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawAuto", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawIndexed", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawIndexedInstanced", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawIndexedInstancedIndirect", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawInstanced", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::DrawInstancedIndirect", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::ExecuteCommandList", CALL_FLAG_RENDER }, + { "ID3D11DeviceContext::OMSetRenderTargets", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3D11DeviceContext::OMSetRenderTargetsAndUnorderedAccessViews", CALL_FLAG_SWAP_RENDERTARGET }, + { "ID3DUserDefinedAnnotation::BeginEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "ID3DUserDefinedAnnotation::EndEvent", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP }, + { "ID3DUserDefinedAnnotation::SetMarker", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "IDXGIDecodeSwapChain::PresentBuffer", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChain1::Present", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChain1::Present1", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChain2::Present", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChain2::Present1", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChain::Present", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDXGISwapChainDWM::Present", CALL_FLAG_END_FRAME /* CALL_FLAG_SWAPBUFFERS */ }, + { "IDirect3D8::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D8::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::CheckDeviceFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::EnumAdapterModes", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::GetAdapterModeCount", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3D9Ex::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice2::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice2::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawIndexedPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice3::DrawPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawIndexedPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitiveStrided", CALL_FLAG_RENDER }, + { "IDirect3DDevice7::DrawPrimitiveVB", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice8::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice8::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice8::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DDevice9::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice9::GetRenderTargetData", CALL_FLAG_END_FRAME }, + { "IDirect3DDevice9::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DDevice9Ex::Clear", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawIndexedPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawIndexedPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawPrimitive", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawPrimitiveUP", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawRectPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::DrawTriPatch", CALL_FLAG_RENDER }, + { "IDirect3DDevice9Ex::GetDeviceCaps", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "IDirect3DDevice9Ex::GetRenderTargetData", CALL_FLAG_END_FRAME }, + { "IDirect3DDevice9Ex::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9Ex::PresentEx", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DDevice9Ex::SetRenderTarget", CALL_FLAG_SWAP_RENDERTARGET }, + { "IDirect3DSwapChain9::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DSwapChain9Ex::Present", CALL_FLAG_SWAPBUFFERS }, + { "IDirect3DViewport2::Clear", CALL_FLAG_RENDER }, + { "IDirect3DViewport3::Clear", CALL_FLAG_RENDER }, + { "IDirect3DViewport3::Clear2", CALL_FLAG_RENDER }, + { "IDirect3DViewport::Clear", CALL_FLAG_RENDER }, + { "eglGetConfigAttrib", CALL_FLAG_VERBOSE }, + { "eglGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "eglQueryString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "eglSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "glAreProgramsResidentNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glAreTexturesResident", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glAreTexturesResidentEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glBindFramebuffer", CALL_FLAG_SWAP_RENDERTARGET }, + { "glBindFramebufferEXT", CALL_FLAG_SWAP_RENDERTARGET }, + { "glBindFramebufferOES", CALL_FLAG_SWAP_RENDERTARGET }, + { "glBlitFramebuffer", CALL_FLAG_RENDER }, + { "glBlitFramebufferANGLE", CALL_FLAG_RENDER }, + { "glBlitFramebufferEXT", CALL_FLAG_RENDER }, + { "glBlitFramebufferNV", CALL_FLAG_RENDER }, + { "glBufferRegionEnabled", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glCallList", CALL_FLAG_RENDER }, + { "glCallLists", CALL_FLAG_RENDER }, + { "glClear", CALL_FLAG_RENDER }, + { "glDebugMessageControl", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageControlARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageEnableAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glDebugMessageInsert", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertAMD", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDebugMessageInsertKHR", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glDrawArrays", CALL_FLAG_RENDER }, + { "glDrawArraysEXT", CALL_FLAG_RENDER }, + { "glDrawArraysIndirect", CALL_FLAG_RENDER }, + { "glDrawArraysInstanced", CALL_FLAG_RENDER }, + { "glDrawArraysInstancedANGLE", CALL_FLAG_RENDER }, + { "glDrawArraysInstancedARB", CALL_FLAG_RENDER }, + { "glDrawArraysInstancedBaseInstance", CALL_FLAG_RENDER }, + { "glDrawArraysInstancedEXT", CALL_FLAG_RENDER }, + { "glDrawElements", CALL_FLAG_RENDER }, + { "glDrawElementsBaseVertex", CALL_FLAG_RENDER }, + { "glDrawElementsIndirect", CALL_FLAG_RENDER }, + { "glDrawElementsInstanced", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedANGLE", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedARB", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedBaseInstance", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedBaseVertex", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedBaseVertexBaseInstance", CALL_FLAG_RENDER }, + { "glDrawElementsInstancedEXT", CALL_FLAG_RENDER }, + { "glDrawMeshArraysSUN", CALL_FLAG_RENDER }, + { "glDrawPixels", CALL_FLAG_RENDER }, + { "glDrawRangeElementArrayAPPLE", 0 }, + { "glDrawRangeElementArrayATI", 0 }, + { "glDrawRangeElements", CALL_FLAG_RENDER }, + { "glDrawRangeElementsBaseVertex", CALL_FLAG_RENDER }, + { "glDrawRangeElementsEXT", CALL_FLAG_RENDER }, + { "glDrawTransformFeedback", CALL_FLAG_RENDER }, + { "glDrawTransformFeedbackInstanced", CALL_FLAG_RENDER }, + { "glDrawTransformFeedbackNV", CALL_FLAG_RENDER }, + { "glDrawTransformFeedbackStream", CALL_FLAG_RENDER }, + { "glDrawTransformFeedbackStreamInstanced", CALL_FLAG_RENDER }, + { "glEnd", CALL_FLAG_RENDER }, + { "glEvalMesh1", CALL_FLAG_RENDER }, + { "glEvalMesh2", CALL_FLAG_RENDER }, + { "glFrameTerminatorGREMEDY", CALL_FLAG_END_FRAME }, + { "glGetActiveAtomicCounterBufferiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveAttrib", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveAttribARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineUniformName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveSubroutineUniformiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniform", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformBlockName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformBlockiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveUniformsiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetActiveVaryingNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetArrayObjectfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetArrayObjectivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetAttachedObjectsARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetAttachedShaders", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleanIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleani_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBooleanv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameteri64v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameterivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferParameterui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferPointerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferPointervARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferSubData", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetBufferSubDataARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetClipPlane", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTable", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterfvSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableParameterivSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetColorTableSGI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerInputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerInputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerOutputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerOutputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetCombinerStageParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionFilterEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetConvolutionParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDetailTexFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoubleIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoublei_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetDoublev", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetError", CALL_FLAG_NO_SIDE_EFFECTS }, // verbose will be set later for GL_NO_ERROR + { "glGetFenceivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFinalCombinerInputParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFinalCombinerInputParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFloatIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFloati_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFloatv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFogFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragDataIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentLightfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentLightivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentMaterialfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFragmentMaterialivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferAttachmentParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferAttachmentParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetFramebufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetGraphicsResetStatusARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHandleARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetHistogramParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetImageTransformParameterfvHP", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetImageTransformParameterivHP", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInfoLogARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInstrumentsSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInteger64i_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInteger64v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetIntegerIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetIntegeri_v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetIntegerui64i_vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetIntegerui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetIntegerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInternalformati64v", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInternalformativ", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetInvariantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLightfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLightiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetListParameterfvSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetListParameterivSGIX", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetLocalConstantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapAttribParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapAttribParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapControlPointsNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapParameterivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMapiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMaterialfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMaterialiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMinmaxParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexEnvfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexEnvivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGendvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGenfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexGenivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexLevelParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexLevelParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultiTexParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultisamplefv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetMultisamplefvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferParameterui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedBufferSubDataEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedFramebufferAttachmentParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedFramebufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterdvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramLocalParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramStringEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedProgramivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedRenderbufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedStringARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetNamedStringivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectBufferfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectBufferivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterivAPPLE", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectParameterivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetObjectPtrLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetOcclusionQueryivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetOcclusionQueryuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterDataAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterInfoAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCounterStringAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorCountersAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorGroupStringAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPerfMonitorGroupsAMD", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPixelTexGenParameterfvSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPixelTexGenParameterivSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointerIndexedvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramBinary", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterIivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterIuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramEnvParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramInterfaceiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterIivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterIuivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramLocalParameterfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramNamedParameterdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramNamedParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramParameterdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramParameterfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramPipelineInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramPipelineiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceLocation", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceLocationIndex", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceName", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramResourceiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStageiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStringARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramStringNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramSubroutineParameteruivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetProgramivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryIndexediv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetQueryivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetRenderbufferParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetRenderbufferParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterIiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterIuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSamplerParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSeparableFilterEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderInfoLog", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderPrecisionFormat", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderSource", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderSourceARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetShaderiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetSharpenTexFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glGetStringi", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glGetSynciv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexBumpParameterfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexBumpParameterivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexEnvfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexEnviv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexFilterFuncSGIS", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGendv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGenfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexGeniv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexLevelParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexLevelParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterIiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterIuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterPointervAPPLE", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameterfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTexParameteriv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureLevelParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureLevelParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureParameterIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureParameterIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureParameterfvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTextureParameterivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTrackMatrixivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVarying", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVaryingEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetTransformFeedbackVaryingNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformIndices", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformSubroutineuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformi64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetUniformuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantArrayObjectfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantArrayObjectivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantBooleanvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantFloatvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVariantPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayIntegeri_vEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayIntegervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayPointeri_vEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexArrayPointervEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribArrayObjectfvATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribArrayObjectivATI", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribIiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribIivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribIuiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribIuivEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribLdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribLdvEXT", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribLi64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribLui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribPointerv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribPointervARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribPointervNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribdv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribfv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribiv", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVertexAttribivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamdvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamfvNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureStreamivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoCaptureivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoi64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideoui64vNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetVideouivNV", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnMapivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformdvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformfvARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glGetnUniformuivARB", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glInsertEventMarkerEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_MARKER }, + { "glIsAsyncMarkerSGIX", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBufferARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsBufferResidentNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabled", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabledIndexedEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsEnabledi", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFenceAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFenceNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFramebuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsFramebufferEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsList", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNameAMD", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNamedBufferResidentNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsNamedStringARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsObjectBufferATI", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsOcclusionQueryNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgram", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsProgramPipeline", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsQuery", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsQueryARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsRenderbuffer", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsRenderbufferEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsSampler", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsShader", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsSync", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTexture", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTextureEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTransformFeedback", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsTransformFeedbackNV", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVariantEnabledEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexArray", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexArrayAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glIsVertexAttribEnabledAPPLE", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glMultiDrawArrays", CALL_FLAG_RENDER }, + { "glMultiDrawArraysEXT", CALL_FLAG_RENDER }, + { "glMultiDrawArraysIndirect", CALL_FLAG_RENDER }, + { "glMultiDrawArraysIndirectAMD", CALL_FLAG_RENDER }, + { "glMultiDrawArraysIndirectBindlessNV", CALL_FLAG_RENDER }, + { "glMultiDrawArraysIndirectCountARB", CALL_FLAG_RENDER }, + { "glMultiDrawElementArrayAPPLE", 0 }, + { "glMultiDrawElements", CALL_FLAG_RENDER }, + { "glMultiDrawElementsBaseVertex", CALL_FLAG_RENDER }, + { "glMultiDrawElementsEXT", CALL_FLAG_RENDER }, + { "glMultiDrawElementsIndirect", CALL_FLAG_RENDER }, + { "glMultiDrawElementsIndirectAMD", CALL_FLAG_RENDER }, + { "glMultiDrawElementsIndirectBindlessNV", CALL_FLAG_RENDER }, + { "glMultiDrawElementsIndirectCountARB", CALL_FLAG_RENDER }, + { "glMultiDrawRangeElementArrayAPPLE", 0 }, + { "glMultiModeDrawArraysIBM", CALL_FLAG_RENDER }, + { "glMultiModeDrawElementsIBM", CALL_FLAG_RENDER }, + { "glObjectLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectLabelKHR", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectPtrLabel", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glObjectPtrLabelKHR", CALL_FLAG_NO_SIDE_EFFECTS }, + { "glPopDebugGroup", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPopDebugGroupKHR", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPopGroupMarkerEXT", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_POP}, + { "glPushDebugGroup", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glPushDebugGroupKHR", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glPushGroupMarkerEXT", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER | CALL_FLAG_MARKER_PUSH }, + { "glRectd", CALL_FLAG_RENDER }, + { "glRectdv", CALL_FLAG_RENDER }, + { "glRectf", CALL_FLAG_RENDER }, + { "glRectfv", CALL_FLAG_RENDER }, + { "glRecti", CALL_FLAG_RENDER }, + { "glRectiv", CALL_FLAG_RENDER }, + { "glRects", CALL_FLAG_RENDER }, + { "glRectsv", CALL_FLAG_RENDER }, + { "glStringMarkerGREMEDY", /* CALL_FLAG_NO_SIDE_EFFECTS | */ CALL_FLAG_MARKER }, + { "glXGetClientString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetConfig", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDisplay", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDisplayEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentDrawable", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentReadDrawable", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetCurrentReadDrawableSGI", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetFBConfigAttrib", CALL_FLAG_VERBOSE }, + { "glXGetFBConfigAttribSGIX", CALL_FLAG_VERBOSE }, + { "glXGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXGetProcAddressARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXIsDirect", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryExtension", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryExtensionsString", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXQueryVersion", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "glXSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglDescribePixelFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetCurrentContext", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetCurrentDC", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetDefaultProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetExtensionsStringARB", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetExtensionsStringEXT", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetPixelFormat", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglGetPixelFormatAttribivARB", CALL_FLAG_VERBOSE }, + { "wglGetPixelFormatAttribivEXT", CALL_FLAG_VERBOSE }, + { "wglGetProcAddress", CALL_FLAG_NO_SIDE_EFFECTS | CALL_FLAG_VERBOSE }, + { "wglSwapBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglSwapLayerBuffers", CALL_FLAG_SWAPBUFFERS }, + { "wglSwapMultipleBuffers", CALL_FLAG_SWAPBUFFERS }, +}; + + +TEST(common_parser, lookupCallFlags) +{ + typedef const Entry * ConstIterator; + + ConstIterator first = &entries[0]; + ConstIterator last = &entries[sizeof entries / sizeof entries[0]]; + + for (ConstIterator it = first; it != last; ++it) { + CallFlags flags = Parser::lookupCallFlags(it->name); + + EXPECT_EQ(it->value, flags) << "flags differ for " << it->name; + } +} + + +int +main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/lib/trace/trace_parser_loop.cpp b/lib/trace/trace_parser_loop.cpp new file mode 100644 index 00000000..04fbc135 --- /dev/null +++ b/lib/trace/trace_parser_loop.cpp @@ -0,0 +1,111 @@ +/************************************************************************** + * + * Copyright 2014 LunarG, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_parser.hpp" + + +namespace trace { + + +// Decorator for parser which loops +class LastFrameLoopParser : public AbstractParser { +public: + LastFrameLoopParser(AbstractParser *p, int c) { + parser = p; + loopCount = c; + } + + ~LastFrameLoopParser() { + delete parser; + } + + Call *parse_call(void) override; + + // Delegate to Parser + void getBookmark(ParseBookmark &bookmark) override { parser->getBookmark(bookmark); } + void setBookmark(const ParseBookmark &bookmark) override { parser->setBookmark(bookmark); } + bool open(const char *filename) override; + void close(void) override { parser->close(); } + unsigned long long getVersion(void) const override { return parser->getVersion(); } +private: + int loopCount; + AbstractParser *parser; + ParseBookmark frameStart; + ParseBookmark lastFrameStart; +}; + + +bool +LastFrameLoopParser::open(const char *filename) +{ + bool ret = parser->open(filename); + if (ret) { + /* If the user wants to loop we need to get a bookmark target. We + * usually get this after replaying a call that ends a frame, but + * for a trace that has only one frame we need to get it at the + * beginning. */ + parser->getBookmark(frameStart); + lastFrameStart = frameStart; + } + return ret; +} + +Call * +LastFrameLoopParser::parse_call(void) +{ + trace::Call *call; + + call = parser->parse_call(); + + /* Restart last frame when looping is requested. */ + if (call) { + lastFrameStart = frameStart; + if (call->flags & trace::CALL_FLAG_END_FRAME) { + parser->getBookmark(frameStart); + } + } else { + if (loopCount) { + frameStart = lastFrameStart; + parser->setBookmark(frameStart); + call = parser->parse_call(); + if (loopCount > 0) { + --loopCount; + } + } + } + + return call; +} + + +AbstractParser * +lastFrameLoopParser(AbstractParser *parser, int loopCount) +{ + return new LastFrameLoopParser(parser, loopCount); +} + + +} /* namespace trace */ diff --git a/lib/trace/trace_profiler.cpp b/lib/trace/trace_profiler.cpp new file mode 100644 index 00000000..65c91aad --- /dev/null +++ b/lib/trace/trace_profiler.cpp @@ -0,0 +1,259 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * Copyright 2013 Intel, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#include "trace_profiler.hpp" +#include "os_time.hpp" +#include +#include +#include + +namespace trace { +Profiler::Profiler() + : baseGpuTime(0), + baseCpuTime(0), + minCpuTime(1000), + baseVsizeUsage(0), + baseRssUsage(0), + cpuTimes(false), + gpuTimes(true), + pixelsDrawn(false), + memoryUsage(false) +{ +} + +Profiler::~Profiler() +{ +} + +void Profiler::setup(bool cpuTimes_, bool gpuTimes_, bool pixelsDrawn_, bool memoryUsage_) +{ + cpuTimes = cpuTimes_; + gpuTimes = gpuTimes_; + pixelsDrawn = pixelsDrawn_; + memoryUsage = memoryUsage_; + + std::cout << "# call no gpu_start gpu_dura cpu_start cpu_dura vsize_start vsize_dura rss_start rss_dura pixels program name" << std::endl; +} + +int64_t Profiler::getBaseCpuTime() +{ + return baseCpuTime; +} + +int64_t Profiler::getBaseGpuTime() +{ + return baseGpuTime; +} + +int64_t Profiler::getBaseVsizeUsage() +{ + return baseVsizeUsage; +} + +int64_t Profiler::getBaseRssUsage() +{ + return baseRssUsage; +} + +void Profiler::setBaseCpuTime(int64_t cpuStart) +{ + baseCpuTime = cpuStart; +} + +void Profiler::setBaseGpuTime(int64_t gpuStart) +{ + baseGpuTime = gpuStart; +} + +void Profiler::setBaseVsizeUsage(int64_t vsizeStart) +{ + baseVsizeUsage = vsizeStart; +} + +void Profiler::setBaseRssUsage(int64_t rssStart) +{ + baseRssUsage = rssStart; +} + +bool Profiler::hasBaseTimes() +{ + return baseCpuTime != 0 || baseGpuTime != 0; +} + +void Profiler::addCall(unsigned no, + const char *name, + unsigned program, + int64_t pixels, + int64_t gpuStart, int64_t gpuDuration, + int64_t cpuStart, int64_t cpuDuration, + int64_t vsizeStart, int64_t vsizeDuration, + int64_t rssStart, int64_t rssDuration) +{ + if (gpuTimes && gpuStart) { + gpuStart -= baseGpuTime; + } else { + gpuStart = 0; + } + + if (cpuTimes && cpuStart) { + cpuStart = cpuStart - baseCpuTime; + + if (cpuDuration < minCpuTime) { + return; + } + } else { + cpuStart = 0; + cpuDuration = 0; + } + + if (!pixelsDrawn) { + pixels = 0; + } + + if (!memoryUsage || !vsizeStart || !rssStart) { + vsizeStart = 0; + vsizeDuration = 0; + rssStart = 0; + rssDuration = 0; + } + + std::cout << "call" + << " " << no + << " " << gpuStart + << " " << gpuDuration + << " " << cpuStart + << " " << cpuDuration + << " " << vsizeStart + << " " << vsizeDuration + << " " << rssStart + << " " << rssDuration + << " " << pixels + << " " << program + << " " << name + << std::endl; +} + +void Profiler::addFrameEnd() +{ + std::cout << "frame_end" << std::endl; +} + +void Profiler::parseLine(const char* in, Profile* profile) +{ + std::stringstream line(in, std::ios_base::in); + std::string type; + static int64_t lastGpuTime; + static int64_t lastCpuTime; + static int64_t lastVsizeUsage; + static int64_t lastRssUsage; + + if (in[0] == '#' || strlen(in) < 4) + return; + + if (profile->programs.size() == 0 && profile->calls.size() == 0 && profile->frames.size() == 0) { + lastGpuTime = 0; + lastCpuTime = 0; + lastVsizeUsage = 0; + lastRssUsage = 0; + } + + line >> type; + + if (type.compare("call") == 0) { + Profile::Call call; + + line >> call.no + >> call.gpuStart + >> call.gpuDuration + >> call.cpuStart + >> call.cpuDuration + >> call.vsizeStart + >> call.vsizeDuration + >> call.rssStart + >> call.rssDuration + >> call.pixels + >> call.program + >> call.name; + + if (lastGpuTime < call.gpuStart + call.gpuDuration) { + lastGpuTime = call.gpuStart + call.gpuDuration; + } + + if (lastCpuTime < call.cpuStart + call.cpuDuration) { + lastCpuTime = call.cpuStart + call.cpuDuration; + } + + if (lastVsizeUsage < call.vsizeStart + call.vsizeDuration) { + lastVsizeUsage = call.vsizeStart + call.vsizeDuration; + } + + if (lastRssUsage < call.rssStart + call.rssDuration) { + lastRssUsage = call.rssStart + call.rssDuration; + } + + profile->calls.push_back(call); + + if (call.pixels >= 0) { + if (profile->programs.size() <= call.program) { + profile->programs.resize(call.program + 1); + } + + Profile::Program& program = profile->programs[call.program]; + program.cpuTotal += call.cpuDuration; + program.gpuTotal += call.gpuDuration; + program.pixelTotal += call.pixels; + program.vsizeTotal += call.vsizeDuration; + program.rssTotal += call.rssDuration; + program.calls.push_back((unsigned int)(profile->calls.size() - 1)); + } + } else if (type.compare("frame_end") == 0) { + Profile::Frame frame; + frame.no = unsigned(profile->frames.size()); + + if (frame.no == 0) { + frame.gpuStart = 0; + frame.cpuStart = 0; + frame.vsizeStart = 0; + frame.rssStart = 0; + frame.calls.begin = 0; + } else { + frame.gpuStart = profile->frames.back().gpuStart + profile->frames.back().gpuDuration; + frame.cpuStart = profile->frames.back().cpuStart + profile->frames.back().cpuDuration; + frame.vsizeStart = profile->frames.back().vsizeStart + profile->frames.back().vsizeDuration; + frame.rssStart = profile->frames.back().rssStart + profile->frames.back().rssDuration; + frame.calls.begin = profile->frames.back().calls.end + 1; + } + + frame.gpuDuration = lastGpuTime - frame.gpuStart; + frame.cpuDuration = lastCpuTime - frame.cpuStart; + frame.vsizeDuration = lastVsizeUsage - frame.vsizeStart; + frame.rssDuration = lastRssUsage - frame.rssStart; + frame.calls.end = (unsigned int)(profile->calls.size() - 1); + + profile->frames.push_back(frame); + } +} +} diff --git a/lib/trace/trace_profiler.hpp b/lib/trace/trace_profiler.hpp new file mode 100644 index 00000000..ebe28b46 --- /dev/null +++ b/lib/trace/trace_profiler.hpp @@ -0,0 +1,143 @@ +/************************************************************************** + * + * Copyright 2012 VMware, Inc. + * Copyright 2013 Intel, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#pragma once + +#include +#include +#include + +namespace trace +{ + +struct Profile { + struct Call { + unsigned no; + + unsigned program; + + int64_t gpuStart; + int64_t gpuDuration; + + int64_t cpuStart; + int64_t cpuDuration; + + int64_t vsizeStart; + int64_t vsizeDuration; + int64_t rssStart; + int64_t rssDuration; + + int64_t pixels; + + std::string name; + }; + + struct Frame { + unsigned no; + + int64_t gpuStart; + int64_t gpuDuration; + + int64_t cpuStart; + int64_t cpuDuration; + + int64_t vsizeStart; + int64_t vsizeDuration; + int64_t rssStart; + int64_t rssDuration; + + /* Indices to profile->calls array */ + struct { + unsigned begin; + unsigned end; + } calls; + }; + + struct Program { + Program() : gpuTotal(0), cpuTotal(0), pixelTotal(0) {} + + uint64_t gpuTotal; + uint64_t cpuTotal; + uint64_t pixelTotal; + int64_t vsizeTotal; + int64_t rssTotal; + + /* Indices to profile->calls array */ + std::vector calls; + }; + + std::vector calls; + std::vector frames; + std::vector programs; +}; + +class Profiler +{ +public: + Profiler(); + ~Profiler(); + + void setup(bool cpuTimes_, bool gpuTimes_, bool pixelsDrawn_, bool memoryUsage_); + + void addCall(unsigned no, + const char* name, + unsigned program, + int64_t pixels, + int64_t gpuStart, int64_t gpuDuration, + int64_t cpuStart, int64_t cpuDuration, + int64_t vsizeStart, int64_t vsizeDuration, + int64_t rssStart, int64_t rssDuration); + + void addFrameEnd(); + + bool hasBaseTimes(); + + void setBaseCpuTime(int64_t cpuStart); + void setBaseGpuTime(int64_t gpuStart); + void setBaseVsizeUsage(int64_t vsizeStart); + void setBaseRssUsage(int64_t rssStart); + + int64_t getBaseCpuTime(); + int64_t getBaseGpuTime(); + int64_t getBaseVsizeUsage(); + int64_t getBaseRssUsage(); + + static void parseLine(const char* line, Profile* profile); + +private: + int64_t baseGpuTime; + int64_t baseCpuTime; + int64_t minCpuTime; + int64_t baseVsizeUsage; + int64_t baseRssUsage; + + bool cpuTimes; + bool gpuTimes; + bool pixelsDrawn; + bool memoryUsage; +}; +} + diff --git a/lib/trace/trace_snappy.hpp b/lib/trace/trace_snappy.hpp new file mode 100644 index 00000000..5d82c746 --- /dev/null +++ b/lib/trace/trace_snappy.hpp @@ -0,0 +1,34 @@ +/************************************************************************** + * + * Copyright 2015 VMware, Inc + * Copyright 2011 Zack Rusin + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#pragma once + + +#define SNAPPY_BYTE1 'a' +#define SNAPPY_BYTE2 't' + + diff --git a/lib/trace/trace_writer.cpp b/lib/trace/trace_writer.cpp new file mode 100644 index 00000000..3ad06e4f --- /dev/null +++ b/lib/trace/trace_writer.cpp @@ -0,0 +1,372 @@ +/************************************************************************** + * + * Copyright 2007-2009 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include +#include +#include +#include +#include +#include +#include + +#include "os.hpp" +#include "trace_ostream.hpp" +#include "trace_writer.hpp" +#include "trace_format.hpp" + +namespace trace { + + +Writer::Writer() : + call_no(0) +{ + m_file = nullptr; +} + +Writer::~Writer() +{ + close(); +} + +void +Writer::close(void) { + delete m_file; + m_file = nullptr; +} + +bool +Writer::open(const char *filename) { + close(); + + m_file = createSnappyStream(filename); + if (!m_file) { + return false; + } + + call_no = 0; + functions.clear(); + structs.clear(); + enums.clear(); + bitmasks.clear(); + frames.clear(); + + _writeUInt(TRACE_VERSION); + + return true; +} + +void inline +Writer::_write(const void *sBuffer, size_t dwBytesToWrite) { + m_file->write(sBuffer, dwBytesToWrite); +} + +void inline +Writer::_writeByte(char c) { + _write(&c, 1); +} + +void inline +Writer::_writeUInt(unsigned long long value) { + char buf[2 * sizeof value]; + unsigned len; + + len = 0; + do { + assert(len < sizeof buf); + buf[len] = 0x80 | (value & 0x7f); + value >>= 7; + ++len; + } while (value); + + assert(len); + buf[len - 1] &= 0x7f; + + _write(buf, len); +} + +void inline +Writer::_writeFloat(float value) { + static_assert(sizeof value == 4, "float is not 4 bytes"); + _write((const char *)&value, sizeof value); +} + +void inline +Writer::_writeDouble(double value) { + static_assert(sizeof value == 8, "double is not 8 bytes"); + _write((const char *)&value, sizeof value); +} + +void inline +Writer::_writeString(const char *str) { + size_t len = strlen(str); + _writeUInt(len); + _write(str, len); +} + +inline bool lookup(std::vector &map, size_t index) { + if (index >= map.size()) { + map.resize(index + 1); + return false; + } else { + return map[index]; + } +} + +void Writer::beginBacktrace(unsigned num_frames) { + if (num_frames) { + _writeByte(trace::CALL_BACKTRACE); + _writeUInt(num_frames); + } +} + +void Writer::writeStackFrame(const RawStackFrame *frame) { + _writeUInt(frame->id); + if (!lookup(frames, frame->id)) { + if (frame->module != NULL) { + _writeByte(trace::BACKTRACE_MODULE); + _writeString(frame->module); + } + if (frame->function != NULL) { + _writeByte(trace::BACKTRACE_FUNCTION); + _writeString(frame->function); + } + if (frame->filename != NULL) { + _writeByte(trace::BACKTRACE_FILENAME); + _writeString(frame->filename); + } + if (frame->linenumber >= 0) { + _writeByte(trace::BACKTRACE_LINENUMBER); + _writeUInt(frame->linenumber); + } + if (frame->offset >= 0) { + _writeByte(trace::BACKTRACE_OFFSET); + _writeUInt(frame->offset); + } + _writeByte(trace::BACKTRACE_END); + frames[frame->id] = true; + } +} + +unsigned Writer::beginEnter(const FunctionSig *sig, unsigned thread_id) { + _writeByte(trace::EVENT_ENTER); + _writeUInt(thread_id); + _writeUInt(sig->id); + if (!lookup(functions, sig->id)) { + _writeString(sig->name); + _writeUInt(sig->num_args); + for (unsigned i = 0; i < sig->num_args; ++i) { + _writeString(sig->arg_names[i]); + } + functions[sig->id] = true; + } + + return call_no++; +} + +void Writer::endEnter(void) { + _writeByte(trace::CALL_END); +} + +void Writer::beginLeave(unsigned call) { + _writeByte(trace::EVENT_LEAVE); + _writeUInt(call); +} + +void Writer::endLeave(void) { + _writeByte(trace::CALL_END); +} + +void Writer::beginArg(unsigned index) { + _writeByte(trace::CALL_ARG); + _writeUInt(index); +} + +void Writer::beginReturn(void) { + _writeByte(trace::CALL_RET); +} + +void Writer::beginArray(size_t length) { + _writeByte(trace::TYPE_ARRAY); + _writeUInt(length); +} + +void Writer::beginStruct(const StructSig *sig) { + _writeByte(trace::TYPE_STRUCT); + _writeUInt(sig->id); + if (!lookup(structs, sig->id)) { + _writeString(sig->name); + _writeUInt(sig->num_members); + for (unsigned i = 0; i < sig->num_members; ++i) { + _writeString(sig->member_names[i]); + } + structs[sig->id] = true; + } +} + +void Writer::beginRepr(void) { + _writeByte(trace::TYPE_REPR); +} + +void Writer::writeBool(bool value) { + _writeByte(value ? trace::TYPE_TRUE : trace::TYPE_FALSE); +} + +void Writer::writeSInt(signed long long value) { + if (value < 0) { + _writeByte(trace::TYPE_SINT); + _writeUInt(-value); + } else { + _writeByte(trace::TYPE_UINT); + _writeUInt(value); + } +} + +void Writer::writeUInt(unsigned long long value) { + _writeByte(trace::TYPE_UINT); + _writeUInt(value); +} + +void Writer::writeFloat(float value) { + _writeByte(trace::TYPE_FLOAT); + _writeFloat(value); +} + +void Writer::writeDouble(double value) { + _writeByte(trace::TYPE_DOUBLE); + _writeDouble(value); +} + +void Writer::writeString(const char *str) { + if (!str) { + Writer::writeNull(); + return; + } + _writeByte(trace::TYPE_STRING); + _writeString(str); +} + +void Writer::writeString(const char *str, size_t len) { + if (!str) { + Writer::writeNull(); + return; + } + _writeByte(trace::TYPE_STRING); + _writeUInt(len); + _write(str, len); +} + +void Writer::writeWString(const wchar_t *str, size_t len) { + if (!str) { + Writer::writeNull(); + return; + } + /* XXX: Encode wide-strings as ASCII for now, to avoid introducing a trace format version bump. */ +#if 0 + _writeByte(trace::TYPE_WSTRING); + size_t len = wcslen(str); + _writeUInt(len); + for (size_t i = 0; i < len; ++i) { + _writeUInt(str[i]); + } +#else + _writeByte(trace::TYPE_STRING); + _writeUInt(len); + for (size_t i = 0; i < len; ++i) { + wchar_t wc = str[i]; + char c = wc >= 0 && wc < 0x80 ? (char)wc : '?'; + _writeByte(c); + } +#endif +} + +void Writer::writeWString(const wchar_t *str) { + if (!str) { + Writer::writeNull(); + return; + } + size_t len = wcslen(str); + writeWString(str, len); +} + +void Writer::writeBlob(const void *data, size_t size) { + if (!data) { + Writer::writeNull(); + return; + } + _writeByte(trace::TYPE_BLOB); + _writeUInt(size); + if (size) { + _write(data, size); + } +} + +void Writer::writeEnum(const EnumSig *sig, signed long long value) { + _writeByte(trace::TYPE_ENUM); + _writeUInt(sig->id); + if (!lookup(enums, sig->id)) { + _writeUInt(sig->num_values); + for (unsigned i = 0; i < sig->num_values; ++i) { + _writeString(sig->values[i].name); + writeSInt(sig->values[i].value); + } + enums[sig->id] = true; + } + writeSInt(value); +} + +void Writer::writeBitmask(const BitmaskSig *sig, unsigned long long value) { + _writeByte(trace::TYPE_BITMASK); + _writeUInt(sig->id); + if (!lookup(bitmasks, sig->id)) { + _writeUInt(sig->num_flags); + for (unsigned i = 0; i < sig->num_flags; ++i) { + if (i != 0 && sig->flags[i].value == 0) { + os::log("apitrace: warning: sig %s is zero but is not first flag\n", sig->flags[i].name); + } + _writeString(sig->flags[i].name); + _writeUInt(sig->flags[i].value); + } + bitmasks[sig->id] = true; + } + _writeUInt(value); +} + +void Writer::writeNull(void) { + _writeByte(trace::TYPE_NULL); +} + +void Writer::writePointer(unsigned long long addr) { + if (!addr) { + Writer::writeNull(); + return; + } + _writeByte(trace::TYPE_OPAQUE); + _writeUInt(addr); +} + + +} /* namespace trace */ + diff --git a/lib/trace/trace_writer.hpp b/lib/trace/trace_writer.hpp new file mode 100644 index 00000000..e293a938 --- /dev/null +++ b/lib/trace/trace_writer.hpp @@ -0,0 +1,116 @@ +/************************************************************************** + * + * Copyright 2007-2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Trace writing functions. + */ + +#pragma once + + +#include + +#include + +#include "trace_model.hpp" + +namespace trace { + class OutStream; + + class Writer { + protected: + OutStream *m_file; + unsigned call_no; + + std::vector functions; + std::vector structs; + std::vector enums; + std::vector bitmasks; + std::vector frames; + + public: + Writer(); + ~Writer(); + + bool open(const char *filename); + void close(void); + + unsigned beginEnter(const FunctionSig *sig, unsigned thread_id); + void endEnter(void); + + void beginLeave(unsigned call); + void endLeave(void); + + void beginArg(unsigned index); + inline void endArg(void) {} + + void beginReturn(void); + inline void endReturn(void) {} + + void beginBacktrace(unsigned num_frames); + void writeStackFrame(const RawStackFrame *frame); + inline void endBacktrace(void) {} + + void beginArray(size_t length); + inline void endArray(void) {} + + inline void beginElement(void) {} + inline void endElement(void) {} + + void beginStruct(const StructSig *sig); + inline void endStruct(void) {} + + void beginRepr(void); + inline void endRepr(void) {} + + void writeBool(bool value); + void writeSInt(signed long long value); + void writeUInt(unsigned long long value); + void writeFloat(float value); + void writeDouble(double value); + void writeString(const char *str); + void writeString(const char *str, size_t size); + void writeWString(const wchar_t *str); + void writeWString(const wchar_t *str, size_t size); + void writeBlob(const void *data, size_t size); + void writeEnum(const EnumSig *sig, signed long long value); + void writeBitmask(const BitmaskSig *sig, unsigned long long value); + void writeNull(void); + void writePointer(unsigned long long addr); + + void writeCall(Call *call); + + protected: + void inline _write(const void *sBuffer, size_t dwBytesToWrite); + void inline _writeByte(char c); + void inline _writeUInt(unsigned long long value); + void inline _writeFloat(float value); + void inline _writeDouble(double value); + void inline _writeString(const char *str); + + }; + +} /* namespace trace */ + diff --git a/lib/trace/trace_writer_local.cpp b/lib/trace/trace_writer_local.cpp new file mode 100644 index 00000000..79ff962b --- /dev/null +++ b/lib/trace/trace_writer_local.cpp @@ -0,0 +1,287 @@ +/************************************************************************** + * + * Copyright 2007-2011 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include +#include +#include +#include +#include + +#include "os.hpp" +#include "os_thread.hpp" +#include "os_string.hpp" +#include "os_version.hpp" +#include "trace_ostream.hpp" +#include "trace_writer_local.hpp" +#include "trace_format.hpp" +#include "os_backtrace.hpp" + + +namespace trace { + + +static const char *memcpy_args[3] = {"dest", "src", "n"}; +const FunctionSig memcpy_sig = {0, "memcpy", 3, memcpy_args}; + +static const char *malloc_args[1] = {"size"}; +const FunctionSig malloc_sig = {1, "malloc", 1, malloc_args}; + +static const char *free_args[1] = {"ptr"}; +const FunctionSig free_sig = {2, "free", 1, free_args}; + +static const char *realloc_args[2] = {"ptr", "size"}; +const FunctionSig realloc_sig = {3, "realloc", 2, realloc_args}; + + +static void exceptionCallback(void) +{ + localWriter.flush(); +} + + +LocalWriter::LocalWriter() : + acquired(0) +{ + os::String process = os::getProcessName(); + os::log("apitrace: loaded into %s\n", process.str()); + + // Install the signal handlers as early as possible, to prevent + // interfering with the application's signal handling. + os::setExceptionCallback(exceptionCallback); +} + +LocalWriter::~LocalWriter() +{ + os::resetExceptionCallback(); + checkProcessId(); + + os::String process = os::getProcessName(); + os::log("apitrace: unloaded from %s\n", process.str()); +} + +void +LocalWriter::open(void) { + os::String szFileName; + + const char *lpFileName; + + lpFileName = getenv("TRACE_FILE"); + if (!lpFileName) { + static unsigned dwCounter = 0; + + os::String process = os::getProcessName(); +#ifdef _WIN32 + process.trimExtension(); +#endif + process.trimDirectory(); + +#ifdef ANDROID + os::String prefix = "/data/data"; + prefix.join(process); +#else + os::String prefix = os::getCurrentDir(); +#ifdef _WIN32 + // Avoid writing into Windows' system directory as quite often access + // will be denied. + if (IsWindows8OrGreater()) { + char szDirectory[MAX_PATH + 1]; + GetSystemDirectoryA(szDirectory, sizeof szDirectory); + if (stricmp(prefix, szDirectory) == 0) { + GetTempPathA(sizeof szDirectory, szDirectory); + prefix = szDirectory; + } + } +#endif +#endif + prefix.join(process); + + for (;;) { + FILE *file; + + if (dwCounter) + szFileName = os::String::format("%s.%u.trace", prefix.str(), dwCounter); + else + szFileName = os::String::format("%s.trace", prefix.str()); + + lpFileName = szFileName; + file = fopen(lpFileName, "rb"); + if (file == NULL) + break; + + fclose(file); + + ++dwCounter; + } + } + + os::log("apitrace: tracing to %s\n", lpFileName); + + if (!Writer::open(lpFileName)) { + os::log("apitrace: error: failed to open %s\n", lpFileName); + os::abort(); + } + + pid = os::getCurrentProcessId(); + +#if 0 + // For debugging the exception handler + *((int *)0) = 0; +#endif +} + +static uintptr_t next_thread_num = 1; + +static OS_THREAD_SPECIFIC(uintptr_t) +thread_num; + +void LocalWriter::checkProcessId(void) { + if (m_file && + os::getCurrentProcessId() != pid) { + // We are a forked child process that inherited the trace file, so + // create a new file. We can't call any method of the current + // file, as it may cause it to flush and corrupt the parent's + // trace, so we effectively leak the old file object. + close(); + // Don't want to open the same file again + os::unsetEnvironment("TRACE_FILE"); + open(); + } +} + +unsigned LocalWriter::beginEnter(const FunctionSig *sig, bool fake) { + mutex.lock(); + ++acquired; + + checkProcessId(); + if (!m_file) { + open(); + } + + uintptr_t this_thread_num = thread_num; + if (!this_thread_num) { + this_thread_num = next_thread_num++; + thread_num = this_thread_num; + } + + assert(this_thread_num); + unsigned thread_id = this_thread_num - 1; + unsigned call_no = Writer::beginEnter(sig, thread_id); + if (!fake && os::backtrace_is_needed(sig->name)) { + std::vector backtrace = os::get_backtrace(); + beginBacktrace(backtrace.size()); + for (auto & frame : backtrace) { + writeStackFrame(&frame); + } + endBacktrace(); + } + return call_no; +} + +void LocalWriter::endEnter(void) { + Writer::endEnter(); + --acquired; + mutex.unlock(); +} + +void LocalWriter::beginLeave(unsigned call) { + mutex.lock(); + ++acquired; + Writer::beginLeave(call); +} + +void LocalWriter::endLeave(void) { + Writer::endLeave(); + --acquired; + mutex.unlock(); +} + +void LocalWriter::flush(void) { + /* + * Do nothing if the mutex is already acquired (e.g., if a segfault happen + * while writing the file) as state could be inconsistent, therefore yield + * inconsistent trace files and/or repeated segfaults till infinity. + */ + + mutex.lock(); + if (acquired) { + os::log("apitrace: ignoring exception while tracing\n"); + } else { + ++acquired; + if (m_file) { + if (os::getCurrentProcessId() != pid) { + os::log("apitrace: ignoring exception in child process\n"); + } else { + os::log("apitrace: flushing trace due to an exception\n"); + m_file->flush(); + } + } + --acquired; + } + mutex.unlock(); +} + + +LocalWriter localWriter; + + +void fakeMemcpy(const void *ptr, size_t size) { + assert(ptr); + if (!size) { + return; + } + + unsigned _call = localWriter.beginEnter(&memcpy_sig, true); + +#if defined(_WIN32) && !defined(NDEBUG) + size_t maxSize = 0; + MEMORY_BASIC_INFORMATION mi; + while (VirtualQuery((const uint8_t *)ptr + maxSize, &mi, sizeof mi) == sizeof mi && + mi.Protect & (PAGE_READONLY|PAGE_READWRITE)) { + maxSize = (const uint8_t *)mi.BaseAddress + mi.RegionSize - (const uint8_t *)ptr; + } + if (maxSize < size) { + os::log("apitrace: warning: %u: clamping size from %Iu to %Iu\n", _call, size, maxSize); + size = maxSize; + } +#endif + + localWriter.beginArg(0); + localWriter.writePointer((uintptr_t)ptr); + localWriter.endArg(); + localWriter.beginArg(1); + localWriter.writeBlob(ptr, size); + localWriter.endArg(); + localWriter.beginArg(2); + localWriter.writeUInt(size); + localWriter.endArg(); + localWriter.endEnter(); + localWriter.beginLeave(_call); + localWriter.endLeave(); +} + + +} /* namespace trace */ + diff --git a/lib/trace/trace_writer_local.hpp b/lib/trace/trace_writer_local.hpp new file mode 100644 index 00000000..5d55bd9d --- /dev/null +++ b/lib/trace/trace_writer_local.hpp @@ -0,0 +1,121 @@ +/************************************************************************** + * + * Copyright 2007-2013 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +/* + * Trace writing functions, used to trace calls in the current process. + */ + +#pragma once + + +#include + +#include "os_thread.hpp" +#include "os_process.hpp" +#include "trace_writer.hpp" + + +namespace trace { + + extern const FunctionSig memcpy_sig; + extern const FunctionSig malloc_sig; + extern const FunctionSig free_sig; + extern const FunctionSig realloc_sig; + + /** + * A specialized Writer class, mean to trace the current process. + * + * In particular: + * - it creates a trace file based on the current process name + * - uses mutexes to allow tracing from multiple threades + * - flushes the output to ensure the last call is traced in event of + * abnormal termination + */ + class LocalWriter : public Writer { + protected: + /** + * This mutex guarantees that only one thread writes to the trace file + * at one given instance. + * + * We need a recursive mutex so that we dont't dead lock in the event + * of a segfault happens while the mutex is held. + * + * To prevent deadlocks, the call for the real function (the one being + * traced) should not be done with the mutex held. That is, it should + * be done outside the beginEnter/endEnter and beginLeave/endLeave + * pairs. Preferably between these two pairs. + */ + os::recursive_mutex mutex; + int acquired; + + /** + * ID of the processed that opened the trace file. + */ + os::ProcessId pid; + + void checkProcessId(); + + public: + /** + * Should never called directly -- use localWriter singleton below + * instead. + */ + LocalWriter(); + ~LocalWriter(); + + void open(void); + + /** + * It will acquire the mutex. + */ + unsigned beginEnter(const FunctionSig *sig, bool fake = false); + + /** + * It will release the mutex. + */ + void endEnter(void); + + /** + * It will acquire the mutex. + */ + void beginLeave(unsigned call); + + /** + * It will release the mutex. + */ + void endLeave(void); + + void flush(void); + }; + + /** + * Singleton. + */ + extern LocalWriter localWriter; + + void fakeMemcpy(const void *ptr, size_t size); + +} /* namespace trace */ + diff --git a/lib/trace/trace_writer_model.cpp b/lib/trace/trace_writer_model.cpp new file mode 100644 index 00000000..d497e5b9 --- /dev/null +++ b/lib/trace/trace_writer_model.cpp @@ -0,0 +1,149 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#include "trace_writer.hpp" + + +namespace trace { + + +class ModelWriter : public Visitor +{ +protected: + Writer &writer; + +public: + ModelWriter(Writer &_writer) : + writer(_writer) { + } + + void visit(Null *) override { + writer.writeNull(); + } + + void visit(Bool *node) override { + writer.writeBool(node->value); + } + + void visit(SInt *node) override { + writer.writeSInt(node->value); + } + + void visit(UInt *node) override { + writer.writeUInt(node->value); + } + + void visit(Float *node) override { + writer.writeFloat(node->value); + } + + void visit(Double *node) override { + writer.writeDouble(node->value); + } + + void visit(String *node) override { + writer.writeString(node->value); + } + + void visit(WString *node) override { + writer.writeWString(node->value); + } + + void visit(Enum *node) override { + writer.writeEnum(node->sig, node->value); + } + + void visit(Bitmask *node) override { + writer.writeBitmask(node->sig, node->value); + } + + void visit(Struct *node) override { + writer.beginStruct(node->sig); + for (unsigned i = 0; i < node->sig->num_members; ++i) { + _visit(node->members[i]); + } + writer.endStruct(); + } + + void visit(Array *node) override { + writer.beginArray(node->values.size()); + for (auto & value : node->values) { + _visit(value); + } + writer.endArray(); + } + + void visit(Blob *node) override { + writer.writeBlob(node->buf, node->size); + } + + void visit(Pointer *node) override { + writer.writePointer(node->value); + } + + void visit(Repr *node) override { + writer.beginRepr(); + _visit(node->humanValue); + _visit(node->machineValue); + writer.endRepr(); + } + + void visit(Call *call) { + unsigned call_no = writer.beginEnter(call->sig, call->thread_id); + if (call->backtrace != NULL) { + writer.beginBacktrace(call->backtrace->size()); + for (auto & frame : *call->backtrace) { + writer.writeStackFrame(frame); + } + writer.endBacktrace(); + } + for (unsigned i = 0; i < call->args.size(); ++i) { + if (call->args[i].value) { + writer.beginArg(i); + _visit(call->args[i].value); + writer.endArg(); + } + } + writer.endEnter(); + writer.beginLeave(call_no); + if (call->ret) { + writer.beginReturn(); + _visit(call->ret); + writer.endReturn(); + } + writer.endLeave(); + } +}; + + +void Writer::writeCall(Call *call) { + ModelWriter visitor(*this); + visitor.visit(call); +} + + +} /* namespace trace */ + -- cgit v1.2.3